Pause café #185. Un guide complet du framework de collection Java

Source : Medium Ce didacticiel vous aidera à mieux comprendre le fonctionnement des différentes classes et interfaces incluses dans Java Collection Framework. Java Collection est un framework qui fournit une architecture unifiée pour stocker et gérer un groupe d'objets. À la base, il s’agit d’un ensemble de classes et d’interfaces qui fournissent un moyen standard de représenter et de manipuler des collections d’objets dans le langage Java. Le framework aide également à implémenter des structures de données couramment utilisées telles que List, Set et Map. Le Java Collection Framework comprend plusieurs interfaces et classes. Voici une liste de quelques-uns d’entre eux :

Interfaces

Les interfaces de Java Collection Framework définissent le comportement général et les opérations qui peuvent être effectuées sur les collections. Cela inclut l'ajout ou la suppression d'éléments, la répétition d'éléments dans une collection, etc.

• Collection : L'interface racine dans une hiérarchie de collection, représentant un groupe d'objets appelés éléments.
• Liste : Une collection ordonnée d’éléments qui permet la duplication.
• Set : une collection d'éléments qui ne permettent pas la duplication.
• Map : une collection de paires clé-valeur, où chaque clé est unique.
• File d'attente : Une file d'attente est une structure de données utilisée pour stocker des éléments dans l'ordre premier entré, premier sorti (FIFO).

Cette liste ne comprend pas tout, mais uniquement les interfaces les plus utilisées du Java Collection Framework. Examinons maintenant de plus près chacun d'eux.

Collection

Une collection est un groupe d’objets appelés éléments. Il s'agit d'un objet qui peut contenir des références à d'autres objets. L'interface Collection est la racine de la hiérarchie des collections. Il s'agit de l'interface de base pour toutes les collections de Java Collection Framework. Il définit les méthodes de base qui doivent être implémentées dans toutes les collections, telles que add() , remove() et contain() . Voici un exemple d'utilisation de collections dans Java Collection Framework. Ici, l'interface Collection est utilisée pour ajouter et supprimer des éléments d'une collection :

import java.util.Collection;
import java.util.ArrayList;

public class CollectionExample {
    public static void main(String[] args) {
        // Создаем новую коллекцию
        Collection<String> stringCollection = new ArrayList<>();

        // Добавляем несколько элементов в коллекцию
        stringCollection.add("hello");
        stringCollection.add("world");
        stringCollection.add("foo");
        stringCollection.add("bar");

        // Печатаем число элементов в коллекции
        System.out.println("Number of elements: " + stringCollection.size());

        // Удаляем элемент из коллекции
        stringCollection.remove("foo");

        // Опять печатаем число элементов в коллекции
        System.out.println("Number of elements: " + stringCollection.size());
    }
}

Le résultat est : Comme vous pouvez le constater, l'interface Collection est un moyen simple et pratique d'effectuer des opérations courantes avec une collection d'objets. Il est souvent utilisé comme point de départ lorsque l'on travaille avec des collections en Java. Le Java Collection Framework comprend plusieurs interfaces qui définissent un comportement commun pour différents types de collections. Certains d'entre eux font partie du groupe d'interfaces java.util.Collection :

• java.util.Liste
• java.util.set
• java.util.Queue

java.util.Liste

Une liste est une collection ordonnée d'objets dont chaque élément occupe une position spécifique dans la liste. L'interface List étend l'interface Collection et ajoute plusieurs méthodes pour travailler avec des listes, telles que des méthodes pour accéder aux éléments en fonction de leur position dans la liste et des méthodes pour rechercher et trier les listes. Une Liste peut contenir des éléments en double , ces éléments sont accessibles par leur position dans la liste. Voici un exemple d'utilisation de l'interface List pour ajouter, supprimer et accéder à des éléments dans une liste :

import java.util.List;
import java.util.ArrayList;

public class ListExample {
    public static void main(String[] args) {
        // Создаем новый список
        List<String> stringList = new ArrayList<>();

        // Добавляем несколько элементов в список
        stringList.add("India");
        stringList.add("UAE");
        stringList.add("London");
        stringList.add("US");

        // Печатаем первый элемент в списке
        System.out.println("First element: " + stringList.get(0));

        // Удаляем второй элемент из списка
        stringList.remove(1);

        // Печатаем второй элемент в списке
        System.out.println("Second element: " + stringList.get(1));
    }
}

