O TreeMap em Java é usado para implementar a interface Map e NavigableMap junto com a classe AbstractMap. O mapa é classificado de acordo com a ordem natural de suas chaves ou por um Comparador fornecido no momento da criação do mapa, dependendo de qual construtor é usado. Isso prova ser uma maneira eficiente de classificar e armazenar os pares de valores-chave. A ordem de armazenamento mantida pelo mapa de árvore deve ser consistente com iguais, assim como qualquer outro mapa classificado, independentemente dos comparadores explícitos. A implementação do mapa de árvore não é sincronizada no sentido de que se um mapa for acessado por vários encadeamentos, simultaneamente e pelo menos um dos encadeamentos modifica o mapa estruturalmente, ele deve ser sincronizado externamente.

Exemplo: A implementação a seguir demonstra como criar, inserir e percorrer o TreeMap .

// Java code to show creation, insertion,
// searching, and traversal in a TreeMap
  
import java.util.*;
import java.util.concurrent.*;
  
public class TreeMapImplementation {
  
    // Declaring a TreeMap
    static TreeMap<Integer, String> tree_map;
  
    // Function to create TreeMap
    static void create()
    {
        // Creating an empty TreeMap
        tree_map
            = new TreeMap<Integer, String>();
  
        System.out.println(
            "TreeMap successfully"
            + " created");
    }
  
    // Function to Insert values in
    // the TreeMap
    static void insert()
    {
        // Mapping string values to int keys
        tree_map.put(10, "Geeks");
        tree_map.put(15, "4");
        tree_map.put(20, "Geeks");
        tree_map.put(25, "Welcomes");
        tree_map.put(30, "You");
  
        System.out.println(
            "\nElements successfully"
            + " inserted in the TreeMap");
    }
  
    // Function to search a key in TreeMap
    static void search(int key)
    {
  
        // Checking for the key
        System.out.println(
            "\nIs key \""
            + key + "\" present? "
            + tree_map.containsKey(key));
    }
  
    // Function to search a value in TreeMap
    static void search(String value)
    {
  
        // Checking for the value
        System.out.println(
            "\nIs value \""
            + value + "\" present? "
            + tree_map.containsValue(value));
    }
  
    // Function to display the elements in TreeMap
    static void display()
    {
        // Displaying the TreeMap
        System.out.println(
            "\nDisplaying the TreeMap:");
  
        System.out.println(
            "TreeMap: " + tree_map);
    }
  
    // Function to traverse TreeMap
    static void traverse()
    {
        System.out.println("\nTraversing the TreeMap:");
        for (Map.Entry<Integer, String> e : tree_map.entrySet())
            System.out.println(e.getKey()
                               + " "
                               + e.getValue());
    }
  
    // Driver code
    public static void main(String[] args)
    {
  
        // Creating the TreeMap
        create();
  
        // Inserting values in the TreeMap
        insert();
  
        // Search key "50" in the TreeMap
        search(50);
  
        // Search value "Geeks" in the TreeMap
        search("Geeks");
  
        // Display the elements in TreeMap
        display();
  
        // Traverse the TreeMap
        traverse();
    }
}

TreeMap criado com sucesso
Elementos inseridos com sucesso no TreeMap
A chave "50" está presente? falso
O valor "Geeks" está presente? verdade
Exibindo o TreeMap:
TreeMap: {10 = Geeks, 15 = 4, 20 = Geeks, 25 = Welcome, 30 = You}
Percorrendo o TreeMap:
10 geeks
15 4
20 geeks
25 Boas-vindas
30 você

Executando Várias Operações no TreeMap

Após a introdução dos Genéricos no Java 1.5, é possível restringir o tipo de objeto que pode ser armazenado no TreeMap. Agora, vamos ver como realizar algumas operações usadas com frequência no TreeMap.

1. Adicionando Elementos: Para adicionar um elemento ao TreeMap, podemos usar o método put() . No entanto, a ordem de inserção não é retida no TreeMap. Internamente, para cada elemento, as chaves são comparadas e classificadas em ordem crescente.

