Java에서 HashMap을 정렬하는 방법

Java에서 HashMap을 정렬하는 방법

이 질문에는 이미 답변이 있습니다.

값별로 맵 정렬 <키, 값> (63 회답)

닫힘3년 전.

'어느 정도'를할 수 있을까요?HashMap<key, ArrayList>

의의 the the the in in in in in in in in in in in in in 의 값을 기준으로 정렬하고 싶습니다.의 값을 .ArrayList.

HashMap을 사용해야 합니까?맵 인터페이스만 필요한 경우 TreeMap을 사용합니다.

---

해시맵의 값을 비교하여 정렬하는 경우.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 HashMap에 ).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

해당되는 경우 커스텀 컴퍼레이터를 전달할 수 있습니다.

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

터키어 알파벳 또는 영어 이외의 다른 언어에 대한 기능을 포함하는 사용자 정의 비교 기능.

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을 사용할 수 있습니다.

물론 키는 정렬에 사용되는 값이어야 합니다.

Linked Hash Map을 사용하는 것을 고려해 본 적이 있습니까?< > ( ) .. ?

  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

여기서 선택한 정렬 부분을 확인합니다.

키와 값을 기준으로 지도를 정렬할 수 있는 클래스를 개발했습니다.기본 아이디어는 키를 사용하여 지도를 정렬하는 경우 맵에서 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

값을 기준으로 해시 맵 정렬:

다른 사람들이 지적한 것처럼.해시맵은 쉽게 검색할 수 있는 맵입니다.이 맵을 변경하거나 맵 내에서 정렬하려고 하면 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 자체는 정렬을 유지할 수 없습니다.해시 맵이며 해시 값은 정렬되지 않습니다.따라서 필요할 때 키를 정렬한 다음 위의 예시와 같이 값에 순서대로 액세스하거나 Apache Commons에 있는 Pair와 Tuples의 ArrayList와 같이 데이터를 저장하는 다른 컬렉션을 찾을 수 있습니다.

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

여기 git 링크가 있습니다.

해시맵을 쌍 클래스가 있는 ArrayList로 변환합니다.

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

로.

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

원하는 대로 정렬하거나 순서를 추가하여 정렬할 수 있습니다.

Java에서 해시 맵을 값별로 정렬하는 중

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