Introdução

A classe TreeMap em Java faz parte da Interface de Coleções Java e implementa a interface Map. Ela armazena os pares chave-valor em ordem classificada, diferentemente de outras implementações de Map. Neste laboratório, você aprenderá como usar a classe TreeMap de forma eficaz em seus programas Java.

Criando um TreeMap

• Abra seu editor de texto e crie um novo arquivo chamado TreeMapDemo.java no diretório ~/project.
• Importe os pacotes necessários:

import java.util.Comparator;
import java.util.Map;
import java.util.TreeMap;

• Crie um objeto TreeMap:

Map<Integer, String> map = new TreeMap<>();

Adicionando Elementos ao TreeMap

• Use o método put() para adicionar elementos ao TreeMap:

map.put(1, "John");
map.put(2, "Mary");
map.put(3, "Peter");

Adicione este código dentro do método main.

Imprimindo o TreeMap

• Use um loop for-each para iterar através do TreeMap:

for(Map.Entry<Integer, String> entry : map.entrySet()) {
    System.out.println(entry.getKey() + " " + entry.getValue());
}

Usando Ordenação Personalizada

• Crie uma nova classe chamada Employee:

class Employee implements Comparable<Employee> {
    private int id;
    private String name;

    public Employee(int id, String name) {
        this.id = id;
        this.name = name;
    }

    public int getId() {
        return id;
    }

    public String getName() {
        return name;
    }

    @Override
    public int compareTo(Employee e) {
        return this.id - e.getId();
    }
}

• Adicione alguns Employees ao TreeMap:

Map<Employee, String> employeeMap = new TreeMap<>();
employeeMap.put(new Employee(3, "John"), "IT");
employeeMap.put(new Employee(2, "Mary"), "HR");
employeeMap.put(new Employee(1, "Peter"), "Finance");

• Agora, quando você iterar através do TreeMap, ele será ordenado com base no ID do funcionário:

for(Map.Entry<Employee, String> entry : employeeMap.entrySet()) {
    System.out.println(entry.getKey().getId() + " "
                       + entry.getKey().getName() + " "
                       + entry.getValue());
}

Usando Comparadores para Ordenação

• Defina um Comparator personalizado na sua classe TreeMapDemo:

class DescendingOrder implements Comparator<Integer> {
    @Override
    public int compare(Integer o1, Integer o2) {
        return o2 - o1;
    }
}

• Crie um novo objeto TreeMap com o Comparator personalizado:

Map<Integer, String> treeMap = new TreeMap<>(new DescendingOrder());
treeMap.put(1, "John");
treeMap.put(4, "Mary");
treeMap.put(2, "Peter");

• Agora, quando você iterar através do TreeMap, ele será ordenado em ordem decrescente:

for(Map.Entry<Integer, String> entry : treeMap.entrySet()) {
    System.out.println(entry.getKey() + " " + entry.getValue());
}

Acessando Elementos de um Mapa

• Use o método get() para acessar um elemento específico:

String name = map.get(1);
System.out.println("Name is " + name);

Removendo Elementos de um Mapa

• Use o método remove() para remover um elemento específico:

String removedName = map.remove(2);
System.out.println("Removed: " + removedName);

Obtendo o Tamanho do Mapa

• Use o método size() para obter o número de elementos no TreeMap:

int size = map.size();
System.out.println(size);

Obtendo os Primeiros e Últimos Elementos

• Use os métodos firstKey() e lastKey() para recuperar os primeiros e últimos elementos no TreeMap:

int firstKey = map.firstKey();
int lastKey = map.lastKey();

Obtendo um Intervalo de Elementos

• Use o método subMap() para recuperar um intervalo de elementos:

Map<Integer, String> rangeMap = map.subMap(1, 3);
for(Map.Entry<Integer, String> entry : rangeMap.entrySet()) {
    System.out.println(entry.getKey() + " " + entry.getValue());
}

Compilar e Executar o Programa

• Abra seu terminal e navegue até o diretório ~/project.
• Compile o arquivo TreeMapDemo.java usando o comando javac:

javac TreeMapDemo.java

• Execute o programa usando o comando java:

java TreeMapDemo

Resumo

Neste laboratório, você aprendeu sobre a classe TreeMap em Java e como usá-la efetivamente em seus programas. Você aprendeu como criar um TreeMap, adicionar e remover elementos, e recuperar elementos com base em critérios específicos. Você também aprendeu como personalizar a ordem de classificação usando Comparators (Comparadores). A classe TreeMap oferece muita flexibilidade e controle sobre a classificação e o armazenamento de pares chave-valor.