Sort a Map Key Value by values

Question

I am relatively new to Java  and often find that I need to sort a Map lt Key  Value gt  on the values   Since the values are not unique  I find myself converting the keySet into an array  and sorting that array through array sort with a custom comparator that sorts on the value associated with the key   Is there an easier way

User · Answer

Late Entry   With the advent of Java-8  we can use streams for data manipulation in a very easy succinct way  You can use streams to sort the map entries by value and create a LinkedHashMap which preserves insertion-order iteration   Eg   LinkedHashMap sortedByValueMap   map entrySet   stream                    sorted comparing Entry lt Key Value gt   getValue  thenComparing Entry  getKey         first sorting by Value  then sorting by Key entries with same value                   collect LinkedHashMap  new  map entry  - gt  map put entry getKey   entry getValue    LinkedHashMap  putAll       For reverse ordering  replace   comparing Entry lt Key Value gt   getValue  thenComparing Entry  getKey    with  comparing Entry lt Key Value gt   getValue  thenComparing Entry  getKey  reversed

User · Answer

The simplest brute-force sortHashMap method for HashMap lt String  Long gt   you can just copypaste it and use like this   public class Test        public static void main String   args             HashMap lt String  Long gt  hashMap   new HashMap lt  gt             hashMap put  Cat    long  4           hashMap put  Human    long  2           hashMap put  Dog    long  4           hashMap put  Fish    long  0           hashMap put  Tree    long  1           hashMap put  Three-legged-human    long  3           hashMap put  Monkey    long  2            System out println hashMap       Human 2  Cat 4  Three-legged-human 3  Monkey 2  Fish 0  Tree 1  Dog 4          System out println sortHashMap hashMap        Cat 4  Dog 4  Three-legged-human 3  Human 2  Monkey 2  Tree 1  Fish 0             public LinkedHashMap lt String  Long gt  sortHashMap HashMap lt String  Long gt  unsortedMap             LinkedHashMap lt String  Long gt  result   new LinkedHashMap lt  gt                add String keys to an array  the array would get sorted  based on those keys  values         ArrayList lt String gt  sortedKeys   new ArrayList lt  gt             for  String key  unsortedMap keySet                   sortedKeys add key                        sort the ArrayList lt String gt  of keys             for  int i 0  i lt unsortedMap size    i                   for  int j 1  j lt sortedKeys size    j                       if  unsortedMap get sortedKeys get j    gt  unsortedMap get sortedKeys get j-1                          String temp   sortedKeys get j                       sortedKeys set j  sortedKeys get j-1                        sortedKeys set j-1  temp                                                         construct the result Map         for  String key  sortedKeys                 result put key  unsortedMap get key                       return result

User · Answer

Instead of using Collections sort as some do I d suggest using Arrays sort  Actually what Collections sort does is something like this   public static  lt T extends Comparable lt   super T gt  gt  void sort List lt T gt  list        Object   a   list toArray        Arrays sort a       ListIterator lt T gt  i   list listIterator        for  int j 0  j lt a length  j              i next            i set  T a j              It just calls toArray on the list and then uses Arrays sort  This way all the map entries will be copied three times  once from the map to the temporary list  be it a LinkedList or ArrayList   then to the temporary array and finally to the new map   My solution ommits this one step as it does not create unnecessary LinkedList  Here is the code  generic-friendly and performance-optimal   public static  lt K  V extends Comparable lt   super V gt  gt  Map lt K  V gt  sortByValue Map lt K  V gt  map          SuppressWarnings  unchecked       Map Entry lt K V gt    array   map entrySet   toArray new Map Entry map size           Arrays sort array  new Comparator lt Map Entry lt K  V gt  gt                   public int compare Map Entry lt K  V gt  e1  Map Entry lt K  V gt  e2                         return e1 getValue   compareTo e2 getValue                            Map lt K  V gt  result   new LinkedHashMap lt K  V gt         for  Map Entry lt K  V gt  entry   array          result put entry getKey    entry getValue          return result

User · Answer

as map is unordered  to sort it  we can do following   Map lt String  String gt  map  new TreeMap lt String  String gt  unsortMap     You should note that  unlike a hash map  a tree map guarantees that its elements will be sorted in ascending key order

User · Answer

Some simple changes in order to have a sorted map with pairs that have duplicate values  In the compare method  class ValueComparator  when values are equal do not return 0 but return the result of comparing the 2 keys  Keys are distinct in a map so you succeed to keep duplicate values  which are sorted by keys by the way   So the above example could be modified like this       public int compare Object a  Object b             if  Double base get a   lt   Double base get b               return 1            else if  Double base get a      Double base get b               return   String a  compareTo  String b             else             return -1

User · Answer

creates a list of entries for each value  where the values are sorted requires Java 8 or above  Map lt Double List lt Entry lt String Double gt  gt  gt  sorted   map entrySet   stream   collect  Collectors groupingBy  Entry  getValue  TreeMap  new      Collectors mapping  Function identity    Collectors toList            using the map   A 99 5    B 67 4    C 67 4    D 67 3   gets  67 3  D 67 3   67 4  B 67 4  C 67 4   99 5  A 99 5       and how to access each entry one after the other   sorted entrySet   forEach  e - gt  e getValue   forEach  l - gt  System out println  l          D 67 3 B 67 4 C 67 4 A 99 5

User · Answer

This method will just serve the purpose   the  setback  is that the Values must implement the java util Comparable interface             Sort a map according to values       param  lt K gt  the key of the map      param  lt V gt  the value to sort according to      param mapToSort the map to sort       return a map sorted on the values        public static  lt K  V extends Comparable lt    super V gt  gt  Map lt K  V gt  sortMapByValues final Map  lt K  V gt  mapToSort        List lt Map Entry lt K  V gt  gt  entries           new ArrayList lt Map Entry lt K  V gt  gt  mapToSort size            entries addAll mapToSort entrySet          Collections sort entries                       new Comparator lt Map Entry lt K  V gt  gt                   Override         public int compare                 final Map Entry lt K  V gt  entry1                 final Map Entry lt K  V gt  entry2                        return entry1 getValue   compareTo entry2 getValue                                  Map lt K  V gt  sortedMap   new LinkedHashMap lt K  V gt                for  Map Entry lt K  V gt  entry   entries                sortedMap put entry getKey    entry getValue                       return sortedMap       http   javawithswaranga blogspot com 2011 06 generic-method-to-sort-hashmap html

User · Answer

Afaik the most cleaner way is utilizing collections to sort map on value   Map lt String  Long gt  map   new HashMap lt String  Long gt        populate with data to sort on Value    use datastructure designed for sorting  Queue queue   new PriorityQueue  map size    new MapComparable      queue addAll  map entrySet          get a sorted map LinkedHashMap lt String  Long gt  linkedMap   new LinkedHashMap lt String  Long gt      for  Map Entry lt String  Long gt  entry   entry   queue poll     null         linkedMap put entry getKey    entry getValue        public static class MapComparable implements Comparator lt Map Entry lt String  Long gt  gt      public int compare Entry lt String  Long gt  e1  Entry lt String  Long gt  e2        return e1 getValue   compareTo e2 getValue

User · Answer

To accomplish this with the new features in Java 8   import static java util Map Entry comparingByValue  import static java util stream Collectors toList    lt K  V gt  List lt Entry lt K  V gt  gt  sort Map lt K  V gt  map  Comparator lt   super V gt  comparator        return map entrySet   stream   sorted comparingByValue comparator   collect toList         The entries are ordered by their values using the given comparator  Alternatively  if your values are mutually comparable  no explicit comparator is needed    lt K  V extends Comparable lt   super V gt  gt  List lt Entry lt K  V gt  gt  sort Map lt K  V gt  map        return map entrySet   stream   sorted comparingByValue    collect toList         The returned list is a snapshot of the given map at the time this method is called  so neither will reflect subsequent changes to the other  For a live iterable view of the map    lt K  V extends Comparable lt   super V gt  gt  Iterable lt Entry lt K  V gt  gt  sort Map lt K  V gt  map        return    - gt  map entrySet   stream   sorted comparingByValue    iterator        The returned iterable creates a fresh snapshot of the given map each time it s iterated  so barring concurrent modification  it will always reflect the current state of the map