// Java program to demonstrate
// the working of TreeMap
  
import java.util.*;
class GFG {
    public static void main(String args[])
    {
        // Default Initialization of a
        // TreeMap
        TreeMap tm1 = new TreeMap();
  
        // Initialization of a TreeMap
        // using Generics
        TreeMap<Integer, String> tm2
            = new TreeMap<Integer, String>();
  
        // Inserting the Elements
        tm1.put(3, "Geeks");
        tm1.put(2, "For");
        tm1.put(1, "Geeks");
  
        tm2.put(new Integer(3), "Geeks");
        tm2.put(new Integer(2), "For");
        tm2.put(new Integer(1), "Geeks");
  
        System.out.println(tm1);
        System.out.println(tm2);
    }
}

{1 = Geeks, 2 = For, 3 = Geeks}
{1 = Geeks, 2 = For, 3 = Geeks}

2. Alterando Elementos: Depois de adicionar os elementos, se desejarmos alterar o elemento, isso pode ser feito adicionando novamente o elemento com o método put() . Uma vez que os elementos no mapa de árvore são indexados usando as chaves, o valor da chave pode ser alterado simplesmente inserindo o valor atualizado para a chave que desejamos alterar.

// Java program to demonstrate
// the working of TreeMap
  
import java.util.*;
class GFG {
    public static void main(String args[])
    {
        // Initialization of a TreeMap
        // using Generics
        TreeMap<Integer, String> tm
            = new TreeMap<Integer, String>();
  
        // Inserting the Elements
        tm.put(3, "Geeks");
        tm.put(2, "Geeks");
        tm.put(1, "Geeks");
  
        System.out.println(tm);
  
        tm.put(2, "For");
  
        System.out.println(tm);
    }
}

{1 = Geeks, 2 = Geeks, 3 = Geeks}
{1 = Geeks, 2 = For, 3 = Geeks}

3. Removendo Elemento: Para remover um elemento do TreeMap, podemos usar o método remove() . Este método pega o valor da chave e remove o mapeamento da chave deste mapa de árvore, se estiver presente no mapa.

// Java program to demonstrate
// the working of TreeMap
  
import java.util.*;
class GFG {
    public static void main(String args[])
    {
        // Initialization of a TreeMap
        // using Generics
        TreeMap<Integer, String> tm
            = new TreeMap<Integer, String>();
  
        // Inserting the Elements
        tm.put(3, "Geeks");
        tm.put(2, "Geeks");
        tm.put(1, "Geeks");
        tm.put(4, "For");
  
        System.out.println(tm);
  
        tm.remove(4);
  
        System.out.println(tm);
    }
}

{1 = Geeks, 2 = Geeks, 3 = Geeks, 4 = For}
{1 = Geeks, 2 = Geeks, 3 = Geeks}

4. Iterando por meio do TreeMap: Existem várias maneiras de iterar por meio do Mapa. A maneira mais famosa é usar um loop for-each e obter as chaves. O valor da chave é encontrado usando o método getValue() .

// Java program to demonstrate
// the working of TreeMap
  
import java.util.*;
class GFG {
    public static void main(String args[])
    {
        // Initialization of a TreeMap
        // using Generics
        TreeMap<Integer, String> tm
            = new TreeMap<Integer, String>();
  
        // Inserting the Elements
        tm.put(3, "Geeks");
        tm.put(2, "For");
        tm.put(1, "Geeks");
  
        for (Map.Entry mapElement : tm.entrySet()) {
            int key
                = (int)mapElement.getKey();
  
            // Finding the value
            String value
                = (String)mapElement.getValue();
  
            System.out.println(key + " : "
                               + value);
        }
    }
}

1: Geeks
2: para
3: Geeks

Características de um TreeMap:

Alguns recursos importantes do mapa de árvore são:

