Java TreeMap

Neste tutorial, aprenderemos sobre a classe Java TreeMap e suas operações com a ajuda de exemplos.

O TreeMap A classe da estrutura de coleções Java fornece a implementação da estrutura de dados em árvore.

Ele implementa a interface NavigableMap.

Criando um TreeMap

Para criar um TreeMap , devemos importar o java.util.TreeMap pacote primeiro. Depois de importar o pacote, veja como podemos criar um TreeMap em Java.

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

No código acima, criamos um TreeMap chamados números sem nenhum argumento. Neste caso, os elementos em TreeMap são classificados naturalmente (ordem crescente).

No entanto, podemos personalizar a classificação dos elementos usando o Comparator interface. Vamos aprender sobre isso mais tarde neste tutorial.

Aqui,

Chave - um identificador único usado para associar cada elemento (valor) em um mapa
Valor - elementos associados por chaves em um mapa

Métodos de TreeMap

Os TreeMap classe fornece vários métodos que nos permitem realizar operações no mapa.

Inserir Elementos no TreeMap

put() - insere o mapeamento de chave/valor especificado (entrada) no mapa
putAll() - insere todas as entradas do mapa especificado para este mapa
putIfAbsent() - insere o mapeamento de chave/valor especificado no mapa se a chave especificada não estiver presente no mapa

Por exemplo,

import java.util.TreeMap;

class Main {
    public static void main(String[] args) {
        // Creating TreeMap of even numbers
        TreeMap<String, Integer> evenNumbers = new TreeMap<>();

        // Using put()
        evenNumbers.put("Two", 2);
        evenNumbers.put("Four", 4);

        // Using putIfAbsent()
        evenNumbers.putIfAbsent("Six", 6);
        System.out.println("TreeMap of even numbers: " + evenNumbers);

        //Creating TreeMap of numbers
        TreeMap<String, Integer> numbers = new TreeMap<>();
        numbers.put("One", 1);

        // Using putAll()
        numbers.putAll(evenNumbers);
        System.out.println("TreeMap of numbers: " + numbers);
    }
}

Saída

TreeMap of even numbers: {Four=4, Six=6, Two=2}
TreeMap of numbers: {Four=4, One=1, Six=6, Two=2}

Acessar elementos do TreeMap

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

entrySet() - retorna um conjunto de todos os mapeamentos de chave/valor (entrada) de um mapa de árvore
keySet() - retorna um conjunto de todas as chaves de um mapa de árvore
values() - retorna um conjunto de todos os mapas de um mapa de árvore

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);

        // Using entrySet()
        System.out.println("Key/Value mappings: " + numbers.entrySet());

        // Using keySet()
        System.out.println("Keys: " + numbers.keySet());

        // Using values()
        System.out.println("Values: " + numbers.values());
    }
}

Saída

TreeMap: {One=1, Three=3, Two=2}
Key/Value mappings: [One=1, Three=3, Two=2]
Keys: [One, Three, Two]
Values: [1, 3, 2]

2. Usando get() e getOrDefault()

get() - Retorna o valor associado à chave especificada. Retorna null se a chave não for encontrada.
getOrDefault() - Retorna o valor associado à chave especificada. Retorna o valor padrão especificado se a chave não for encontrada.

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);

        // Using get()
        int value1 = numbers.get("Three");
        System.out.println("Using get(): " + value1);

        // Using getOrDefault()
        int value2 = numbers.getOrDefault("Five", 5);
        System.out.println("Using getOrDefault(): " + value2);
    }
}

Saída

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

Aqui, o getOrDefault() método não encontra a chave Five . Portanto, ele retorna o valor padrão especificado 5 .

Remover elementos do TeeMap

remove(key) - retorna e remove a entrada associada à chave especificada de um TreeMap
remove(key, value) - remove a entrada do mapa somente se a chave especificada estiver associada ao valor especificado e retorna um 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);

        // remove method with single parameter
        int value = numbers.remove("Two");
        System.out.println("Removed value: " + value);

        // remove method with two parameters
        boolean result = numbers.remove("Three", 3);
        System.out.println("Is the entry {Three=3} removed? " + result);

        System.out.println("Updated TreeMap: " + numbers);
    }
}

Saída

TreeMap: {One=1, Three=3, Two=2}
Removed value = 2
Is the entry {Three=3} removed? True
Updated TreeMap: {One=1}

Substituir elementos do mapa de árvore