User · Answer

From http   www programmersheaven com download 49349 download aspx  private static  lt K  V gt  Map lt K  V gt  sortByValue Map lt K  V gt  map        List lt Entry lt K  V gt  gt  list   new LinkedList lt  gt  map entrySet         Collections sort list  new Comparator lt Object gt               SuppressWarnings  unchecked           public int compare Object o1  Object o2                return   Comparable lt V gt     Map Entry lt K  V gt    o1   getValue    compareTo   Map Entry lt K  V gt    o2   getValue                            Map lt K  V gt  result   new LinkedHashMap lt  gt         for  Iterator lt Entry lt K  V gt  gt  it   list iterator    it hasNext               Map Entry lt K  V gt  entry    Map Entry lt K  V gt   it next            result put entry getKey    entry getValue                return result

User · Answer

This has the added benefit of being able to sort ascending or descending  using Java 8  import static java util Comparator comparingInt  import static java util stream Collectors toMap  import java util LinkedHashMap  import java util Map  import java util Map Entry  import java util stream Collectors  import java util stream Stream   class Utils       public static Map lt String  Integer gt  sortMapBasedOnValues Map lt String  Integer gt  map  boolean descending            int multiplyBy    descending    -1  1          Map lt String  Integer gt  sorted    map entrySet   stream                    sorted comparingInt e - gt  multiplyBy   e getValue                       collect toMap                          Map Entry  getKey                           Map Entry  getValue                           a  b  - gt    throw new AssertionError                              LinkedHashMap  new                                 return sorted

User · Answer

Depending on the context  using java util LinkedHashMap lt T gt  which rememebers the order in which items are placed into the map   Otherwise  if you need to sort values based on their natural ordering  I would recommend maintaining a separate List which can be sorted via Collections sort

User · Answer

You can try Guava s multimaps   TreeMap lt Integer  Collection lt String gt  gt  sortedMap   new TreeMap lt  gt           Multimaps invertFrom Multimaps forMap originalMap            ArrayListMultimap  lt Integer  String gt create    asMap       As a result you get a map from original values to collections of keys that correspond to them  This approach can be used even if there are multiple keys for the same value

User · Answer

Use java util TreeMap    The map is sorted according to the natural ordering of its keys  or by a Comparator provided at map creation time  depending on which constructor is used

User · Answer

I ve merged the solutions of user157196 and Carter Page   class MapUtil        public static  lt K  V extends Comparable lt   super V gt  gt  Map lt K  V gt  sortByValue  Map lt K  V gt  map            ValueComparator lt K V gt  bvc    new ValueComparator lt K V gt  map           TreeMap lt K V gt  sorted map   new TreeMap lt K V gt  bvc           sorted map putAll map           return sorted map            class ValueComparator lt K  V extends Comparable lt   super V gt  gt  implements Comparator lt K gt         Map lt K  V gt  base      public ValueComparator Map lt K  V gt  base            this base   base             public int compare K a  K b            int result    base get a  compareTo base get b             if  result    0  result 1             returning 0 would merge keys         return result

User · Answer

If there s not any value bigger than the size of the map  you could use arrays  this should be the fastest approach   public List lt String gt  getList Map lt String  Integer gt  myMap        String   copyArray   new String myMap size         for  Entry lt String  Integer gt  entry   myMap entrySet              copyArray entry getValue      entry getKey              return Arrays asList copyArray

User · Answer

Best Approach  import java util ArrayList  import java util Collections  import java util Comparator  import java util HashMap  import java util List  import java util Map  import java util Set  import java util Map Entry    public class OrderByValue      public static void main String a         Map lt String  Integer gt  map   new HashMap lt String  Integer gt         map put  java   20       map put  C     45       map put  Unix   67       map put  MAC   26       map put  Why this kolavari   93       Set lt Entry lt String  Integer gt  gt  set   map entrySet        List lt Entry lt String  Integer gt  gt  list   new ArrayList lt Entry lt String  Integer gt  gt  set       Collections sort  list  new Comparator lt Map Entry lt String  Integer gt  gt                  public int compare  Map Entry lt String  Integer gt  o1  Map Entry lt String  Integer gt  o2                         return  o1 getValue    compareTo  o2 getValue       Ascending order               return  o2 getValue    compareTo  o1 getValue       Descending order                        for Map Entry lt String  Integer gt  entry list           System out println entry getKey            entry getValue                  Output  java      20  MAC      26  C        45  Unix      67  Why this kolavari      93

User · Answer

Simple way to sort any map in Java 8 and above Map lt String  Object gt  mapToSort   new HashMap lt  gt      List lt Map Entry lt String  Object gt  gt  list   new LinkedList lt  gt  mapToSort entrySet      Collections sort list  Comparator comparing o - gt  o getValue   getAttribute       HashMap lt String  Object gt  sortedMap   new LinkedHashMap lt  gt     for  Map Entry lt String  Object gt  map   list       sortedMap put map getKey    map getValue        if you are using Java 7 and below Map lt String  Object gt  mapToSort   new HashMap lt  gt      List lt Map Entry lt String  Object gt  gt  list   new LinkedList lt  gt  mapToSort entrySet      Collections sort list  new Comparator lt Map Entry lt String  Object gt  gt           Override     public int compare Map Entry lt String  Object gt  o1  Map Entry lt String  Object gt  o2           return o1 getValue   getAttribute   compareTo o2 getValue   getAttribute                      HashMap lt String  Object gt  sortedMap   new LinkedHashMap lt  gt     for  Map Entry lt String  Object gt  map   list       sortedMap put map getKey    map getValue

User · Answer

map   your hashmap   List lt Map Entry lt String  Integer gt  gt  list   new LinkedList lt Map Entry lt String  Integer gt  gt  map entrySet     Collections sort list  new cm      IMP  HashMap lt String  Integer gt  sorted   new LinkedHashMap lt String  Integer gt     for Map Entry lt String  Integer gt  en  list       sorted put en getKey   en getValue        System out println sorted    sorted hashmap   create new class  class cm implements Comparator lt Map Entry lt String  Integer gt  gt        Override     public int compare Map Entry lt String  Integer gt  a                               Map Entry lt String  Integer gt  b                return  a getValue    compareTo b getValue

User · Answer

Here s a generic-friendly version   public class MapUtil       public static  lt K  V extends Comparable lt   super V gt  gt  Map lt K  V gt  sortByValue Map lt K  V gt  map            List lt Entry lt K  V gt  gt  list   new ArrayList lt  gt  map entrySet             list sort Entry comparingByValue              Map lt K  V gt  result   new LinkedHashMap lt  gt             for  Entry lt K  V gt  entry   list                result put entry getKey    entry getValue                        return result

User · Answer

