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

Question

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

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

Answer 1

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

---

Если вы хотите сортировать, сравнивая значения в HashMap. Вы должны написать код для этого, если вы хотите сделать это один раз, вы можете отсортировать значения вашего HashMap:

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

Если вы хотите часто обращаться к этому отсортированному списку, вы можете вставить свои элементы в HashMap<TreeSet<Person>>, хотя семантика наборов и списков немного отличается.

Answer 2

Сортировка списка по ключам hasmap:

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

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

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

В случае дублированных значений карты:

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

Удачи!

Answer 3

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 4

Похоже, вы хотите древовидную карту.

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

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

Answer 5

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

Использование Гуава :

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 6

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

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 7

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

Answer 8

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

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

Answer 9

рассматривали ли вы использование 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

проверьте сортировку, выбранную из здесь ..

Answer 10

Я разработал класс, который можно использовать для сортировки карты по ключам и значениям. Основная идея заключается в том, что если вы сортируете карту с помощью ключей, то создайте 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