Back

L’interface Set en Java

L’interface Set en Java

  1. Objectifs

    • Comprendre ce qu’est une interface en Java.
    • Expliquer le rôle et l’importance de l’interface Set dans la Collection Framework.

  2. Introduction :

    • L’API Collections propose un ensemble d’interfaces et de classes dont le but est de stocker de multiples objets. Elle propose quatre grandes familles de collections, chacune définie par une interface de base :
    • List : collection d’éléments ordonnés qui accepte les doublons
    • Set : collection d’éléments non ordonnés par défaut qui n’accepte pas les doublons
    • Map : collection sous la forme d’une association de paires clé/valeur
    • Queue et Deque : collections qui stockent des éléments dans un certain ordre avant qu’ils ne soient extraits pour traitement

  3. L’interface Set

    • L’interface Set en Java est utilisée pour représenter une collection qui ne contient pas d’éléments en double. Les exemples ci-dessus montrent comment utiliser certaines des méthodes les plus courantes pour manipuler des ensembles. Les implémentations courantes de l’interface Set incluent HashSet, LinkedHashSet, et TreeSet.

  4. Méthodes de l’interface Set

    • Voici quelques-unes des méthodes les plus couramment utilisées de l’interface Set:
      1. add(E element) : ajoute un élément à l’ensemble.

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

public class SetExample {
    public static void main(String[] args) {
        Set<String> set = new HashSet<>();
        
        // Ajout d'éléments à l'ensemble
        set.add("Apple");
        set.add("Banana");
        set.add("Cherry");
        
        // Affichage de l'ensemble
        System.out.println("Set: " + set);
    }
}

      2. remove(Object o) : supprime l’élément donné de l’ensemble.

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

public class SetExample {
    public static void main(String[] args) {
        Set<String> set = new HashSet<>();
        set.add("Apple");
        set.add("Banana");
        set.add("Cherry");
        
        // Suppression d'un élément de l'ensemble
        set.remove("Banana");
        
        // Affichage de l'ensemble après suppression
        System.out.println("Set après suppression: " + set);
    }
}

      3. contains(Object o) : vérifie si l’élément donné est présent dans l’ensemble.

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

public class SetExample {
    public static void main(String[] args) {
        Set<String> set = new HashSet<>();
        set.add("Apple");
        set.add("Banana");
        set.add("Cherry");
        
        // Vérification de la présence d'un élément
        boolean containsApple = set.contains("Apple");
        boolean containsMango = set.contains("Mango");
        
        System.out.println("L'ensemble contient 'Apple': " + containsApple);
        System.out.println("L'ensemble contient 'Mango': " + containsMango);
    }
}

      4. size(): renvoie le nombre d’éléments dans l’ensemble.

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

public class SetExample {
    public static void main(String[] args) {
        Set<String> set = new HashSet<>();
        set.add("Apple");
        set.add("Banana");
        set.add("Cherry");
        
        // Taille de l'ensemble
        int size = set.size();
        
        System.out.println("Taille de l'ensemble: " + size);
    }
}

      5. iterator(): renvoie un itérateur sur les éléments de l’ensemble.

          6. import java.util.HashSet;
import java.util.Iterator;
import java.util.Set;

public class SetExample {
    public static void main(String[] args) {
        Set<String> set = new HashSet<>();
        set.add("Apple");
        set.add("Banana");
        set.add("Cherry");
        
        // Itération sur les éléments de l'ensemble
        Iterator<String> iterator = set.iterator();
        System.out.println("Éléments de l'ensemble:");
        while (iterator.hasNext()) {
            System.out.println(iterator.next());
        }
    }
}




  5. Les implémentations de Set

    • Set est une interface, donc elle ne peut pas être instanciée directement. Il faut utiliser une implémentation concrète comme HashSet ou TreeSet pour créer un ensemble et manipuler ses éléments.
    • Les implémentations de l’interface Set en Java sont des classes concrètes qui fournissent différentes manières de stocker et de gérer des ensembles de données uniques. Voici un aperçu des implémentations les plus courantes et leurs caractéristiques :
      1. HashSet
        • Description : HashSet est basé sur une table de hachage. Il ne garantit pas l’ordre des éléments.
        • Caractéristiques :
          • Non ordonné : Les éléments ne sont pas stockés dans un ordre particulier.
          • Rapide pour les opérations de base (add, remove, contains) avec une complexité moyenne O(1).
        • Exemple :

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