Conclusion: Comme indiqué ci-dessus, l'interface List offre un moyen pratique de travailler avec des collections ordonnées d'éléments. Il est généralement utilisé lorsque vous devez conserver l'ordre des éléments dans une collection ou lorsque vous devez accéder aux éléments par leur index dans une liste.

java.util.Set

Un ensemble dans Java Collection Framework est un ensemble non ordonné d'éléments uniques qui n'autorise pas les éléments en double . L'interface Set étend l'interface Collection et ajoute plusieurs méthodes, telles que des méthodes permettant de vérifier si un élément se trouve dans un ensemble et des méthodes permettant d'ajouter et de supprimer des éléments d'un ensemble. Voici un exemple d'utilisation de l'interface Set pour ajouter et supprimer des éléments d'un ensemble dans Java Collection Framework :

import java.util.Set;
import java.util.HashSet;

public class SetExample {
    public static void main(String[] args) {
        // Создаем новый set
        Set<String> stringSet = new HashSet<>();

        // Добавляем несколько элементов в set
        stringSet.add("Jan");
        stringSet.add("Feb");
        stringSet.add("March");
        stringSet.add("April");

        // Проверяем наличие в set element "March"
        if (stringSet.contains("March")) {
            System.out.println("The set contains the element 'March'");
        }

        // Удаляем элемент "April" из set
        stringSet.remove("April");

        // Опять проверяем наличие element "April" в set
        if (!stringSet.contains("April")) {
            System.out.println("The set no longer contains the element 'April'");
        }
    }
}

Conclusion:

java.util.Queue

Une file d'attente est une structure de données utilisée pour stocker des éléments dans l'ordre premier entré, premier sorti (FIFO). Cela signifie que le premier élément ajouté à la file d'attente sera le premier élément supprimé. Voici un exemple d'utilisation d'une file d'attente dans Java Collection Framework :

// Creation очереди
Queue<String> queue = new LinkedList<>();

// Добавление элементов в очередь
queue.add("apple");
queue.add("banana");
queue.add("orange");
// Печатаем очередь
System.out.println("Queue: " + queue);
// Удаляем элемент из очереди
String element = queue.remove();
System.out.println("Removed element: " + element);
// Печатаем обновленную очередь
System.out.println("Queue: " + queue);

Dans cet exemple, nous avons créé une file d'attente de chaînes et y avons ajouté trois éléments : « pomme », « banane » et « orange ». Nous imprimons ensuite la file d'attente pour voir son état actuel. Ensuite, nous supprimons l'élément de la file d'attente et l'imprimons sur la console. Enfin, nous imprimons la file d'attente mise à jour pour nous assurer que l'élément supprimé n'est plus dans la file d'attente.

Carte

L' interface java.util.Map de Java Collection Framework est utilisée pour mapper les clés aux valeurs. Il vous permet de stocker des éléments sous forme de paires clé-valeur et fournit des méthodes pour accéder, modifier et itérer sur les éléments d'une carte. Ci-dessous un exemple d'utilisation de l' interface Map :

// Создаем Map
 Map<String, Integer> map = new  HashMap <>();
// Добавляем элементы в Map
map.put("apple", 1);
map.put("banana", 2);
map.put("orange", 3);
// Печать Map
 System.out.println("Map: " + map);
// Получаем meaning для определенного ключа
int  value  = map.get( "banana" );
System.out.println("Value for 'banana': " + value);
// Удаляем элемент из Map
map.remove("orange");
// Печать обновленной карты
 System.out.println( "Map: " + map);

Dans cet exemple, nous créons une carte de chaînes et d'entiers en y ajoutant trois éléments : "pomme" correspond à 1, "banane" correspond à 2 et "orange" correspond à 3. Nous imprimons ensuite la carte pour voir son état actuel. signification. Après cela, nous obtenons la valeur de la clé « banane » et l'imprimons sur la console. Enfin, nous supprimons la paire clé-valeur pour « orange » de la carte et imprimons la carte mise à jour pour voir que l'élément supprimé n'est plus là.

Des classes

Une classe est une implémentation concrète d’une interface de collection. Il fournit des implémentations spécifiques de comportements et d'opérations courants définis par les interfaces du framework.