If there is a preference of having a Map data structure that inherently sorts by values without having to trigger any sort methods or explicitly pass to a utility  then the following solutions may be applicable    1  org drools chance core util ValueSortedMap  JBoss project  maintains two maps internally one for lookup and one for maintaining the sorted values  Quite similar to previously added answers  but probably it is the abstraction and encapsulation part  including copying mechanism  that makes it safer to use from the outside     2  http   techblog molindo at 2008 11 java-map-sorted-by-value html avoids maintaining two maps and instead relies extends from Apache Common s LinkedMap   Blog author s note  as all the code here is in the public domain       required to access LinkEntry before and LinkEntry after package org apache commons collections map      SNIP  imports        map implementation based on LinkedMap that maintains a sorted list of   values for iteration    public class ValueSortedHashMap extends LinkedMap       private final boolean  asc          don t use super        public ValueSortedHashMap final boolean asc            super DEFAULT CAPACITY            asc   asc                SNIP  some more constructors with initial capacity and the like      protected void addEntry final HashEntry entry  final int hashIndex            final LinkEntry link    LinkEntry  entry          insertSorted link           data hashIndex    entry             protected void updateEntry final HashEntry entry  final Object newValue            entry setValue newValue           final LinkEntry link    LinkEntry  entry          link before after   link after          link after before   link before          link after   link before   null          insertSorted link              private void insertSorted final LinkEntry link            LinkEntry cur   header             iterate whole list  could  should   be replaced with quicksearch            start at end to optimize speed for in-order insertions         while   cur   cur before     header  amp  amp   amp  amp   insertAfter cur  link              link after   cur after          link before   cur          cur after before   link          cur after   link             protected boolean insertAfter final LinkEntry cur  final LinkEntry link            if   asc                return   Comparable  cur getValue                 compareTo  V  link getValue     amp  lt    0            else               return   Comparable  cur getValue                 compareTo  V  link getValue     amp  gt    0                       public boolean isAscending             return  asc             3  Write a custom Map or extends from LinkedHashMap that will only sort during enumeration  e g   values    keyset    entryset    as needed  The inner implementation behavior is abstracted from the one using this class but it appears to the client of this class that values are always sorted when requested for enumeration  This class hopes that sorting will happen mostly once if all put operations have been completed before enumerations  Sorting method adopts some of the previous answers to this question    public class SortByValueMap lt K  V gt  implements Map lt K  V gt         private boolean isSortingNeeded   false       private final Map lt K  V gt  map   new LinkedHashMap lt  gt           Override     public V put K key  V value            isSortingNeeded   true          return map put key  value               Override     public void putAll Map lt   extends K    extends V gt  map            isSortingNeeded   true          map putAll map               Override     public Set lt K gt  keySet             sort            return map keySet                Override     public Set lt Entry lt K  V gt  gt  entrySet             sort            return map entrySet                Override     public Collection lt V gt  values             sort            return map values               private void sort             if   isSortingNeeded                return                     List lt Entry lt K  V gt  gt  list   new ArrayList lt  gt  size              for  Iterator lt Map Entry lt K  V gt  gt  it   map entrySet   iterator    it hasNext                   Map Entry lt K  V gt  entry   it next                list add entry               it remove                       Collections sort list            for  Entry lt K  V gt  entry   list                map put entry getKey    entry getValue                        isSortingNeeded   false              Override     public String toString             sort            return map toString               4  Guava offers ImmutableMap Builder orderEntriesByValue Comparator valueComparator  although the resulting map will be immutable      Configures this Builder to order entries by value according to the   specified comparator       The sort order is stable  that is  if two entries have values that   compare as equivalent  the entry that was inserted first will be first   in the built map s iteration order

User · Answer

Based on  devinmoore code  a map sorting methods using generics and supporting both ascending and descending ordering          Sort a map by it s keys in ascending order            return new instance of   link LinkedHashMap  contained sorted entries of supplied map      author Maxim Veksler     public static  lt K  V gt  LinkedHashMap lt K  V gt  sortMapByKey final Map lt K  V gt  map        return sortMapByKey map  SortingOrder ASCENDING             Sort a map by it s values in ascending order           return new instance of   link LinkedHashMap  contained sorted entries of supplied map      author Maxim Veksler     public static  lt K  V gt  LinkedHashMap lt K  V gt  sortMapByValue final Map lt K  V gt  map        return sortMapByValue map  SortingOrder ASCENDING             Sort a map by it s keys           param sortingOrder   link SortingOrder  enum specifying requested sorting order       return new instance of   link LinkedHashMap  contained sorted entries of supplied map      author Maxim Veksler     public static  lt K  V gt  LinkedHashMap lt K  V gt  sortMapByKey final Map lt K  V gt  map  final SortingOrder sortingOrder        Comparator lt Map Entry lt K  V gt  gt  comparator   new Comparator lt Entry lt K V gt  gt              public int compare Entry lt K  V gt  o1  Entry lt K  V gt  o2                return comparableCompare o1 getKey    o2 getKey    sortingOrder                         return sortMap map  comparator             Sort a map by it s values           param sortingOrder   link SortingOrder  enum specifying requested sorting order       return new instance of   link LinkedHashMap  contained sorted entries of supplied map      author Maxim Veksler     public static  lt K  V gt  LinkedHashMap lt K  V gt  sortMapByValue final Map lt K  V gt  map  final SortingOrder sortingOrder        Comparator lt Map Entry lt K  V gt  gt  comparator   new Comparator lt Entry lt K V gt  gt              public int compare Entry lt K  V gt  o1  Entry lt K  V gt  o2                return comparableCompare o1 getValue    o2 getValue    sortingOrder                         return sortMap map  comparator       SuppressWarnings  unchecked   private static  lt T gt  int comparableCompare T o1  T o2  SortingOrder sortingOrder        int compare     Comparable lt T gt  o1  compareTo o2        switch  sortingOrder        case ASCENDING          return compare      case DESCENDING          return  -1    compare             return 0            Sort a map by supplied comparator logic           return new instance of   link LinkedHashMap  contained sorted entries of supplied map      author Maxim Veksler     public static  lt K  V gt  LinkedHashMap lt K  V gt  sortMap final Map lt K  V gt  map  final Comparator lt Map Entry lt K  V gt  gt  comparator           Convert the map into a list of key value pairs      List lt Map Entry lt K  V gt  gt  mapEntries   new LinkedList lt Map Entry lt K  V gt  gt  map entrySet             Sort the converted list according to supplied comparator      Collections sort mapEntries  comparator           Build a new ordered map  containing the same entries as the old map        LinkedHashMap lt K  V gt  result   new LinkedHashMap lt K  V gt  map size      map size     20        for Map Entry lt K  V gt  entry   mapEntries               We iterate on the mapEntries list which is sorted by the comparator putting new entries into             the targeted result which is a sorted map           result put entry getKey    entry getValue                return result            Sorting order enum  specifying request result sort behavior      author Maxim Veksler        public static enum SortingOrder                  Resulting sort will be from smaller to biggest              ASCENDING                 Resulting sort will be from biggest to smallest              DESCENDING

User · Answer

Create customized comparator and use it while creating new TreeMap object   class MyComparator implements Comparator lt Object gt         Map lt String  Integer gt  map       public MyComparator Map lt String  Integer gt  map            this map   map             public int compare Object o1  Object o2             if  map get o2     map get o1               return 1          else             return   Integer  map get o2   compareTo  Integer                                                                   map get o1               Use the below code in your main func      Map lt String  Integer gt  lMap   new HashMap lt String  Integer gt         lMap put  A   35       lMap put  B   75       lMap put  C   50       lMap put  D   50        MyComparator comparator   new MyComparator lMap        Map lt String  Integer gt  newMap   new TreeMap lt String  Integer gt  comparator       newMap putAll lMap       System out println newMap     Output    B 75  D 50  C 50  A 35

User · Answer

If you have duplicate keys and only a small set of data   lt 1000  and your code is not performance critical you can just do the following   Map lt String Integer gt  tempMap new HashMap lt String Integer gt  inputUnsortedMap   LinkedHashMap lt String Integer gt  sortedOutputMap new LinkedHashMap lt String Integer gt      for int i 0 i lt inputUnsortedMap size   i         Map Entry lt String Integer gt  maxEntry null      Integer maxValue -1      for Map Entry lt String Integer gt  entry tempMap entrySet             if entry getValue   gt maxValue               maxValue entry getValue                maxEntry entry                      tempMap remove maxEntry getKey         sortedOutputMap put maxEntry getKey   maxEntry getValue         inputUnsortedMap is the input to the code   The variable sortedOutputMap will contain the data in decending order when iterated over  To change order just change   to a  lt  in the if statement   Is not the fastest sort but does the job without any additional dependencies

User · Answer

