it-swarm.com.de

So sortieren Sie eine HashMap in Java

Wie können wir einen HashMap<key, ArrayList> sortieren?

Ich möchte nach einem Wert in der ArrayList sortieren.

101
rosh

Müssen Sie eine HashMap verwenden? Wenn Sie nur die Kartenoberfläche benötigen, verwenden Sie eine TreeMap


Wenn Sie sortieren möchten, indem Sie Werte in der HashMap vergleichen. Sie müssen dazu Code schreiben, wenn Sie dies tun möchten, sobald Sie die Werte Ihrer HashMap sortieren können:

Map<String, Person> people = new HashMap<>();
Person jim = new Person("Jim", 25);
Person scott = new Person("Scott", 28);
Person anna = new Person("Anna", 23);

people.put(jim.getName(), jim);
people.put(scott.getName(), scott);
people.put(anna.getName(), anna);

// not yet sorted
List<Person> peopleByAge = new ArrayList<>(people.values());

Collections.sort(peopleByAge, Comparator.comparing(Person::getAge));

for (Person p : peopleByAge) {
    System.out.println(p.getName() + "\t" + p.getAge());
}

Wenn Sie häufig auf diese sortierte Liste zugreifen möchten, können Sie Ihre Elemente in einen HashMap<TreeSet<Person>> einfügen, obwohl die Semantik von Mengen und Listen etwas unterschiedlich ist.

125
pgras

Sortierte Liste nach Hashtasten:

SortedSet<String> keys = new TreeSet<String>(myHashMap.keySet());

Sortierte Liste nach Hashmap-Werten:

SortedSet<String> values = new TreeSet<String>(myHashMap.values());

Bei doppelten Kartenwerten:

List<String> mapValues = new ArrayList<String>(myHashMap.values());
Collections.sort(mapValues);

Viel Glück!

34
gokhansari

http://snipplr.com/view/2789/sorting-map-keys-by-comparing-its-values/

holen Sie sich die Schlüssel

List keys = new ArrayList(yourMap.keySet());

Sortiere sie

 Collections.sort(keys)

drucke sie aus.

In jedem Fall können Sie keine Werte in HashMap sortiert haben (gemäß API This class makes no guarantees as to the order of the map; in particular, it does not guarantee that the order will remain constant over time]. 

Sie können alle diese Werte auch zur späteren Verwendung in LinkedHashMap verschieben.

23
Rakesh Juyal

Anscheinend möchten Sie vielleicht eine Treemap.

http://docs.Oracle.com/javase/7/docs/api/Java/util/TreeMap.html

In diesem Fall können Sie einen benutzerdefinierten Vergleicher übergeben.

13
JH.

In Java 8:

Comparator<Entry<String, Item>> valueComparator = 
    (e1, e2) -> e1.getValue().getField().compareTo(e2.getValue().getField());

Map<String, Item> sortedMap = 
    unsortedMap.entrySet().stream().
    sorted(valueComparator).
    collect(Collectors.toMap(Entry::getKey, Entry::getValue,
                             (e1, e2) -> e1, LinkedHashMap::new));

Verwenden von Guave :

Map<String, Item> map = ...;
Function<Item, Integer> getField = new Function<Item, Integer>() {
    public Integer apply(Item item) {
        return item.getField(); // the field to sort on
    }
};
comparatorFunction = Functions.compose(getField, Functions.forMap(map));
comparator = Ordering.natural().onResultOf(comparatorFunction);
Map<String, Item> sortedMap = ImmutableSortedMap.copyOf(map, comparator);
10

Benutzerdefinierte Vergleichsfunktion die Funktionalität für das türkische Alphabet oder andere Sprachen als Englisch enthält. 

public <K extends Comparable,V extends Comparable> LinkedHashMap<K,V> sortByKeys(LinkedHashMap<K,V> map){
    List<K> keys = new LinkedList<K>(map.keySet());
    Collections.sort(keys, (Comparator<? super K>) new Comparator<String>() {
        @Override
        public int compare(String first, String second) {
            Collator collator = Collator.getInstance(Locale.getDefault());
            //Collator collator = Collator.getInstance(new Locale("tr", "TR"));
            return collator.compare(first, second);
        }
    });

    LinkedHashMap<K,V> sortedMap = new LinkedHashMap<K,V>();
    for(K key: keys){
        sortedMap.put(key, map.get(key));
    }

    return sortedMap;
}

