Java TreeMap

Neste tutorial, vamos aprender com exemplos a classe Java TreeMap e suas operações.

Ele herdaInterface NavigableMap.

Criar um TreeMap

Para criar um TreeMap, devemos primeiro importar o pacote java.util.TreeMap. Após a importação do pacote, podemos criar um TreeMap usando o seguinte método no Java.

TreeMap<Key, Value> numbers = new TreeMap<>();

No código acima, criamos um TreeMap chamado numbers sem parâmetros. Neste exemplo, os elementos do TreeMap são ordenados naturalmente (em ordem crescente).

mas, podemos personalizar a ordenação dos elementos usando o interface Comparator. Vamos aprender isso na parte posterior do tutorial.

Aqui,

• Chave - Usado como identificador único para associar cada elemento (valor) no map

• Valor - Elemento associado à chave no map

Métodos do TreeMap

A classe TreeMap fornece várias métodos, permitindo que executemos operações no mapeamento.

Insira o elemento no TreeMap

• put() - Insira a chave especificada/Mapeamento de valores (itens) inserido no mapeamento

• putAll() - Insira todos os itens do mapeamento especificado neste mapeamento

• putIfAbsent() - Se o mapeamento não contiver a chave especificada, insira a chave/Mapeamento de valores inserido no map

por exemplo:

import java.util.TreeMap;
class Main {
　　　　public static void main(String[] args) {
　　　　　　　　//Criar TreeMap de números pares
　　　　　　　　TreeMap<String, Integer> evenNumbers = new TreeMap<>();
　　　　　　　　//　Usar put()
　　　　　　　　evenNumbers.put("Two",　2);
　　　　　　　　evenNumbers.put("Four",　4);
　　　　　　　　//　Usar putIfAbsent()
　　　　　　　　evenNumbers.putIfAbsent("Six",　6);
　　　　　　　　System.out.println("TreeMap de números pares: ",　+　evenNumbers);
　　　　　　　　//Criando TreeMap de números
　　　　　　　　TreeMap<String, Integer> numbers = new TreeMap<>();
　　　　　　　　numbers.put("One",　1);
　　　　　　　　//　Usar putAll()
　　　　　　　　numbers.putAll(evenNumbers);
　　　　　　　　System.out.println("Números do TreeMap: ",　+　numbers);
　　　　}
}

Resultados de saída

TreeMap de números pares: {Four=4, Six=6, Two=2}
Números do TreeMap: {Four=4, One=1, Six=6, Two=2}

Acessar elementos do TreeMap

1.Usar entrySet(), keySet() e values()

• entrySet() - Retorna todas as chaves do TreeMap/Coleção de mapeamento de valores (itens)

• keySet() - Retorna a coleção de todas as chaves do TreeMap

• values() - Retorna a coleção de todos os gráficos do TreeMap

por exemplo:

import java.util.TreeMap;
class Main {
　　　　public static void main(String[] args) {
　　　　　　　　TreeMap<String, Integer> numbers = new TreeMap<>();
　　　　　　　　numbers.put("One",　1);
　　　　　　　　numbers.put("Two",　2);
　　　　　　　　numbers.put("Three",　3);
　　　　　　　　System.out.println("TreeMap: "　+　numbers);
　　　　　　　　//　Usar entrySet()
　　　　　　　　System.out.println("Chave",/Mapeamento de valores:　+　numbers.entrySet());
　　　　　　　　//　Usar keySet()
　　　　　　　　System.out.println("Chaves: ",　+　numbers.keySet());
　　　　　　　　//　Usar values()
　　　　　　　　System.out.println("Valores: ")　+　numbers.values());
　　　　}
}

Resultados de saída

TreeMap: {One=1, Three=3, Two=2}
Chave/Mapeamento de valores: [One=1, Three=3, Two=2]
Chaves: [One, Three, Two]
Valores: [1,　3,　2]

2.usar get() e getOrDefault()

• get() - retorna o valor associado à chave especificada. Se a chave não for encontrada, retorna null.

• getOrDefault() - retorna o valor associado à chave especificada. Se a chave não for encontrada, retorna o valor padrão especificado.

por exemplo:

