Comment trier un HashMap en Java
Comment pouvons-nous trier un HashMap<key, ArrayList>?
Je veux trier sur la base d'une valeur dans la ArrayList.
Devez-vous utiliser un HashMap? Si vous avez seulement besoin de l'interface de la carte, utilisez un TreeMap
Si vous souhaitez effectuer un tri en comparant les valeurs dans HashMap. Vous devez écrire du code pour cela. Si vous voulez le faire une fois, vous pouvez trier les valeurs de votre HashMap:
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());
}
Si vous souhaitez accéder souvent à cette liste triée, vous pouvez alors insérer vos éléments dans un HashMap<TreeSet<Person>>, bien que la sémantique des ensembles et des listes diffère légèrement.
Liste triée par clés hasmap:
SortedSet<String> keys = new TreeSet<String>(myHashMap.keySet());
Liste triée par les valeurs de hashmap:
SortedSet<String> values = new TreeSet<String>(myHashMap.values());
En cas de valeurs de carte dupliquées:
List<String> mapValues = new ArrayList<String>(myHashMap.values());
Collections.sort(mapValues);
Bonne chance!
http://snipplr.com/view/2789/sorting-map-keys-by-comparing-its-values/
obtenir les clés
List keys = new ArrayList(yourMap.keySet());
Les trier
Collections.sort(keys)
imprimez-les.
Dans tous les cas, vous ne pouvez pas avoir de valeurs triées dans HashMap (selon l'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].
Bien que vous puissiez transmettre toutes ces valeurs à LinkedHashMap, vous pourrez également les utiliser ultérieurement.
On dirait que vous voudrez peut-être un treemap.
http://docs.Oracle.com/javase/7/docs/api/Java/util/TreeMap.html
Vous pouvez lui transmettre un comparateur personnalisé si cela s'applique.
En 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));
Utiliser Goyave :
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);
Fonction de comparaison Custom qui inclut des fonctionnalités pour l'alphabet turc ou d'autres langues que l'anglais.
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;
}
voici l'exemple d'utilisation comme suit
LinkedHashMap<String, Boolean> ligList = new LinkedHashMap<String, Boolean>();
ligList = sortByKeys(ligList);
Sans plus d'informations, il est difficile de savoir exactement ce que vous voulez. Toutefois, lors du choix de la structure de données à utiliser, vous devez prendre en compte vos besoins. Les cartes de hachage ne sont pas conçues pour le tri - elles sont conçues pour une récupération facile. Ainsi, dans votre cas, vous devrez probablement extraire chaque élément de la table de hachage et les placer dans une structure de données plus propice au tri, telle qu'un tas ou un ensemble, puis les trier ici.
Si vous souhaitez combiner une carte pour une récupération efficace avec une SortedMap, vous pouvez utiliser le ConcurrentSkipListMap .
Bien entendu, la clé doit être la valeur utilisée pour le tri.
avez-vous envisagé d'utiliser un LinkedHashMap <> () ..?
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());
}
});
}
résultats dans un objet lié organisé.
item>>Value
2>>Movies
isAlive>>true
vérifiez la partie de tri choisie de ici ..
Tri de HashMap par valeur:
Comme d'autres l'ont souligné. Les tables de hachage sont conçues pour faciliter les recherches. Si vous modifiez cela ou essayez de trier à l'intérieur de la carte, vous n'aurez plus la recherche O(1).
Le code pour votre tri est le suivant:
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
}
J'ai développé une classe qui peut être utilisée pour trier une carte sur la base de clés et de valeurs. L'idée de base est que si vous devez trier une carte à l'aide de clés, créez une carte TreepMap à partir de votre carte pour trier la carte par clé. Et en cas de tri par valeurs, créez une liste à partir de entrySet et triez-la à l'aide de l'interface du comparateur.
Voici la solution complète:
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());
}
}
Le code est correctement testé: D
Une bonne réponse.
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);
}
Notez que HashMap lui-même ne peut pas maintenir le tri, comme d'autres réponses l'ont souligné. C'est une carte hash, et les valeurs hachées ne sont pas triées. Vous pouvez donc soit trier les clés à votre guise, puis accéder aux valeurs dans l’ordre, comme je l’ai montré ci-dessus, ou vous pouvez trouver une autre collection pour stocker vos données, comme une ArrayList de paires/tuples, telle que la paire trouvée dans Apache Commons:
https://commons.Apache.org/proper/commons-lang/apidocs/org/Apache/commons/lang3/Tuple/Pair.html
Tri par clé:
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));
}
}
HashMap ne maintient aucun ordre, donc si vous voulez n'importe quel type de commande, vous devez le stocker dans autre chose, qui est une carte et peut avoir une sorte de commande, comme LinkedHashMap.
vous trouverez ci-dessous un programme simple vous permettant de trier par clé, valeur, croissant, croissant ... (si vous modifiez le compacteur, vous pouvez utiliser n’importe quel type de commande, de clé ou de valeur)
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());
}
}
}
voici le git link
J'ai développé une solution de travail entièrement testée. J'espère que ça aide
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;
}
}
}
Conversion de hashmap en ArrayList avec une classe de paire
Hashmap<Object,Object> items = new HashMap<>();
à
List<Pair<Object,Object>> items = new ArrayList<>();
afin que vous puissiez le trier comme vous le souhaitez, ou la liste triée en ajoutant l'ordre.
Tri de HashMap par valeur en Java:
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;
}
}