Ниже кода причины Тип безопасности Предупреждение
Карта & lt; String, Object & gt; myInput = (Map & lt; String, Object & gt;) myRequest.get ();
Обходной путь
blockquote>Создайте новый объект карты без упоминания параметры, потому что тип объекта, хранящийся в списке, не проверен.
Шаг 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 ()); }
Преобразовать hashmap в ArrayList с парным классом
Hashmap<Object,Object> items = new HashMap<>();
в
List<Pair<Object,Object>> items = new ArrayList<>();
, чтобы вы могли сортировать его по своему усмотрению или отсортировать список путем добавления порядка.
Правильный ответ.
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
Сортировка 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
}
Я разработал класс, который можно использовать для сортировки карты на основе ключей и значений. Основная идея заключается в том, что если у вас есть сортировка карты с помощью ключей, тогда создайте 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
Похоже, вам может понадобиться treemap.
http://docs.oracle.com/javase/7/docs/api/java/util/TreeMap.html
Если это применимо, вы можете передать в него произвольный компаратор.
Этот может быть тем, что вы ищете. Он показывает, как использовать TreeMap и пользовательский Comparator для выполнения этой работы.
Я разработал полностью протестированное рабочее решение. Надеюсь, что это поможет
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;
}
}
}
Сортированный список с помощью клавиш 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);
Удачи!
Если вы хотите объединить карту для эффективного извлечения с помощью SortedMap, вы можете использовать ConcurrentSkipListMap .
Конечно, вам нужно, чтобы ключ был значением, используемым для сортировка.
Пользовательская функция сравнения, которая включает в себя функциональность для турецкого алфавита или других языков, кроме английского.
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);
вы рассмотрели использование результатов 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
проверить часть сортировки, выбранную из здесь ..
Вам нужно использовать 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) ...
TreeMap
похоже на действительно плохой выбор имени для класса ... должно быть что-то вроде SortedMap
. От имени я бы подумал, что это не Map
вообще, а какой-то Tree
... Tree
часть TreeMap
- это действительно больше деталей реализации, которые не должны касаться пользователя класс вообще.
– ArtOfWarfare
13 October 2017 в 13:33
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
, для дальнейшего использования.
Без дополнительной информации трудно точно знать, что вы хотите. Однако, выбирая, какую структуру данных использовать, вы должны принять во внимание то, что вам нужно. Hashmaps не предназначены для сортировки - они предназначены для легкого извлечения. Поэтому в вашем случае вам, вероятно, придется извлечь каждый элемент из хэш-карты и поместить их в структуру данных, более удобную для сортировки, такую как куча или набор, а затем отсортировать их там.
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
В 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);
Comparator<Map.Entry<String, String>> valueComparator = Comparator.comparing(Map.Entry::getValue().getField());
– Mathias Ghys
18 April 2017 в 07:35