1. Esta classe é membro do Java Collections Framework.
2. Os implementos classe Mapa de interfaces incluindo NavigableMap , SortedMap e estende a classe AbstractMap.
3. TreeMap em Java não permite chaves nulas (como Map) e, portanto, um NullPointerException é lançada. No entanto, vários valores nulos podem ser associados a chaves diferentes.
4. Os pares de entrada retornados pelos métodos nesta classe e suas visualizações representam instantâneos de mapeamentos no momento em que foram produzidos. Eles não oferecem suporte ao método Entry.setValue .

TreeMap sincronizado:

A implementação de um TreeMap não está sincronizada. Isso significa que se vários threads acessam um conjunto de árvore simultaneamente e pelo menos um dos threads modifica o conjunto, ele deve ser sincronizado externamente. Normalmente, isso é feito usando o método Collections.synchronizedSortedSet . Isso é melhor feito no momento da criação, para evitar o acesso não sincronizado acidental ao conjunto. Isso pode ser feito como:

SortedMap m = Collections.synchronizedSortedMap (novo TreeMap (…));

Como o TreemMap funciona internamente?

Os métodos em um TreeMap ao obter o conjunto de chaves e os valores, retornam um Agente Iterativo que é rápido para falhas por natureza. Portanto, qualquer modificação simultânea lançará ConcurrentModificationException . Um TreeMap é baseado em uma estrutura de dados de árvore em preto - vermelho . Cada nó da árvore possui:

• 3 variáveis ​​( chave K = chave, valor V = valor, cor booleana = cor )
• 3 referências ( entrada esquerda = esquerda, entrada direita = direita, entrada pai = pai )

Construtores em TreeMap

Para criar um TreeMap, precisamos criar um objeto da classe TreeMap. A classe TreeMap consiste em vários construtores que permitem a possível criação do TreeMap. A seguir estão os construtores disponíveis nesta classe:

1. TreeMap(): Este construtor é usado para construir um mapa de árvore vazio que será classificado usando a ordem natural de suas chaves. Vamos entender isso com um exemplo:

// Java program to demonstrate an
// example of TreeMap using the
// default constructor
  
import java.util.*;
import java.util.concurrent.*;
  
public class TreeMapImplementation {
  
    // Function to show TreeMap()
    // constructor example
    static void Example1stConstructor()
    {
        // Creating an empty TreeMap
        TreeMap<Integer, String> tree_map
            = new TreeMap<Integer, String>();
  
        // Mapping string values to int keys
        tree_map.put(10, "Geeks");
        tree_map.put(15, "4");
        tree_map.put(20, "Geeks");
        tree_map.put(25, "Welcomes");
        tree_map.put(30, "You");
  
        // Displaying the TreeMap
        System.out.println("TreeMap: "
                           + tree_map);
    }
  
    // Driver code
    public static void main(String[] args)
    {
  
        System.out.println("TreeMap using "
                           + "TreeMap() constructor:\n");
  
        Example1stConstructor();
    }
}

TreeMap usando o construtor TreeMap():
TreeMap: {10 = Geeks, 15 = 4, 20 = Geeks, 25 = Welcome, 30 = You}

2. TreeMap (Comparator comp): Este construtor é usado para construir um objeto TreeMap vazio no qual os elementos precisarão de uma especificação externa da ordem de classificação. Vamos entender isso com um exemplo:

// Java program to demonstrate
// an example of TreeMap using
// a comparator constructor
  
import java.util.*;
import java.util.concurrent.*;
  
// A class to represent a student.
class Student {
    int rollno;
    String name, address;
  
    // Constructor
    public Student(int rollno, String name,
                   String address)
    {
        this.rollno = rollno;
        this.name = name;
        this.address = address;
    }
  
    // Used to print student details
    // in main()
    public String toString()
    {
        return this.rollno + " "
            + this.name + " "
            + this.address;
    }
}
  
// Comparator implementattion
class Sortbyroll
    implements Comparator<Student> {
  
    // Used for sorting in ascending order of
    // roll number
    public int compare(Student a, Student b)
    {
        return a.rollno - b.rollno;
    }
}
  