public class SortedMapExample        public static void main String   args            Map lt String  String gt  map   new HashMap lt String  String gt              map put  Cde    C            map put  Abc    A            map put  Cbc    Z            map put  Dbc    D            map put  Bcd    B            map put  sfd    Bqw            map put  DDD    Bas            map put  BGG    Basd             System out println sort map  new Comparator lt String gt                   Override             public int compare String o1  String o2                        return o1 compareTo o2                                 SuppressWarnings  unchecked       public static  lt K  V gt  Map lt K V gt  sort Map lt K  V gt  in  Comparator lt   super V gt  compare            Map lt K  V gt  result   new LinkedHashMap lt K  V gt             V   array    V   in values   toArray            for int i 0 i lt array length i                                 Arrays sort array  compare           for  V item   array                K key   K  getKey in  item               result put key  item                     return result             public static  lt K  V gt   Object getKey Map lt K  V gt  in V value               Set lt K gt  key  in keySet           Iterator lt K gt  keyIterator key iterator           while  keyIterator hasNext                 K valueObject    K  keyIterator next               if in get valueObject  equals value                                   return valueObject                               return null               Please try here  I am modifing the code for value sort

User · Answer

Java 8 offers a new answer  convert the entries into a stream  and use the comparator combinators from Map Entry   Stream lt Map Entry lt K V gt  gt  sorted       map entrySet   stream           sorted Map Entry comparingByValue       This will let you consume the entries sorted in ascending order of value   If you want descending value  simply reverse the comparator   Stream lt Map Entry lt K V gt  gt  sorted       map entrySet   stream           sorted Collections reverseOrder Map Entry comparingByValue        If the values are not comparable  you can pass an explicit comparator   Stream lt Map Entry lt K V gt  gt  sorted       map entrySet   stream           sorted Map Entry comparingByValue comparator      You can then proceed to use other stream operations to consume the data  For example  if you want the top 10 in a new map   Map lt K V gt  topTen       map entrySet   stream           sorted Map Entry comparingByValue Comparator reverseOrder             limit 10          collect Collectors toMap            Map Entry  getKey  Map Entry  getValue   e1  e2  - gt  e1  LinkedHashMap  new      Or print to System out   map entrySet   stream       sorted Map Entry comparingByValue        forEach System out  println

User · Answer

Use a generic comparator such as    final class MapValueComparator lt K V extends Comparable lt V gt  gt  implements Comparator lt K gt         private Map lt K V gt  map       private MapValueComparator             super               public MapValueComparator Map lt K V gt  map            this            this map   map             public int compare K o1  K o2            return map get o1  compareTo map get o2

User · Answer

With Java 8  you can use the streams api to do it in a significantly less verbose way   Map lt K  V gt  sortedMap   map entrySet   stream                             sorted Entry comparingByValue                              collect Collectors toMap Entry  getKey  Entry  getValue   e1  e2  - gt  e1  LinkedHashMap  new

User · Answer

My solution is a quite simple approach in the way of using mostly given APIs  We use the feature of Map to export its content as Set via entrySet   method  We now have a Set containing Map Entry objects    Okay  a Set does not carry an order  but we can take the content an put it into an ArrayList  It now has an random order  but we will sort it anyway   As ArrayList is a Collection  we now use the Collections sort   method to bring order to chaos  Because our Map Entry objects do not realize the kind of comparison we need  we provide a custom Comparator   public static void main String   args        HashMap lt String  String gt  map   new HashMap lt  gt         map put  Z    E        map put  G    A        map put  D    C        map put  E   null       map put  O    C        map put  L    D        map put  Q    B        map put  A    F        map put null   X        MapEntryComparator mapEntryComparator   new MapEntryComparator         List lt Entry lt String String gt  gt  entryList   new ArrayList lt  gt  map entrySet         Collections sort entryList  mapEntryComparator        for  Entry lt String  String gt  entry   entryList            System out println entry getKey             entry getValue

User · Answer

Using Guava library   public static  lt K V extends Comparable lt V gt  gt SortedMap lt K V gt  sortByValue Map lt K V gt  original       var comparator   Ordering natural                reverse      highest first              nullsLast                onResultOf Functions forMap original  null                compound Ordering usingToString         return ImmutableSortedMap copyOf original  comparator

User · Answer

Given Map     Map lt String  Integer gt  wordCounts   new HashMap lt  gt         wordCounts put  USA   100       wordCounts put  jobs   200       wordCounts put  software   50       wordCounts put  technology   70       wordCounts put  opportunity   200     Sort the map based on the value in ascending order  Map lt String Integer gt   sortedMap    wordCounts entrySet                                                    stream                                                    sorted Map Entry comparingByValue             collect Collectors toMap Map Entry  getKey  Map Entry  getValue   e1  e2  - gt  e1  LinkedHashMap  new        System out println sortedMap     Sort the map based on value in desending order  Map lt String Integer gt   sortedMapReverseOrder    wordCounts entrySet                stream                sorted Map Entry comparingByValue Comparator reverseOrder                  collect Collectors toMap Map Entry  getKey  Map Entry  getValue   e1  e2  - gt  e1  LinkedHashMap  new        System out println sortedMapReverseOrder     Output    software 50  technology 70  USA 100  jobs 200  opportunity 200    jobs 200  opportunity 200  USA 100  technology 70  software 50

User · Answer

If your Map values implement Comparable  e g  String   this should work  Map lt Object  String gt  map   new HashMap lt Object  String gt        Populate the Map List lt String gt  mapValues   new ArrayList lt String gt  map values     Collections sort mapValues     If the map values themselves don t implement Comparable  but you have an instance of Comparable that can sort them  replace the last line with this   Collections sort mapValues  comparable

User · Answer

When I m faced with this  I just create a list on the side  If you put them together in a custom Map implementation  it ll have a nice feel to it    You can use something like the following  performing the sort only when needed   Note  I haven t really tested this  but it compiles    might be a silly little bug in there somewhere    If you want it sorted by both keys and values  have the class extend TreeMap  don t define the accessor methods  and have the mutators call super xxxxx instead of map  xxxx   package com javadude sample   import java util ArrayList  import java util Collection  import java util Collections  import java util Comparator  import java util HashMap  import java util List  import java util Map  import java util Set   public class SortedValueHashMap lt K  V gt  implements Map lt K  V gt        private Map lt K  V gt  map    new HashMap lt K  V gt         private List lt V gt  valueList    new ArrayList lt V gt         private boolean needsSort    false      private Comparator lt V gt  comparator        public SortedValueHashMap               public SortedValueHashMap List lt V gt  valueList            valueList    valueList             public List lt V gt  sortedValues             if  needsSort                 needsSort    false              Collections sort valueList   comparator                      return valueList                 mutators     public void clear             map  clear            valueList  clear            needsSort    false             public V put K key  V value            valueList  add value           needsSort    true          return map  put key  value              public void putAll Map lt   extends K    extends V gt  m            map  putAll m           valueList  addAll m values             needsSort    true             public V remove Object key            V value   map  remove key           valueList  remove value           return value                accessors     public boolean containsKey Object key              return map  containsKey key         public boolean containsValue Object value          return map  containsValue value         public Set lt java util Map Entry lt K  V gt  gt  entrySet     return map  entrySet          public boolean equals Object o                     return map  equals o         public V get Object key                            return map  get key         public int hashCode                                return map  hashCode          public boolean isEmpty                             return map  isEmpty          public Set lt K gt  keySet                               return map  keySet          public int size                                    return map  size          public Collection lt V gt  values                        return map  values

User · Answer

This is a variation of Anthony s answer  which doesn t work if there are duplicate values   public static  lt K  V extends Comparable lt V gt  gt  Map lt K  V gt  sortMapByValues final Map lt K  V gt  map        Comparator lt K gt  valueComparator    new Comparator lt K gt              public int compare K k1  K k2                final V v1   map get k1               final V v2   map get k2                   Not sure how to handle nulls                    if  v1    null                    return  v2    null    0   1                             int compare   v2 compareTo v1               if  compare    0                                return compare                            else                               Integer h1   k1 hashCode                    Integer h2   k2 hashCode                    return h2 compareTo h1                                      Map lt K  V gt  sortedByValues   new TreeMap lt K  V gt  valueComparator       sortedByValues putAll map       return sortedByValues      Note that it s rather up in the air how to handle nulls    One important advantage of this approach is that it actually returns a Map  unlike some of the other solutions offered here

User · Answer