import java.util.TreeMap;
class Main {
　　　　public static void main(String[] args) {
　　　　　　　　TreeMap<String, Integer> numbers = new TreeMap<>();
　　　　　　　　numbers.put("One",　1);
　　　　　　　　numbers.put("Two",　2);
　　　　　　　　numbers.put("Three",　3);
　　　　　　　　System.out.println("TreeMap: "　+　numbers);
　　　　　　　　//　usar get()
　　　　　　　　int value1　= numbers.get("Three");
　　　　　　　　System.out.println("usar get(): ")　+　value1);
　　　　　　　　//　usar getOrDefault()
　　　　　　　　int value2　= numbers.getOrDefault("Five",　5);
　　　　　　　　System.out.println("usar getOrDefault(): ")　+　value2);
　　　　}
}

Resultados de saída

TreeMap: {One=1, Three=3, Two=2}
usar get():　3
usar getOrDefault():　5

remover elemento TeeMap

• remove(key) - retorna e remove do TreeMap o item associado à chave especificada

• remove(key, value) -remove apenas o item do mapeamento quando a chave especificada estiver associada ao valor especificado, e retorne o valor booleano

por exemplo:

import java.util.TreeMap;
class Main {
　　　　public static void main(String[] args) {
　　　　　　　　TreeMap<String, Integer> numbers = new TreeMap<>();
　　　　　　　　numbers.put("One",　1);
　　　　　　　　numbers.put("Two",　2);
　　　　　　　　numbers.put("Three",　3);
　　　　　　　　System.out.println("TreeMap: "　+　numbers);
　　　　　　　　//método de exclusão com um parâmetro
　　　　　　　　int value = numbers.remove("Two");
　　　　　　　　System.out.println("valor removido: ")　+　value);
　　　　　　　　//método de exclusão com dois parâmetros
　　　　　　　　boolean result = numbers.remove("Three",　3);
　　　　　　　　System.out.println("entrada {Three=")3} foi removido? "　+　result);
　　　　　　　　System.out.println("TreeMap atualizado: ");　+　numbers);
　　　　}
}

Resultados de saída

TreeMap: {One=1, Three=3, Two=2}
valor removido =　2
entrada {Three=3} foi removido? True
TreeMap atualizado: {One=1}

substituir elemento TreeMap

• replace(key, value)-usar key novo para substituir o valor mapeado especificado value

• replace(key, old, new) -substitua o valor antigo apenas quando o valor antigo já estiver associado à chave especificada

• replaceAll(function) -substitua cada valor do map com a função especificada

por exemplo:

import java.util.TreeMap;
class Main {
　　　　public static void main(String[] args) {
　　　　　　　　TreeMap<String, Integer> numbers = new TreeMap<>();
　　　　　　　　numbers.put("First",　1);
　　　　　　　　numbers.put("Second",　2);
　　　　　　　　numbers.put("Third",　3);
　　　　　　　　System.out.println("TreeMap original: "　+　numbers);
　　　　　　　　//　usar replace()
　　　　　　　　numbers.replace("Second",　22);
　　　　　　　　numbers.replace("Third",　3,　33);
　　　　　　　　System.out.println("TreeMap usa o método replace(): "　+　numbers);
　　　　　　　　//　usar replaceAll()
　　　　　　　　numbers.replaceAll((key, oldValue)　-> oldValue　+　2);
　　　　　　　　System.out.println("TreeMap usa o método replaceAll(): "　+　numbers);
　　　　}
}

Resultados de saída

TreeMap original: {Primeiro=1, Segundo=2, Third=3}
TreeMap usa o método replace(): {Primeiro=1, Segundo=22, Third=33}
TreeMap usa o método replaceAll(): {Primeiro=3, Segundo=24, Third=35}

No programa acima, note a sentença

numbers.replaceAll((key, oldValue)　-> oldValue　+　2);

Aqui, passamos umaexpressão lambdacomo parâmetro.

O método replaceAll() acessa todas as entradas do map. Em seguida, ele substitui todos os elementos por novos valores (retornados pela expressão lambda).

métodos de navegação

Porque a classe TreeMap implementou NavigableMap, ela fornece várias métodos de navegação nos elementos do TreeMap.

1.primeira e última métodos

• firstKey() - retorna a primeira chave do mapeamento