• ArrayList : Une implémentation de l' interface List avec un tableau redimensionnable.
• LinkedList : une liste doublement chaînée, une implémentation des interfaces List et Deque .
• HashSet : Une implémentation de Set qui utilise une table de hachage pour le stockage.
• TreeSet : Une implémentation de Set qui utilise une arborescence pour le stockage.
• HashMap : Une implémentation de Map qui utilise une table de hachage pour le stockage.

La liste ci-dessus est l’une des classes les plus couramment utilisées dans Java Collection Framework. Voyons maintenant l'explication détaillée de ces classes.

Liste des tableaux

La classe java.util.ArrayList dans les collections Java est utilisée pour stocker un tableau redimensionnable d'éléments dans une liste. Il s'agit d'une implémentation largement utilisée de l' interface java.util.List qui utilise un tableau pour stocker des éléments et fournit des méthodes efficaces pour accéder, modifier et parcourir les éléments d'une liste. La classe java.util.ArrayList fournit un accès aléatoire rapide à ses éléments, mais une insertion et une suppression lentes à des positions aléatoires. Vous trouverez ci-dessous un exemple d'utilisation de la classe ArrayList dans Java Collection Framework :

// Создаем array list
List<String> list = new ArrayList<>();
// Добавляем элементы в array list
list.add("qa");
list.add("devops");
list.add("dev");
// Печатаем array list
System.out.println("Array list: " + list);
// Доступ к элементу по определенному индексу
String element = list.get(1);
System.out.println("Element at index 1: " + element);
// Удаление element из the array list
list.remove(1);
// Print the updated array list
System.out.println("Array list: " + list);

Comme vous pouvez le voir, nous avons créé un tableau de chaînes et y avons ajouté trois éléments : « qa », « devops » et « dev ». Nous avons ensuite imprimé la liste des tableaux pour voir son état actuel. Après cela, nous accédons à l'élément à l'index 1 et l'imprimons sur la console. Enfin, nous supprimons l'élément à l'index 1 de la liste des tableaux et imprimons une liste de tableaux mise à jour pour nous assurer que l'élément supprimé n'est plus dans la liste.

Liste liée

La classe java.util.LinkedList de Java Collection Framework hérite de la classe AbstractList et implémente les interfaces List et Deque . Il fournit des méthodes efficaces pour ajouter, supprimer et accéder à des éléments au début et à la fin d'une liste. Cette classe est également une implémentation de l' interface List , qui utilise une liste à double lien pour stocker les éléments. Il permet une insertion et une suppression rapides à des positions arbitraires, mais un accès aléatoire lent à ses éléments. Voici un exemple d'utilisation de la classe LinkedList dans Java Collection Framework :

// Создаем linked list
List<String> list = new LinkedList<>();
// Добавляем элементы в linked list
list.add("selenium");
list.add("cypress");
list.add("playwright");
// Печатаем linked list
System.out.println("Linked list: " + list);
// Добавляем элемент в начало списка
list.add(0, "webdriver.io");
// Печатаем обновленный linked list
System.out.println("Linked list: " + list);
// Удаляем первый элемент в списке
list.remove(0);
// Еще раз печатаем обновленный linked list
System.out.println("Linked list: " + list);

Dans cet exemple, nous avons créé une liste chaînée de chaînes et y avons ajouté trois éléments : « sélénium », « cyprès » et « dramaturge ». Nous imprimons ensuite la liste chaînée pour voir son état actuel. Ensuite, nous ajoutons l'élément « webdriver.io » au début de la liste et imprimons la liste chaînée mise à jour. Enfin, nous supprimons le premier élément de la liste et imprimons à nouveau la liste chaînée mise à jour pour voir que l'élément supprimé n'est plus dans la liste.

Jeu de hachage

La classe java.util.HashSet de Java Collection Framework est utilisée pour stocker une collection d'éléments uniques dans un ensemble. Il fournit une implémentation basée sur une table de hachage de l'interface java.util.Set . Il permet également une insertion, une suppression et une recherche rapides, mais ne préserve pas l'ordre de ses éléments. Vous trouverez ci-dessous un exemple d'utilisation de la classe HashSet dans Java Collection Framework :

// Создаем hash set
Set<String> set = new HashSet<>();

// Добавляем элементы в hash set
set.add("rose");
set.add("lily");
set.add("lotus");
// Попытка добавить повторяющийся элемент
set.add("rose");
// Печатаем hash set
System.out.println("Hash set: " + set);
// Удаляем элемент из hash set
set.remove("lily");
// Печать обновленного hash set
System.out.println("Hash set: " + set);