public class HashSetExample {
    public static void main(String[] args) {
        Set hashSet = new HashSet<>();
        hashSet.add("Apple");
        hashSet.add("Banana");
        hashSet.add("Cherry");

        System.out.println("HashSet: " + hashSet);
    }
}

      2. LinkedHashSet
        • Description : LinkedHashSet est une sous-classe de HashSet qui maintient une liste doublement chaînée de ses éléments. Il conserve l’ordre d’insertion.
        • Caractéristiques :
          • Ordonné : Maintient l’ordre d’insertion des éléments.
          • Un peu plus lent que HashSet en raison de la gestion de la liste chaînée, mais toujours avec une complexité moyenne O(1) pour les opérations de base.
        • Exemple :

            • import java.util.LinkedHashSet;
import java.util.Set;

public class LinkedHashSetExample {
    public static void main(String[] args) {
        Set linkedHashSet = new LinkedHashSet<>();
        linkedHashSet.add("Apple");
        linkedHashSet.add("Banana");
        linkedHashSet.add("Cherry");

        System.out.println("LinkedHashSet: " + linkedHashSet);
    }
}

      3. TreeSet
        • Description : TreeSet est basé sur une structure d’arbre de recherche binaire (Red-Black Tree). Il garantit que les éléments sont stockés dans un ordre trié.
        • Caractéristiques :
          • Trié : Maintient les éléments dans un ordre naturel (ou un ordre personnalisé défini par un Comparator).
          • Plus lent que HashSet et LinkedHashSet pour les opérations de base avec une complexité O(log n).
        • Exemple :

            • import java.util.Set;
import java.util.TreeSet;

public class TreeSetExample {
    public static void main(String[] args) {
        Set treeSet = new TreeSet<>();
        treeSet.add("Apple");
        treeSet.add("Banana");
        treeSet.add("Cherry");

        System.out.println("TreeSet: " + treeSet);
    }
}

      4. Comparaison des Implémentations de Set
          5. Implémentation Ordre des Éléments Complexité Moyenne des Opérations de Base Caractéristiques Spéciales
          HashSet Non ordonné O(1) Rapide, mais sans ordre particulier
          LinkedHashSet Ordre d’insertion O(1) Maintient l’ordre d’insertion des éléments
          TreeSet Ordre naturel ou défini O(log n) Trie les éléments, plus lent
      5. Exercice Pratique: Comparaison des Implémentations de Set
        • Comparer le comportement des différentes implémentations de Set (HashSet, LinkedHashSet, TreeSet) en ajoutant, supprimant et recherchant des éléments.
          • Créez une application Java qui utilise les trois implémentations de Set.
          • Ajoutez les mêmes éléments dans chaque ensemble.
          • Supprimez certains éléments.
          • Vérifiez la présence de certains éléments.
          • Affichez les ensembles pour observer l’ordre des éléments.
          Code 

            import java.util.HashSet;
import java.util.LinkedHashSet;
import java.util.Set;
import java.util.TreeSet;

public class SetComparisonExample {
    public static void main(String[] args) {
        Set hashSet = new HashSet<>();
        Set linkedHashSet = new LinkedHashSet<>();
        Set treeSet = new TreeSet<>();

        // Ajout des éléments
        String[] elements = {"Banana", "Apple", "Cherry", "Date"};

        for (String element : elements) {
            hashSet.add(element);
            linkedHashSet.add(element);
            treeSet.add(element);
        }

        // Affichage des ensembles
        System.out.println("HashSet: " + hashSet);
        System.out.println("LinkedHashSet: " + linkedHashSet);
        System.out.println("TreeSet: " + treeSet);

        // Suppression d'un élément
        hashSet.remove("Apple");
        linkedHashSet.remove("Apple");
        treeSet.remove("Apple");

        // Vérification de la présence d'un élément
        System.out.println("HashSet contient 'Cherry': " + hashSet.contains("Cherry"));
        System.out.println("LinkedHashSet contient 'Cherry': " + linkedHashSet.contains("Cherry"));
        System.out.println("TreeSet contient 'Cherry': " + treeSet.contains("Cherry"));

        // Affichage des ensembles après suppression
        System.out.println("HashSet après suppression: " + hashSet);
        System.out.println("LinkedHashSet après suppression: " + linkedHashSet);
        System.out.println("TreeSet après suppression: " + treeSet);
    }
}

      6. En exécutant ce code, vous observerez comment chaque implémentation de Set gère l’ordre des éléments et la suppression des éléments. Cela vous aidera à choisir l’implémentation la plus appropriée en fonction de vos besoins spécifiques.

  6. Applications

    1. Exercice 1 : Gestion d’une Liste de Noms Uniques
      • Créer un programme Java qui permet de gérer une liste de noms uniques en utilisant un Set. Le programme doit permettre d’ajouter des noms, de vérifier si un nom est déjà présent, et d’afficher tous les noms.
        • Déclarez et initialisez un Set de type String pour stocker les noms.
        • Demandez à l’utilisateur de saisir un nombre de noms à ajouter.
        • Pour chaque nom, vérifiez s’il est déjà présent dans le Set.
          • Si le nom n’est pas présent, ajoutez-le au Set et affichez un message confirmant l’ajout.
          • Si le nom est déjà présent, affichez un message indiquant que le nom existe déjà.
          • Affichez tous les noms présents dans le Set.
        • Demandez à l’utilisateur de saisir un nom pour vérifier s’il est présent dans le Set.
        • Si le nom est trouvé, affichez un message confirmant sa présence.
        • Sinon, indiquez que le nom n’est pas présent.
        Code 

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