• firstEntry() - retorna a chave da primeira entrada do mapeamento/mapeamento de valores

• lastKey() - retorna a última chave do mapeamento

• lastEntry() - retorna a chave da última entrada do mapeamento/mapeamento de valores

por exemplo:

import java.util.TreeMap;
class Main {
　　　　public static void main(String[] args) {
　　　　　　　　TreeMap<String, Integer> numbers = new TreeMap<>();
　　　　　　　　numbers.put("First",　1);
　　　　　　　　numbers.put("Second",　2);
　　　　　　　　numbers.put("Third",　3);
　　　　　　　　System.out.println("TreeMap: "　+　numbers);
　　　　　　　　//　usar o método firstKey()
　　　　　　　　String firstKey = numbers.firstKey();
　　　　　　　　System.out.println("Primeira chave: "　+　firstKey);
　　　　　　　　//　usar o método lastKey()
　　　　　　　　String lastKey = numbers.lastKey();
　　　　　　　　System.out.println("Última chave: "　+　lastKey);
　　　　　　　　//　usar o método firstEntry()
　　　　　　　　System.out.println("Primeira entrada: "　+　numbers.firstEntry());
　　　　　　　　//　Usando　o　método　lastEntry()
　　　　　　　　System.out.println("Último item:　"　+　numbers.lastEntry());
　　　　}
}

Resultados de saída

TreeMap: {First=1, Segundo=2, Third=3}
Primeira chave:　First
Última chave:　Third
Primeiro item:　First=1
Último item:　Third=3

2.Métodos de limite superior, inferior e central

• HigherKey() - Retorna a chave mais baixa entre as chaves maiores que a chave especificada.

• HigherEntry() - Retorna a entrada associada à chave mais baixa entre todas as chaves maiores que a chave especificada.

• lowerKey() - Retorna a chave mais alta entre todas as chaves menores que a chave especificada.

• lowerEntry() - Retorna a entrada associada à chave mais alta entre todas as chaves menores que a chave especificada.

• ceilingKey() - Retorna a chave mais baixa entre as chaves maiores que a chave especificada. Se houver uma entrada associada à chave passada como parâmetro, ela retornará essa chave.

• ceilingEntry() - Retorna a entrada associada à chave mais baixa entre as chaves maiores que a chave especificada. Se houver uma entrada associada à chave passada como argumento, retornará essa entrada.

• floorKey() - Retorna a chave mais alta entre as chaves menores que a chave especificada. Se existir a chave passada como parâmetro, ela retornará essa chave.

• floorEntry() - Retorna a entrada associada à chave mais alta entre as chaves menores que a chave especificada. Se existir a chave passada como parâmetro, ela retornará essa chave.

por exemplo:

import java.util.TreeMap;
class Main {
　　　　public static void main(String[] args) {
　　　　　　　　TreeMap<String, Integer> numbers = new TreeMap<>();
　　　　　　　　numbers.put("First",　1);
　　　　　　　　numbers.put("Second",　5);
　　　　　　　　numbers.put("Third",　4);
　　　　　　　　numbers.put("Fourth",　6);
　　　　　　　　System.out.println("TreeMap: "　+　numbers);
　　　　　　　　//　Usando　higher()
　　　　　　　　System.out.println("Usando　higherKey():　"　+　numbers.higherKey("Fourth"));
　　　　　　　　System.out.println("Usando　higherEntry():　"　+　numbers.higherEntry("Fourth"));
　　　　　　　　//　Usando　lower()
　　　　　　　　System.out.println("\nUsando　lowerKey():　"　+　numbers.lowerKey("Fourth"));
　　　　　　　　System.out.println("Usando　lowerEntry():　"　+　numbers.lowerEntry("Fourth"));
　　　　　　　　//　Usando　ceiling()
　　　　　　　　System.out.println("\nUsando　ceilingKey():　"　+　numbers.ceilingKey("Fourth"));
　　　　　　　　System.out.println("Usando　ceilingEntry():　"　+　numbers.ceilingEntry("Fourth"));
　　　　　　　　//　Usando floor()
　　　　　　　　System.out.println("\nUsando floorKey(): ");　+　numbers.floorKey("Fourth"));
　　　　　　　　System.out.println("Usando floorEntry(): ");　+　numbers.floorEntry("Fourth"));
　　　　}
}

