Java에서 Map 값을 키별로 정렬하려면 어떻게 해야 합니까?

Java에서 Map 값을 키별로 정렬하려면 어떻게 해야 합니까?

키와 값 모두에 대한 문자열이 있는 맵이 있습니다.

데이터는 다음과 같습니다.

" "question1", "1"
"question9", "1"
"question2", "4"
"question5", "2"

키를 기준으로 지도를 정렬하고 싶습니다.ㅇㅇㅇㅇㅇㅇ, ㅇㅇㅇㅇㅇ로 .question1, question2, question3......★★★★★★ 。

나는에서 두 .

• 첫 번째 문자열:질문 (순서 1 ..10)
• 두 번째 문자열:답변(질문과 같은 순서)

현재 저는 다음과 같은 것을 가지고 있습니다.

Iterator it = paramMap.entrySet().iterator();
while (it.hasNext()) {
    Map.Entry pairs = (Map.Entry) it.next();
    questionAnswers += pairs.getKey() + ",";
}

이렇게 하면 질문들이 줄지어 나오지만 순서가 맞지 않습니다.

단답

a를 사용하세요. 이게 바로 그 용도입니다.

이 맵이 전달되어도 유형을 확인할 수 없는 경우 다음을 수행할 수 있습니다.

SortedSet<String> keys = new TreeSet<>(map.keySet());
for (String key : keys) { 
   String value = map.get(key);
   // do something
}

이것은 키의 자연스러운 순서로 맵 전체에서 반복됩니다.

---

더 긴 답변

말하면, '이든', '무엇이든', '무엇이든'을 구현하는 것을 사용할 수 있습니다.SortedMap, 드문 하고 이 은 ', ', '에 해당합니다TreeMap「」를 하는 것과 Map으로 현현보보 implement에 해당한다.HashMap

가 않은 이거나 자연스러운 Comparible은 Comparible을 사용합니다.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)로 넘어갑니다.

①의 HashMap에서 10의 항목으로 하는 것은 하는 데 큰 을 주지 1000개의 에서 10,000개의 항목은 조회 시간에 을 주지 않습니다.TreeMap조회 시간이 약 3배 느려집니다(Log를 가정₂).1000에서 100,000으로 이동하는 것은 모든 요소 검색에 대해 약 6배 느려집니다.

Tree Map이 당신에게 좋지 않다고 가정할 때(그리고 제네릭을 사용할 수 없다고 가정할 때):

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만 사용

new TreeMap<String, String>(unsortMap);

TreeMap은 '키'의 자연스러운 순서에 따라 정렬됩니다.

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

「 」를 할 수 TreeMapJava 8에서는 toMap() 메서드를 사용할 수 있습니다.Collectors여기에는 다음 파라미터가 필요합니다.

• keymapper: 키를 생성하기 위한 매핑 기능
• valuemapper: 값을 생성하기 위한 매핑 함수
• merge Function : 같은 키에 관련된 값 간의 충돌을 해결하기 위해 사용되는 병합 함수
• mapSupplier: 결과를 삽입할 새 빈 Map을 반환하는 함수입니다.

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

Java 8 사용:

Map<String, Integer> sortedMap = unsortMap.entrySet().stream()
            .sorted(Map.Entry.comparingByKey())
            .collect(Collectors.toMap(Map.Entry::getKey, Map.Entry::getValue,
                    (oldValue, newValue) -> oldValue, LinkedHashMap::new));

Java 8의 경우

를 Map<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(비교자) 클래스를 사용합니다.

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

이 코드는 키 값 맵을 오름차순과 내림차순으로 정렬할 수 있습니다.

<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 order

List<String> list = new ArrayList<String>();
Map<String, String> map = new HashMap<String, String>();
for (String str : map.keySet()) {
 list.add(str);
}
Collections.sort(list);
for (String str : list) {
 System.out.println(str);
}

Java 8에서는 .stream().sorted()도 사용할 수 있습니다.

myMap.keySet().stream().sorted().forEach(key -> {
        String value = myMap.get(key);

        System.out.println("key: " + key);
        System.out.println("value: " + value);
    }
);

을 위해, ★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★.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 LinkedHashMap<>();
        list.forEach(e -> sortedMap.put(e.getKey(), e.getValue()));
        return sortedMap;
    }

