map의 value값으로 정렬 .내림차순

 public class Testing {
    public static void main(String[] args) {

        HashMap<String,Double> map = new HashMap<String,Double>();
        ValueComparator bvc =  new ValueComparator(map);
        TreeMap<String,Double> sorted_map = new TreeMap<String,Double>(bvc);

        map.put("A",99.5);
        map.put("B",67.4);
        map.put("C",67.4);
        map.put("D",67.3);

        System.out.println("unsorted map: "+map);

        sorted_map.putAll(map);

        System.out.println("results: "+sorted_map);
    }
}

class ValueComparator implements Comparator<String> {

    Map<String, Double> base;
    public ValueComparator(Map<String, Double> base) {
        this.base = base;
    }

    // Note: this comparator imposes orderings that are inconsistent with equals.    
    public int compare(String a, String b) {
        if (base.get(a) >= base.get(b)) {
            return -1;
        } else {
            return 1;
        } // returning 0 would merge keys
    }
}

Here's a generic-friendly version you're free to use:

import java.util.*;

public class MapUtil
{
    public static <K, V extends Comparable<? super V>> Map<K, V> 
        sortByValue( Map<K, V> map )
    {
        List<Map.Entry<K, V>> list =
            new LinkedList<Map.Entry<K, V>>( map.entrySet() );
        Collections.sort( list, new Comparator<Map.Entry<K, V>>()
        {
            public int compare( Map.Entry<K, V> o1, Map.Entry<K, V> o2 )
            {
                return (o1.getValue()).compareTo( o2.getValue() );
            }
        } );

        Map<K, V> result = new LinkedHashMap<K, V>();
        for (Map.Entry<K, V> entry : list)
        {
            result.put( entry.getKey(), entry.getValue() );
        }
        return result;
    }
}

And an associated JUnit4 test so you don't have to take my word for it:

import java.util.*;

import org.junit.*;

public class MapUtilTest
{
    @Test
    public void testSortByValue()
    {
        Random random = new Random(System.currentTimeMillis());
        Map<String, Integer> testMap = new HashMap<String, Integer>(1000);
        for(int i = 0 ; i < 1000 ; ++i) {
            testMap.put( "SomeString" + random.nextInt(), random.nextInt());
        }

        testMap = MapUtil.sortByValue( testMap );
        Assert.assertEquals( 1000, testMap.size() );

        Integer previous = null;
        for(Map.Entry<String, Integer> entry : testMap.entrySet()) {
            Assert.assertNotNull( entry.getValue() );
            if (previous != null) {
                Assert.assertTrue( entry.getValue() >= previous );
            }
            previous = entry.getValue();
        }
    }

}

Java 7 Version

public static <K, V extends Comparable<? super V>> Map<K, V>

    sortByValue( Map<K, V> map )
{
    List<Map.Entry<K, V>> list =
        new LinkedList<>( map.entrySet() );
    Collections.sort( list, new Comparator<Map.Entry<K, V>>()
    {
        @Override
        public int compare( Map.Entry<K, V> o1, Map.Entry<K, V> o2 )
        {
            return (o1.getValue()).compareTo( o2.getValue() );
        }
    } );

    Map<K, V> result = new LinkedHashMap<>();
    for (Map.Entry<K, V> entry : list)
    {
        result.put( entry.getKey(), entry.getValue() );
    }
    return result;
}

Java 8 Version

public static <K, V extends Comparable<? super V>> Map<K, V>

    sortByValue( Map<K, V> map )
{
      Map<K,V> result = new LinkedHashMap<>();
     Stream <Entry<K,V>> st = map.entrySet().stream();

     st.sorted(Comparator.comparing(e -> e.getValue()))
          .forEach(e ->result.put(e.getKey(),e.getValue()));

     return result;
}

Map(HashMap)에 있는 value를 sort 하는 방법

샘플 코드

List<TestBean> testList = new ArrayList<TestBean>(testMap.values());

Comparator<TestBean> c = Collections.reversOrder();

Collections.sort(testList, c);

위의 예처럼

1. 먼저 대상 맵의 value 만을 가지고 리스트를 하나 만든다.

2. 어떻게 비교할것인지 정한다 (여기선 내림차순)

3. Collections.sort 메소드에 위에서 만든 대상 리스트와 비교 방법을 넣어준다.

이렇게 하면 리스트가 정렬되어있다

여기서 리스트가 직접 정의한 클래스를 대상으로 비교를 해야하는 경우에는

해당 클래스가 Comparable 인터페이스를 구현하고, compareTo() 메소드를 오버라이드 하고 있어야 한다

위의 예를 들면(여기서는 해당 객체의 count를 가지고 비교를 하려고 한다)