public class GestionNomsSet {
    public static void main(String[] args) {
        // Initialisation du Set pour stocker les noms uniques
        Set nomsSet = new HashSet<>();
        Scanner scanner = new Scanner(System.in);

        // Demander à l'utilisateur de saisir un nombre de noms à ajouter
        System.out.print("Entrez le nombre de noms à ajouter : ");
        int nombreNoms = scanner.nextInt();
        scanner.nextLine(); // Consomme la ligne vide

        // Ajouter des noms au Set
        for (int i = 0; i < nombreNoms; i++) {
            System.out.print("Entrez un nom : ");
            String nom = scanner.nextLine();

            // Vérifier si le nom est déjà présent dans le Set
            if (nomsSet.contains(nom)) {
                System.out.println("Le nom '" + nom + "' existe déjà.");
            } else {
                nomsSet.add(nom);
                System.out.println("Le nom '" + nom + "' a été ajouté.");
            }
        }

        // Afficher tous les noms dans le Set
        System.out.println("Les noms dans le Set sont : " + nomsSet);

        // Vérifier la présence d'un nom dans le Set
        System.out.print("Entrez un nom pour vérifier sa présence : ");
        String nomRecherche = scanner.nextLine();

        if (nomsSet.contains(nomRecherche)) {
            System.out.println("Le nom '" + nomRecherche + "' est présent dans le Set.");
        } else {
            System.out.println("Le nom '" + nomRecherche + "' n'est pas présent dans le Set.");
        }

        scanner.close();
    }
}

    2. Exercice 2 : Ajout d'Éléments à un Set et Affichage dans une ListView
      • Créer une interface JavaFX qui permet à l'utilisateur d'ajouter des éléments à un Set et d'afficher ces éléments dans une ListView.
        • Créez une application JavaFX de base.
        • Ajoutez un champ de texte et un bouton pour ajouter des éléments à un Set.
        • Utilisez un Set pour stocker les éléments ajoutés.
        • Affichez les éléments du Set dans une ListView.
        Code 

          package application;


import javafx.application.Application;
import javafx.scene.Scene;
import javafx.scene.control.*;
import javafx.scene.layout.VBox;
import javafx.stage.Stage;
import java.util.HashSet;
import java.util.Set;

public class InterfaceSet extends Application {
    private Set<String> itemsSet = new HashSet<>();
    private ListView<String> listView = new ListView<>();

    public static void main(String[] args) {
        launch(args);
    }

    @Override
    public void start(Stage primaryStage) {
        TextField inputField = new TextField();
        Button addButton = new Button("Add Item");

        addButton.setOnAction(e -> {
            String item = inputField.getText();
            if (itemsSet.add(item)) {
                listView.getItems().add(item);
                inputField.clear();
            } else {
                Alert alert = new Alert(Alert.AlertType.WARNING, "Item already exists in the set!");
                alert.showAndWait();
            }
        });

        VBox vbox = new VBox(10, inputField, addButton, listView);
        Scene scene = new Scene(vbox, 300, 400);

        primaryStage.setTitle("Set Example");
        primaryStage.setScene(scene);
        primaryStage.show();
    }
}

    3. Exercice 3 : Suppression d'Éléments d'un Set via une Interface JavaFX
      • Ajouter la fonctionnalité pour supprimer des éléments d'un Set via une interface JavaFX.
        • Étendre l'application précédente.
        • Ajouter un bouton pour supprimer l'élément sélectionné dans la ListView.
        • Mettre à jour le Set et la ListView en conséquence
        Code 

          package application;

import javafx.application.Application;
import javafx.scene.Scene;
import javafx.scene.control.*;
import javafx.scene.layout.VBox;
import javafx.stage.Stage;
import java.util.HashSet;
import java.util.Set;

public class InterfaceSet extends Application {
    private Set<String> itemsSet = new HashSet<>();
    private ListView<String> listView = new ListView<>();

    public static void main(String[] args) {
        launch(args);
    }

