sort - Cómo ordenar un HashMap en Java

sort map list java

Question

¿Cómo podemos ordenar una HashMap<key, ArrayList> ?

Quiero ordenar sobre la base de un valor en ArrayList .

Answer 1

¿Ha considerado usar 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());
        }
    });
}

resultados en un objeto vinculado organizado.

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

revisa la parte de selección elegida here ...

Answer 2

¿Tienes que usar un HashMap? Si solo necesita la interfaz de mapa, use un TreeMap

Ok, creo que ahora entendí tu pregunta, quieres ordenar comparando los valores en el hashMap. Debes escribir el código para hacer esto, si quieres hacerlo una vez que puedas ordenar los valores de tu 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 desea acceder a esta lista ordenada a menudo, entonces debe insertar sus elementos en el hashMap AND en un conjunto ordenado (TreeSet, por ejemplo) ...

Answer 3

Clasificación de HashMap por valor:

Como otros han señalado. Los HashMaps son para búsquedas fáciles si cambias eso o tratas de ordenar dentro del mapa, ya no tendrás la búsqueda O (1).

El código para su clasificación es el siguiente:

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
}

Answer 4

Convierte hashmap en una ArrayList con una clase de par

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

a

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

para que pueda ordenarlo como desee, o enumerar ordenado agregando orden.

Answer 5

Desarrollé una clase que se puede usar para ordenar un mapa en base a claves y valores. La idea básica es si tienes que ordenar un mapa usando claves y luego crear un TreepMap desde tu mapa que ordenará el mapa por claves. Y en caso de ordenar por valores, cree una lista de entrySet y ordene la lista usando la interfaz del comparador.

Aquí está la solución completa:

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());
    }
}

El código está probado adecuadamente: D

Answer 6

Desarrollé una solución de trabajo completamente probada. Espero eso ayude

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;
    }


}
}

Answer 7

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));

Usando Guava :

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);

Answer 8

HashMap no mantiene ningún orden, por lo que si desea cualquier tipo de pedido, debe almacenarlo en otra cosa, que es un mapa y puede tener algún tipo de orden, como LinkedHashMap.

a continuación se muestra un programa simple, mediante el cual puede ordenar por clave, valor, ascendente, descendente ... (si modifica el compactador, puede usar cualquier tipo de orden, en claves y valores)

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());
    }
}
}

aquí está el link git

Answer 9

Lista ordenada por las teclas hasmap:

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

Lista ordenada por valores de hashmap:

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

¡Buena suerte!

Answer 10

Parece que tal vez quieras un treemap.

http://docs.oracle.com/javase/7/docs/api/java/util/TreeMap.html

Puede pasar un comparador personalizado si corresponde.

Answer 11

Si desea combinar un Mapa para una recuperación eficiente con un SortedMap, puede usar el ConcurrentSkipListMap .

Por supuesto, necesita la clave para ser el valor utilizado para la clasificación.

Answer 12

Sin más información, es difícil saber exactamente lo que quieres. Sin embargo, al elegir qué estructura de datos usar, debe tener en cuenta para qué lo necesita. Los Hashmaps no están diseñados para la clasificación, están diseñados para una fácil recuperación. Entonces, en su caso, probablemente tenga que extraer cada elemento del hashmap y ponerlos en una estructura de datos más propicia para la clasificación, como un montón o un conjunto, y luego ordenarlos allí.

Answer 13

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

obtener las llaves

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

Ordenarlos

 Collections.sort(keys)

imprimirlos.

En cualquier caso, no puede haber valores ordenados en HashMap (según 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 ].

Aunque puede enviar todos estos valores a LinkedHashMap , para usarlos también más adelante.

Answer 14

This podría ser lo que estás buscando. Muestra cómo usar TreeMap y un comparador personalizado para realizar el trabajo.

Answer 15

Función de comparación personalizada que incluye la funcionalidad del alfabeto turco u otros idiomas diferentes al inglés .

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;
}

aquí está el ejemplo de uso como el siguiente

LinkedHashMap<String, Boolean> ligList = new LinkedHashMap<String, Boolean>();
ligList = sortByKeys(ligList);