Hoe een HashMap in Java te sorteren

Hoe kunnen we een HashMap<key, ArrayList>sorteren?

Ik wil sorteren op basis van een waarde in de ArrayList.

Antwoord 1, autoriteit 100%

Moet je een HashMap gebruiken? Als je alleen de kaartinterface nodig hebt, gebruik dan een Boomkaart

Als u wilt sorteren door waarden in de HashMap te vergelijken. Je moet hiervoor code schrijven, als je het een keer wilt doen, kun je de waarden van je HashMap sorteren:

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

Als u deze gesorteerde lijst vaak wilt openen, kunt u uw elementen invoegen in een HashMap<TreeSet<Person>>, hoewel de semantiek van sets en lijsten een beetje anders is.

Antwoord 2, autoriteit 27%

Gesorteerde lijst op hasmap-toetsen:

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

Gesorteerde lijst op hashmap-waarden:

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

In het geval van gedupliceerde kaartwaarden:

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

Veel succes!

3, Autoriteit 16%

http://snipplr.com/view / 2789 / Sorteer-kaart-toetsen-by-vergelijking-zijn-waarden /

Download de sleutels

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

Sorteer ze

Collections.sort(keys)

Print ze.

In elk geval geen gesorteerde waarden in Hashmap (volgens 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].

Hoewel u al deze waarden naar LinkedHashMapkunt duwen, voor later gebruik.

4, Autoriteit 9%

Het lijkt erop dat u misschien een treemap wilt.

http://docs.oracle.com/ Javase / 7 / DOCS / API / JAVA / UTIL / TREEMAP.HTML

U kunt er een aangepaste comparator opgeven als dat van toepassing is.

5, Autoriteit 8%

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

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

Antwoord 6, autoriteit 3%

Zonder meer informatie is het moeilijk om precies te weten wat je wilt. Bij het kiezen van welke datastructuur u wilt gebruiken, moet u echter rekening houden met waar u deze voor nodig heeft. Hashmaps zijn niet ontworpen om te sorteren – ze zijn ontworpen om gemakkelijk terug te vinden. Dus in jouw geval zou je waarschijnlijk elk element uit de hashmap moeten halen en ze in een datastructuur moeten plaatsen die beter geschikt is voor sorteren, zoals een heap of een set, en ze daar dan sorteren.

Antwoord 7, autoriteit 3%

heb je overwogen om een LinkedHashMap<>() te gebruiken?

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

resulteert in een georganiseerd gekoppeld object.

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

bekijk het sorteergedeelte dat u hierhebt gekozen..

Antwoord 8, autoriteit 2%

Als u een kaart voor efficiënt ophalen wilt combineren met een SortedMap, kunt u de ConcurrentSkipListMap.

Natuurlijk heb je de sleutel nodig als de waarde die wordt gebruikt voor het sorteren.

Antwoord 9, autoriteit 2%

Ik heb een klasse ontwikkeld die kan worden gebruikt om een kaart te sorteren op basis van sleutels en waarden. Het basisidee is dat als u een kaart sorteert met behulp van toetsen, vervolgens een TreepMap van uw kaart maakt die de kaart op toetsen sorteert. En in het geval van sorteren op waarden, maak een lijst van entrySet en sorteer de lijst met behulp van de vergelijkingsinterface.

Hier is de volledige oplossing:

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 is correct getest 😀

Antwoord 10

HashMap sorteren op waarde:

Zoals anderen al hebben opgemerkt. HashMaps zijn voor gemakkelijke opzoekingen. Als je dat verandert of probeert te sorteren op de kaart zelf, heb je geen O(1) lookup meer.

De code voor uw sortering is als volgt:

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
}

Antwoord 11

Een goed antwoord.

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

Merk op dat HashMap zelf de sortering niet kan handhaven, zoals andere antwoorden hebben aangegeven. Het is een hash-kaart en gehashte waarden zijn ongesorteerd. Je kunt dus ofwel de sleutels sorteren wanneer dat nodig is en vervolgens de waarden op volgorde openen, zoals ik hierboven heb aangetoond, of je kunt een andere verzameling vinden om je gegevens op te slaan, zoals een ArrayList of Pairs/Tupels, zoals het Pair gevonden in Apache Commons:

https:/ /commons.apache.org/proper/commons-lang/apidocs/org/apache/commons/lang3/tuple/Pair.html

Antwoord 12

Sorteren op sleutel:

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

Antwoord 13

Ik heb een volledig geteste werkende oplossing ontwikkeld. Ik hoop dat het helpt

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

Antwoord 14

HashMap houdt geen volgorde bij, dus als je een bestelling wilt, moet je die in iets anders opslaan, wat een kaart is en een soort volgorde kan hebben, zoals LinkedHashMap

hieronder is een eenvoudig programma, waarmee u kunt sorteren op sleutel, waarde, oplopend, aflopend ..( als u de compactor wijzigt, kunt u elke soort volgorde gebruiken, op sleutels en waarden)

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 is de git link

Antwoord 15

Converteer hashmap naar een ArrayList met een paarklasse

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

naar

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

zodat je het kunt sorteren zoals je wilt, of een lijst kunt sorteren door volgorde toe te voegen.

Antwoord 16

HashMap sorteren op waarde in 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;
          }
}