키와 값 모두에 대한 문자열이있는 맵이 있습니다.
데이터는 다음과 같습니다.
"question1", "1"
"question9", "1"
"question2", "4"
"question5", "2"
키를 기준으로 맵을 정렬하고 싶습니다. 결국에는 question1, question2, question3.... 등이 있습니다.
결국, 나는이 맵에서 두 개의 문자열을 얻으려고합니다.
지금 나는 다음을 가지고 있습니다.
Iterator it = paramMap.entrySet().iterator();
while (it.hasNext()) {
Map.Entry pairs = (Map.Entry) it.next();
questionAnswers += pairs.getKey() + ",";
}이것은 나에게 문자열로 질문을 받지만 순서가 맞지 않습니다.
답변:
를 사용하십시오 TreeMap. 이것이 바로 그 목적입니다.
이지도가 전달되어 유형을 결정할 수없는 경우 다음을 수행 할 수 있습니다.
SortedSet<String> keys = new TreeSet<>(map.keySet());
for (String key : keys) {
String value = map.get(key);
// do something
}이것은 자연스럽게 키 순서대로 맵을 반복합니다.
기술적으로 구현하는 모든 것을 사용할 수 SortedMap있지만 드문 경우를 제외하고 TreeMap는 Map구현 을 사용하는 것이 일반적으로 그렇듯이이 정도에 해당합니다 HashMap.
Comparable를 구현하지 않거나 다음 자연의 질서를 사용하지 않으려는 키가 복잡한 유형의 경우를 들어 TreeMap그리고 TreeSet당신이 전달하자 추가 생성자를 가지고 Comparator:
// placed inline for the demonstration, but doesn't have to be a lambda expression
Comparator<Foo> comparator = (Foo o1, Foo o2) -> {
...
}
SortedSet<Foo> keys = new TreeSet<>(comparator);
keys.addAll(map.keySet());를 사용할 때 기억 TreeMap나 TreeSet는 다른 성능 특성있을 것이라는 점을 HashMap또는 HashSet. 요소를 찾거나 삽입하는 대략적인 연산은 O (1) 에서 O (Log (N))로 이동 합니다.
A의 HashMap1 만 1000 개 항목에서 이동하는 것은 정말 요소를 조회하는 시간에 영향을 미치지 않지만, 대한 TreeMap조회 시간은 약 3 배 더 느리게 (로그인 가정 할 것이다 2 ). 1000에서 100,000으로 이동하면 모든 요소 조회에 대해 약 6 배 느려집니다.
TreeMap이 좋지 않다고 가정하고 제네릭을 사용할 수 없다고 가정합니다.
List sortedKeys=new ArrayList(yourMap.keySet());
Collections.sort(sortedKeys);
// Do what you need with sortedKeys.를 사용하여 TreeMap지도를 정렬 할 수 있습니다.
Map<String, String> map = new HashMap<>();
Map<String, String> treeMap = new TreeMap<>(map);
for (String str : treeMap.keySet()) {
System.out.println(str);
}TreeMap을 사용하십시오 !
이미 맵이 있고 키로 정렬하려면 다음을 사용하십시오.
Map<String, String> treeMap = new TreeMap<String, String>(yourMap);완전한 작업 예 :
import java.util.HashMap;
import java.util.Set;
import java.util.Map;
import java.util.TreeMap;
import java.util.Iterator;
class SortOnKey {
public static void main(String[] args) {
HashMap<String,String> hm = new HashMap<String,String>();
hm.put("3","three");
hm.put("1","one");
hm.put("4","four");
hm.put("2","two");
printMap(hm);
Map<String, String> treeMap = new TreeMap<String, String>(hm);
printMap(treeMap);
}//main
public static void printMap(Map<String,String> map) {
Set s = map.entrySet();
Iterator it = s.iterator();
while ( it.hasNext() ) {
Map.Entry entry = (Map.Entry) it.next();
String key = (String) entry.getKey();
String value = (String) entry.getValue();
System.out.println(key + " => " + value);
}//while
System.out.println("========================");
}//printMap
}//class당신이 사용할 수 없습니다 제공 TreeMap에 자바 (8) 우리는 사용 할 수 toMap () 메서드에서 Collectors어떤 매개 변수 다음 걸립니다를 :
자바 8 예제
Map<String,String> sample = new HashMap<>(); // push some values to map
Map<String, String> newMapSortedByKey = sample.entrySet().stream()
.sorted(Map.Entry.<String,String>comparingByKey().reversed())
.collect(Collectors.toMap(Map.Entry::getKey, Map.Entry::getValue, (e1, e2) -> e1, LinkedHashMap::new));
Map<String, String> newMapSortedByValue = sample.entrySet().stream()
.sorted(Map.Entry.<String,String>comparingByValue().reversed())
.collect(Collectors.toMap(Map.Entry::getKey, Map.Entry::getValue, (e1,e2) -> e1, LinkedHashMap::new));커스텀 비교기를 사용하고 다음과 같이 키를 기준으로 정렬하도록 예제를 수정할 수 있습니다.
Map<String, String> newMapSortedByKey = sample.entrySet().stream()
.sorted((e1,e2) -> e1.getKey().compareTo(e2.getKey()))
.collect(Collectors.toMap(Map.Entry::getKey, Map.Entry::getValue, (e1,e2) -> e1, LinkedHashMap::new));이 코드는 키-값 맵을 오름차순과 내림차순으로 정렬 할 수 있습니다.
<K, V extends Comparable<V>> Map<K, V> sortByValues
(final Map<K, V> map, int ascending)
{
Comparator<K> valueComparator = new Comparator<K>() {
private int ascending;
public int compare(K k1, K k2) {
int compare = map.get(k2).compareTo(map.get(k1));
if (compare == 0) return 1;
else return ascending*compare;
}
public Comparator<K> setParam(int ascending)
{
this.ascending = ascending;
return this;
}
}.setParam(ascending);
Map<K, V> sortedByValues = new TreeMap<K, V>(valueComparator);
sortedByValues.putAll(map);
return sortedByValues;
}예로서:
Map<Integer,Double> recommWarrVals = new HashMap<Integer,Double>();
recommWarrVals = sortByValues(recommWarrVals, 1); // Ascending order
recommWarrVals = sortByValues(recommWarrVals,-1); // Descending orderMap<K, V>키 를 기준으로 정렬하려면 키를 List<K>:
List<K> result = map.keySet().stream().sorted().collect(Collectors.toList());Map<K, V>키 를 기준으로 정렬하려면 다음과 같이 입력하십시오 List<Map.Entry<K, V>>.
List<Map.Entry<K, V>> result =
map.entrySet()
.stream()
.sorted(Map.Entry.comparingByKey())
.collect(Collectors.toList());마지막 으로, 로케일 구분 방식으로 문자열 을 정렬하려면 Collator (comparator) 클래스를 사용하십시오.
Collator collator = Collator.getInstance(Locale.US);
collator.setStrength(Collator.PRIMARY); // case insensitive collator
List<Map.Entry<String, String>> result =
map.entrySet()
.stream()
.sorted(Map.Entry.comparingByKey(collator))
.collect(Collectors.toList());Arrays.sort 메서드를 사용하여 키를 정렬 할 수도 있습니다.
Map<String, String> map = new HashMap<String, String>();
Object[] objArr = new Object[map.size()];
for (int i = 0; i < map.size(); i++) {
objArr[i] = map.get(i);
}
Arrays.sort(objArr);
for (Object str : objArr) {
System.out.println(str);
}당신이 사용하고 싶지 않은 경우에 대비하여 TreeMap
public static Map<Integer, Integer> sortByKey(Map<Integer, Integer> map) {
List<Map.Entry<Integer, Integer>> list = new ArrayList<>(map.entrySet());
list.sort(Comparator.comparingInt(Map.Entry::getKey));
Map<Integer, Integer> sortedMap = new HashMap<>();
list.forEach(sortedMap.put(e.getKey(), e.getValue()));
return sortedMap;
}또한을 values변경 Map.Entry::getKey하기 만하면 지도를 정렬하려는 경우Map.Entry::getValue