반응형
Java에서 HashMap을 정렬하는 방법
이 질문에는 이미 답변이 있습니다.
- 값을 기준으로 맵 <키, 값> 정렬 51 답변
어떻게 정렬 할 수 HashMap<key, ArrayList>있습니까?
의 값을 기준으로 정렬하고 싶습니다 ArrayList.
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>>집합 및 목록의 의미가 약간 다르지만 요소를에 삽입 할 수 있습니다 .
hasmap 키를 기준으로 정렬 된 목록 :
SortedSet<String> keys = new TreeSet<String>(myHashMap.keySet());
해시 맵 값을 기준으로 정렬 된 목록 :
SortedSet<String> values = new TreeSet<String>(myHashMap.values());
중복 된지도 값의 경우 :
List<String> mapValues = new ArrayList<String>(myHashMap.values());
Collections.sort(mapValues);
행운을 빕니다!
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나중에 사용할 수 있습니다.
트리 맵을 원할 것 같습니다.
http://docs.oracle.com/javase/7/docs/api/java/util/TreeMap.html
해당되는 경우 사용자 지정 비교기를 전달할 수 있습니다.
자바 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);
터키어 알파벳 또는 영어 이외의 다른 언어 기능 을 포함하는 사용자 정의 비교 기능 .
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);
더 이상 정보가 없으면 원하는 것을 정확히 아는 것이 어렵습니다. 그러나 사용할 데이터 구조를 선택할 때 필요한 데이터 구조를 고려해야합니다. 해시 맵은 정렬을 위해 설계되지 않았으며 쉽게 검색 할 수 있도록 설계되었습니다. 따라서 귀하의 경우 해시 맵에서 각 요소를 추출하여 힙이나 집합과 같은 정렬에 더 도움이되는 데이터 구조에 넣은 다음 정렬해야합니다.
효율적인 검색을 위해 Map을 SortedMap과 결합하려면 ConcurrentSkipListMap을 사용할 수 있습니다 .
물론 정렬에 사용되는 값이 키가 필요합니다.
키와 값을 기준으로지도를 정렬하는 데 사용할 수있는 클래스를 개발했습니다. 기본 아이디어는 키를 사용하여지도를 정렬 한 다음지도에서 키를 기준으로 정렬하는 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
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
값으로 해시 맵 정렬 :
다른 사람들이 지적했듯이. 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
}
정답입니다.
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 자체는 정렬을 유지할 수 없습니다. 그것은이다 해시 지도 및 해시 값은 정렬되지 않은 있습니다. 따라서 위에서 설명했듯이 필요할 때 키를 정렬 한 다음 값에 순서대로 액세스하거나 데이터를 저장하는 다른 컬렉션 (예 : Pairs / Tuples의 ArrayList of Pairs 등)을 찾을 수 있습니다. 아파치 커먼즈 :
https://commons.apache.org/proper/commons-lang/apidocs/org/apache/commons/lang3/tuple/Pair.html
키를 기준으로 정렬 :
public static void main(String[] args) {
Map<String,String> map = new HashMap<>();
map.put("b", "dd");
map.put("c", "cc");
map.put("a", "aa");
map = new TreeMap<>(map);
for (String key : map.keySet()) {
System.out.println(key+"="+map.get(key));
}
}
완전히 테스트 된 작업 솔루션을 개발했습니다. 그것이 도움이되기를 바랍니다.
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;
}
}
}
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());
}
}
}
여기 자식 링크가 있습니다
페어 클래스를 사용하여 해시 맵을 ArrayList로 변환
Hashmap<Object,Object> items = new HashMap<>();
에
List<Pair<Object,Object>> items = new ArrayList<>();
원하는대로 정렬하거나 순서를 추가하여 정렬 할 수 있습니다.
Java에서 값을 기준으로 HashMap 정렬 :
public class HashMapSortByValue {
public static void main(String[] args) {
HashMap<Long,String> unsortMap = new HashMap<Long,String>();
unsortMap.put(5l,"B");
unsortMap.put(8l,"A");
unsortMap.put(2l, "D");
unsortMap.put(7l,"C" );
System.out.println("Before sorting......");
System.out.println(unsortMap);
HashMap<Long,String> sortedMapAsc = sortByComparator(unsortMap);
System.out.println("After sorting......");
System.out.println(sortedMapAsc);
}
public static HashMap<Long,String> sortByComparator(
HashMap<Long,String> unsortMap) {
List<Map.Entry<Long,String>> list = new LinkedList<Map.Entry<Long,String>>(
unsortMap.entrySet());
Collections.sort(list, new Comparator<Map.Entry<Long,String>> () {
public int compare(Map.Entry<Long,String> o1, Map.Entry<Long,String> o2) {
return o1.getValue().compareTo(o2.getValue());
}
});
HashMap<Long,String> sortedMap = new LinkedHashMap<Long,String>();
for (Entry<Long,String> entry : list) {
sortedMap.put(entry.getKey(), entry.getValue());
}
return sortedMap;
}
}
참고 URL : https://stackoverflow.com/questions/780541/how-to-sort-a-hashmap-in-java
반응형
'program tip' 카테고리의 다른 글
| 교리 2의 대리 란 무엇입니까? (0) | 2020.07.30 |
|---|---|
| Express 앱에서 디버깅을 제거하는 방법은 무엇입니까? (0) | 2020.07.30 |
| AngularJs에서 ng-repeat로 필터링 (키, 값)하는 방법은 무엇입니까? (0) | 2020.07.30 |
| Powershell v3 Invoke-WebRequest HTTPS 오류 (0) | 2020.07.30 |
| Java에서 URL 또는 URI를 작성하는 관용적 방법은 무엇입니까? (0) | 2020.07.30 |