Le Java Set comme interface

Un ensemble est simplement une collection d'objets uniques. Unique signifie que deux objets ne peuvent pas avoir la ou les mêmes valeurs. Selon la mise en œuvre de l'ensemble, il peut ou non être commandé. L'ensemble Java, en tant que type de données abstrait (ADT), comporte quelques opérations clés (où T représente n'importe quel type de données, par exemple int, String ou n'importe quel objet de classe): Le Java Set comme interface - 1

boolean add(T item): renvoie vrai si l'élément est ajouté avec succès à l'ensemble, et faux si l'élément était déjà dans l'ensemble.
boolean remove(T item): renvoie true si l'élément a été supprimé avec succès de l'ensemble et false sinon (si l'élément n'était pas dans l'ensemble).
boolean contains(T item): renvoie vrai si l'élément est dans l'ensemble et faux sinon.
boolean isEmpty(): renvoie true si l'ensemble est vide et false sinon.

Les ensembles en Java ont des signatures de fonction assez explicites (comme il se doit). Si vous ajoutez deux éléments identiques à un ensemble, seul le premier élément ajouté sera dans l'ensemble. Toutes les tentatives ultérieures d'ajout du même élément seraient ignorées à moins que l'élément ne soit d'abord supprimé. L'une des opérations d'ensemble les plus couramment utilisées consiste à vérifier si un élément se trouve dans un ensemble donné. La contains()fonction donne un excellent temps d'exécution pour cela : O(1) ou O(log n) complexité temporelle selon si l'implémentation utilisée est a HashSetou aTreeSet, respectivement. Alors, à quoi peut servir un ensemble? Eh bien, si vous avez besoin de suivre de nombreux objets distincts - tels que des identifiants, des noms ou d'autres identifiants uniques - et de vérifier fréquemment si un élément existe dans une telle collection, alors un ensemble est probablement un bon choix. Voici un exemple de cas d'utilisation d'un ensemble : imaginez que vous disposez d'une liste d' Studentobjets représentant tous les élèves d'une classe donnée. Chacun Studentpeut avoir un nom (chaîne) et une note (int) uniques pour cette classe. Si vous vouliez référencer fréquemment une liste de tous les étudiants A (note> = 90), il serait fastidieux de parcourir cette liste et de vérifier la note de chaque étudiant à chaque fois. Au lieu de cela, vous pouvez utiliser une HashSetchaîne de caractères qui garde une trace de tous les élèves A de la classe, en tant que telle :

Chaque fois que les notes des étudiants sont mises à jour, vous pouvez simplement vérifier si la nouvelle note de l'étudiant est supérieure ou égale à 90 ou non.
- Si oui, ajoutez-les à l'ensemble des élèves A en utilisantadd()
  - S'ils étaient déjà un étudiant A, cette opération est simplement ignorée.
- Si ce n'est pas le cas, supprimez-les de l'ensemble des étudiants A en utilisantremove()
  - S'ils n'étaient pas un étudiant A à ce stade, cette opération est simplement ignorée.

Avec un tel système, vous auriez toujours un ensemble à jour de tous les élèves "A" de votre classe. Si vous vouliez vérifier si Johnny Appleseed se débrouillait bien dans votre classe, vous pourriez facilement le faire en appelant contains(“Johnny Appleseed”)sur le plateau. Bien sûr, ce n'est qu'un exemple de cas d'utilisation d'un ensemble, et ce problème spécifique de suivi des étudiants A pourrait être résolu d'autres manières.

Implémentations: HashSet en Java et Java TreeSet Exemples

Le HashSetin Java et le TreeSetin Java viennent tous les deux dans le java.utils package. Vous pouvez les importer tels quels :

// imports everything from Java's util package, including HashSet and TreeSet
import java.util.*;

import java.util.HashSet; // imports only the Java HashSet
import java.util.TreeSet; // imports only the Java TreeSet

La principale différence entre Java HashSetet Java TreeSetest que le TreeSetest trié, alors que le HashSetne l'est pas. C'est pourquoi le TreeSeta une complexité temporelle O (log n) pour les opérations clés, alors qu'il HashSeta une complexité temporelle O (1) ou constante; le TreeSetdoit maintenir l'ordre à tout moment. En plus des opérations d'ensemble de clés mentionnées précédemment, les HashSetet TreeSeten Java ont quelques autres fonctions utiles :

void clear(): efface l'ensemble de tous les objets.
int size(): renvoie le nombre d'objets dans l'ensemble.
Object clone(): renvoie une copie superficielle de l'ensemble.
Iterator iterator(): renvoie un itérateur à l'ensemble, en commençant par le premier objet.

Vous pouvez imaginer trouver des utilisations pour ces fonctions dans l'exemple de la « liste d'étudiants A » : vous pourriez appeler size()si vous vouliez voir combien d'étudiants « A » vous aviez, ou clear()si vous vouliez effacer la liste à la fin du semestre. Vous pouvez utiliser clone()pour créer et conserver un clone de la liste des étudiants A à un moment précis, comme lors des rapports de mi-session (de cette façon, le clone ne reste pas à jour avec l'original).

Exemple d'ensemble de hachage Java

Voici un court exemple d'un HashSetde Strings utilisé en Java :

import java.util.HashSet;
class HashSetDemo {
    public static void main(String[] args)
    {
	  // create a HashSet of Strings
        HashSet<String> hs = new HashSet<String>();

        // Add elements using the add() method
        hs.add("Collin");
	  hs.add("Bob");
 	  hs.add("Abigail");

        // Duplicates will ignored; this statement is useless
        hs.add("Collin");


        System.out.println(hs);
	  System.out.println("Bob is in the set (T/F): " + hs.contains("Bob"));
  System.out.println("Max is in the set (T/F): " + hs.contains("Max"));


    }
}

Sortir: --------

[Collin, Bob, Abigail]
Bob is in the set (T/F): true
Max is in the set (T/F): false

Exemple Java TreeSet

L'exemple d'ensemble Java pourrait vous aider à comprendre la théorie. Voici le court exemple d'un TreeSetde Strings utilisé en Java:

import java.util.TreeSet;
class TreeSetDemo {
    public static void main(String[] args)
    {
	  // create a TreeSet of Strings
        TreeSet<String> ts = new TreeSet<String>();

        // Add elements using the add() method.
        ts.add("Collin");
	  ts.add("Bob");
 	  ts.add("Abigail");

        // Duplicates will ignored; this statement is useless
        ts.add("Collin");

        // printing the set prints the names in alphabetical order!
        System.out.println(ts);

	  System.out.println("Bob is in the set (T/F): " + ts.contains("Bob"));
  System.out.println("Max is in the set (T/F): " + ts.contains("Max"));
  System.out.println("Size of the set: " + ts.size());
 	  ts.clear();
	  System.out.println("Size of the set after clear(): " + ts.size());


    }
}

Sortir: -------

[Abigail, Bob, Collin]
Bob is in the set (T/F): true
Max is in the set (T/F): false
Size of the set: 3
Size of the set after clear(): 0

C'est tout! J'espère que cela a aidé 😊