hier ist das Anwendungsbeispiel wie folgt

LinkedHashMap<String, Boolean> ligList = new LinkedHashMap<String, Boolean>();
ligList = sortByKeys(ligList);
9
Mustafa Güven

Ohne weitere Informationen ist es schwierig, genau zu wissen, was Sie wollen. Bei der Auswahl der zu verwendenden Datenstruktur müssen Sie jedoch berücksichtigen, wofür Sie sie benötigen. Hashmaps sind nicht zum Sortieren gedacht - sie sind so konzipiert, dass sie leicht abgerufen werden können. In Ihrem Fall müssten Sie also wahrscheinlich jedes Element aus der Hash-Map extrahieren und in eine für das Sortieren günstigere Datenstruktur (z. B. einen Heap oder Satz) einfügen und diese dort sortieren.

4
Smashery

Wenn Sie eine Map für einen effizienten Abruf mit einer SortedMap kombinieren möchten, können Sie die ConcurrentSkipListMap verwenden.

Natürlich muss der Schlüssel der zum Sortieren verwendete Wert sein.

3

haben Sie überlegt, eine LinkedHashMap <> () zu verwenden?

  public static void main(String[] args) {
    Map<Object, Object> handler = new LinkedHashMap<Object, Object>();
    handler.put("item", "Value");
    handler.put(2, "Movies");
    handler.put("isAlive", true);

    for (Map.Entry<Object, Object> entrY : handler.entrySet())
        System.out.println(entrY.getKey() + ">>" + entrY.getValue());

    List<Map.Entry<String, Integer>> entries = new ArrayList<Map.Entry<String, Integer>>();
    Collections.sort(entries, new Comparator<Map.Entry<String, Integer>>() {
        public int compare(Map.Entry<String, Integer> a,
                Map.Entry<String, Integer> b) {
            return a.getValue().compareTo(b.getValue());
        }
    });
}

führt zu einem organisierten verknüpften Objekt.

 item>>Value
 2>>Movies
 isAlive>>true

Überprüfen Sie das ausgewählte Sortierteil aus hier ..

2
Olu Smith

HashMap nach Wert sortieren:

Wie andere darauf hingewiesen haben. HashMaps dienen der einfachen Suche, wenn Sie dies ändern oder versuchen, innerhalb der Karte selbst zu sortieren, und Sie müssen nicht mehr nach O(1) suchen.

Der Code für Ihre Sortierung lautet wie folgt:

class Obj implements Comparable<Obj>{
    String key;
    ArrayList<Integer> val;
    Obj(String key, ArrayList<Integer> val)
    {
    this.key=key;
    this.val=val;
    }
    public int compareTo(Obj o)
    {
     /* Write your sorting logic here. 
     this.val compared to o.val*/
     return 0;
    }
}

public void sortByValue(Map<String, ArrayList<>> mp){

    ArrayList<Obj> arr=new ArrayList<Obj>();
    for(String z:mp.keySet())//Make an object and store your map into the arrayList
    {

        Obj o=new Obj(z,mp.get(z));
        arr.add(o);
    }
    System.out.println(arr);//Unsorted
    Collections.sort(arr);// This sorts based on the conditions you coded in the compareTo function.
    System.out.println(arr);//Sorted
}
2
Anuj Mehta

Ich habe eine Klasse entwickelt, mit der eine Karte anhand von Schlüsseln und Werten sortiert werden kann. Wenn Sie eine Karte mit Schlüsseln sortieren, erstellen Sie eine TreepMap aus Ihrer Karte, die die Karte nach Schlüsseln sortiert. Wenn Sie nach Werten sortieren, erstellen Sie eine Liste aus entrySet und sortieren Sie die Liste mithilfe der Vergleichsschnittstelle.

Hier ist die vollständige Lösung:

