नेस्टेड ग्रुपबी का उपयोग करके जावा 8 में मल्टी-लेवल ग्रुपिंग

यह लेख बताता है कि नेस्टेड क्लासेस से निपटते समय मल्टी-लेवल ग्रुपिंग को कैसे लागू किया जाए जावा 8. विशेष रूप से, लक्ष्य आइटमों को key1 फ़ील्ड द्वारा समूहित करना है और फिर, आइटमों के प्रत्येक समूह के लिए, उन्हें key2 फ़ील्ड द्वारा समूहित करना है। अंततः, आउटपुट बाहरी कुंजी के रूप में key1 के साथ एक मानचित्र होना चाहिए और उप-आइटम की सूची में key2 का एक मानचित्र होना चाहिए।

प्रारंभिक दृष्टिकोण इसे प्राप्त करने के लिए Collecters.groupingBy विधि का उपयोग करने का प्रयास करता है, हालांकि, यह है किसी एक आइटम को सीधे एकाधिक कुंजियों द्वारा समूहित करना संभव नहीं है। इसे दूर करने के लिए, एक फ़्लैटमैप ऑपरेशन का उपयोग किया जाता है।

एक विधि में संग्रह करने से पहले वस्तुओं और उप-आइटमों के संयोजन को पकड़ने के लिए Map.entrySet का उपयोग करके एक अस्थायी जोड़ी बनाना शामिल है। जावा 9 में उपलब्ध अन्य दृष्टिकोण, फ्लैटमैपिंग कलेक्टर का लाभ उठाता है, जो सीधे कलेक्टर में फ्लैटमैप ऑपरेशन करने में सक्षम बनाता है।

यहां फ्लैटमैप समाधान है:

Map>> result = pojo.getItems().stream()
    .flatMap(item -> item.getSubItems().stream()
        .map(sub -> new AbstractMap.SimpleImmutableEntry(item.getKey1(), sub)))
    .collect(Collectors.groupingBy(AbstractMap.SimpleImmutableEntry::getKey,
                Collectors.mapping(Map.Entry::getValue,
                    Collectors.groupingBy(SubItem::getKey2))));

जावा 8 में कस्टम कलेक्टर का उपयोग करने वाला एक विकल्प:

static  Collector flatMapping(
    Function super T,? extends Stream extends U>> mapper,
    Collector super U,A,R> downstream) {

    BiConsumer acc = downstream.accumulator();
    return Collector.of(downstream.supplier(),
        (a, t) -> { try(Stream extends U> s=mapper.apply(t)) {
            if(s!=null) s.forEachOrdered(u -> acc.accept(a, u));
        }},
        downstream.combiner(), downstream.finisher(),
        downstream.characteristics().toArray(new Collector.Characteristics[0]));
}

इस कस्टम कलेक्टर का उपयोग निम्नानुसार किया जा सकता है:

Map>> result = pojo.getItems().stream()
    .collect(Collectors.groupingBy(Item::getKey1,
                Collectors.flatMapping(item -> item.getSubItems().stream(),
                    Collectors.groupingBy(SubItem::getKey2))));