replace(key, value) - substitui o valor mapeado pela chave especificada com o novo valor
replace(key, old, new) - substitui o valor antigo pelo novo valor somente se o valor antigo já estiver associado à chave especificada
replaceAll(function) - substitui cada valor do mapa pelo resultado da 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("Original TreeMap: " + numbers);

        // Using replace()
        numbers.replace("Second", 22);
        numbers.replace("Third", 3, 33);
        System.out.println("TreeMap using replace: " + numbers);

        // Using replaceAll()
        numbers.replaceAll((key, oldValue) -> oldValue + 2);
        System.out.println("TreeMap using replaceAll: " + numbers);
    }
}

Saída

Original TreeMap: {First=1, Second=2, Third=3}
TreeMap using replace(): {First=1, Second=22, Third=33}
TreeMap using replaceAll(): {First=3, Second=24, Third=35}

No programa acima observe a declaração

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

Aqui, passamos uma expressão lambda como argumento.

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

Desde o TreeMap classe implementa NavigableMap , ele fornece vários métodos para navegar pelos elementos do mapa de árvore.

1. Primeiro e último métodos

firstKey() - retorna a primeira chave do mapa
firstEntry() - retorna o mapeamento de chave/valor da primeira chave do mapa
lastKey() - retorna a última chave do mapa
lastEntry() - retorna o mapeamento de chave/valor da última chave do mapa

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);

        // Using the firstKey() method
        String firstKey = numbers.firstKey();
        System.out.println("First Key: " + firstKey);

        // Using the lastKey() method
        String lastKey = numbers.lastKey();
        System.out.println("Last Key: " + lastKey);

        // Using firstEntry() method
        System.out.println("First Entry: " + numbers.firstEntry());


        // Using the lastEntry() method
        System.out.println("Last Entry: " + numbers.lastEntry());
    }
}

Saída

TreeMap: {First=1, Second=2, Third=3}
First Key: First
Last Key: Third
First Entry: First=1
Last Entry: Third=3

2. Métodos de teto, piso, superior e inferior

maiorKey() - Retorna a chave mais baixa entre as chaves que são maiores que a chave especificada.
highEntry() - Retorna uma entrada associada a uma chave que é a mais baixa entre todas as chaves maiores que a chave especificada.
lowerKey() - Retorna a maior chave entre todas as chaves que são menores que a chave especificada.
inferiorEntry() - Retorna uma entrada associada a uma chave que é a maior entre todas as chaves que são menores que a chave especificada.
tetoKey() - Retorna a chave mais baixa entre as chaves que são maiores que a chave especificada. Se a chave passada como argumento estiver presente no mapa, ele retornará essa chave.
tetoEntrada() - Retorna uma entrada associada a uma chave mais baixa entre as chaves maiores que a chave especificada. Se uma entrada associada à chave passada um argumento estiver presente no mapa, ele retornará a entrada associada a essa chave.
floorKey() - Retorna a maior chave entre as chaves que são menores que a chave especificada. Se a chave passada como argumento estiver presente, ela retornará essa chave.
pisoEntrada() - Retorna uma entrada associada a uma chave que é maior entre as chaves que são menores que a chave especificada. Se a chave passada como argumento estiver presente, 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);

        // Using higher()
        System.out.println("Using higherKey(): " + numbers.higherKey("Fourth"));
        System.out.println("Using higherEntry(): " + numbers.higherEntry("Fourth"));

        // Using lower()
        System.out.println("\nUsing lowerKey(): " + numbers.lowerKey("Fourth"));
        System.out.println("Using lowerEntry(): " + numbers.lowerEntry("Fourth"));

        // Using ceiling()
        System.out.println("\nUsing ceilingKey(): " + numbers.ceilingKey("Fourth"));
        System.out.println("Using ceilingEntry(): " + numbers.ceilingEntry("Fourth"));

        // Using floor()
        System.out.println("\nUsing floorKey(): " + numbers.floorKey("Fourth"));
        System.out.println("Using floorEntry(): " + numbers.floorEntry("Fourth"));


    }
}

Saída

TreeMap: {First=1, Fourth=6, Second=5, Third=4}
Using higherKey(): Second
Using higherEntry(): Second=5

Using lowerKey(): First
Using lowerEntry(): First=1

Using ceilingKey(): Fourth
Using ceilingEntry(): Fourth=6

Using floorkey(): Fourth
Using floorEntry(): Fourth=6

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

pollFirstEntry() - retorna e remove a entrada associada à primeira chave do mapa
pollLastEntry() - retorna e remove a entrada associada à última chave do mapa

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);

        //Using the pollFirstEntry() method
        System.out.println("Using pollFirstEntry(): " + numbers.pollFirstEntry());

        // Using the pollLastEntry() method
        System.out.println("Using pollLastEntry(): " + numbers.pollLastEntry());

        System.out.println("Updated TreeMap: " + numbers);

    }
}

