Comment trier un HashMap en Java
Comment Pouvons-nous Trier un HashMap<key, ArrayList> ?
je veux sur la base d'une valeur dans la ArrayList .
18 réponses
avez-vous d'utiliser une table de hachage ? Si vous avez seulement besoin de L'Interface de carte utiliser un TreeMap
Ok je pense que maintenant j'ai compris votre question, vous voulez trier en comparant les valeurs dans le hashMap. Vous devez écrire le code pour le faire, si vous voulez le faire une fois que vous pouvez trier les valeurs de votre hashMap:
Map<String, Person> people = new HashMap<String, Person>();
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<Person>(people.values());
Collections.sort(peopleByAge, new Comparator<Person>() {
public int compare(Person o1, Person o2) {
return o1.getAge() - o2.getAge();
}
});
for (Person p : peopleByAge) {
System.out.println(p.getName() + "\t" + p.getAge());
}
Si vous voulez accéder à cette liste triée souvent, alors vous devez insérer vos éléments en le hashMap et dans un ensemble trié (TreeSet par exemple)...
liste triée par clés hasmap:
SortedSet<String> keys = new TreeSet<String>(myHashMap.keySet());
liste triée par valeurs hashmap:
SortedSet<String> values = new TreeSet<String>(myHashMap.values());
dans le cas de valeurs cartographiques 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());
triez-les
Collections.sort(keys)
imprimez-les.
dans tous les cas, vous ne pouvez pas avoir trié les valeurs dans HashMap (selon 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 pouvez pousser toutes ces valeurs à LinkedHashMap , pour une utilisation ultérieure aussi bien.
semble que vous pourriez vouloir un tapis roulant.
http://docs.oracle.com/javase/7/docs/api/java/util/TreeMap.html
vous pouvez passer dans un comparateur personnalisé à elle 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));
Utilisant 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 personnalisée qui inclut la fonctionnalité pour alphabet turc ou autres langues différentes 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, lorsque vous choisissez la structure de données à utiliser, vous devez tenir compte de ce dont vous avez besoin. Les Hashmaps ne sont pas conçus pour le tri - ils sont conçus pour une récupération facile. Donc, dans votre cas, vous devrez probablement extraire chaque élément du hashmap, et les mettre dans une structure de données plus propice au tri, comme un tas ou un ensemble, et puis les trier là.
si vous voulez combiner une carte pour une récupération efficace avec une carte SortedMap, vous pouvez utiliser le Compimentskiplistmap .
bien sûr, vous avez besoin que la clé soit la valeur utilisée pour le tri.
ce pourrait être ce que vous cherchez. Il montre comment utiliser TreeMap et personnalisé Comparateur de faire le travail.
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());
}
});
}
aboutit à un objet lié organisé.
item>>Value
2>>Movies
isAlive>>true
vérifiez la partie de tri choisie dans ici ..
tri de HashMap par valeur:
Comme d'autres l'ont souligné. HashMaps sont pour des recherches faciles si vous changez cela ou essayez de trier à l'intérieur de la carte elle-même, vous n'aurez plus de recherche O(1).
le code de 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é pour trier une carte sur la base de clés et de valeurs. L'idée de base est que si vous avez trié une carte en utilisant des clés, alors créez une carte arborescente à partir de votre carte qui triera la carte par des clés. Et en cas de tri par les valeurs créent une liste d'entrySet et trient la liste en utilisant l'interface de 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
j'ai développé une solution de travail entièrement testée. Espérons que cela 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;
}
}
}
HashMap ne pas maintenir n'importe quel ordre, donc, si vous voulez tout type de commande, vous avez besoin de la stocker dans quelque chose d'autre, qui est une carte et peut avoir un certain type de commande, à l'instar de LinkedHashMap
ci-dessous est un programme simple, par lequel vous pouvez trier par clé, valeur, ascendant ,descendant ..( si vous modifiez le compacteur, vous pouvez utiliser n'importe quel type de commande, les clés et les valeurs)
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());
}
}
}
ici, c'est le git lien
convertir hashmap en un ArrayList avec une classe de paire
Hashmap<Object,Object> items = new HashMap<>();
à
List<Pair<Object,Object>> items = new ArrayList<>();
ainsi vous pouvez le trier comme vous voulez, ou la liste triée en ajoutant l'ordre.
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 fait remarquer. C'est une carte hash , et les valeurs hash ne sont pas triées. Vous pouvez donc soit trier les clés lorsque vous en avez besoin et accéder ensuite aux valeurs dans l'ordre, comme je l'ai démontré ci-dessus, ou vous pouvez trouver une collection différente pour stocker vos données, comme un tableau de paires / Tuples, comme la paire trouvée dans Apache Commons:
https://commons.apache.org/proper/commons-lang/apidocs/org/apache/commons/lang3/tuple/Pair.html
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;
}
}
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));
}
}