The answer voted for the most does not work when you have 2 items that equals  the TreeMap leaves equal values out   the exmaple  unsorted map   key value  D 67 3 key value  A 99 5 key value  B 67 4 key value  C 67 5 key value  E 99 5   results   key value  A 99 5 key value  C 67 5 key value  B 67 4 key value  D 67 3   So leaves out E    For me it worked fine to adjust the comparator  if it equals do not return 0 but -1   in the example           class ValueComparator implements Comparator            Map base        public ValueComparator Map base              this base   base                   public int compare Object a  Object b     if  Double base get a   lt   Double base get b       return 1    else if  Double base get a      Double base get b       return -1    else     return -1                           now it returns   unsorted map    key value  D 67 3 key value  A 99 5 key value  B 67 4 key value  C 67 5 key value  E 99 5   results    key value  A 99 5 key value  E 99 5 key value  C 67 5 key value  B 67 4 key value  D 67 3   as a response to Aliens  2011 nov  22   I Am using this solution for a map of Integer Id s and names  but the idea is the same  so might be the code above is not correct  I will write it in a test and give you the correct code   this is the code for a Map sorting  based on the solution above   package nl iamit util   import java util Comparator  import java util Map   public class Comparators         public static class MapIntegerStringComparator implements Comparator            Map lt Integer  String gt  base           public MapIntegerStringComparator Map lt Integer  String gt  base                this base   base                     public int compare Object a  Object b                 int compare     String  base get a                        compareTo  String  base get b                if  compare    0                    return -1                            return compare                        and this is the test class  I just tested it  and this works for the Integer  String Map   package test nl iamit util   import java util HashMap  import java util TreeMap  import nl iamit util Comparators  import org junit Test  import static org junit Assert assertArrayEquals   public class TestComparators          Test     public void testMapIntegerStringComparator            HashMap lt Integer  String gt  unSoretedMap   new HashMap lt Integer  String gt             Comparators MapIntegerStringComparator bvc   new Comparators MapIntegerStringComparator                  unSoretedMap           TreeMap lt Integer  String gt  sorted map   new TreeMap lt Integer  String gt  bvc             the testdata          unSoretedMap put new Integer 1    E            unSoretedMap put new Integer 2    A            unSoretedMap put new Integer 3    E            unSoretedMap put new Integer 4    B            unSoretedMap put new Integer 5    F             sorted map putAll unSoretedMap            Object   targetKeys  new Integer 2  new Integer 4  new Integer 3  new Integer 1  new Integer 5             Object   currecntKeys sorted map keySet   toArray             assertArrayEquals targetKeys currecntKeys             here is the code for the Comparator of a Map   public static class MapStringDoubleComparator implements Comparator        Map lt String  Double gt  base       public MapStringDoubleComparator Map lt String  Double gt  base            this base   base               note if you want decending in stead of ascending  turn around 1 and -1     public int compare Object a  Object b            if   Double  base get a      Double  base get b                 return 0            else if  Double  base get a   lt   Double  base get b                 return -1           else              return 1                      and this is the testcase for this    Test public void testMapStringDoubleComparator        HashMap lt String  Double gt  unSoretedMap   new HashMap lt String  Double gt         Comparators MapStringDoubleComparator bvc   new Comparators MapStringDoubleComparator              unSoretedMap       TreeMap lt String  Double gt  sorted map   new TreeMap lt String  Double gt  bvc         the testdata      unSoretedMap put  D  new Double 67 3        unSoretedMap put  A  new Double 99 5        unSoretedMap put  B  new Double 67 4        unSoretedMap put  C  new Double 67 5        unSoretedMap put  E  new Double 99 5         sorted map putAll unSoretedMap        Object   targetKeys   D   B   C   E   A        Object   currecntKeys sorted map keySet   toArray         assertArrayEquals targetKeys currecntKeys       of cource you can make this a lot more generic  but I just needed it for 1 case  the Map

User · Answer

Here is the code by Java 8 with AbacusUtil  Map lt String  Integer gt  map   N asMap  a   2   b   3   c   1   d   2   Map lt String  Integer gt  sortedMap   Stream of map entrySet    sorted Map Entry comparingByValue    toMap e - gt  e getKey    e - gt  e getValue        LinkedHashMap  new   N println sortedMap      output   c 1  a 2  d 2  b 3    Declaration  I m the developer of AbacusUtil

User · Answer

I ve looked at the given answers  but a lot of them are more complicated than needed or remove map elements when several keys have same value   Here is a solution that I think fits better   public static  lt K  V extends Comparable lt V gt  gt  Map lt K  V gt  sortByValues final Map lt K  V gt  map        Comparator lt K gt  valueComparator    new Comparator lt K gt              public int compare K k1  K k2                int compare   map get k2  compareTo map get k1                if  compare    0  return 1              else return compare                       Map lt K  V gt  sortedByValues   new TreeMap lt K  V gt  valueComparator       sortedByValues putAll map       return sortedByValues      Note that the map is sorted from the highest value to the lowest

User · Answer

This could be achieved very easily with java 8 public static LinkedHashMap lt Integer  String gt  sortByValue HashMap lt Integer  String gt  map             List lt Map Entry lt Integer  String gt  gt  list   new ArrayList lt  gt  map entrySet             list sort Map Entry comparingByValue             LinkedHashMap lt Integer  String gt  sortedMap   new LinkedHashMap lt  gt             list forEach e - gt  sortedMap put e getKey    e getValue              return sortedMap

User · Answer

For sure the solution of Stephen is really great  but for those who can t use Guava   Here s my solution for sorting by value a map  This solution handle the case where there are twice the same value etc        If you want to sort a map by value  and if there can be twice the same value      here is your original map Map lt String Integer gt  mapToSortByValue   new HashMap lt String  Integer gt     mapToSortByValue put  A   3   mapToSortByValue put  B   1   mapToSortByValue put  C   3   mapToSortByValue put  D   5   mapToSortByValue put  E   -1   mapToSortByValue put  F   1000   mapToSortByValue put  G   79   mapToSortByValue put  H   15       Sort all the map entries by value Set lt Map Entry lt String Integer gt  gt  set   new TreeSet lt Map Entry lt String Integer gt  gt           new Comparator lt Map Entry lt String Integer gt  gt                  Override             public int compare Map Entry lt String Integer gt  obj1  Map Entry lt String Integer gt  obj2                    Integer val1   obj1 getValue                    Integer val2   obj2 getValue                       DUPLICATE VALUE CASE                    If the values are equals  we can t return 0 because the 2 entries would be considered                    as equals and one of them would be deleted  because we use a set  no duplicate  remember                   int compareValues   val1 compareTo val2                   if   compareValues    0                         String key1   obj1 getKey                        String key2   obj2 getKey                        int compareKeys   key1 compareTo key2                       if   compareKeys    0                                what you return here will tell us if you keep REAL KEY-VALUE duplicates in your set                            if you want to  do whatever you want but do not return 0  but don t break the comparator contract                           return 0                                            return compareKeys                                    return compareValues                             set addAll mapToSortByValue entrySet          OK NOW OUR SET IS SORTED COOL         And there s nothing more to do  the entries are sorted by value  for   Map Entry lt String Integer gt  entry   set         System out println  Set entries      entry getKey       - gt      entry getValue              But if you add them to an hashmap Map lt String Integer gt  myMap   new HashMap lt String Integer gt        When iterating over the set the order is still good in the println    for   Map Entry lt String Integer gt  entry   set         System out println  Added to result map entries      entry getKey           entry getValue         myMap put entry getKey    entry getValue           But once they are in the hashmap  the order is not kept  for   Integer value   myMap values           System out println  Result map values      value        Also this way doesn t work     Logic because the entryset is a hashset for hashmaps and not a treeset     and even if it was a treeset  it would be on the keys only  for   Map Entry lt String Integer gt  entry   myMap entrySet           System out println  Result map entries      entry getKey       - gt      entry getValue            CONCLUSION     If you want to iterate on a map ordered by value  you need to remember     1  Maps are only sorted by keys  so you can t sort them directly by value    2  So you simply CAN T return a map to a sortMapByValue function    3  You can t reverse the keys and the values because you have duplicate values       This also means you can t neither use Guava Commons bidirectionnal treemaps or stuff like that     SOLUTIONS    So you can     1  only sort the values which is easy  but you loose the key value link  since you have duplicate values     2  sort the map entries  but don t forget to handle the duplicate value case  like i did     3  if you really need to return a map  use a LinkedHashMap which keep the insertion order   The exec  http   www ideone com dq3Lu  The output   Set entries  E - gt  -1 Set entries  B - gt  1 Set entries  A - gt  3 Set entries  C - gt  3 Set entries  D - gt  5 Set entries  H - gt  15 Set entries  G - gt  79 Set entries  F - gt  1000 Added to result map entries  E -1 Added to result map entries  B 1 Added to result map entries  A 3 Added to result map entries  C 3 Added to result map entries  D 5 Added to result map entries  H 15 Added to result map entries  G 79 Added to result map entries  F 1000 Result map values  5 Result map values  -1 Result map values  1000 Result map values  79 Result map values  3 Result map values  1 Result map values  3 Result map values  15 Result map entries  D - gt  5 Result map entries  E - gt  -1 Result map entries  F - gt  1000 Result map entries  G - gt  79 Result map entries  A - gt  3 Result map entries  B - gt  1 Result map entries  C - gt  3 Result map entries  H - gt  15   Hope it will help some folks

