Java TreeMap

Arborescence Java

Dans ce didacticiel, nous allons découvrir la classe Java TreeMap et ses opérations à l'aide d'exemples.

Le TreeMap La classe du framework de collections Java fournit l'implémentation de la structure de données arborescente.

Il implémente l'interface NavigableMap.

Création d'un TreeMap

Pour créer un TreeMap , il faut importer le java.util.TreeMap paquet d'abord. Une fois que nous avons importé le package, voici comment nous pouvons créer un TreeMap en Java.

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

Dans le code ci-dessus, nous avons créé un TreeMap numéros nommés sans aucun argument. Dans ce cas, les éléments de TreeMap sont triés naturellement (ordre croissant).

Cependant, nous pouvons personnaliser le tri des éléments en utilisant le Comparator interface. Nous en apprendrons plus tard dans ce tutoriel.

Ici,

Clé - un identifiant unique utilisé pour associer chaque élément (valeur) dans une carte
Valeur - éléments associés par clés dans une carte

Méthodes de TreeMap

Le TreeMap fournit diverses méthodes qui nous permettent d'effectuer des opérations sur la carte.

Insérer des éléments dans TreeMap

put() - insère le mappage clé/valeur spécifié (entrée) dans la carte
putAll() - insère toutes les entrées de la carte spécifiée dans cette carte
putIfAbsent() - insère le mappage clé/valeur spécifié dans la carte si la clé spécifiée n'est pas présente dans la carte

Par exemple,

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

Sortie

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

Accéder aux éléments TreeMap

1. Utilisation de entrySet(), keySet() et values()

entrySet() - renvoie un ensemble de tous les mappages clés/valeurs (entrée) d'un treemap
keySet() - renvoie un ensemble de toutes les clés d'une carte arborescente
values() - renvoie un ensemble de toutes les cartes d'une carte arborescente

Par exemple,

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

Sortie

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. Utilisation de get() et getOrDefault()

get() - Renvoie la valeur associée à la clé spécifiée. Renvoie null si la clé est introuvable.
getOrDefault() - Renvoie la valeur associée à la clé spécifiée. Renvoie la valeur par défaut spécifiée si la clé est introuvable.

Par exemple,

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

Sortie

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

Ici, le getOrDefault() la méthode ne trouve pas la clé Cinq . Par conséquent, il renvoie la valeur par défaut spécifiée 5 .

Supprimer les éléments TeeMap

remove(key) - renvoie et supprime l'entrée associée à la clé spécifiée d'un TreeMap
remove(key, value) - supprime l'entrée de la carte uniquement si la clé spécifiée est associée à la valeur spécifiée et renvoie une valeur booléenne

Par exemple,

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

Sortie

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

Remplacer les éléments TreeMap

replace(key, value) - remplace la valeur mappée par la clé spécifiée avec la nouvelle valeur
replace(key, old, new) - remplace l'ancienne valeur par la nouvelle uniquement si l'ancienne valeur est déjà associée à la clé spécifiée
replaceAll(function) - remplace chaque valeur de la carte par le résultat de la fonction spécifiée

Par exemple,

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

Sortie

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}

Dans le programme ci-dessus, notez la déclaration

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

Ici, nous avons passé une expression lambda en argument.

Le replaceAll() La méthode accède à toutes les entrées de la carte. Il remplace ensuite tous les éléments par les nouvelles valeurs (renvoyées de l'expression lambda).

Depuis le TreeMap la classe implémente NavigableMap , il fournit diverses méthodes pour naviguer sur les éléments du treemap.

1. Première et dernière méthodes

firstKey() - renvoie la première clé de la carte
firstEntry() - renvoie le mappage clé/valeur de la première clé de la carte
lastKey() - renvoie la dernière clé de la carte
lastEntry() - renvoie le mappage clé/valeur de la dernière clé de la carte

Par exemple,

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

Sortie

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

2. Méthodes Plafond, Sol, Supérieur et Inférieur

higherKey() - Renvoie la clé la plus basse parmi les clés supérieures à la clé spécifiée.
higherEntry() - Renvoie une entrée associée à une clé qui est la plus basse parmi toutes les clés supérieures à la clé spécifiée.
lowerKey() - Renvoie la plus grande clé parmi toutes les clés inférieures à la clé spécifiée.
lowerEntry() - Renvoie une entrée associée à une clé qui est la plus grande parmi toutes les clés inférieures à la clé spécifiée.
ceilingKey() - Renvoie la clé la plus basse parmi les clés supérieures à la clé spécifiée. Si la clé passée en argument est présente dans la carte, elle renvoie cette clé.
ceilingEntry() - Renvoie une entrée associée à une clé qui est la plus basse parmi les clés supérieures à la clé spécifiée. Si une entrée associée à la clé passée en argument est présente dans la carte, elle renvoie l'entrée associée à cette clé.
floorKey() - Renvoie la plus grande clé parmi les clés inférieures à la clé spécifiée. Si la clé passée en argument est présente, il renvoie cette clé.
floorEntry() - Renvoie une entrée associée à une clé qui est la plus grande parmi les clés inférieures à la clé spécifiée. Si la clé passée en argument est présente, il renvoie cette clé.

Par exemple,

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


    }
}

