java - मूल्यों से हैश मैप को छंटनी

कोड के नीचे आज़माएं यह मेरे लिए ठीक काम करता है। आप आरोही के साथ-साथ अवरोही क्रम दोनों चुन सकते हैं

``````import java.util.Collections;
import java.util.Comparator;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.Map.Entry;

public class SortMapByValue
{
public static boolean ASC = true;
public static boolean DESC = false;

public static void main(String[] args)
{

// Creating dummy unsorted map
Map<String, Integer> unsortMap = new HashMap<String, Integer>();
unsortMap.put("B", 55);
unsortMap.put("A", 80);
unsortMap.put("D", 20);
unsortMap.put("C", 70);

System.out.println("Before sorting......");
printMap(unsortMap);

System.out.println("After sorting ascending order......");
Map<String, Integer> sortedMapAsc = sortByComparator(unsortMap, ASC);
printMap(sortedMapAsc);

System.out.println("After sorting descindeng order......");
Map<String, Integer> sortedMapDesc = sortByComparator(unsortMap, DESC);
printMap(sortedMapDesc);

}

private static Map<String, Integer> sortByComparator(Map<String, Integer> unsortMap, final boolean order)
{

List<Entry<String, Integer>> list = new LinkedList<Entry<String, Integer>>(unsortMap.entrySet());

// Sorting the list based on values
Collections.sort(list, new Comparator<Entry<String, Integer>>()
{
public int compare(Entry<String, Integer> o1,
Entry<String, Integer> o2)
{
if (order)
{
return o1.getValue().compareTo(o2.getValue());
}
else
{
return o2.getValue().compareTo(o1.getValue());

}
}
});

// Maintaining insertion order with the help of LinkedList
Map<String, Integer> sortedMap = new LinkedHashMap<String, Integer>();
for (Entry<String, Integer> entry : list)
{
sortedMap.put(entry.getKey(), entry.getValue());
}

return sortedMap;
}

public static void printMap(Map<String, Integer> map)
{
for (Entry<String, Integer> entry : map.entrySet())
{
System.out.println("Key : " + entry.getKey() + " Value : "+ entry.getValue());
}
}
}
``````
java sorting hashmap

इस प्रश्न का उत्तर यहां दिया गया है:

मुझे अपने `HashMap` को उसमें संग्रहीत मूल्यों के अनुसार सॉर्ट करना होगा। `HashMap` में फोन में संग्रहीत संपर्क नाम शामिल हैं।

साथ ही मुझे यह भी चाहिए कि जैसे ही मैं मानों को क्रमबद्ध करता हूं, कुंजियां स्वचालित रूप से क्रमबद्ध हो जाती हैं, या आप कह सकते हैं कि चाबियाँ और मान एक साथ बंधे हैं, इस प्रकार मानों में कोई भी परिवर्तन कुंजी में दिखाई दे सकता है।

``````HashMap<Integer,String> map = new HashMap<Integer,String>();
map.put(1,"froyo");
map.put(2,"abby");
map.put(3,"denver");
map.put(4,"frost");
map.put(5,"daisy");
``````

आवश्यक आउटपुट:

``````2,abby;
5,daisy;
3,denver;
4,frost;
1,froyo;
``````

आप मूल रूप से नहीं करते हैं। एक `HashMap` मौलिक रूप से अनियंत्रित है। आदेश में आप जो भी पैटर्न देख सकते हैं उस पर भरोसा नहीं किया जाना चाहिए।

`TreeMap` मानचित्र जैसे `TreeMap` किए गए मानचित्र हैं, लेकिन वे परंपरागत रूप से मूल्य के बजाय कुंजी द्वारा सॉर्ट करते हैं। मूल्य से क्रमबद्ध करना अपेक्षाकृत असामान्य है - विशेष रूप से एकाधिक कुंजी के समान मूल्य हो सकता है।

क्या आप जो भी करने की कोशिश कर रहे हैं उसके लिए आप अधिक संदर्भ दे सकते हैं? यदि आप वाकई केवल चाबियों के लिए संख्याओं (तारों के रूप में) संग्रहीत कर रहे हैं, तो संभवतः एक `SortedSet` जैसे `SortedSet` आपके लिए काम करेगा?

वैकल्पिक रूप से, आप एक ही कक्षा में एक ही समय में अद्यतन करने के लिए दो अलग-अलग संग्रहों को संग्रहीत कर सकते हैं?

