Cách sắp xếp một HashMap trong Java

Question

Làm thế nào để chúng tôi có thể sắp xếp một HashMap<key, ArrayList>?

Tôi muốn sắp xếp dựa trên giá trị trong ArrayList.

Answer 1

Nếu không có thêm thông tin, thật khó để biết chính xác những gì bạn muốn. Tuy nhiên, khi chọn cấu trúc dữ liệu để sử dụng, bạn cần tính đến những gì bạn cần. Hashmaps không được thiết kế để sắp xếp - chúng được thiết kế để dễ dàng truy xuất. Vì vậy, trong trường hợp của bạn, bạn có thể phải trích xuất từng phần tử từ hashmap và đặt chúng vào một cấu trúc dữ liệu thuận lợi hơn để phân loại, chẳng hạn như một đống hoặc một tập hợp, và sau đó sắp xếp chúng ở đó.

Answer 2

Bạn có phải sử dụng HashMap không? Nếu bạn chỉ cần giao diện Map có sử dụng một TreeMap

---

Ok Tôi nghĩ rằng bây giờ tôi hiểu câu hỏi của bạn, bạn muốn sắp xếp bằng cách so sánh giá trị trong HashMap. Bạn cần phải viết mã để làm điều này, nếu bạn muốn làm điều đó một khi bạn có thể sắp xếp các giá trị của HashMap của bạn:

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

Nếu bạn muốn truy cập danh sách được sắp xếp này thường xuyên, sau đó bạn nên chèn các yếu tố của bạn trong hashMap VÀ trong một Tập hợp đã sắp xếp (TreeSet chẳng hạn) ...

Answer 3

Dường như bạn có thể muốn có một sơ đồ trang web.

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

Bạn có thể chuyển qua bộ so sánh tùy chỉnh nếu áp dụng.

Answer 4

Nếu bạn muốn kết hợp Bản đồ để truy xuất hiệu quả với một SortedMap, bạn có thể sử dụng ConcurrentSkipListMap.

Tất nhiên, bạn cần khóa làm giá trị được sử dụng để sắp xếp.

Answer 5

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

lấy chìa khóa

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

Sắp xếp chúng

Collections.sort(keys) 

in chúng.

Trong mọi trường hợp, bạn không thể có được sắp xếp giá trị trong HashMap (theo 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].

Mặc dù bạn có thể đẩy tất cả các giá trị để LinkedHashMap, cho sau này sử dụng là tốt.

Answer 6

This sức là những gì bạn đang tìm kiếm Nó cho thấy làm thế nào để sử dụng TreeMap và một sánh tùy chỉnh để có được việc làm

Answer 7

Sắp xếp Danh sách bằng các phím hasmap:..

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

Sắp xếp Danh sách bởi các giá trị hashmap:

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

Good Luck!

Answer 8

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

Sử dụng 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

Tuỳ chỉnh so sánh chức năng trong đó bao gồm chức năng cho bảng chữ cái Thổ Nhĩ Kỳ hoặc ngôn ngữ khác ngoài tiếng Anh.

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

ở đây là sử dụng ví dụ như sau

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

Answer 10

có bạn xem là sử dụng một 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()); 
     } 
    }); 
} 

kết quả thành đối tượng được liên kết có tổ chức.

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

kiểm tra phần sắp xếp nhặt từ here ..

Answer 11

tôi đã phát triển một giải pháp làm việc kiểm tra đầy đủ. Hy vọng nó giúp

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

Sorting HashMap bởi Value:

Như những người khác đã chỉ ra. HashMaps là để tra cứu dễ dàng nếu bạn thay đổi hoặc cố gắng sắp xếp bên trong bản đồ, bạn sẽ không có O (1) tra cứu nữa.

Mã cho phân loại của bạn là như sau:

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

tôi đã phát triển một lớp mà có thể được sử dụng để sắp xếp bản đồ trên cơ sở khóa và giá trị. Ý tưởng cơ bản là nếu bạn đã sắp xếp bản đồ bằng cách sử dụng các phím thì hãy tạo TreepMap từ Bản đồ của bạn để sắp xếp bản đồ theo các phím. Và trong trường hợp sắp xếp theo giá trị tạo một danh sách từ entrySet và sắp xếp danh sách bằng cách sử dụng giao diện so sánh.

Dưới đây là giải pháp đầy đủ:

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

Mã được thử nghiệm đúng: D

Answer 14

HashMap doesnt duy trì thứ tự bất kỳ, vì vậy nếu bạn muốn bất kỳ loại đặt hàng, bạn cần lưu trữ trong một cái gì đó khác, đó là một bản đồ và có thể có một số thứ tự, như LinkedHashMap

dưới đây là một chương trình đơn giản, theo đó bạn có thể sắp xếp theo khóa, giá trị, tăng dần, giảm dần ..(Nếu bạn sửa đổi Đầm, bạn có thể sử dụng bất kỳ loại đặt hàng, trên khóa và giá trị)

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

đây là git link