Resultados de saída

TreeMap: {First=1, Quarto=6, Segundo=5, Third=4}
Usando higherKey(): Second
Usando higherEntry(): Second=5
Usando lowerKey(): First
Usando lowerEntry(): First=1
Usando ceilingKey(): Fourth
Usando ceilingEntry(): Fourth=6
Usando floorkey(): Fourth
Usando floorEntry(): Fourth=6

3. métodos pollFirstEntry() e pollLastEntry()

• pollFirstEntry() - Retorna e remove a entrada associada à primeira chave do mapeamento

• pollLastEntry()　 -Retorna e remove a entrada associada à última chave do mapeamento

por exemplo:

import java.util.TreeMap;
class Main {
　　　　public static void main(String[] args) {
　　　　　　　　TreeMap<String, Integer> numbers = new TreeMap<>();
　　　　　　　　numbers.put("First",　1);
　　　　　　　　numbers.put("Second",　2);
　　　　　　　　numbers.put("Third",　3);
　　　　　　　　System.out.println("TreeMap: "　+　numbers);
　　　　　　　　//Usando o método pollFirstEntry()
　　　　　　　　System.out.println("Usando pollFirstEntry(): ");　+　numbers.pollFirstEntry());
　　　　　　　　//　Usando o método pollLastEntry()
　　　　　　　　System.out.println("Usando pollLastEntry(): ");　+　numbers.pollLastEntry());
　　　　　　　　System.out.println("TreeMap atualizado: ");　+　numbers);
　　　　}
}

Resultados de saída

TreeMap: {First=1, Segundo=2, Third=3}
Usando pollFirstEntry(): First=1
Usando pollLastEntry(): Third=3
TreeMap atualizado: {Second=2}

4. métodos headMap(), tailMap() e subMap()

headMap(key,booleanValue)

O parâmetro booleanValue é opcional. O valor padrão é false.

Se o valor booleanValue for true, o método também inclui a chave especificada/pares de valores.

por exemplo:

import java.util.TreeMap;
class Main {
　　　　public static void main(String[] args) {
　　　　　　　　TreeMap<String, Integer> numbers = new TreeMap<>();
　　　　　　　　numbers.put("First",　1);
　　　　　　　　numbers.put("Second",　2);
　　　　　　　　numbers.put("Third",　3);
　　　　　　　　numbers.put("Fourth",　4);
　　　　　　　　System.out.println("TreeMap: "　+　numbers);
　　　　　　　　System.out.println("\nUsando o método headMap():");
　　　　　　　　//　headMap() usando o valor padrão booleano false
　　　　　　　　System.out.println("Não especificando o valor booleano: ");　+　numbers.headMap("Fourth"));
　　　　　　　　//　headMap() usando o valor booleano especificado true
　　　　　　　　System.out.println("Especificando o valor booleano true: ");　+　numbers.headMap("Fourth", true));
　　　　}
}

Resultados de saída

TreeMap: {First=1, Quarto=4, Segundo=2, Third=3}
usando o método headMap():　
não especificando o valor booleano: {First=1}
especificando o valor booleano true: {First=1, Quarto=4}

tailMap(key,booleanValue)

o método tailMap() começa a retornar todas as chaves do TreeMap a partir da chave especificada (passada como parâmetro)/pares de valores.

booleanValue é um parâmetro opcional. O valor padrão é true.

se booleanValue for false, o método não inclui a chave especificada/pares de valores.

por exemplo:

import java.util.TreeMap;
class Main {
　　　　public static void main(String[] args) {
　　　　　　　　TreeMap<String, Integer> numbers = new TreeMap<>();
　　　　　　　　numbers.put("First",　1);
　　　　　　　　numbers.put("Second",　2);
　　　　　　　　numbers.put("Third",　3);
　　　　　　　　numbers.put("Fourth",　4);
　　　　　　　　System.out.println("TreeMap: "　+　numbers);
　　　　　　　　System.out.println("\nUsando o método tailMap():");
　　　　　　　　//　tailMap() booleanValue usando valor padrão true
　　　　　　　　System.out.println("booleanValue usando valor padrão true: ");　+　numbers.tailMap("Second"));
　　　　　　　　//　tailMap() booleanValue usando valor especificado false
　　　　　　　　System.out.println("booleanValue usando false especificado: ");　+　numbers.tailMap("Second", false));
　　　　}
}