User · Answer

Using LinkedList    Create a list by HashMap List lt Map Entry lt String  Double gt  gt  list   new LinkedList lt  gt  hashMap entrySet        Sorting the list Collections sort list  new Comparator lt Map Entry lt String  Double gt  gt          public int compare Map Entry lt String  Double gt  o1  Map Entry lt String  Double gt  o2            return  o1 getValue    compareTo o2 getValue                  put data from sorted list to hashmap HashMap lt String  Double gt  sortedData   new LinkedHashMap lt  gt     for  Map Entry lt String  Double gt  data   list        sortedData put data getKey    data getValue        System out print sortedData

User · Answer

The commons-collections library contains a solution called TreeBidiMap  Or  you could have a look at the Google Collections API  It has TreeMultimap which you could use   And if you don t want to use these framework    they come with source code

User · Answer

There are a lot of answers for this question already  but none provided me what I was looking for  a map implementation that returns keys and entries sorted by the associated value  and maintains this property as keys and values are modified in the map  Two other questions ask for this specifically    I cooked up a generic friendly example that solves this use case  This implementation does not honor all of the contracts of the Map interface  such as reflecting value changes and removals in the sets return from keySet   and entrySet   in the original object  I felt such a solution would be too large to include in a Stack Overflow answer  If I manage to create a more complete implementation  perhaps I will post it to Github and then to it link in an updated version of this answer   import java util            A map where   link  keySet    and   link  entrySet    return sets ordered    by associated values based on the the comparator provided at construction    time  The order of two or more keys with identical values is not defined      lt p gt     Several contracts of the Map interface are not satisfied by this minimal    implementation      public class ValueSortedMap lt K  V gt  extends HashMap lt K  V gt        protected Map lt V  Collection lt K gt  gt  valueToKeysMap          uses natural order of value object  if any     public ValueSortedMap             this  Comparator lt   super V gt   null              public ValueSortedMap Comparator lt   super V gt  valueComparator            this valueToKeysMap   new TreeMap lt V  Collection lt K gt  gt  valueComparator              public boolean containsValue Object o            return valueToKeysMap containsKey o              public V put K k  V v            V oldV   null          if  containsKey k                 oldV   get k               valueToKeysMap get oldV  remove k                     super put k  v           if   valueToKeysMap containsKey v                 Collection lt K gt  keys   new ArrayList lt K gt                 keys add k               valueToKeysMap put v  keys             else               valueToKeysMap get v  add k                     return oldV             public void putAll Map lt   extends K    extends V gt  m            for  Map Entry lt   extends K    extends V gt  e   m entrySet                put e getKey    e getValue                public V remove Object k            V oldV   null          if  containsKey k                 oldV   get k               super remove k               valueToKeysMap get oldV  remove k                     return oldV             public void clear             super clear            valueToKeysMap clear               public Set lt K gt  keySet             LinkedHashSet lt K gt  ret   new LinkedHashSet lt K gt  size             for  V v   valueToKeysMap keySet                  Collection lt K gt  keys   valueToKeysMap get v               ret addAll keys                     return ret             public Set lt Map Entry lt K  V gt  gt  entrySet             LinkedHashSet lt Map Entry lt K  V gt  gt  ret   new LinkedHashSet lt Map Entry lt K  V gt  gt  size             for  Collection lt K gt  keys   valueToKeysMap values                  for  final K k   keys                    final V v   get k                   ret add new Map Entry lt K V gt                          public K getKey                             return k                                             public V getValue                             return v                                             public V setValue V v                            throw new UnsupportedOperationException                                                                              return ret

User · Answer

Major problem  If you use the first answer  Google takes you here   change the comparator to add an equal clause  otherwise you cannot get values from the sorted map by keys   public int compare String a  String b            if  base get a   gt  base get b                 return 1            else if  base get a   lt  base get b                return -1                      return 0             returning 0 would merge keys

User · Answer

While I agree that the constant need to sort a map is probably a smell  I think the following code is the easiest way to do it without using a different data structure   public class MapUtilities    public static  lt K  V extends Comparable lt V gt  gt  List lt Entry lt K  V gt  gt  sortByValue Map lt K  V gt  map        List lt Entry lt K  V gt  gt  entries   new ArrayList lt Entry lt K  V gt  gt  map entrySet         Collections sort entries  new ByValue lt K  V gt          return entries     private static class ByValue lt K  V extends Comparable lt V gt  gt  implements Comparator lt Entry lt K  V gt  gt        public int compare Entry lt K  V gt  o1  Entry lt K  V gt  o2            return o1 getValue   compareTo o2 getValue                  And here is an embarrassingly incomplete unit test   public class MapUtilitiesTest extends TestCase   public void testSorting         HashMap lt String  Integer gt  map   new HashMap lt String  Integer gt         map put  One   1       map put  Two   2       map put  Three   3        List lt Map Entry lt String  Integer gt  gt  sorted   MapUtilities sortByValue map       assertEquals  First    One   sorted get 0  getKey         assertEquals  Second    Two   sorted get 1  getKey         assertEquals  Third    Three   sorted get 2  getKey            The result is a sorted list of Map Entry objects  from which you can obtain the keys and values

User · Answer

We simply sort a map just like this              Map lt String  String gt  unsortedMap   new HashMap lt String  String gt          unsortedMap put  E    E Val        unsortedMap put  F    F Val        unsortedMap put  H    H Val        unsortedMap put  B    B Val        unsortedMap put  C    C Val        unsortedMap put  A    A Val        unsortedMap put  G    G Val        unsortedMap put  D    D Val         Map lt String  String gt  sortedMap   new TreeMap lt String  String gt  unsortedMap        System out println   nAfter sorting          for  Map Entry  lt String  String gt  mapEntry   sortedMap entrySet              System out println mapEntry getKey        t    mapEntry getValue

User · Answer

Important note  This code can break in multiple ways  If you intend to use the code provided  be sure to read the comments as well to be aware of the implications  For example  values can no longer be retrieved by their key   get always returns null    It seems much easier than all of the foregoing  Use a TreeMap as follows  public class Testing       public static void main String   args            HashMap lt String  Double gt  map   new HashMap lt String  Double gt             ValueComparator bvc   new ValueComparator map           TreeMap lt String  Double gt  sorted map   new TreeMap lt String  Double gt  bvc            map put  quot A quot   99 5           map put  quot B quot   67 4           map put  quot C quot   67 4           map put  quot D quot   67 3            System out println  quot unsorted map   quot    map           sorted map putAll map           System out println  quot results   quot    sorted map            class ValueComparator implements Comparator lt String gt        Map lt String  Double gt  base       public ValueComparator Map lt String  Double gt  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   gt   base get b                 return -1            else               return 1               returning 0 would merge keys          Output  unsorted map   D 67 3  A 99 5  B 67 4  C 67 4  results   D 67 3  B 67 4  C 67 4  A 99 5

