Ordenando um HashMap

Introdução

Um HashMap é uma coleção que armazena pares chave-valor. No entanto, ele não armazena os pares chave-valor em nenhuma ordem específica e não mantém a ordem de inserção dos elementos. Pode haver casos em que queremos visualizar os dados armazenados de forma ordenada. Nesses casos, precisamos ordenar o HashMap.

Criar um novo arquivo Java

Primeiramente, precisamos criar um novo arquivo Java para escrever o código para ordenar um HashMap. Abra o terminal e navegue até o diretório onde deseja criar o arquivo. Use o seguinte comando para criar um novo arquivo chamado HashMapSortDemo.java.

touch HashMapSortDemo.java

Ordenando por Chaves usando Collections.sort()

Podemos ordenar um HashMap por chaves usando o método Collections.sort(). Siga o código abaixo:

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

public class HashMapSortDemo {
    public static void main(String args[]) {
        HashMap<String, Integer> unsortedMap = new HashMap<>();
        unsortedMap.put("one", 1);
        unsortedMap.put("two", 2);
        unsortedMap.put("three", 3);
        unsortedMap.put("four", 4);
        unsortedMap.put("five", 5);

        System.out.println("Printing the Unsorted HashMap");
        for(Entry<String, Integer> e : unsortedMap.entrySet()) {
            System.out.println(e.getKey() + "-->" + e.getValue());
        }

        ArrayList<String> sortedList = new ArrayList<>(unsortedMap.keySet());
        Collections.sort(sortedList);

        System.out.println("\nPrinting the Alphabetically Sorted Keys");
        for(String s : sortedList) {
            System.out.println(s + "-->" + unsortedMap.get(s));
        }
    }
}

O código acima está ordenando o HashMap por chaves usando o método Collections.sort().

Use o seguinte comando para compilar e executar o código:

javac HashMapSortDemo.java && java HashMapSortDemo

Ordenando por Valores usando Collections.sort()

Podemos ordenar um HashMap por valores usando o método Collections.sort(). Siga o código abaixo:

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

public class HashMapSortDemo {
    public static void main(String args[]) {
        HashMap<String, Integer> unsortedMap = new HashMap<>();
        unsortedMap.put("one", 1);
        unsortedMap.put("two", 2);
        unsortedMap.put("three", 3);
        unsortedMap.put("four", 4);
        unsortedMap.put("five", 5);

        System.out.println("Printing the Unsorted HashMap");
        for(Entry<String, Integer> e : unsortedMap.entrySet()) {
            System.out.println(e.getKey() + "-->" + e.getValue());
        }

        ArrayList<Integer> sortedList = new ArrayList<>(unsortedMap.values());
        Collections.sort(sortedList);

        System.out.println("\nPrinting the Sorted Values");
        for(Integer i : sortedList) {
            System.out.println(i);
        }
    }
}

O código acima está ordenando o HashMap por valores usando o método Collections.sort().

Use o seguinte comando para compilar e executar o código:

javac HashMapSortDemo.java && java HashMapSortDemo

Ordenando por Chaves usando TreeMap

Podemos ordenar um HashMap por chaves usando um TreeMap. Um TreeMap armazena automaticamente os pares chave-valor em ordem ordenada (ordenada por chaves). Siga o código abaixo:

import java.util.HashMap;
import java.util.Map.Entry;
import java.util.TreeMap;

public class HashMapSortDemo {
    public static void main(String args[]) {
        HashMap<String, Integer> unsortedMap = new HashMap<>();
        unsortedMap.put("one", 1);
        unsortedMap.put("two", 2);
        unsortedMap.put("three", 3);
        unsortedMap.put("four", 4);
        unsortedMap.put("five", 5);

        System.out.println("Printing the Unsorted HashMap");
        for(Entry<String, Integer> e : unsortedMap.entrySet()) {
            System.out.println(e.getKey() + "-->" + e.getValue());
        }

        TreeMap<String, Integer> sortedMap = new TreeMap<>(unsortedMap);

        System.out.println("\nPrinting the Sorted TreeMap");
        for(Entry<String, Integer> e : sortedMap.entrySet()) {
            System.out.println(e.getKey() + "-->" + e.getValue());
        }
    }
}

O código acima está ordenando o HashMap por chaves usando um TreeMap.

Use o seguinte comando para compilar e executar o código:

javac HashMapSortDemo.java && java HashMapSortDemo

Ordenando por Valores usando TreeSet

Podemos ordenar um HashMap por valores usando um TreeSet. Um TreeSet também armazena dados em ordem ordenada (ordenada por valores). Siga o código abaixo:

import java.util.HashMap;
import java.util.Map.Entry;
import java.util.TreeSet;

