java इश्क - मूल्यों द्वारा क्रमबद्ध कुंजी की सूची में जावा 8 स्ट्रीम मानचित्र




सीरियल मरजावा (6)

मेरे पास Map<Type, Long> countByType और मैं एक सूची चाहता हूं जो क्रमबद्ध (न्यूनतम से अधिकतम) कुंजी को उनके संबंधित मानों से क्रमबद्ध कर दे। मेरी कोशिश है:

countByType.entrySet().stream().sorted().collect(Collectors.toList());

हालांकि यह सिर्फ मुझे प्रविष्टियों की एक सूची देता है, आदेश को खोए बिना, मैं प्रकार की सूची कैसे प्राप्त कर सकता हूं?


Answers

आप कहते हैं कि आप मूल्य से क्रमबद्ध करना चाहते हैं, लेकिन आपके पास यह कोड नहीं है। एक लैम्ब्डा (या विधि संदर्भ) पास करें ताकि यह बताने के लिए कि आप कैसे सॉर्ट करना चाहते हैं।

और आप चाबियाँ प्राप्त करना चाहते हैं; प्रविष्टियों को कुंजी में बदलने के लिए map का उपयोग map

List<Type> types = countByType.entrySet().stream()
        .sorted(Comparator.comparing(Map.Entry::getValue))
        .map(Map.Entry::getKey)
        .collect(Collectors.toList());

StreamEx साथ सरल समाधान यहां दिया गया है

EntryStream.of(countByType).sortedBy(e -> e.getValue()).keys().toList();

आपको प्रविष्टि के मूल्य के आधार पर एक कस्टम तुलनित्र के साथ सॉर्ट करना होगा। फिर एकत्र करने से पहले सभी चाबियाँ चुनें

countByType.entrySet()
           .stream()
           .sorted((e1, e2) -> e1.getValue().compareTo(e2.getValue())) // custom Comparator
           .map(e -> e.getKey())
           .collect(Collectors.toList());

आप नीचे दिए गए मान के आधार पर मानचित्र को सॉर्ट कर सकते हैं, here अधिक उदाहरण

//Sort a Map by their Value.
Map<Integer, String> random = new HashMap<Integer, String>();

random.put(1,"z");
random.put(6,"k");
random.put(5,"a");
random.put(3,"f");
random.put(9,"c");

Map<Integer, String> sortedMap =
        random.entrySet().stream()
                .sorted(Map.Entry.comparingByValue())
                .collect(Collectors.toMap(Map.Entry::getKey, Map.Entry::getValue,
                        (e1, e2) -> e2, LinkedHashMap::new));
System.out.println("Sorted Map: " + Arrays.toString(sortedMap.entrySet().toArray()));

आप इसे अपनी समस्या का एक उदाहरण के रूप में उपयोग कर सकते हैं

    Map<Integer, String> map = new HashMap<>();
    map.put(10, "apple");
    map.put(20, "orange");
    map.put(30, "banana");
    map.put(40, "watermelon");
    map.put(50, "dragonfruit");

    // split a map into 2 List
    List<Integer> resultSortedKey = new ArrayList<>();
    List<String> resultValues = map.entrySet().stream()
            //sort a Map by key and stored in resultSortedKey
            .sorted(Map.Entry.<Integer, String>comparingByKey().reversed())
            .peek(e -> resultSortedKey.add(e.getKey()))
            .map(x -> x.getValue())
            // filter banana and return it to resultValues
            .filter(x -> !"banana".equalsIgnoreCase(x))
            .collect(Collectors.toList());

    resultSortedKey.forEach(System.out::println);
    resultValues.forEach(System.out::println);

public static class SmartHashMap <T1 extends Object, T2 extends Object> {
    public HashMap<T1, T2> keyValue;
    public HashMap<T2, T1> valueKey;

    public SmartHashMap(){
        this.keyValue = new HashMap<T1, T2>();
        this.valueKey = new HashMap<T2, T1>();
    }

    public void add(T1 key, T2 value){
        this.keyValue.put(key, value);
        this.valueKey.put(value, key);
    }

    public T2 getValue(T1 key){
        return this.keyValue.get(key);
    }

    public T1 getKey(T2 value){
        return this.valueKey.get(value);
    }

}




java collections lambda java-8 java-stream