JAVA8 - 用lambda分組

Question

我有一個像這樣結構的集合：

@Entity
public class RRR{

    private Map<XClas, YClas> xySets;

}

和XClas有一個名為ZZZ的領域

我的問題是：我想將它與lambda聚合得到一個Map<ZZZ, List<RRR>> 。

可能嗎？ 現在我堅持：

Map xxx = rrrList.stream().collect(
                Collectors.groupingBy(x->x.xySets().entrySet().stream().collect(
                        Collectors.groupingBy(y->y.getKey().getZZZ()))));

但它是Map<Map<ZZZ, List<XClas>>, List<RRR>>所以它不是我想要的:)

現在只是為了讓它工作，我用兩個嵌套循環進行聚合，但如果你可以幫我用lambdas完成它，那就太棒了。

編輯

據我所知，我發布了現在的內容。 我已經離開了嵌套循環，並且我設法工作到這一點：

Map<ZZZ, List<RRR>> temp;
rrrList.stream().forEach(x -> x.getxySetsAsList().stream().forEach(z -> {
            if (temp.containsKey(z.getKey().getZZZ())){
                List<RRR> uuu = new LinkedList<>(temp.get(z.getKey().getZZZ()));
                uuu.add(x);
                temp.put(z.getKey().getZZZ(), uuu);
            } else {
                temp.put(z.getKey().getZZZ(), Collections.singletonList(x));
            }
        }));

提前致謝

Answer 1

那樣的東西？ ：

    Map<ZZZ, List<RRR>> map = new HashMap<>();

    list.stream().forEach(rrr -> {
        rrr.xySets.keySet().stream().forEach(xclas -> {
            if (!map.containsKey(xclas.zzz))
                map.put(xclas.zzz, new ArrayList<RRR>());
            map.get(xclas.zzz).add(rrr);
        });
    });

Answer 2

另一種方法可以做到這一點：

Map<Z, List<R>> map = rs.stream()
        .map(r -> r.xys.keySet()
            .stream()
            .collect(Collectors.<X, Z, R>toMap(x -> x.z, x -> r, (a, b) -> a)))
        .map(Map::entrySet)
        .flatMap(Collection::stream)
        .collect(Collectors.groupingBy(Entry::getKey,
                Collectors.mapping(Entry::getValue, Collectors.toList())));

Answer 3

我嘗試了一下，找到了以下解決方案，將其發布在這里作為另一個例子：

rrrList.stream().map(x -> x.xySets).map(Map::entrySet).flatMap(x -> x.stream())
    .collect(Collectors.groupingBy(x -> x.getKey().getZZZ(), 
        Collectors.mapping(Entry::getValue, Collectors.toList())));

第一行也可以寫成rrrList.stream().flatMap(x -> x.xySets.entrySet().stream()) ，它們可能更易讀。 這是一個自包含的示例代碼，適合那些想要自己玩耍的人：

public static void main(String[] args) {
    List<RRR> rrrList = Arrays.asList(new RRR(), new RRR(), new RRR());
    System.out.println(rrrList);
    Stream<Entry<XClas, YClas>> sf = rrrList.stream().map(x -> x.xySets).map(Map::entrySet).flatMap(x -> x.stream());
    Map<ZZZ, List<YClas>> res = sf.collect(Collectors.groupingBy(x -> x.getKey().getZZZ(), Collectors.mapping(Entry::getValue, Collectors.toList())));
    System.out.println(res);
}

public static class RRR {
    static XClas shared = new XClas();
    private Map<XClas, YClas> xySets = new HashMap<>();
    RRR() { xySets.put(shared, new YClas()); xySets.put(new XClas(), new YClas()); }
    static int s = 0; int n = s++; 
    public String toString() { return "RRR" + n + "(" + xySets + ")"; }
}
public static class XClas {
    private ZZZ zzz = new ZZZ();
    public ZZZ getZZZ() { return zzz; }
    public String toString() { return "XClas(" + zzz + ")"; } 
    public boolean equals(Object o) { return (o instanceof XClas) && ((XClas)o).zzz.equals(zzz); }
    public int hashCode() { return zzz.hashCode(); }
}
public static class YClas {
    static int s = 0; int n = s++; 
    public String toString() { return "YClas" + n; }
}
public static class ZZZ { 
    static int s = 0; int n = s++ / 2;
    public String toString() { return "ZZZ" + n; }
    public boolean equals(Object o) { return (o instanceof ZZZ) && ((ZZZ)o).n == n; }
    public int hashCode() { return n; }
}