Sortie

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éthodes pollFirstEntry() et pollLastEntry()

pollFirstEntry() - renvoie et supprime l'entrée associée à la première clé de la carte
pollLastEntry() - renvoie et supprime l'entrée associée à la dernière clé de la carte

Par exemple,

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

    }
}

Sortie

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

4. Méthodes headMap(), tailMap() et subMap()

headMap (clé, valeur booléenne)

Le headMap() La méthode renvoie toutes les paires clé/valeur d'un treemap avant la clé spécifiée (qui est passé en argument).

La booleanValue paramètre est facultatif. Sa valeur par défaut est false .

Si true est passé en tant que booleanValue , la méthode inclut également la paire clé/valeur du key qui est passé en argument.

Par exemple,

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

    }
}

Sortie

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(clé, valeur booléenne)

Le tailMap() La méthode renvoie toutes les paires clé/valeur d'un treemap à partir de la clé spécifiée (qui est passé en argument).

La booleanValue est un paramètre facultatif. Sa valeur par défaut est true .

Si false est passé en tant que booleanValue , la méthode n'inclut pas la paire clé/valeur du key spécifié .

Par exemple,

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

    }
}

Sortie

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

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

sousCarte(k1, bV1, k2, bV2)

Le subMap() la méthode renvoie toutes les entrées associées aux clés entre k1 et k2 y compris l'entrée de k1 .

Le bV1 et bV2 sont des paramètres booléens facultatifs. La valeur par défaut de bV1 est true et la valeur par défaut de bV2 est false .

Si false est passé comme bV1 , la méthode renvoie toutes les entrées associées aux clés entre k1 et k2 sans inclure l'entrée de k1 .

Si true est passé comme bV2 , la méthode renvoie toutes les entrées associées aux clés entre k1 et k2 y compris l'entrée de k2 .

Par exemple,

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

    }
}

Sortie

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}

Autres méthodes de TreeMap

Méthode	Description
`clone()`	Crée une copie du `TreeMap`
`containsKey()`	Recherche le `TreeMap` pour la clé spécifiée et renvoie un résultat booléen
`containsValue()`	Recherche le `TreeMap` pour la valeur spécifiée et renvoie un résultat booléen
`size()`	Renvoie la taille du `TreeMap`
`clear()`	Supprime toutes les entrées du `TreeMap`

Comparateur TreeMap

Dans tous les exemples ci-dessus, les éléments du treemap sont triés naturellement (par ordre croissant). Cependant, nous pouvons également personnaliser la commande des clés.

Pour cela, nous devons créer notre propre classe de comparaison en fonction des clés d'un treemap qui sont triées. Par exemple,

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

Sortie

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

Dans l'exemple ci-dessus, nous avons créé un treemap passant CustomComparator classe comme argument.

Le CustomComparator la classe implémente le Comparator interface.

Nous remplaçons alors le compare() méthode pour trier les éléments dans l'ordre inverse.

Pour en savoir plus, visitez Java Comparator (documentation officielle de Java).

Interface Java NavigableMap Interface Java ConcurrentMap

Java

Java TreeMap

Arborescence Java

Création d'un TreeMap

Méthodes de TreeMap

Insérer des éléments dans TreeMap

Accéder aux éléments TreeMap

Supprimer les éléments TeeMap

Remplacer les éléments TreeMap

Méthodes de navigation

1. Première et dernière méthodes

2. Méthodes Plafond, Sol, Supérieur et Inférieur

3. Méthodes pollFirstEntry() et pollLastEntry()

4. Méthodes headMap(), tailMap() et subMap()

Autres méthodes de TreeMap

Comparateur TreeMap