``````map.entrySet().stream()
.sorted((k1, k2) -> -k1.getValue().compareTo(k2.getValue()))
.forEach(k -> System.out.println(k.getKey() + ": " + k.getValue()));
``````

मैं एक वृक्षारोपण बढ़ाता हूं और एंट्रीसेट () और मान () विधियों को ओवरराइड करता हूं। कुंजी और मूल्य तुलनात्मक होने की आवश्यकता है।

कोड का पालन करें:

``````public class ValueSortedMap<K extends Comparable, V extends Comparable> extends TreeMap<K, V> {

@Override
public Set<Entry<K, V>> entrySet() {
Set<Entry<K, V>> originalEntries = super.entrySet();
Set<Entry<K, V>> sortedEntry = new TreeSet<Entry<K, V>>(new Comparator<Entry<K, V>>() {
@Override
public int compare(Entry<K, V> entryA, Entry<K, V> entryB) {
int compareTo = entryA.getValue().compareTo(entryB.getValue());
if(compareTo == 0) {
compareTo = entryA.getKey().compareTo(entryB.getKey());
}
return compareTo;
}
});
return sortedEntry;
}

@Override
public Collection<V> values() {
Set<V> sortedValues = new TreeSet<>(new Comparator<V>(){
@Override
public int compare(V vA, V vB) {
return vA.compareTo(vB);
}
});
return sortedValues;
}
}
``````

यूनिट टेस्ट:

``````public class ValueSortedMapTest {

@Test
public void basicTest() {
Map<String, Integer> sortedMap = new ValueSortedMap<>();
sortedMap.put("A",3);
sortedMap.put("B",1);
sortedMap.put("C",2);

Assert.assertEquals("{B=1, C=2, A=3}", sortedMap.toString());
}

@Test
public void repeatedValues() {
Map<String, Double> sortedMap = new ValueSortedMap<>();
sortedMap.put("D",67.3);
sortedMap.put("A",99.5);
sortedMap.put("B",67.4);
sortedMap.put("C",67.4);

Assert.assertEquals("{D=67.3, B=67.4, C=67.4, A=99.5}", sortedMap.toString());
}

}
``````

``````package SortedSet;

import java.util.*;

public class HashMapValueSort {
public static void main(String[] args){
final Map<Integer, String> map = new HashMap<Integer,String>();
map.put(4,"Mango");
map.put(3,"Apple");
map.put(5,"Orange");
map.put(8,"Fruits");
map.put(23,"Vegetables");
map.put(1,"Zebra");
map.put(5,"Yellow");
System.out.println(map);
final HashMapValueSort sort = new HashMapValueSort();
final Set<Map.Entry<Integer, String>> entry = map.entrySet();
final Comparator<Map.Entry<Integer, String>> comparator = new Comparator<Map.Entry<Integer, String>>() {
@Override
public int compare(Map.Entry<Integer, String> o1, Map.Entry<Integer, String> o2) {
String value1 = o1.getValue();
String value2 = o2.getValue();
return value1.compareTo(value2);
}
};
final SortedSet<Map.Entry<Integer, String>> sortedSet = new TreeSet(comparator);
final Map<Integer,String> sortedMap =  new LinkedHashMap<Integer, String>();
for(Map.Entry<Integer, String> entry1 : sortedSet ){
sortedMap.put(entry1.getKey(),entry1.getValue());
}
System.out.println(sortedMap);
}
}
``````

``````import java.util.ArrayList;
import java.util.Collections;
import java.util.HashMap;
import java.util.List;
import java.util.Map.Entry;

public class CollectionsSort {

/**
* @param args
*/`enter code here`
public static void main(String[] args) {
// TODO Auto-generated method stub

CollectionsSort colleciotns = new CollectionsSort();

List<combine> list = new ArrayList<combine>();
HashMap<String, Integer> h = new HashMap<String, Integer>();
h.put("nayanana", 10);
h.put("lohith", 5);

for (Entry<String, Integer> value : h.entrySet()) {
combine a = colleciotns.new combine(value.getValue(),
value.getKey());
}

Collections.sort(list);
for (int i = 0; i < list.size(); i++) {
System.out.println(list.get(i));
}
}

public class combine implements Comparable<combine> {

public int value;
public String key;

public combine(int value, String key) {
this.value = value;
this.key = key;
}

@Override
public int compareTo(combine arg0) {
// TODO Auto-generated method stub
return this.value > arg0.value ? 1 : this.value < arg0.value ? -1
: 0;
}

public String toString() {
return this.value + " " + this.key;
}
}

}
``````

Tags

java   sorting   hashmap