public TestBean implements Comparable{

private int count;

public int compareTo(Object arg0){

TestBean comparer = (TestBean) arg0;

return this.count - comparer.count;

}

요렇게 되어있으면 된다!!

[Java] Map, Table의 value 값 정렬

TreeMap이라고 하여 key 값으로 자동 정렬해주는 데이터구조는 있지만

value값으로는 정렬이 불가능하다. 이를 위해서는 Comparator를 재정의하여 사용할 수 있다.

예제에서는 Hashtable을 사용하나, HashMap 등 key, value값으로 이루어진 데이터 구조는 모두 동일하게 사용 가능하다고 본다.

List<Map.Entry<String, Integer>> list = new ArrayList<Map.Entry<String, Integer>>(table.entrySet());

우선 table의 entrySet을 받아서 ArrayList에 저장한다. 이 때 중요한 점은 ArrayList의 타입이 Map.Entry<K,V> 라는 것이다.

이렇게 하면 List에 key, value의 object를 저장할 수 있다.

Collections.sort(list, new Comparator<Map.Entry<String, Integer>>() {

public int compare(Map.Entry<String, Integer> e1, Map.Entry<String, Integer> e2)

{

if (e1.getValue() == e2.getValue())

return e1.getKey().compareTo(e2.getKey());

else

return e2.getValue().compareTo(e1.getValue());

}

});

이 list에 대해 Collections의 sort 함수를 사용하는데 이때 Comparator를 정의한다.

compare 함수에서는 value 값인 integer 값을 비교하며, (위와 같은 방식이면 내림차순)

만약 value 값이 같으면 key 값을 비교하여 오름차순으로 정렬되도록 한다.

이렇게 sort함수에 넣으면 list 는 정렬이 되고, 이 list를 출력해보면 정렬된 결과를 얻을 수 있다.

하지만 List의 타입이 Map.Entry<String, Integer> 이기 때문에 여간 불편한게 아니다.

그래서 HashMap에 넣는다.

LinkedHashMap<String, Integer> result = new LinkedHashMap<String, Integer>();

for (Map.Entry<String, Integer> e : list)

result.put(e.getKey(), e.getValue());

그냥 HashMap에 넣을 경우 put 과정에서 순서 보장이 안되므로 LinkedHashMap에 넣어야 한다.

그래서 어차피 LinkedHashMap은 HashMap을 상속받은거라 HashMap으로 return하는데는 문제가 없다.

import java.util.ArrayList;
import java.util.Collections;
import java.util.Comparator;
import java.util.HashMap;
import java.util.Iterator;
import java.util.List;
import java.util.Map;
  
  
public class Test {
  
    public static void main(String[] args) {
        Map<string,integer> map = new HashMap<string,integer>();
        map.put("a",3);
        map.put("b",2);
        map.put("c",1);
         
        System.out.println("------------sort 전 -------------");
        System.out.println(map);
         
        Iterator it = Test.sortByValue(map).iterator();
         
         
        System.out.println("---------sort 후------------");
        while(it.hasNext()){
            String temp = (String) it.next();
            System.out.println(temp + " = " + map.get(temp));
        }
        //System.out.println(map);
    }
     
    public static List sortByValue(final Map map){
        List<string> list = new ArrayList();
        list.addAll(map.keySet());
         
        Collections.sort(list,new Comparator(){
             
            public int compare(Object o1,Object o2){
                Object v1 = map.get(o1);
                Object v2 = map.get(o2);
                 
                return ((Comparable) v1).compareTo(v2);
            }
             
        });
        Collections.reverse(list); // 주석시 오름차순
        return list;
    }
}
</string></string,integer></string,integer>

When you use a TreeMap, the entries in the Map is sorted by the keys.

This following code outputs the elements of the map sorted by value.

import java.util.*;

@SuppressWarnings("unchecked") // for JDK 1.5 and above
public class HashMapSort {
    public static void main(String[] args) {
        Map m = new HashMap();
        m.put("a", "some");
        m.put("b", "random");
        m.put("c", "words");
        m.put("d", "to");
        m.put("e", "be");
        m.put("f", "sorted");
        m.put("g", "by");
        m.put("h", "value");
        for (Iterator i = sortByValue(m).iterator(); i.hasNext(); ) {
            String key = (String) i.next();
            System.out.printf("key: %s, value: %s\n", key, m.get(key));
        }
    }

    public static List sortByValue(final Map m) {
        List keys = new ArrayList();
        keys.addAll(m.keySet());
        Collections.sort(keys, new Comparator() {
            public int compare(Object o1, Object o2) {
                Object v1 = m.get(o1);
                Object v2 = m.get(o2);
                if (v1 == null) {
                    return (v2 == null) ? 0 : 1;
                }
                else if (v1 instanceof Comparable) {
                    return ((Comparable) v1).compareTo(v2);
                }
                else {
                    return 0;
                }
            }
        });
        return keys;
    }
}

The output is:

key: e, value: be
key: g, value: by
key: b, value: random
key: a, value: some
key: f, value: sorted
key: d, value: to
key: h, value: value
key: c, value: words

Map param = new HashMap();

param.put("A", "2");

param.put("B", "1");

param.put("C", "4");

param.put("D", "3");

Collection cols = param.values();

List temps = new ArrayList(cols);

Collections.sort(temps);

if (temps != null) {

for (int i = 0, j = temps.size() ; i < j ; i++) {

System.out.println(i + "번째 값은 : " + (String)temps.get(i));

}

위에는 오름차순 정렬이구요

내림차순 정렬하실려면

Collections.sort(temps, Collections.reverseOrder());

이걸루 바꾸세요.