public static void main(String[] args) {
    Map<String, Integer> unSortedMap = new LinkedHashMap<String, Integer>();
    unSortedMap.put("A", 2);
    unSortedMap.put("V", 1);
    unSortedMap.put("G", 5);
    System.out.println("Unsorted Map :\n");
    for (Map.Entry<String, Integer> entry : unSortedMap.entrySet()) {
        System.out.println(entry.getKey() + "   " + entry.getValue());
    }
    System.out.println("\n");
    System.out.println("Sorting Map Based on Keys :\n");
    Map<String, Integer> keySortedMap = new TreeMap<String, Integer>(unSortedMap);
    for (Map.Entry<String, Integer> entry : keySortedMap.entrySet()) {
        System.out.println(entry.getKey() + "   " + entry.getValue());
    }
    System.out.println("\n");
    System.out.println("Sorting Map Based on Values :\n");
    List<Entry<String, Integer>> entryList = new ArrayList<Entry<String, Integer>>(unSortedMap.entrySet());
    Collections.sort(entryList, new Comparator<Entry<String, Integer>>() {

        @Override
        public int compare(Entry<String, Integer> obj1, Entry<String, Integer> obj2) {
            return obj1.getValue().compareTo(obj2.getValue());
        }
    });
    unSortedMap.clear();
    for (Entry<String, Integer> entry : entryList) {
        unSortedMap.put(entry.getKey(), entry.getValue());
        System.out.println(entry.getKey() + "   " + entry.getValue());
    }
}

Code wurde ordnungsgemäß getestet: D

2
Ayush Jayaswal

Eine richtige Antwort.

HashMap<Integer, Object> map = new HashMap<Integer, Object>();

ArrayList<Integer> sortedKeys = new ArrayList<Integer>(map.keySet());
Collections.sort(sortedKeys, new Comparator<Integer>() {
  @Override
  public int compare(Integer a, Integer b) {
    return a.compareTo(b);
  }
});

for (Integer key: sortedKeys) {
  //map.get(key);
}

Beachten Sie, dass HashMap selbst die Sortierung nicht beibehalten kann, wie andere Antworten gezeigt haben. Es ist eine Hash - Map, und Hash-Werte sind unsortiert. Sie können also entweder die Schlüssel nach Bedarf sortieren und dann auf die Werte zugreifen, wie oben gezeigt, oder Sie können eine andere Sammlung zum Speichern Ihrer Daten finden, beispielsweise eine ArrayList aus Paaren/Tupeln, wie z Apache Commons:

https://commons.Apache.org/proper/commons-lang/apidocs/org/Apache/commons/lang3/Tuple/Pair.html

1
Andrew

Sortierung nach Schlüssel:

public static void main(String[] args) {
    Map<String,String> map = new HashMap<>();

    map.put("b", "dd");
    map.put("c", "cc");
    map.put("a", "aa");

    map = new TreeMap<>(map);

    for (String key : map.keySet()) {
        System.out.println(key+"="+map.get(key));
    }
}
1
ssoo

HashMap behält keine Reihenfolge bei. Wenn Sie also irgendeine Art von Reihenfolge wünschen, müssen Sie diese in etwas anderem speichern, was eine Karte ist und eine Art von Reihenfolge haben kann, wie LinkedHashMap

im Folgenden finden Sie ein einfaches Programm, mit dem Sie nach Schlüssel, Wert, Aufsteigend, Absteigend sortieren können.

package com.Edge.collection.map;

import Java.util.Collections;
import Java.util.Comparator;
import Java.util.HashMap;
import Java.util.LinkedHashMap;
import Java.util.LinkedList;
import Java.util.List;
import Java.util.Map;
import Java.util.Map.Entry;

public class SortMapByKeyValue {
Map<String, Integer> map = new HashMap<String, Integer>();

public static void main(String[] args) {

    SortMapByKeyValue smkv = new SortMapByKeyValue();
    smkv.createMap();

    System.out.println("After sorting by key ascending order......");
    smkv.sortByKey(true);

    System.out.println("After sorting by key descindeng order......");
    smkv.sortByKey(false);

    System.out.println("After sorting by value ascending order......");
    smkv.sortByValue(true);

    System.out.println("After sorting by value  descindeng order......");
    smkv.sortByValue(false);

}

void createMap() {
    map.put("B", 55);
    map.put("A", 80);
    map.put("D", 20);
    map.put("C", 70);
    map.put("AC", 70);
    map.put("BC", 70);
    System.out.println("Before sorting......");
    printMap(map);
}

void sortByValue(boolean order) {

    List<Entry<String, Integer>> list = new LinkedList<Entry<String, Integer>>(map.entrySet());
    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());

            }
        }
    });
    Map<String, Integer> sortedMap = new LinkedHashMap<String, Integer>();
    for (Entry<String, Integer> entry : list) {
        sortedMap.put(entry.getKey(), entry.getValue());
    }
    printMap(sortedMap);

}