Resultados de saída

TreeMap: {First=1, Quarto=4, Segundo=2, Third=3}
usando o método tailMap():
booleanValue usando true padrão: {Second=2, Third=3}
booleanValue usando false especificado: {Third=3}

subMap(k1,bV1,k2,bV2)

o método subMap() retorna as entradas associadas às chaves com1e k2as entradas associadas às chaves entre1das entradas.

bV1e bV2é um parâmetro booleano opcional. bV1o valor padrão é true, bV2o valor padrão é false.

se bV1se bV1e k2as entradas associadas às chaves entre1das entradas.

se bV2se bV1e k2as entradas associadas às chaves entre2das entradas.

por exemplo:

import java.util.TreeMap;
class Main {
　　　　public static void main(String[] args) {
　　　　　　　　TreeMap<String, Integer> numbers = new TreeMap<>();
　　　　　　　　numbers.put("First",　1);
　　　　　　　　numbers.put("Second",　2);
　　　　　　　　numbers.put("Third",　3);
　　　　　　　　numbers.put("Fourth",　4);
　　　　　　　　System.out.println("TreeMap: "　+　numbers);
　　　　　　　　System.out.println("\nUsar método subMap():");
　　　　　　　　//　tailMap() usar valor booleano padrão
　　　　　　　　System.out.println("Usar valor booleano padrão: ")　+　numbers.subMap("Fourth", "Third"));
　　　　　　　　//　tailMap() especificar valor booleano
　　　　　　　　System.out.println("Especificar valor booleano: ")　+　numbers.subMap("Fourth", false, "Third", true));
　　　　}
}

Resultados de saída

TreeMap: {First=1, Quarto=2, Segundo=2, Third=3}
Usar método subMap():
Usar valor booleano padrão: {Fourth=4, Segundo=2}
Especificar valor booleano: {Second=2, Third=3}

Outros métodos do TreeMap

Comparador TreeMap

Em todos os exemplos acima, os elementos do TreeMap são ordenados naturalmente (em ordem crescente). No entanto, também podemos definir nossa própria ordem das chaves.

Para isso, precisamos criar nossa própria classe comparadora com base na ordenação das chaves do TreeMap. Por exemplo,

import java.util.TreeMap;
import java.util.Comparator;
class Main {
　　　　public static void main(String[] args) {
　　　　　　　　//Criar um TreeMap usando um comparador personalizado
　　　　　　　　TreeMap<String, Integer> numbers = new TreeMap<>(new CustomComparator());
　　　　　　　　numbers.put("First",　1);
　　　　　　　　numbers.put("Second",　2);
　　　　　　　　numbers.put("Third",　3);
　　　　　　　　numbers.put("Fourth",　4);
　　　　　　　　System.out.println("TreeMap: "　+　numbers);
　　　　}
　　　　//Criar uma classe comparadora
　　　　public static class CustomComparator implements Comparator<String> {
　　　　　　　　@Override
　　　　　　　　public int compare(String number1, String number2) {
　　　　　　　　　　　　int value = number1.compareTo(number2);
　　　　　　　　　　　　//Os elementos são ordenados em ordem inversa
　　　　　　　　　　　　if (value > 0) {
　　　　　　　　　　　　　　　　return　-1;
　　　　　　　　　　　　}
　　　　　　　　　　　　else if (value < 0) {
　　　　　　　　　　　　　　　　return　1;
　　　　　　　　　　　　}
　　　　　　　　　　　　else {
　　　　　　　　　　　　　　　　return 0;
　　　　　　　　　　　　}
　　　　　　　　}
　　　　}
}

Resultados de saída

TreeMap: {Terceiro=3, Segundo=2, Quarto=4, Primeiro=1}

No exemplo acima, criamos um TreeMap, passando a classe CustomComparator como parâmetro.

A classe CustomComparator implementa a interface Comparator.

Então, reescreva o método compare() para ordenar os elementos em ordem inversa.