public class TreeMapImplementation {
  
    static void Example2ndConstructor()
    {
        // Creating an empty TreeMap
        TreeMap<Student, Integer> tree_map
            = new TreeMap<Student, Integer>(new Sortbyroll());
  
        // Mapping string values to int keys
        tree_map.put(new Student(111, "bbbb",
                                 "london"),
                     2);
        tree_map.put(new Student(131, "aaaa",
                                 "nyc"),
                     3);
        tree_map.put(new Student(121, "cccc",
                                 "jaipur"),
                     1);
  
        // Displaying the TreeMap
        System.out.println("TreeMap: "
                           + tree_map);
    }
  
    public static void main(String[] args)
    {
  
        System.out.println("TreeMap using "
                           + "TreeMap(Comparator)"
                           + " constructor:\n");
        Example2ndConstructor();
    }
}

TreeMap usando o construtor TreeMap (Comparador):
TreeMap: {111 bbbb london = 2, 121 cccc jaipur = 1, 131 aaaa nyc = 3}

3. TreeMap (Mapa M): Este construtor é usado para inicializar um TreeMap com as entradas do mapa M fornecido, que será classificado usando a ordem natural das chaves. Vamos entender isso com um exemplo:

// Java program to demonstrate an
// example of TreeMap using the
// default constructor
  
import java.util.*;
import java.util.concurrent.*;
  
public class TreeMapImplementation {
  
    static void Example3rdConstructor()
    {
        // Creating a Map
        Map<Integer, String> hash_map
            = new HashMap<Integer, String>();
  
        // Mapping string values to int keys
        hash_map.put(10, "Geeks");
        hash_map.put(15, "4");
        hash_map.put(20, "Geeks");
        hash_map.put(25, "Welcomes");
        hash_map.put(30, "You");
  
        // Creating the TreeMap using the Map
        TreeMap<Integer, String> tree_map
            = new TreeMap<Integer, String>(hash_map);
  
        // Displaying the TreeMap
        System.out.println("TreeMap: "
                           + tree_map);
    }
  
    public static void main(String[] args)
    {
  
        System.out.println("TreeMap using "
                           + "TreeMap(Map)"
                           + " constructor:\n");
        Example3rdConstructor();
    }
}

TreeMap usando o construtor TreeMap (Map):
TreeMap: {10 = Geeks, 15 = 4, 20 = Geeks, 25 = Welcome, 30 = You}

4. TreeMap (SortedMap sm): Este construtor é usado para inicializar um TreeMap com as entradas de um determinado mapa classificado, que será armazenado na mesma ordem que o dado mapa classificado. Vamos entender isso com um exemplo:

// Java program to demonstrate an
// example of TreeMap using the
// sortedmap constructor
  
import java.util.*;
import java.util.concurrent.*;
  
public class TreeMapImplementation {
  
    // Function to show
    // TreeMap(SortedMap) constructor example
    static void Example4thConstructor()
    {
        // Creating a SortedMap
        SortedMap<Integer, String> sorted_map
            = new ConcurrentSkipListMap<Integer, String>();
  
        // Mapping string values to int keys
        sorted_map.put(10, "Geeks");
        sorted_map.put(15, "4");
        sorted_map.put(20, "Geeks");
        sorted_map.put(25, "Welcomes");
        sorted_map.put(30, "You");
  
        // Creating the TreeMap using the SortedMap
        TreeMap<Integer, String> tree_map
            = new TreeMap<Integer, String>(sorted_map);
  
        // Displaying the TreeMap
        System.out.println("TreeMap: "
                           + tree_map);
    }
  
    // Driver code
    public static void main(String[] args)
    {
  
        System.out.println("TreeMap using "
                           + "TreeMap(SortedMap)"
                           + " constructor:\n");
        Example4thConstructor();
    }
}

TreeMap usando o construtor TreeMap (SortedMap):
TreeMap: {10 = Geeks, 15 = 4, 20 = Geeks, 25 = Welcome, 30 = You}

Métodos na classe TreeMap