User · Answer

For sorting upon the keys I found a better solution with a TreeMap  I will try to get a solution for value based sorting ready too    public static void main String   args        Map lt String  String gt  unsorted   new HashMap lt String  String gt         unsorted put  Cde    Cde Value        unsorted put  Abc    Abc Value        unsorted put  Bcd    Bcd Value         Comparator lt String gt  comparer   new Comparator lt String gt               Override         public int compare String o1  String o2                return o1 compareTo o2                    Map lt String  String gt  sorted   new TreeMap lt String  String gt  comparer       sorted putAll unsorted       System out println sorted       Output would be    Abc Abc Value  Bcd Bcd Value  Cde Cde Value

User · Answer

public class Test     public static void main String   args        TreeMap lt Integer  String gt  hm new TreeMap        hm put 3   arun singh        hm put 5   vinay singh        hm put 1   bandagi singh        hm put 6   vikram singh        hm put 2   panipat singh        hm put 28   jakarta singh         ArrayList lt String gt  al new ArrayList hm values         Collections sort al  new myComparator          System out println    sort by values  n        for String obj  al           for Map Entry lt Integer  String gt  map2 hm entrySet                 if map2 getValue   equals obj                    System out println map2 getKey       map2 getValue                                            class myComparator implements Comparator       Override     public int compare Object o1  Object o2           String o3  String  o1         String o4   String  o2         return o3 compareTo o4                OUTPUT     sort by values   3 arun singh 1 bandagi singh 28 jakarta singh 2 panipat singh 6 vikram singh 5 vinay singh

User · Answer

Since TreeMap lt   does not work for values that can be equal  I used this   private  lt K  V extends Comparable lt   super V gt  gt  List lt Entry lt K  V gt  gt  sort Map lt K  V gt  map            List lt Map Entry lt K  V gt  gt  list   new LinkedList lt Map Entry lt K  V gt  gt  map entrySet         Collections sort list  new Comparator lt Map Entry lt K  V gt  gt              public int compare Map Entry lt K  V gt  o1  Map Entry lt K  V gt  o2                return o1 getValue   compareTo o2 getValue                            return list      You might want to put list in a LinkedHashMap  but if you re only going to iterate over it right away  that s superfluous

User · Answer

Here is an OO solution  i e   doesn t use static methods    import java util Collections  import java util Comparator  import java util HashMap  import java util Iterator  import java util LinkedList  import java util LinkedHashMap  import java util List  import java util Map   public class SortableValueMap lt K  V extends Comparable lt V gt  gt    extends LinkedHashMap lt K  V gt      public SortableValueMap          public SortableValueMap  Map lt K  V gt  map         super  map           public void sortByValue         List lt Map Entry lt K  V gt  gt  list   new LinkedList lt Map Entry lt K  V gt  gt   entrySet           Collections sort  list  new Comparator lt Map Entry lt K  V gt  gt            public int compare  Map Entry lt K  V gt  entry1  Map Entry lt K  V gt  entry2             return entry1 getValue   compareTo  entry2 getValue                           clear         for  Map Entry lt K  V gt  entry   list           put  entry getKey    entry getValue                   private static void print  String text  Map lt String  Double gt  map         System out println  text         for  String key   map keySet             System out println   key value      key         map get  key                   public static void main  String   args         SortableValueMap lt String  Double gt  map         new SortableValueMap lt String  Double gt          map put   A   67 5        map put   B   99 5        map put   C   82 4        map put   D   42 0         print   Unsorted map   map        map sortByValue        print   Sorted map   map            Hereby donated to the public domain

User · Answer

Best thing is to convert HashMap to TreeMap  TreeMap sort keys on its own  If you want to sort on values than quick fix can be you can switch values with keys if your values are not duplicates

User · Answer

I can give you an example but sure this is what you need  map    10   3  11   1 12   2    Let s say you want the top 2 most frequent key which is  10  12  So the easiest way is using a PriorityQueue to sort based on the value of the map  PriorityQueue lt Integer gt  pq   new PriorityQueue lt  gt   a  b  - gt   map get a  - map get b    for int key  map keySets         pq add key      if pq size    gt  2          pq poll              Now pq has the top 2 most frequent key based on value  It sorts the value

User · Answer

Okay  this version works with two new Map objects and two iterations and sorts on values  Hope  the performs well although the map entries must be looped twice   public static void main String   args        Map lt String  String gt  unsorted   new HashMap lt String  String gt         unsorted put  Cde    Cde Value        unsorted put  Abc    Abc Value        unsorted put  Bcd    Bcd Value         Comparator lt String gt  comparer   new Comparator lt String gt               Override         public int compare String o1  String o2                return o1 compareTo o2                    System out println sortByValue unsorted  comparer        public static  lt K  V gt  Map lt K V gt  sortByValue Map lt K  V gt  in  Comparator lt   super V gt  compare        Map lt V  K gt  swapped   new TreeMap lt V  K gt  compare       for Entry lt K V gt  entry  in entrySet              if  entry getValue      null                swapped put entry getValue    entry getKey                         LinkedHashMap lt K  V gt  result   new LinkedHashMap lt K  V gt         for Entry lt V K gt  entry  swapped entrySet              if  entry getValue      null                result put entry getValue    entry getKey                         return result      The solution uses a TreeMap with a Comparator and sorts out all null keys and values  First  the ordering functionality from the TreeMap is used to sort upon the values  next the sorted Map is used to create a result as a LinkedHashMap that retains has the same order of values   Greetz  GHad

User · Answer

I rewrote devinmoore s method that performs sorting a map by it s value without using Iterator    public static Map lt K  V gt  sortMapByValue Map lt K  V gt  inputMap         Set lt Entry lt K  V gt  gt  set   inputMap entrySet        List lt Entry lt K  V gt  gt  list   new ArrayList lt Entry lt K  V gt  gt  set        Collections sort list  new Comparator lt Map Entry lt K  V gt  gt                   Override         public int compare Entry lt K  V gt  o1  Entry lt K  V gt  o2                return  o1 getValue    compareTo  o2 getValue         Ascending order                         Map lt K  V gt  sortedMap   new LinkedHashMap lt  gt          for Map Entry lt K  V gt  entry   list           sortedMap put entry getKey    entry getValue                return sortedMap      Note  that we used  LinkedHashMap as output map  because our list has been sorted by value and now we should store our list into output map with order of inserted key values  So if you use for example TreeMap as your output map  your map will be sorted by map keys again   This is the main method   public static void main String   args        Map lt String  String gt  map   new HashMap lt  gt         map put  3    three        map put  1    one        map put  5    five        System out println  Input Map     map       System out println  Sorted Map     sortMapByValue map        Finally  this is the output   Input Map  1 one  3 three  5 five  Sorted Map  5 five  1 one  3 three

User · Answer

This is just too complicated  Maps were not supposed to do such job as sorting them by Value  The easiest way is to create your own Class so it fits your requirement   In example lower you are supposed to add TreeMap a comparator at place where   is  But by java API it gives comparator only keys  not values  All of examples stated here is based on 2 Maps  One Hash and one new Tree  Which is odd   The example   Map lt Driver driver  Float time gt  map   new TreeMap lt Driver driver  Float time gt        So change the map into a set this way   ResultComparator rc   new ResultComparator    Set lt Results gt  set   new TreeSet lt Results gt  rc     You will create class Results   public class Results       private Driver driver      private Float time       public Results Driver driver  Float time            this driver   driver          this time   time             public Float getTime             return time             public void setTime Float time            this time   time             public Driver getDriver             return driver             public void setDriver  Driver driver            this driver   driver            and the Comparator class   public class ResultsComparator implements Comparator lt Results gt        public int compare Results t  Results t1            if  t getTime    lt  t1 getTime                  return 1            else if  t getTime      t1 getTime                  return 0            else               return -1                      This way you can easily add more dependencies   And as the last point I ll add simple iterator   Iterator it   set iterator    while  it hasNext          Results r    Results it next        System out println  r getDriver   toString           or whatever that is related to Driver class -getName   getSurname                           r getTime

