Como ordenar um mapa por valor em Java

  2. HowTo
  3. Java Howtos
  4. Como ordenar um mapa por valor em Java
Mohammad Irfan 12 outubro 2023
Java Java Map
  1. Ordenar um Map<key, value> Utilizando sort() Método em Java
  2. Ordenar um Map<key, value> Utilizando o sorted() metodo em Java
  3. Ordenar um Map<key, value> Utilizando sort() Método com o Comparador em Java
  4. Ordenar um Map<key, value> Utilizando sorted() e toMap() Método em Java
  5. Ordenar um Map<key, value> Utilizando código personalizado em Java
Como ordenar um mapa por valor em Java

Este tutorial introduz como ordenar um Map<key, value> por valor em Java e lista alguns exemplos de códigos para entendê-lo.

Há várias maneiras de ordenar um Map<key, value>. Aqui utilizamos o método sort(), sorted() e a interface do comparador, etc. Vamos ver os exemplos.

Ordenar um Map<key, value> Utilizando sort() Método em Java

Podemos utilizar o método sort() da interface List para ordenar os elementos do Mapa. O método sort() ordena os elementos em ordem ascendente e especificamos a ordenação por valor utilizando o método comparingByValue(). Veja o exemplo abaixo.

import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.Map.Entry;

public class SimpleTesting {
  public static void main(String[] args) {
    Map<Integer, Integer> map = new HashMap<>();
    map.put(2, 1020);
    map.put(3, 300);
    map.put(1, 100);
    map.put(5, 500);
    map.forEach((k, v) -> System.out.println(k + "=" + v));
    System.out.println("After Sorting by value");
    List<Entry<Integer, Integer>> list = new ArrayList<>(map.entrySet());
    list.sort(Entry.comparingByValue());
    list.forEach(System.out::println);
  }
}

Resultado:

1=100
2=1020
3=300
5=500
After Sorting
1=100
3=300
5=500
2=1020

Ordenar um Map<key, value> Utilizando o sorted() metodo em Java

Se você estiver trabalhando com correntes, você pode utilizar o método sorted() que ordena os elementos em ordem ascendente. Passamos o Map.Entry.comparingByValue() como um argumento para o método sorted() para ordenar o Map<key, value> por valores.

import java.util.HashMap;
import java.util.Map;
import java.util.stream.Stream;

public class SimpleTesting {
  public static void main(String[] args) {
    Map<Integer, Integer> map = new HashMap<>();
    map.put(2, 1020);
    map.put(3, 300);
    map.put(1, 100);
    map.put(5, 500);
    map.forEach((k, v) -> System.out.println(k + "=" + v));
    System.out.println("After Sorting by value");
    Stream<Map.Entry<Integer, Integer>> sorted =
        map.entrySet().stream().sorted(Map.Entry.comparingByValue());
    sorted.forEach(System.out::println);
  }
}

Resultado:

1 = 100 2 = 1020 3 = 300 5 = 500 After Sorting by value 1 = 100 3 = 300 5 = 500 2 = 1020

Ordenar um Map<key, value> Utilizando sort() Método com o Comparador em Java

Neste exemplo, utilizamos o método compareTo() para comparar valores de Map<key, value> dentro do método sort() como um argumento. Você pode ver que criamos uma classe interna anônima da interface Comparator e definimos o método compare() para comparar os valores.

import java.util.Collections;
import java.util.Comparator;
import java.util.HashMap;
import java.util.Iterator;
import java.util.LinkedHashMap;
import java.util.LinkedList;
import java.util.List;
import java.util.Map;
import java.util.Map.Entry;

public class SimpleTesting {
  public static void main(String[] args) {
    Map<Integer, Integer> map = new HashMap<>();
    map.put(2, 1020);
    map.put(3, 300);
    map.put(1, 100);
    map.put(5, 500);
    map.forEach((k, v) -> System.out.println(k + "=" + v));
    System.out.println("After Sorting by value");
    List<Entry<Integer, Integer>> list = new LinkedList<>(map.entrySet());
    Collections.sort(list, new Comparator<Object>() {
      @SuppressWarnings("unchecked")
      public int compare(Object o1, Object o2) {
        return ((Comparable<Integer>) ((Map.Entry<Integer, Integer>) (o1)).getValue())
            .compareTo(((Map.Entry<Integer, Integer>) (o2)).getValue());
      }
    });
    Map<Integer, Integer> result = new LinkedHashMap<>();
    for (Iterator<Entry<Integer, Integer>> it = list.iterator(); it.hasNext();) {
      Map.Entry<Integer, Integer> entry = (Map.Entry<Integer, Integer>) it.next();
      result.put(entry.getKey(), entry.getValue());
    }
    result.forEach((k, v) -> System.out.println(k + "=" + v));
  }
}

Resultado:

1=100
2=1020
3=300
5=500
After Sorting by value
1=100
3=300
5=500
2=1020

Ordenar um Map<key, value> Utilizando sorted() e toMap() Método em Java

Neste exemplo, estamos utilizando o método sorted() para classificar o Map<key, value> e coletar o resultado em LinkedHashMap utilizando o método toMap(). Aqui, utilizamos o conceito de referência do método para criar um objeto LinkedHashMap.

import java.util.HashMap;
import java.util.LinkedHashMap;
import java.util.Map;
import java.util.Map.Entry;
import java.util.stream.Collectors;

public class SimpleTesting {
  public static void main(String[] args) {
    Map<Integer, Integer> map = new HashMap<>();
    map.put(2, 1020);
    map.put(3, 300);
    map.put(1, 100);
    map.put(5, 500);
    map.forEach((k, v) -> System.out.println(k + "=" + v));
    System.out.println("After Sorting by value");
    Map<Integer, Integer> result = map.entrySet()
                                       .stream()
                                       .sorted(Entry.comparingByValue())
                                       .collect(Collectors.toMap(Entry::getKey, Entry::getValue,
                                           (e1, e2) -> e1, LinkedHashMap::new));
    result.forEach((k, v) -> System.out.println(k + "=" + v));
  }
}

Resultado:

1=100
2=1020
3=300
5=500
After Sorting by value
1=100
3=300
5=500
2=1020

Ordenar um Map<key, value> Utilizando código personalizado em Java

Aqui, criamos uma classe definida pelo usuário que implementa a interface Comparator e passamos seu objeto para o TreeMap para ser classificado Map<key, value> por valor.

import java.util.Comparator;
import java.util.HashMap;
import java.util.Map;
import java.util.TreeMap;
class UserComparator implements Comparator<Object> {
  Map<Integer, Integer> map;
  public UserComparator(Map<Integer, Integer> 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(o1)).compareTo((Integer) map.get(o2));
  }
}
public class SimpleTesting {
  public static void main(String[] args) {
    Map<Integer, Integer> map = new HashMap<>();
    map.put(2, 1020);
    map.put(3, 300);
    map.put(1, 100);
    map.put(5, 500);
    map.forEach((k, v) -> System.out.println(k + "=" + v));
    System.out.println("After Sorting by value");
    UserComparator comparator = new UserComparator(map);
    Map<Integer, Integer> result = new TreeMap<Integer, Integer>(comparator);
    result.putAll(map);
    result.forEach((k, v) -> System.out.println(k + "=" + v));
  }
}

Resultado:

1=100
2=1020
3=300
5=500
After Sorting by value
1=100
3=300
5=500
2=1020

Artigo relacionado - Java Map