    @Override
    public void start(Stage primaryStage) {
        TextField inputField = new TextField();
        Button addButton = new Button("Add Item");
        Button removeButton = new Button("Remove Selected Item");

        addButton.setOnAction(e -> {
            String item = inputField.getText();
            if (itemsSet.add(item)) {
                listView.getItems().add(item);
                inputField.clear();
            } else {
                Alert alert = new Alert(Alert.AlertType.WARNING, "Item already exists in the set!");
                alert.showAndWait();
            }
        });

        removeButton.setOnAction(e -> {
            String selectedItem = listView.getSelectionModel().getSelectedItem();
            if (selectedItem != null && itemsSet.remove(selectedItem)) {
                listView.getItems().remove(selectedItem);
            } else {
                Alert alert = new Alert(Alert.AlertType.WARNING, "No item selected or item not in set!");
                alert.showAndWait();
            }
        });

        VBox vbox = new VBox(10, inputField, addButton, removeButton, listView);
        Scene scene = new Scene(vbox, 300, 400);

        primaryStage.setTitle("Set Example");
        primaryStage.setScene(scene);
        primaryStage.show();
    }
}

    4. Exercice 4 : Vérification de la Présence d'un Élément dans un Set
      • Ajouter une fonctionnalité pour vérifier si un élément existe dans le Set via l'interface JavaFX.
        • Étendre l'application précédente.
        • Ajouter un champ de texte et un bouton pour vérifier la présence d'un élément dans le Set.
        • Afficher un message indiquant si l'élément existe ou non.
        Code 

          package application;

import javafx.application.Application;
import javafx.scene.Scene;
import javafx.scene.control.*;
import javafx.scene.layout.VBox;
import javafx.stage.Stage;
import java.util.HashSet;
import java.util.Set;

public class InterfaceSet extends Application {
    private Set<String> itemsSet = new HashSet<>();
    private ListView<String> listView = new ListView<>();

    public static void main(String[] args) {
        launch(args);
    }

    @Override
    public void start(Stage primaryStage) {
        TextField inputField = new TextField();
        Button addButton = new Button("Add Item");
        Button removeButton = new Button("Remove Selected Item");
        TextField checkField = new TextField();
        Button checkButton = new Button("Check Item");

        addButton.setOnAction(e -> {
            String item = inputField.getText();
            if (itemsSet.add(item)) {
                listView.getItems().add(item);
                inputField.clear();
            } else {
                Alert alert = new Alert(Alert.AlertType.WARNING, "Item already exists in the set!");
                alert.showAndWait();
            }
        });

        removeButton.setOnAction(e -> {
            String selectedItem = listView.getSelectionModel().getSelectedItem();
            if (selectedItem != null && itemsSet.remove(selectedItem)) {
                listView.getItems().remove(selectedItem);
            } else {
                Alert alert = new Alert(Alert.AlertType.WARNING, "No item selected or item not in set!");
                alert.showAndWait();
            }
        });

        checkButton.setOnAction(e -> {
            String item = checkField.getText();
            if (itemsSet.contains(item)) {
                Alert alert = new Alert(Alert.AlertType.INFORMATION, "Item exists in the set!");
                alert.showAndWait();
            } else {
                Alert alert = new Alert(Alert.AlertType.INFORMATION, "Item does not exist in the set!");
                alert.showAndWait();
            }
        });

        VBox vbox = new VBox(10, inputField, addButton, removeButton, checkField, checkButton, listView);
        Scene scene = new Scene(vbox, 300, 450);

        primaryStage.setTitle("Set Example");
        primaryStage.setScene(scene);
        primaryStage.show();
    }
}

author avatar
Riadh HAJJI

Riadh HAJJI

You may also like

Installer Spring Tool Suite pour Eclipse
9 juin, 2024

La Classe LocalTime en Java Installer Spring Tool Suite pour Eclipse Objectifs Introduction Spring Tool Suite (STS) est une distribution Eclipse spécialement conçue pour le développement d’applications Spring. Il fournit des outils intégrés pour simplifier la création, la gestion et …

Spring Java
9 juin, 2024

La Classe LocalTime en Java Spring Java Objectifs Spring Java : qu’est-ce que c’est ? Spring Framework est un framework complet et modulaire pour le développement d’applications Java. Il fournit une vaste gamme de fonctionnalités pour le développement d’applications Java …

Exercices manipulation des dates en Java Série 01
8 juin, 2024

La Classe LocalDate en Java La Classe LocalTime en Java La Classe LocalDateTime en Java Récupérer la Valeur d’une Unité Temporelle en Java Fuseaux horaires et formatage en Java Exercices manipulation des dates en Java Série 01   Exercices manipulation …