Saída

TreeMap: {First=1, Second=2, Third=3}
Using pollFirstEntry(): First=1
Using pollLastEntry(): Third=3
Updated TreeMap: {Second=2}

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

headMap(key, booleanValue)

O headMap() retorna todos os pares chave/valor de um mapa de árvore antes da chave especificada (que é passado como um argumento).

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

Se true é passado como um booleanValue , o método também inclui o par chave/valor do key que é passado como argumento.

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("\nUsing headMap() Method:");
        // Using headMap() with default booleanValue
        System.out.println("Without boolean value: " + numbers.headMap("Fourth"));

        // Using headMap() with specified booleanValue
        System.out.println("With boolean value: " + numbers.headMap("Fourth", true));

    }
}

Saída

TreeMap: {First=1, Fourth=4, Second=2, Third=3}

Using headMap() Method: 
Without boolean value: {First=1}
With boolean value: {First=1, Fourth=4}

tailMap(key, booleanValue)

O tailMap() O método retorna todos os pares chave/valor de um mapa de árvore a partir da chave especificada (que é passado como um argumento).

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

Se false é passado como um booleanValue , o método não inclui o par chave/valor do key especificado .

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("\nUsing tailMap() Method:");
        // Using tailMap() with default booleanValue
        System.out.println("Without boolean value: " + numbers.tailMap("Second"));

        // Using tailMap() with specified booleanValue
        System.out.println("With boolean value: " + numbers.tailMap("Second", false));

    }
}

Saída

TreeMap: {First=1, Fourth=4, Second=2, Third=3}

Using tailMap() Method:
Without boolean value: {Second=2, Third=3}
With boolean value: {Third=3}

submapa(k1, bV1, k2, bV2)

O subMap() retorna todas as entradas associadas às chaves entre k1 e k2 incluindo a entrada de k1 .

O bV1 e bV2 são parâmetros booleanos opcionais. O valor padrão de bV1 é true e o valor padrão de bV2 é false .

Se false é passado como bV1 , o método retorna todas as entradas associadas às chaves entre k1 e k2 sem incluir a entrada de k1 .

Se true é passado como bV2 , o método retorna todas as entradas associadas às chaves entre k1 e k2 incluindo a entrada de k2 .

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("\nUsing subMap() Method:");
        // Using subMap() with default booleanValue
        System.out.println("Without boolean value: " + numbers.subMap("Fourth", "Third"));

        // Using subMap() with specified booleanValue
        System.out.println("With boolean value: " + numbers.subMap("Fourth", false, "Third", true));

    }
}

Saída

TreeMap: {First=1, Fourth=2, Second=2, Third=3}

Using subMap() Method:
Without boolean value: {Fourth=4, Second=2}
With boolean value: {Second=2, Third=3}

Outros métodos de TreeMap

Método	Descrição
`clone()`	Cria uma cópia do `TreeMap`
`containsKey()`	Pesquisa o `TreeMap` para a chave especificada e retorna um resultado booleano
`containsValue()`	Pesquisa o `TreeMap` para o valor especificado e retorna um resultado booleano
`size()`	Retorna o tamanho do `TreeMap`
`clear()`	Remove todas as entradas do `TreeMap`

Comparador de mapa de árvore

Em todos os exemplos acima, os elementos do mapa de árvore são classificados naturalmente (em ordem crescente). No entanto, também podemos personalizar a ordenação das chaves.

Para isso, precisamos criar nossa própria classe de comparação com base em quais chaves em um mapa de árvore são classificadas. Por exemplo,

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

class Main {
    public static void main(String[] args) {

        // Creating a treemap with a customized comparator
        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);
    }

    // Creating a comparator class
    public static class CustomComparator implements Comparator<String> {

        @Override
        public int compare(String number1, String number2) {
            int value =  number1.compareTo(number2);

            // elements are sorted in reverse order
            if (value > 0) {
                return -1;
            }
            else if (value < 0) {
                return 1;
            }
            else {
                return 0;
            }
        }
    }
}

Saída

TreeMap: {Third=3, Second=2, Fourth=4, First=1}

No exemplo acima, criamos um mapa de árvore passando CustomComparator classe como argumento.

O Comparador Personalizado classe implementa o Comparator interface.

Em seguida, substituímos o compare() método para classificar elementos em ordem inversa.

Para saber mais, visite Java Comparator (documentação oficial do Java).

Interface de mapa navegável Java Interface Java ConcurrentMap

Java