Java:如何将列表转换为设置然后比较缺失值

Question

我的目标是使用 Set 定位并打印数据中的任何缺失值
界面。
我有一个像下面这样的 POJO

public class Info {

    private final String folder;
    private final String version;
    private final String key;
        
    public static Builder builder() {
        return new Builder();
    }
    
    public static Builder builder(Info info) {
        return new Builder(info);
    }
        
    private Info(Builder builder) {
        this.folder = builder.folder;
        this.version = builder.version;
        this.key = builder.key;
        
    public String getFolder() {
        return folder;
    }
        
    public String getVersion() {
        return version;
    }
        
    public String getCreated() {
        return created;
    }
        
    // toString(), hashCode(), equals()
        
    // Builder class
        
    public Builder withFolder(String folder){
        this.folder = folder;
        return this;
    }

   // withVersion(String version)
   // withKey(String key)


    public Info build(){
        return new Info(this);    
    }

}

使用下面的代码，我从我的数据源创建了一个列表。

List<Info> newList = previousList.stream().map(m -> Info.builder()
            .withFolder(m.getFolder())
            .withKey(m.getKey())
            .withVersion(m.getVersion())
            .build())
            .collect(Collectors.toList());

// Printed output is below
list.forEach(System.out::println);

下面是类似于我的列表输出的输出。
显示了两个示例文件夹和两个示例丢失文件。
对于每个 key ，有多个版本号。

// Output

[folder=folderA, version=3.48.137, key=fileA-sources.jar]
[folder=folderA, version=3.48.128, key=fileA-sources.jar]
[folder=folderA, version=3.48.125, key=fileA-sources.jar]
[folder=folderA, version=3.48.137, key=fileA-javadoc.jar]
[folder=folderA, version=3.48.128, key=fileA-javadoc.jar]
[folder=folderA, version=3.48.125, key=fileA-javadoc.jar]
[folder=folderA, version=3.48.137, key=fileA.jar]
[folder=folderA, version=3.48.128, key=fileA.jar]

// Missing [folder=folderA, version= 3.48.125, key=fileA.jar]

[folder=folderB, version=1.7.16, key=fileB.pom]
[folder=folderB, version=1.7.14, key=fileB.pom]
[folder=folderB, version=1.7.12, key=fileB.pom]
[folder=folderB, version=1.7.16, key=fileB.jar]
[folder=folderB, version=1.7.14, key=fileB.jar]

// Missing [folder=folderB, version 1.7.12, key=fileB.jar]

下面是我将列表转换为集合的流。

Set<Info> set = list.stream().map(m -> Info.builder()
            .withFolder(m.getFolderKey())
            .withVersion(m.getVersion())
            .withKey(m.getKey())
            .build()).collect(Collectors.toSet());

我的目标是使用 Set 定位并打印数据中的任何缺失值。特别是版本号。
我想比较作为 fileA-sources.jar、fileA-javadoc.jar 和 fileA.jar 一部分的版本号，以便找到任何缺失的部分。有关缺失条目的注释示例，请参见上面的输出。
我的数据包含七种不同的文件类型，并且有许多与上述两种类似的条目。
我对 Java 很陌生，很可能遗漏了一些非常基本的东西。我意识到我的计划可能完全偏离了，所以任何帮助或正确方向的观点都值得赞赏。谢谢你。

Answer 1

这还没有完全成熟，但它似乎确实有效。
1:从实际条目中收集一组 key
2:从实际条目中收集一组文件夹/版本组合
3:使用收集的 key 和文件夹/版本组合的组合构建一组所需的条目
4:从所需条目中过滤出实际条目

import java.util.Objects;
import java.util.Set;
import java.util.stream.Collectors;
import java.util.stream.Stream;

public class Test {
    Set<FolderEntry> findMissing(Set<FolderEntry> actual) {
        Set<String> keys = actual.stream().map(e -> e.key).collect(Collectors.toSet());

        Set<FolderEntry> folderVersions = actual.stream()
                .map(e -> new FolderEntry(e.folder, e.version, null))
                .collect(Collectors.toSet());

        Set<FolderEntry> missing = folderVersions.stream()
                .flatMap(fv -> {
                    Stream.Builder<FolderEntry> builder = Stream.builder();
                    keys.forEach(key -> builder.accept(new FolderEntry(fv.folder, fv.version, key)));
                    return builder.build();
                })
                .filter(desired -> !actual.contains(desired))
                .collect(Collectors.toSet());
        
        return missing;
    }

    public static void main(String[] args) {
        Set<FolderEntry> folderAEntries = Set.of(
                new FolderEntry("folderA", "3.48.137", "fileA-sources.jar"),
                new FolderEntry("folderA", "3.48.128", "fileA-sources.jar"),
                new FolderEntry("folderA", "3.48.125", "fileA-sources.jar"),
                new FolderEntry("folderA", "3.48.137", "fileA-javadoc.jar"),
                new FolderEntry("folderA", "3.48.128", "fileA-javadoc.jar"),
                new FolderEntry("folderA", "3.48.125", "fileA-javadoc.jar"),
                new FolderEntry("folderA", "3.48.137", "fileA.jar"),
                new FolderEntry("folderA", "3.48.128", "fileA.jar")
                );
        new Test().findMissing(folderAEntries)
                .forEach(System.out::println);

        Set<FolderEntry> folderBEntries = Set.of(
                new FolderEntry("folderB", "1.7.16", "fileB.pom"),
                new FolderEntry("folderB", "1.7.14", "fileB.pom"),
                new FolderEntry("folderB", "1.7.12", "fileB.pom"),
                new FolderEntry("folderB", "1.7.16", "fileB.jar"),
                new FolderEntry("folderB", "1.7.14", "fileB.jar")
                );
        new Test().findMissing(folderBEntries)
                .forEach(System.out::println);
    }

    static class FolderEntry {
        final String folder;
        final String version;
        final String key;

        public FolderEntry(String folder, String version, String key) {
            this.folder = folder;
            this.version = version;
            this.key = key;
        }

        @Override
        public int hashCode() {
            return Objects.hash(folder, key, version);
        }

        @Override
        public boolean equals(Object obj) {
            if (this == obj)
                return true;
            if (obj == null)
                return false;
            if (getClass() != obj.getClass())
                return false;
            FolderEntry other = (FolderEntry) obj;
            return Objects.equals(folder, other.folder) && Objects.equals(key, other.key)
                    && Objects.equals(version, other.version);
        }

        @Override
        public String toString() {
            return "FolderInfo [folder=" + folder + ", version=" + version + ", key=" + key + "]";
        }
    }
}

输出:

FolderInfo [folder=folderA, version=3.48.125, key=fileA.jar]
FolderInfo [folder=folderB, version=1.7.12, key=fileB.jar]

我一开始误解了你的问题，我最初的回答没有帮助。我把它留在这里看历史:
如果您已经有 List<SetObject> ，那么你可以得到一个 Set<SetObject>通过简单地将列表作为参数传递给 Set 实现的构造函数

Set<SetObject> set = new HashSet<>(list);

如果您能进一步解释确定是否缺少某些东西背后的逻辑，我可能会提供进一步的帮助。