Ici, nous avons créé un jeu de chaînes de hachage et y avons ajouté trois éléments : « rose », « lily » et « lotus ». Nous essayons ensuite d'ajouter à nouveau l'élément « rose », mais comme le jeu de hachage n'autorise pas les doublons, il ne sera pas ajouté. Après cela, nous imprimons le jeu de hachage pour voir son état actuel. Nous supprimons ensuite l'élément « lily » de l'ensemble et imprimons le hachage mis à jour de l'ensemble pour voir que l'élément supprimé n'est plus dans l'ensemble.

Ensemble d'arbres

La classe java.util.TreeSet de Java Collection Framework est utilisée pour stocker une collection d'éléments uniques dans un ensemble trié par ordre croissant. Il fournit une implémentation arborescente de l' interface java.util.Set pour stocker des éléments sans autoriser les éléments en double. La classe permet une insertion, une suppression et une recherche rapides, et maintient l'ordre de ses éléments en fonction de leur ordre naturel ou comparateur. Voici un exemple d'utilisation de la classe TreeSet dans Java Collection Framework :

// Создаем tree set
Set<String> set = new TreeSet<>();

// Добавляем элементы в tree set
set.add("apple");
set.add("banana");
set.add("orange");
// Попытка добавить повторяющийся элемент
set.add("apple");
// Печатаем tree set
System.out.println("Tree set: " + set);
// Удаляем элемент из tree set
set.remove("banana");
// Печатаем обновленный tree set
System.out.println("Tree set: " + set);

Dans cet exemple, nous créons un ensemble arborescent de chaînes et y ajoutons trois éléments : « pomme », « banane » et « orange ». Nous essayons ensuite d'ajouter à nouveau l'élément « pomme », mais comme l'arborescence n'autorise pas les doublons, il ne sera pas ajouté. Après cela, nous imprimons l’ensemble d’arbres pour voir son état actuel. Puisque l'ensemble de l'arbre est trié par ordre croissant, les éléments seront imprimés dans l'ordre : « pomme », « banane » et « orange ». Nous supprimons ensuite l'élément « banane » de l'ensemble et imprimons l'ensemble d'arborescences mis à jour pour voir que l'élément supprimé n'est plus dans l'ensemble.

Carte de hachage

La classe java.util.HashMap de Java Collection Framework est utilisée pour stocker le mappage des clés aux valeurs dans une carte. Il fournit une implémentation basée sur une table de hachage de l'interface java.util.Map et permet de stocker les éléments sous forme de paires clé-valeur. La classe permet une insertion, une suppression et une recherche rapides, mais ne préserve pas l'ordre de ses éléments. Voici un exemple d'utilisation de la classe HashMap dans Java Collection Framework :

// Создаем hash map
Map<String, Integer> map = new HashMap<>();

// Добавляем элементы в hash map
map.put("apple", 1);
map.put("banana", 2);
map.put("orange", 3);
// Печатаем hash map
System.out.println("Hash map: " + map);
// Получаем meaning для определенного ключа
int value = map.get("banana");
System.out.println("Value for 'banana': " + value);
// Удаляем элемент из hash map
map.remove("orange");
// Печатаем обновленный hash map
System.out.println("Hash map: " + map);

Dans cet exemple, nous créons une carte de hachage de chaînes entières et y ajoutons trois éléments : « pomme » correspond à 1, « banane » correspond à 2 et « orange » correspond à 3. Nous imprimons ensuite la carte de hachage pour la voir État actuel. Après cela, nous obtenons la valeur de la clé « banane » et l'imprimons sur la console. Enfin, nous supprimons la paire clé-valeur pour « orange » de la carte de hachage et imprimons la carte de hachage mise à jour pour voir que l'élément supprimé n'y figure plus.

Conclusion

Le Java Collection Framework est un ensemble de classes et d'interfaces qui fournissent un moyen standard de représenter et de manipuler des collections d'objets dans le langage de programmation Java. Cela permet aux développeurs/testeurs de travailler avec des collections d'objets de manière cohérente et efficace. Le framework leur fournit des méthodes pour stocker, accéder et gérer les éléments d'une collection, et leur permet de basculer facilement entre différentes implémentations de collection en fonction des exigences de l'application.