void sortByKey(boolean order) {

    List<Entry<String, Integer>> list = new LinkedList<Entry<String, Integer>>(map.entrySet());
    Collections.sort(list, new Comparator<Entry<String, Integer>>() {
        public int compare(Entry<String, Integer> o1, Entry<String, Integer> o2) {
            if (order) {
                return o1.getKey().compareTo(o2.getKey());
            } else {
                return o2.getKey().compareTo(o1.getKey());

            }
        }
    });
    Map<String, Integer> sortedMap = new LinkedHashMap<String, Integer>();
    for (Entry<String, Integer> entry : list) {
        sortedMap.put(entry.getKey(), entry.getValue());
    }
    printMap(sortedMap);
}

public void printMap(Map<String, Integer> map) {
    // System.out.println(map);
    for (Entry<String, Integer> entry : map.entrySet()) {
        System.out.println(entry.getKey() + " : " + entry.getValue());
    }
}
}

hier ist der git link

0
user3123372

Ich habe eine vollständig getestete Arbeitslösung entwickelt. Ich hoffe es hilft

import Java.io.BufferedReader;
import Java.io.IOException;
import Java.util.ArrayList;
import Java.util.Collections;
import Java.util.Comparator;
import Java.util.HashMap;
import Java.util.List;
import Java.util.StringTokenizer;


public class Main {
    public static void main(String[] args) {
    try {
        BufferedReader in = new BufferedReader(new Java.io.InputStreamReader           (System.in));
            String str;

        HashMap<Integer, Business> hm = new HashMap<Integer, Business>();
        Main m = new Main();


        while ((str = in.readLine()) != null) {


            StringTokenizer st = new StringTokenizer(str);
            int id = Integer.parseInt(st.nextToken());    // first integer
            int rating = Integer.parseInt(st.nextToken());    // second 

            Business a = m.new Business(id, rating);


            hm.put(id, a);


            List<Business> ranking = new ArrayList<Business>(hm.values());

            Collections.sort(ranking, new Comparator<Business>() {

                public int compare(Business i1, Business i2) {
                    return i2.getRating() - i1.getRating();
                }
            });

            for (int k=0;k<ranking.size();k++) {
                System.out.println((ranking.get(k).getId() + " " + (ranking.get(k)).getRating()));
            }


        }
        in.close();

    } catch (IOException e) {
        e.printStackTrace();
    }


}
public class Business{

    Integer id;
    Integer rating;

    public Business(int id2, int rating2)
    {
        id=id2;
        rating=rating2;

    }

    public Integer getId()
    {
        return id;
    }
    public Integer getRating()
    {
        return rating;
    }


}
}
0
danywarner

Konvertieren Sie Hashmap in eine ArrayList mit einer Pair-Klasse

Hashmap<Object,Object> items = new HashMap<>();

zu

List<Pair<Object,Object>> items = new ArrayList<>();

so können Sie es nach Belieben sortieren oder nach Reihenfolge sortieren.

HashMap nach Wert in Java sortieren:

public class HashMapSortByValue {
    public static void main(String[] args) {

        HashMap<Long,String> unsortMap = new HashMap<Long,String>();
            unsortMap.put(5l,"B");
            unsortMap.put(8l,"A");
            unsortMap.put(2l, "D");
            unsortMap.put(7l,"C" );

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

            HashMap<Long,String> sortedMapAsc = sortByComparator(unsortMap);
            System.out.println("After sorting......");
            System.out.println(sortedMapAsc);

    }

    public static HashMap<Long,String> sortByComparator(
            HashMap<Long,String> unsortMap) {

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

            Collections.sort(list, new Comparator<Map.Entry<Long,String>> () {
                public int compare(Map.Entry<Long,String> o1, Map.Entry<Long,String> o2) {
                    return o1.getValue().compareTo(o2.getValue());
                }
            });

            HashMap<Long,String> sortedMap = new LinkedHashMap<Long,String>();
            for (Entry<Long,String> entry : list) {
              sortedMap.put(entry.getKey(), entry.getValue());
            }
            return sortedMap;
          }

}
0
SANTosh Z