public class HashMapSortDemo {
    public static void main(String args[]) {
        HashMap<String, Integer> unsortedMap = new HashMap<>();
        unsortedMap.put("one", 1);
        unsortedMap.put("two", 2);
        unsortedMap.put("three", 3);
        unsortedMap.put("four", 4);
        unsortedMap.put("five", 5);

        unsortedMap.put("fourteen", 4);
        unsortedMap.put("fifteen", 5);
        unsortedMap.put("twenty", 2);

        System.out.println("Printing the Unsorted HashMap");
        for(Entry<String, Integer> e : unsortedMap.entrySet()) {
            System.out.println(e.getKey() + "-->" + e.getValue());
        }

        TreeSet<Integer> sortedSet = new TreeSet<>(unsortedMap.values());

        System.out.println("\nThe sorted values are: " + sortedSet);
    }
}

O código acima está ordenando o HashMap por valores usando um TreeSet.

Use o seguinte comando para compilar e executar o código:

javac HashMapSortDemo.java && java HashMapSortDemo

Ordenação usando Stream e expressões Lambda

Podemos ordenar um HashMap em uma única linha de código usando Java Streams e expressões Lambda. Siga o código abaixo:

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

public class HashMapSortDemo {
    public static void main(String args[]) {
        HashMap<String, Integer> unsortedMap = new HashMap<>();
        unsortedMap.put("one", 1);
        unsortedMap.put("two", 2);
        unsortedMap.put("three", 3);
        unsortedMap.put("four", 4);
        unsortedMap.put("five", 5);

        System.out.println("Printing the Unsorted HashMap");
        for(Entry<String, Integer> e : unsortedMap.entrySet()) {
            System.out.println(e.getKey() + "-->" + e.getValue());
        }

        Stream<Entry<String, Integer>> sortedStream = unsortedMap.entrySet()
                                        .stream()
                                        .sorted(Map.Entry.<String, Integer>comparingByKey());

        System.out.println("\nPrinting the Sorted Key-Value Pairs");
        sortedStream.forEach(System.out :: println);
    }
}

O código acima está ordenando o HashMap usando Java Streams e expressões Lambda.

Use o seguinte comando para compilar e executar o código:

javac HashMapSortDemo.java && java HashMapSortDemo

Ordenação por Valores usando Stream e Expressões Lambda

Também podemos ordenar um HashMap por valores usando Java Streams e expressões Lambda. Siga o código abaixo:

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

public class HashMapSortDemo {
    public static void main(String args[]) {
        HashMap<String, Integer> unsortedMap = new HashMap<>();
        unsortedMap.put("one", 1);
        unsortedMap.put("two", 2);
        unsortedMap.put("three", 3);
        unsortedMap.put("four", 4);
        unsortedMap.put("five", 5);

        System.out.println("Printing the Unsorted HashMap");
        for(Entry<String, Integer> e : unsortedMap.entrySet()) {
            System.out.println(e.getKey() + "-->" + e.getValue());
        }

        Stream<Entry<String, Integer>> sortedStream = unsortedMap.entrySet()
                                        .stream()
                                        .sorted(Map.Entry.<String, Integer>comparingByValue());

        System.out.println("\nPrinting the Sorted Key-Value Pairs");
        sortedStream.forEach(System.out :: println);
    }
}

O código acima está ordenando o HashMap por valores usando Java Streams e expressões Lambda.

Use o seguinte comando para compilar e executar o código:

javac HashMapSortDemo.java && java HashMapSortDemo

Usando a Biblioteca Guava do Google

A biblioteca Guava do Google nos fornece uma classe ImmutableSortedMap. Podemos usar o método copyOf() desta classe para ordenar um HashMap. Siga o código abaixo:

import java.util.HashMap;
import java.util.Map.Entry;
import com.google.common.collect.ImmutableSortedMap;

public class HashMapSortDemo {
    public static void main(String args[]) {
        HashMap<String, Integer> unsortedMap = new HashMap<>();
        unsortedMap.put("one", 1);
        unsortedMap.put("two", 2);
        unsortedMap.put("three", 3);
        unsortedMap.put("four", 4);
        unsortedMap.put("five", 5);

        System.out.println("Printing the Unsorted HashMap");
        for (Entry<String, Integer> e : unsortedMap.entrySet()) {
            System.out.println(e.getKey() + "-->" + e.getValue());
        }

        ImmutableSortedMap<String, Integer> sortedMap = ImmutableSortedMap.copyOf(unsortedMap);

        System.out.println("\nPrinting the Sorted ImmutableSortedMap");
        System.out.println(sortedMap);
    }
}

O código acima está ordenando o HashMap usando a biblioteca Guava do Google.

Use o seguinte comando para compilar e executar o código:

javac -cp ".:guava-30.1.1-jre.jar" HashMapSortDemo.java && java -cp ".:guava-30.1.1-jre.jar" HashMapSortDemo

Limpeza de Dados

Finalmente, exclua o arquivo HashMapSortDemo.java usando o seguinte comando:

rm HashMapSortDemo.java

Resumo

Neste laboratório, vimos como ordenar um HashMap por chaves ou valores. Usamos diferentes métodos como Collections.sort(), TreeMap, TreeSet, Java Streams e expressões Lambda, e a biblioteca Guava do Google para ordenar o HashMap. Também aprendemos sobre seus casos de uso e como podemos escrever um código eficiente para ordenar o HashMap em Java.