कैसे फ्लैट मैप java8 का उपयोग कर मान के लिए चाबियाँ की संख्या के आधार पर हॅश मेम सॉर्ट करने के लिए?



hash lambda (1)

लैम्ब्डा का उपयोग कर एक हैश मैप में मान के लिए चाबी की गणना कैसे करें का यह एक अनुवर्ती है मेरे पास एक HashMap और मैं प्रत्येक मान के लिए चाबियाँ ढूँढ़ना चाहता हूं

Map<Integer, List<Integer>> map = new HashMap<Integer, List<Integer>>() {{
    put(0, Arrays.asList(1, 2));
    put(1, Arrays.asList(2, 0, 3));
    put(2, Arrays.asList(4,0,1));
    put(3, Arrays.asList(4,1, 5));
    put(4, Arrays.asList(5,2,3));
    put(5, Arrays.asList(4,3));
}};

उपरोक्त पोस्ट के अनुसार, मैंने फ्लैट मेपिंग की कोशिश की:

Map<Object, Long> ex = 
                map.values()
                .stream()
                .flatMap(Collection::stream)
                .collect(Collectors.groupingBy(v -> v, Collectors.counting()));

System.out.println(ex);

आउटपुट है

{0=2, 1=3, 2=3, 3=3, 4=3, 5=2}. 

इसका मतलब है कि 0 में दो कुंजियां हैं, 1 की तीन कुंजियां हैं और इसी तरह। अब मैं कुंजियों की गिनती के आधार पर अवरोही क्रम में चाबियाँ और मूल्यों को सॉर्ट करना चाहता हूं। मैंने ऐसा कुछ करने की कोशिश की:

Map<Object, Long> ex = 
                map.values()
                .stream()
                .flatMap(Collection::stream)
                .collect(Collectors.groupingBy(v -> v, Collectors.counting()));

                        .entrySet()
                        .stream()
                        .sorted(Map.Entry.<String, Long>comparingByValue(reverseOrder()).thenComparing(Map.Entry.comparingByKey()))
                        .collect(LinkedHashMap::new, (m,e) -> m.put(e.getKey(), e.getValue()), Map::putAll);

मैं निम्नलिखित आउटपुट चाहता हूं:

1=[2, 3, 0], 2=[1,4,0], 3=[1, 4, 5], 4=[2, 3, 5], 0=[1, 2], 5=[3, 4]

चाबियां और मूल्यों को इस कुंजी के इस गिनती के अनुसार उतरने में व्यवस्थित किया जाना चाहिए {0=2, 1=3, 2=3, 3=3, 4=3, 5=2} : 1, 2, 3, 4 के तीन कुंजियाँ, 0 और 5 में दो कुंजियां हैं

उदाहरण के लिए: 1=[2, 3, 0] : 1 में तीन कुंजियां हैं, इसलिए इसे पहले [2, 3, 0] साथ दिखाई देता है: 2 और 3 में तीन कुंजियां हैं और 0 में केवल दो चाबियाँ हैं


आपके पास निम्न हो सकते हैं:

Map<Integer, List<Integer>> sorted = 
    map.entrySet()
       .stream()
       .sorted(comparing(e -> ex.get(e.getKey()), reverseOrder()))
       .collect(toMap(
           Map.Entry::getKey,
           e -> e.getValue().stream().sorted(comparing(ex::get, reverseOrder())).collect(toList()),
           (v1, v2) -> { throw new IllegalStateException(); },
           LinkedHashMap::new
       ));

यह नक्शे की प्रविष्टियों की एक धारा बनाता है, उन्हें उस प्रविष्टि की कुंजी के लिए चाबी की गिनती के अनुसार रिवर्स ऑर्डर में क्रमबद्ध करता है और आखिरकार वह उस नक्शे में एकत्र करता है जहां नया मान रिवर्स ऑर्डर में प्रत्येक पूर्णांक की गिनती के अनुसार क्रमबद्ध होता है ( ex::get ) मुठभेड़ के आदेश को संरक्षित करने के लिए एकत्रित मानचित्र एक LinkedHashMap है।

आउटपुट:

{1=[2, 3, 0], 2=[4, 1, 0], 3=[4, 1, 5], 4=[2, 3, 5], 0=[1, 2], 5=[4, 3]}

स्थैतिक आयात का उपयोग किया गया:

import static java.util.Comparator.comparing;
import static java.util.Comparator.reverseOrder;
import static java.util.stream.Collectors.toList;
import static java.util.stream.Collectors.toMap;




java-stream