「 」, 「 」에을 정렬하고 :valuesMap.Entry::getKey로로 합니다.Map.Entry::getValue

LinkedHashMap을 사용하다아, 아, 아, 아, 아, 아, 아, 아, 아, 아, 아, 아, 아, 아, 아, 아, 아, 아, 아, 아, 아, 아, 아, 아, 아, 아, 아,HashMap. 둘 다 , 하다, 둘 다 시행합니다.Map인터페이스, 따라서 당신은 초기화를 개체 초기화 object를치환하기만 하면 됩니다를 바꿀 수 있습니다.HashMap로.LinkedHashMap..

아래의 트리 맵은 어떻습니까?

Map<String, String> sortedMap = new TreeMap<>(Comparator.comparingInt(String::length)
.thenComparing(Function.identity()));

무엇 당신이 이 sortedMap을 자동으로 정렬됩니다.이sortedMap에 무엇을자동으로 정렬됩니다 넣든.우선 일단은의TreeMap분류된 실장의 정렬된 구현Map인터페이스.로[자연스러운 질서fashion][https://docs.oracle.com/javase/tutorial/collections/interfaces/order.html].[자연주문 패션][https://docs.oracle.com/javase/tutorial/collections/interfaces/order.html]에 키를정렬하는 방법이 있습니다에서 키를 분류하 인터페이스지만 있다.자바 의사로서 자바 doc의 설명대로 말한다.String매개 변수 형식은 Lexicographic 자연 주문 형식입니다.type은 Lexicographic 자연 순서 유형입니다.. 것으로 예상되지 않는 아래 목록을 정렬됩니다 번호의 String형식과 아래의 목록을 상상해 보세요.아래의 타입의숫자리스트를 상상해 주세요에서 상속됨.아래의 평균은 예상대로정렬되지 않습니다.

List<String> notSortedList = List.of("78","0", "24", "39", "4","53","32");

만약 당신이 단지 기본 디폴트인 경우.TreeMap아래와 같이 컨스트럭터를 한 개씩 푸시합니다.

    Map<String, String> map = new TreeMap<>();
    for (String s : notSortedList) {
        map.put(s, s);
    }


    System.out.println(map);

은 다음과 같습니다.{0=0, 14=14, 24=24, 32=32, 39=39, 4=4, 48=48, 53=53, 54=54, 78=78}

예를 들어, 4번은 '39' 뒤에 나옵니다.이것이 String과 같은 사전 데이터 유형의 특성입니다.만약 그것이 Integer 데이터 타입이었다면 그것은 괜찮았습니다.

이 문제를 해결하려면 인수를 사용하여 String의 길이를 확인한 후 비교합니다.Java 8에서는 다음과 같이 동작합니다.

Map<String, String> sortedMap = new TreeMap<>(Comparator.comparingInt(String::length)
.thenComparing(Function.identity()));

각 , 이 방법으로 합니다.compareTo비교할 요소와 동일한 입력으로 사용됩니다.

보다 알기 쉬운 방법을 사용하고 싶은 경우, 위의 코드는 아래 코드와 동일합니다.

   Map<String, String> sortedMap = new TreeMap<>(
             new Comparator<String>() {
                @Override
                public int compare(String o1, String o2) {
                    int lengthDifference = o1.length() - o2.length();
                    if (lengthDifference != 0) return lengthDifference;
                    return o1.compareTo(o2);
                }
            }
    );

냐하 because는TreeMapComposite는 Compositator Interface를 사용합니다.

이 버전도 더 단순화된 다른 형태입니다.

    Map<String,String> sortedMap = new TreeMap<>(
           (Comparator<String>) (o1, o2) ->
            {
                int lengthDifference = o1.length() - o2.length();
                if (lengthDifference != 0) return lengthDifference;
                return o1.compareTo(o2);
            }
    );

어레이를 사용하여 키를 정렬할 수도 있습니다.정렬 방식

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

여기에는 좋은 해결책이 제시되어 있습니다.저희 회사에는HashMap이치노.TreeMap하여 TreeMap은 HashMap의 TreeMap을 합니다.putAll는 키됩니다.TreeMap tree tree tree tree tree tree tree tree tree tree tree 。

언급URL : https://stackoverflow.com/questions/922528/how-to-sort-map-values-by-key-in-java