Java 8 流过滤和分组使用相同的昂贵方法调用

java java-8 java-stream

2022-09-04 01:05:21

我正在寻找一种以干净的方式优化处理的方法。Stream

我有这样的东西：

try (Stream<Path> stream = Files.list(targetDir)) {
    Map<String, List<Path>> targetDirFilteredAndMapped = stream.parallel()                                                                                                
        .filter(path -> sd.containsKey(md5(path)))                                                                                                                    
        .collect(Collectors.groupingBy(path -> md5(path)));
} catch (IOException ioe) { // manage exception }

由于该函数非常昂贵，我想知道是否有一种方法可以为每个文件仅调用一次。md5

有什么建议吗？

答案 1

您可以创建一些包含实例及其相应 .PathWrapperPathmd5(path)

public class PathWrapper
{
    Path path;
    String md5; // not sure if it's a String
    public PathWrapper(Path path) {
        this.path = path;
        this.md5 = md5(path);
    }
    public Path getPath() {return path;}
    public String getMD5() {return md5;}
}

然后将您的直播映射到：Stream<PathWrapper>

try (Stream<Path> stream = Files.list(targetDir)) {
    Map<String, List<Path>> targetDirFilteredAndMapped =
        stream.parallel() 
              .map(PathWrapper::new)
              .filter(path -> sd.containsKey(path.getMD5()))                                                                                                                    
              .collect(Collectors.groupingBy(PathWrapper::getMD5,
                                             Collectors.mapping(PathWrapper::getPath,
                                                                Collectors.toList())));
} catch (IOException ioe) { /* manage exception */ }

答案 2

如果操作确实主导了性能，则可以考虑在此处取消筛选，然后删除不匹配的组：md5

try(Stream<Path> stream = Files.list(targetDir)) {
    Map<String, List<Path>> targetDirFilteredAndMapped = stream.parallel()
        .collect(Collectors.groupingBy(p -> md5(p), HashMap::new, Collectors.toList()));
    targetDirFilteredAndMapped.keySet().retainAll(sd.keySet());
} catch (IOException ioe) { 
    // manage exception
}

当然，这暂时需要更多的内存。如果这是一个问题，使用更复杂的解决方案，如其他答案所示，是不可避免的。