Как отсортировать HashMap в Java

Question

Как мы можем сортировать HashMap<key, ArrayList>?

Я хочу сортировать на основе значения в ArrayList.

Answer 1

Без дополнительной информации трудно точно знать, что вы хотите. Однако, выбирая, какую структуру данных использовать, вы должны принять во внимание то, что вам нужно. Hashmaps не предназначены для сортировки - они предназначены для легкого извлечения. Поэтому в вашем случае вам, вероятно, придется извлечь каждый элемент из хэш-карты и поместить их в структуру данных, более удобную для сортировки, такую ​​как куча или набор, а затем отсортировать их там.

Answer 2

Вам нужно использовать HashMap? Если вам нужно только карта интерфейс использовать TreeMap

---

Хорошо, я думаю, теперь я понял ваш вопрос, вы хотите отсортировать, сравнивая значения в HashMap. Вы должны написать код, чтобы сделать это, если вы хотите сделать это, как только вы можете сортировать значения вашего 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()); 
    } 

Если вы хотите получить доступ к этому отсортированному списку часто, то вы должны вставить свои элементы в hashMap AND в отсортированном наборе (например, TreeSet) ...

Answer 3

Похоже, что вы можете получить treemap.

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

Вы можете передать в пользовательский компаратора к нему, если это применимо.

Answer 4

Если вы хотите совместить карту для эффективного извлечения с помощью SortedMap, вы можете использовать ConcurrentSkipListMap.

Конечно, для сортировки вам нужен ключ.

Answer 5

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

получить ключи

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

Отсортируйте их

Collections.sort(keys) 

печатать их.

В любом случае, вы не можете быть отсортированы значения в HashMap (в соответствии с 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].

Хотя вы можете нажать все эти значения LinkedHashMap, для последующего использования, а также.

Answer 6

This мощь быть то, что вы ищете Он показывает, как использовать TreeMap и пользовательский компаратор, чтобы получить работу

Answer 7

отсортированного списка с помощью клавиш hasmap:..

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

Сортировка списка по значениям Hashmap:

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

Good Luck!

Answer 8

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

Answer 9

Пользовательские функции сравнения, которая включает в себя функциональные возможности для турецкого алфавита или других различных языках, отличных от английского.

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

здесь является использование пример как следующий

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

Answer 10

вы рассмотренного с помощью 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()); 
     } 
    }); 
} 

Результаты в организованный связанный объект.

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

проверка сортировка часть, выбранная из here ..

Answer 11

Я разработал полностью испытанный рабочий раствор. Надеюсь, что это помогает

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 12

Сортировка HashMap по значению:

Как уже отмечалось. HashMaps предназначены для удобного поиска, если вы измените это или попытаетесь отсортировать внутри самой карты, у вас больше не будет поиска O (1).

Код для сортировки выглядит следующим образом:

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 13

Я разработал класс, который может быть использован для сортировки карты на основе ключей и значений. Основная идея заключается в том, что если у вас есть сортировка карты с помощью ключей, тогда создайте TreepMap с вашей Карты, которая сортирует карту по ключам. А в случае сортировки по значениям создайте список из entrySet и отсортируйте список, используя интерфейс компаратора.

Вот полное решение:

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

Код правильно испытываться: D

Answer 14

HashMap оленья кожа поддерживать любой заказ, поэтому, если вы хотите какой-либо заказа, вам нужно сохранить, что в что-то другое, которое является картой и может иметь какой-то порядок, например LinkedHashMap

ниже - простая программа, с помощью которой вы можете сортировать по ключу, значению, по возрастанию, по убыванию ..(Если вы измените компактор, вы можете использовать любой вид заказа, на ключи и значения)

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

вот мерзавец link