Параметры сортировки Java в новом хэшмапе [дубликат]

Ниже кода причины Тип безопасности Предупреждение

Карта & lt; String, Object & gt; myInput = (Map & lt; String, Object & gt;) myRequest.get ();

Обходной путь

Создайте новый объект карты без упоминания параметры, потому что тип объекта, хранящийся в списке, не проверен.

Шаг 1: Создайте новую временную карту

Карта & lt; ? & GT; tempMap = (Map & lt;?,? & gt;) myRequest.get ();

Шаг 2: Создает главную карту

  Карта & lt; String, Object & gt;  myInput = new HashMap & lt; gt; (myInputObj.size ());   

Шаг 3: Итерируйте временную карту и установите значения в основную карту

  для (Map.Entry & lt ;?  ,? & gt; entry: myInputObj.entrySet ()) {myInput.put ((String) entry.getKey (), entry.getValue ());  }  
96
задан MC Emperor 3 July 2014 в 14:06
поделиться

18 ответов

Преобразовать hashmap в ArrayList с парным классом

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

в

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

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

0
ответ дан Amir Hossein Ghasemi 15 August 2018 в 21:34
поделиться

Правильный ответ.

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

Обратите внимание, что сам HashMap не может поддерживать сортировку, как указывали другие ответы. Это хэш-карта, а хешированные значения - несортированные. Таким образом, вы можете сортировать ключи, когда вам нужно, а затем обращаться к значениям по порядку, как я продемонстрировал выше, или вы можете найти другую коллекцию для хранения ваших данных, например ArrayList of Pairs / Tuples, такую ​​как пара, найденная в Apache Commons:

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

0
ответ дан Andrew 15 August 2018 в 21:34
поделиться

Сортировка 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
}
2
ответ дан Anuj Mehta 15 August 2018 в 21:34
поделиться

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

2
ответ дан Ayush Jayaswal 15 August 2018 в 21:34
поделиться
  • 1
    Это не класс . Кроме того, ваши отсортированные значения хранятся в entryList , почему вы очищаете unSortedMap и печатаете его снова? Я предлагаю сделать метод с именем sortMap , который имеет unSortedMap как параметр и возвращает entryList . – Buffalo 10 May 2018 в 06:34

Похоже, вам может понадобиться treemap.

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

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

12
ответ дан Ben Pearson 15 August 2018 в 21:34
поделиться

Этот может быть тем, что вы ищете. Он показывает, как использовать TreeMap и пользовательский Comparator для выполнения этой работы.

2
ответ дан Can't Tell 15 August 2018 в 21:34
поделиться

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

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


}
}
0
ответ дан danywarner 15 August 2018 в 21:34
поделиться

Сортированный список с помощью клавиш 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);

Удачи!

31
ответ дан GkhnSr 15 August 2018 в 21:34
поделиться
  • 1
    Сортировка значений с помощью SortedSet нецелесообразна, так как значения могут быть дублированы, а набор не позволяет их. – Cjo 14 July 2018 в 10:33
  • 2
    @Cjo, вы правы в этот момент. Я отредактировал ответ. – GkhnSr 18 July 2018 в 14:44
  • 3

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

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

3
ответ дан Lars A Frøyland 15 August 2018 в 21:34
поделиться

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

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);
8
ответ дан Mustafa Güven 15 August 2018 в 21:34
поделиться

вы рассмотрели использование результатов LinkedHashMap & lt;> () ..?

  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

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

2
ответ дан Olu 15 August 2018 в 21:34
поделиться

Вам нужно использовать 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) ...

121
ответ дан pgras 15 August 2018 в 21:34
поделиться
  • 1
    Еще несколько моментов: во-первых, вы должны принять два решения: (1) хотите ли вы сортировать по значениям или по ключам, (2) контролируете ли вы коллекцию в начале, так что вы можете используйте встроенную сортировку, а также когда вы передаете существующие Карты и просто хотите перебирать их в определенном порядке. Кроме того, LinkedHashMap может поддерживать порядок вставки (который мне часто нравится для отладки) или по порядку доступа. И, наконец, если вы это делаете, вы можете проверить Java 1.6 и NavigableMap , потрясающие вещи! – Mark Bennett 5 January 2012 в 02:58
  • 2
    Если вы хотите отсортировать по ключам, используйте вместо этого SortedMap. Он дает вам автоматические сортированные ключи. – Marquinho Peli 3 November 2016 в 17:01
  • 3
    – vedi0boy 27 July 2017 в 13:36
  • 4
    TreeMap похоже на действительно плохой выбор имени для класса ... должно быть что-то вроде SortedMap. От имени я бы подумал, что это не Map вообще, а какой-то Tree ... Tree часть TreeMap - это действительно больше деталей реализации, которые не должны касаться пользователя класс вообще. – ArtOfWarfare 13 October 2017 в 13:33
  • 5
    @ArtOfWarfare: Точно Tree является деталью реализации и поэтому должен касаться пользователя, когда он выбирает, какой класс использовать для реализации интерфейса SortedMap ... – pgras 13 October 2017 в 14:09

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, для дальнейшего использования.

22
ответ дан rogerdpack 15 August 2018 в 21:34
поделиться

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

4
ответ дан Smashery 15 August 2018 в 21:34
поделиться
  • 1
    на самом деле его не для сортировки хэш-карты используется для хранения данных, считанных из файла, и его значений – user 23 April 2009 в 07:55
  • 2
    мы должны сортировать только на основе одного элемента списка массивов в хэш-карте hashmap map & lt; key, arraylist & gt; – user 23 April 2009 в 07:58
  • 3
    Да, похоже, что вы хотите, что говорят другие ребята - TreeMap. TreeMaps похоже на HashMaps, за исключением того, что вы также можете сортировать их. Ура! – Smashery 23 April 2009 в 08:03
  • 4
    Мужчина Мужчина Мужчина – user 23 April 2009 в 08:08
  • 5
    если мы храним в хэш-карте (ключ, человек), человек является классом, у которого есть четыре объекта, если мы хотим, чтобы сортировка основывалась на одном из объектов, как мы это сделаем ...? – user 23 April 2009 в 08:11

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

здесь является git link

0
ответ дан user3123372 15 August 2018 в 21:34
поделиться

В 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);
8
ответ дан Vitalii Fedorenko 15 August 2018 в 21:34
поделиться
  • 1
  • 2
    Компаратор Java 8 можно переписать как: Comparator<Map.Entry<String, String>> valueComparator = Comparator.comparing(Map.Entry::getValue().getField()); – Mathias Ghys 18 April 2017 в 07:35
0
ответ дан Moritz 5 September 2018 в 21:10
поделиться
0
ответ дан ssoo 5 September 2018 в 21:10
поделиться
Другие вопросы по тегам:

Похожие вопросы: