LinkedHashMap Sortierung

Question

Ich versuche, LinkedHashMap basierend auf seinen Werten zu sortieren. Was ich nicht verstehe, sind die Ergebnisse. Es scheint nur zwei Schlüssel für die Sortierung zu nehmen. Irgendwelche Hinweise darauf, was ich vermisse?

public class test { 

    public static void main(String[] args) { 
     // TODO Auto-generated method stub 


     LinkedHashMap<Integer, Integer> sorting = new LinkedHashMap<Integer, Integer>(); 
     sorting.put(1, 100); 
     sorting.put(10, 100); 
     sorting.put(20, 200); 
     sorting.put(30, 100); 
     sorting.put(40, 100); 
     sorting.put(50, 200); 

     for (Entry<Integer, Integer> entry : sorting.entrySet()) { 
      Integer key = entry.getKey(); 
      Integer value = entry.getValue(); 
      System.out.println("LINKED UNSORTED === key: "+ key + '\t' + "Value: " + value); 
       // do stuff 
      } 


     Comparator<Integer> comparator = new ValueCom(sorting); 
     TreeMap<Integer, Integer> sortedMap =new TreeMap<Integer, Integer>(comparator); 
     sortedMap.putAll(sorting);  


     for (Entry<Integer, Integer> entry : sortedMap.entrySet()) { 
      Integer key = entry.getKey(); 
      Integer value = entry.getValue(); 
      System.out.println("SORTED === key: "+ key + '\t' + "Value: " + value); 
       // do stuff 
      } 

    } 

} 


class ValueCom implements Comparator<Integer> { 
    LinkedHashMap<Integer, Integer> map = new LinkedHashMap<Integer, Integer>(); 

public ValueCom(HashMap<Integer, Integer> map) { 
     this.map.putAll(map); 
    } 

public int compare(Integer keyA, Integer keyB){ 

    return map.get(keyB).compareTo(map.get(keyA)); 
} 

} 

Der Stromausgang wird über

LINKED UNSORTED === key: 1 Value: 100 
LINKED UNSORTED === key: 10 Value: 100 
LINKED UNSORTED === key: 20 Value: 200 
LINKED UNSORTED === key: 30 Value: 100 
LINKED UNSORTED === key: 40 Value: 100 
LINKED UNSORTED === key: 50 Value: 200 
SORTED === key: 20 Value: 200 
SORTED === key: 1 Value: 100 

Answer 1

In TreeMap die Einzigartigkeit von Tasten wie erläutert durch die übergebene Comparator bestimmt wird. Da Ihre Comparator Werte der ursprünglichen Map vergleicht, werden alle Einträge mit dem gleichen Wert von der TreeMap mit demselben Schlüssel berücksichtigt, so dass nur einen Eintrag zu TreeMap für jeden eindeutigen Wert hinzugefügt wird.

Wenn Sie eine Map von Werten sortiert werden sollen, können Sie eine LinkedHashMap für Ihre sortiert verwenden Map, und stellen Sie sicher, dass Sie die Einträge in der Map in der gewünschten Reihenfolge bringen.

Answer 2

Das Problem ist, dass Sie auf der Grundlage von Werten sortieren, und wenn zwei Werte gleich sind, dann wird die TreeMap nur einen einzigen Eintrag für diesen Schlüssel machen, Sie können besser verstehen, indem Sie unter Code sehen. Im Folgenden Code wird das Problem lösen, lassen Sie mich wissen, wenn etwas fehlschlägt:

Ändern compare() Methode in ValueCom Klasse wie folgt:

public int compare(Integer i1, Integer i2) { 
     if(map.get(i1).equals(map.get(i2))){ 
      return 1; //To make sure, If values are equal then still there should be entry in TreeMap 
     } 
     return map.get(i1).compareTo(map.get(i2)); 
    } 

Nun wird die gleichen Werte auch hier behandelt. :)

Answer 3

Der folgende Code geben Sie, was Sie wollen

public class test { 

public static void main(String[] args) { 
    // TODO Auto-generated method stub 


    LinkedHashMap<Integer, Integer> sorting = new LinkedHashMap<Integer, Integer>(); 
    sorting.put(10, 100); 
    sorting.put(1, 100); 
    sorting.put(20, 200); 
    sorting.put(40, 100); 
    sorting.put(30, 100); 
    sorting.put(50, 200); 

    for (Entry<Integer, Integer> entry : sorting.entrySet()) { 
     Integer key = entry.getKey(); 
     Integer value = entry.getValue(); 
     System.out.println("LINKED UNSORTED === key: "+ key + '\t' + "Value: " + value); 
      // do stuff 
     } 


    Comparator<Integer> comparator = new ValueCom(); 
    TreeMap<Integer, Integer> sortedMap =new TreeMap<Integer, Integer>(comparator); 
    sortedMap.putAll(sorting);  


    for (Entry<Integer, Integer> entry : sortedMap.entrySet()) { 
     Integer key = entry.getKey(); 
     Integer value = entry.getValue(); 
     System.out.println("SORTED === key: "+ key + '\t' + "Value: " + value); 
      // do stuff 
     } 

} 

} 


class ValueCom implements Comparator<Integer> { 
public int compare(Integer keyA, Integer keyB){ 

return keyA.compareTo(keyB); 
} 

}