User · Answer

static  lt K extends Comparable lt   super K gt   V extends Comparable lt   super V gt  gt      Map sortByValueInDescendingOrder final Map lt K  V gt  map            Map re   new TreeMap new Comparator lt K gt                   Override             public int compare K o1  K o2                    if  map get o1     null    map get o2     null                        return -o1 compareTo o2                                     int result   -map get o1  compareTo map get o2                    if  result    0                        return result                                    return -o1 compareTo o2                                     re putAll map           return re             Test timeout   3000l  expected   Test None class      public void testSortByValueInDescendingOrder             char   arr    googler  toCharArray            Map lt Character  Integer gt  charToTimes   new HashMap            for  int i   0  i  lt  arr length  i                  Integer times   charToTimes get arr i                charToTimes put arr i   times    null   1   times   1                     Map sortedByTimes   sortByValueInDescendingOrder charToTimes           Assert assertEquals charToTimes toString      g 2  e 1  r 1  o 2  l 1             Assert assertEquals sortedByTimes toString      o 2  g 2  r 1  l 1  e 1             Assert assertEquals sortedByTimes containsKey  a    false           Assert assertEquals sortedByTimes get  a    null           Assert assertEquals sortedByTimes get  g    2           Assert assertEquals sortedByTimes equals charToTimes   true

User · Answer

posting my version of answer  List lt Map Entry lt String  Integer gt  gt  list   new ArrayList lt  gt  map entrySet         Collections sort list   obj1  obj2  - gt  obj2 getValue   compareTo obj1 getValue          Map lt String  Integer gt  resultMap   new LinkedHashMap lt  gt         list forEach arg0 - gt            resultMap put arg0 getKey    arg0 getValue                 System out println resultMap

User · Answer

Three 1-line answers     I would use Google Collections Guava to do this - if your values are Comparable then you can use  valueComparator   Ordering natural   onResultOf Functions forMap map     Which will create a function  object  for the map  that takes any of the keys as input  returning the respective value   and then apply natural  comparable  ordering to them  the values    If they re not comparable  then you ll need to do something along the lines of  valueComparator   Ordering from comparator  onResultOf Functions forMap map      These may be applied to a TreeMap  as Ordering extends Comparator   or a LinkedHashMap after some sorting  NB  If you are going to use a TreeMap  remember that if a comparison    0  then the item is already in the list  which will happen if you have multiple values that compare the same    To alleviate this  you could add your key to the comparator like so  presuming that your keys and values are Comparable    valueComparator   Ordering natural   onResultOf Functions forMap map   compound Ordering natural        Apply natural ordering to the value mapped by the key  and compound that with the natural ordering of the key  Note that this will still not work if your keys compare to 0  but this should be sufficient for most comparable items  as hashCode  equals and compareTo are often in sync      See Ordering onResultOf   and Functions forMap     Implementation  So now that we ve got a comparator that does what we want  we need to get a result from it    map   ImmutableSortedMap copyOf myOriginalMap  valueComparator     Now this will most likely work work  but    needs to be done given a complete finished map Don t try the comparators above on a TreeMap  there s no point trying to compare an inserted key when it doesn t have a value until after the put  i e   it will break really fast   Point 1 is a bit of a deal-breaker for me  google collections is incredibly lazy  which is good  you can do pretty much every operation in an instant  the real work is done when you start using the result   and this requires copying a whole map    Full  answer Live sorted map by values  Don t worry though  if you were obsessed enough with having a  live  map sorted in this manner  you could solve not one but both    of the above issues with something crazy like the following   Note  This has changed significantly in June 2012 - the previous code could never work  an internal HashMap is required to lookup the values without creating an infinite loop between the TreeMap get   -  compare   and compare   -  get    import static org junit Assert assertEquals   import java util HashMap  import java util Map  import java util TreeMap   import com google common base Functions  import com google common collect Ordering   class ValueComparableMap lt K extends Comparable lt K gt  V gt  extends TreeMap lt K V gt          A map for doing lookups on the keys for comparison so we don t get infinite loops     private final Map lt K  V gt  valueMap       ValueComparableMap final Ordering lt   super V gt  partialValueOrdering            this partialValueOrdering  new HashMap lt K V gt                 private ValueComparableMap Ordering lt   super V gt  partialValueOrdering              HashMap lt K  V gt  valueMap            super partialValueOrdering   Apply the value ordering                  onResultOf Functions forMap valueMap     On the result of getting the value for the key from the map                  compound Ordering natural        as well as ensuring that the keys don t get clobbered         this valueMap   valueMap             public V put K k  V v            if  valueMap containsKey k                  remove the key in the sorted set before adding the key again             remove k                     valueMap put k v     To get  real  unsorted values for the comparator         return super put k  v     Put it in value order            public static void main String   args           TreeMap lt String  Integer gt  map   new ValueComparableMap lt String  Integer gt  Ordering natural             map put  a   5           map put  b   1           map put  c   3           assertEquals  b  map firstKey             assertEquals  a  map lastKey             map put  d  0           assertEquals  d  map firstKey               ensure it s still a map  by overwriting a key  but with a new value           map put  d   2           assertEquals  b   map firstKey               Ensure multiple values do not clobber keys         map put  e   2           assertEquals 5  map size             assertEquals 2   int  map get  e             assertEquals 2   int  map get  d                When we put  we ensure that the hash map has the value for the comparator  and then put to the TreeSet for sorting  But before that we check the hash map to see that the key is not actually a duplicate  Also  the comparator that we create will also include the key so that duplicate values don t delete the non-duplicate keys  due to    comparison   These 2 items are vital for ensuring the map contract is kept  if you think you don t want that  then you re almost at the point of reversing the map entirely  to Map lt V K gt     The constructor would need to be called as    new ValueComparableMap Ordering natural        or  new ValueComparableMap Ordering from comparator

User · Answer

Sorting the keys requires the Comparator to look up each value for each comparison  A more scalable solution would use the entrySet directly  since then the value would be immediately available for each comparison  although I haven t backed this up by numbers    Here s a generic version of such a thing   public static  lt K  V extends Comparable lt   super V gt  gt  List lt K gt  getKeysSortedByValue Map lt K  V gt  map        final int size   map size        final List lt Map Entry lt K  V gt  gt  list   new ArrayList lt Map Entry lt K  V gt  gt  size       list addAll map entrySet         final ValueComparator lt V gt  cmp   new ValueComparator lt V gt         Collections sort list  cmp       final List lt K gt  keys   new ArrayList lt K gt  size       for  int i   0  i  lt  size  i              keys set i  list get i  getKey               return keys     private static final class ValueComparator lt V extends Comparable lt   super V gt  gt                                       implements Comparator lt Map Entry lt    V gt  gt        public int compare Map Entry lt    V gt  o1  Map Entry lt    V gt  o2            return o1 getValue   compareTo o2 getValue               There are ways to lessen memory rotation for the above solution  The first ArrayList created could for instance be re-used as a return value  this would require suppression of some generics warnings  but it might be worth it for re-usable library code  Also   the Comparator does not have to be re-allocated at every invocation   Here s a more efficient albeit less appealing version   public static  lt K  V extends Comparable lt   super V gt  gt  List lt K gt  getKeysSortedByValue2 Map lt K  V gt  map        final int size   map size        final List reusedList   new ArrayList size       final List lt Map Entry lt K  V gt  gt  meView   reusedList      meView addAll map entrySet         Collections sort meView  SINGLE       final List lt K gt  keyView   reusedList      for  int i   0  i  lt  size  i              keyView set i  meView get i  getKey               return keyView     private static final Comparator SINGLE   new ValueComparator      Finally  if you need to continously access the sorted information  rather than just sorting it once in a while   you can use an additional multi map  Let me know if you need more details

[java] Sort a Map<Key, Value> by values

Examples related to java

Examples related to sorting

Examples related to dictionary

Examples related to collections