LabEx
EntrerRejoindre

Comment vérifier si un ensemble contient tous les éléments d'un autre ensemble en Java

JavaBeginner
Pratiquer maintenant

Introduction

Dans ce laboratoire (lab), vous apprendrez à vérifier si un ensemble contient tous les éléments d'un autre ensemble en Java. Nous allons explorer la méthode containsAll(), un moyen pratique pour effectuer cette vérification de sous-ensemble.

À travers des exemples pratiques, vous apprendrez à utiliser containsAll() avec différents types d'ensembles et à gérer les cas limites tels que les ensembles vides et les ensembles nuls (null sets).

Utiliser containsAll() pour vérifier un sous-ensemble

Dans cette étape, nous allons explorer comment vérifier si un ensemble est un sous-ensemble d'un autre en utilisant la méthode containsAll() en Java. Il s'agit d'une opération courante lorsqu'on travaille avec des collections, et containsAll() offre un moyen pratique d'effectuer cette vérification.

Tout d'abord, créons un nouveau fichier Java nommé SubsetCheck.java dans votre répertoire ~/project. Vous pouvez le faire en cliquant avec le bouton droit dans l'explorateur de fichiers à gauche et en sélectionnant "Nouveau fichier", puis en tapant SubsetCheck.java.

Maintenant, ouvrez le fichier SubsetCheck.java dans l'éditeur et ajoutez le code suivant :

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

public class SubsetCheck {

    public static void main(String[] args) {
        // Create the main set
        Set<Integer> mainSet = new HashSet<>();
        mainSet.add(1);
        mainSet.add(2);
        mainSet.add(3);
        mainSet.add(4);
        mainSet.add(5);

        // Create a potential subset
        Set<Integer> subset = new HashSet<>();
        subset.add(2);
        subset.add(4);

        // Check if 'subset' is a subset of 'mainSet'
        boolean isSubset = mainSet.containsAll(subset);

        // Print the result
        System.out.println("Main Set: " + mainSet);
        System.out.println("Subset: " + subset);
        System.out.println("Is 'subset' a subset of 'mainSet'? " + isSubset);
    }
}

Décortiquons le code :

  • import java.util.HashSet; et import java.util.Set; : Ces lignes importent les classes nécessaires pour travailler avec des ensembles.
  • Set<Integer> mainSet = new HashSet<>(); : Cela crée un HashSet nommé mainSet qui stockera des valeurs entières.
  • mainSet.add(...) : Ces lignes ajoutent des éléments au mainSet.
  • Set<Integer> subset = new HashSet<>(); : Cela crée un autre HashSet nommé subset.
  • subset.add(...) : Ces lignes ajoutent des éléments au subset.
  • boolean isSubset = mainSet.containsAll(subset); : C'est le cœur de cette étape. La méthode containsAll() du mainSet est appelée avec subset comme argument. Elle retourne true si mainSet contient tous les éléments de subset, et false sinon.
  • System.out.println(...) : Ces lignes affichent les ensembles et le résultat de la vérification du sous-ensemble dans la console.

Enregistrez le fichier SubsetCheck.java (Ctrl+S ou Cmd+S).

Maintenant, ouvrez le terminal en bas de l'IDE Web. Assurez-vous que vous êtes dans le répertoire ~/project. Sinon, utilisez la commande cd ~/project.

Compilez le code Java en utilisant la commande javac :

javac SubsetCheck.java

S'il n'y a pas d'erreurs, vous ne devriez voir aucun résultat. Cela signifie que la compilation a réussi et qu'un fichier SubsetCheck.class a été créé.

Enfin, exécutez le programme Java compilé en utilisant la commande java :

java SubsetCheck

Vous devriez voir un résultat similaire à ceci :

Main Set: [1, 2, 3, 4, 5]
Subset: [2, 4]
Is 'subset' a subset of 'mainSet'? true

Ce résultat confirme que la méthode containsAll() a correctement identifié que subset est effectivement un sous-ensemble de mainSet.

Tester avec différents types d'ensembles

Dans l'étape précédente, nous avons utilisé HashSet pour démontrer la méthode containsAll(). Java propose différentes implémentations de l'interface Set, telles que HashSet, LinkedHashSet et TreeSet. Bien qu'elles aient des structures internes et des propriétés différentes (comme l'ordre), la méthode containsAll() fonctionne de manière cohérente pour toutes.

Dans cette étape, nous allons modifier notre fichier SubsetCheck.java pour tester containsAll() avec différents types d'ensembles.

Ouvrez le fichier SubsetCheck.java dans l'éditeur de l'IDE Web.

Remplacez le code existant par le suivant :

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

public class SubsetCheck {

    public static void main(String[] args) {
        // Create a main set using HashSet
        Set<Integer> hashMainSet = new HashSet<>();
        hashMainSet.add(10);
        hashMainSet.add(20);
        hashMainSet.add(30);
        hashMainSet.add(40);

        // Create a subset using LinkedHashSet
        Set<Integer> linkedSubset = new LinkedHashSet<>();
        linkedSubset.add(30);
        linkedSubset.add(10);

        // Create another subset using TreeSet
        Set<Integer> treeSubset = new TreeSet<>();
        treeSubset.add(40);
        treeSubset.add(20);

        // Check subset relationship using containsAll()
        boolean isLinkedSubset = hashMainSet.containsAll(linkedSubset);
        boolean isTreeSubset = hashMainSet.containsAll(treeSubset);

        // Create a subset that is NOT a subset
        Set<Integer> notSubset = new HashSet<>();
        notSubset.add(20);
        notSubset.add(50); // 50 is not in hashMainSet

        boolean isNotSubset = hashMainSet.containsAll(notSubset);


        // Print the results
        System.out.println("Hash Main Set: " + hashMainSet);
        System.out.println("Linked Subset: " + linkedSubset);
        System.out.println("Is Linked Subset a subset of Hash Main Set? " + isLinkedSubset);
        System.out.println("Tree Subset: " + treeSubset);
        System.out.println("Is Tree Subset a subset of Hash Main Set? " + isTreeSubset);
        System.out.println("Not Subset: " + notSubset);
        System.out.println("Is Not Subset a subset of Hash Main Set? " + isNotSubset);
    }
}

Dans ce code mis à jour :

  • Nous avons importé LinkedHashSet et TreeSet.
  • Nous avons créé un hashMainSet en utilisant HashSet.
  • Nous avons créé linkedSubset en utilisant LinkedHashSet et treeSubset en utilisant TreeSet. Notez que l'ordre des éléments ajoutés à linkedSubset est différent de leur ordre dans hashMainSet, mais containsAll() fonctionne toujours correctement. TreeSet trie automatiquement les éléments.
  • Nous avons également ajouté un notSubset pour démontrer un cas où containsAll() retourne false.

Enregistrez le fichier SubsetCheck.java.

Maintenant, compilez le code modifié dans le terminal :

javac SubsetCheck.java

Si la compilation réussit, exécutez le programme :

java SubsetCheck

Vous devriez voir un résultat similaire à ceci :

Hash Main Set: [40, 10, 20, 30]
Linked Subset: [30, 10]
Is Linked Subset a subset of Hash Main Set? true
Tree Subset: [20, 40]
Is Tree Subset a subset of Hash Main Set? true
Not Subset: [50, 20]
Is Not Subset a subset of Hash Main Set? false

Cela démontre que containsAll() fonctionne correctement, quelle que soit l'implémentation spécifique de Set utilisée pour le sous-ensemble, tant que l'ensemble principal contient tous les éléments du sous-ensemble.

Gérer les ensembles vides et nuls

Dans cette étape finale, nous allons examiner le comportement de la méthode containsAll() lorsqu'elle est utilisée avec des ensembles vides et des valeurs nulles. Comprendre ces cas limites est essentiel pour écrire un code robuste.

Ouvrez le fichier SubsetCheck.java dans l'éditeur de l'IDE Web.

Remplacez le code existant par le suivant :

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

public class SubsetCheck {

    public static void main(String[] args) {
        Set<Integer> mainSet = new HashSet<>();
        mainSet.add(1);
        mainSet.add(2);
        mainSet.add(3);

        // Case 1: Checking with an empty set
        Set<Integer> emptySet = new HashSet<>();
        boolean isEmptySubset = mainSet.containsAll(emptySet);
        System.out.println("Main Set: " + mainSet);
        System.out.println("Empty Set: " + emptySet);
        System.out.println("Is Empty Set a subset of Main Set? " + isEmptySubset);

        System.out.println("---"); // Separator

        // Case 2: Checking if an empty set contains all elements of a non-empty set
        Set<Integer> anotherEmptySet = new HashSet<>();
        Set<Integer> nonEmptySet = new HashSet<>();
        nonEmptySet.add(1);
        boolean isEmptyContainingNonEmpty = anotherEmptySet.containsAll(nonEmptySet);
        System.out.println("Another Empty Set: " + anotherEmptySet);
        System.out.println("Non-Empty Set: " + nonEmptySet);
        System.out.println("Is Another Empty Set a subset of Non-Empty Set? " + isEmptyContainingNonEmpty);

        System.out.println("---"); // Separator

        // Case 3: Checking with a null set
        Set<Integer> nullSet = null;
        try {
            boolean isNullSubset = mainSet.containsAll(nullSet);
            System.out.println("Is Null Set a subset of Main Set? " + isNullSubset);
        } catch (NullPointerException e) {
            System.out.println("Checking with a null set resulted in a: " + e.getClass().getName());
        }
    }
}

Examinons les nouvelles parties :

  • Cas 1 : Vérification avec un ensemble vide : Nous créons un emptySet et vérifions si mainSet contient tous ses éléments. Un ensemble vide est considéré comme un sous-ensemble de tout ensemble, y compris un autre ensemble vide.
  • Cas 2 : Vérification si un ensemble vide contient tous les éléments d'un ensemble non vide : Nous vérifions si anotherEmptySet contient tous les éléments de nonEmptySet. Cela devrait être faux car l'ensemble vide ne contient pas l'élément 1.
  • Cas 3 : Vérification avec un ensemble nul : Nous affectons null à une variable de type Set. Tenter d'appeler containsAll() avec un argument null entraînera une NullPointerException. Nous utilisons un bloc try-catch pour gérer cette exception prévisible de manière élégante et afficher un message.

Enregistrez le fichier SubsetCheck.java.

Compilez le code dans le terminal :

javac SubsetCheck.java

Exécutez le programme compilé :

java SubsetCheck

Vous devriez voir un résultat similaire à ceci :

Main Set: [1, 2, 3]
Empty Set: []
Is Empty Set a subset of Main Set? true
---
Another Empty Set: []
Non-Empty Set: [1]
Is Another Empty Set a subset of Non-Empty Set? false
---
Checking with a null set resulted in a: java.lang.NullPointerException

Ce résultat confirme le comportement de containsAll() avec des ensembles vides et nuls :

  • Un ensemble vide est toujours un sous-ensemble d'un autre ensemble (true).
  • Un ensemble non vide n'est jamais un sous-ensemble d'un ensemble vide (false).
  • Passer null à containsAll() entraîne une NullPointerException.

Comprendre ces cas vous aide à éviter les erreurs potentielles lors de l'utilisation d'ensembles en Java.

Résumé

Dans ce laboratoire, nous avons appris à vérifier si un ensemble contient tous les éléments d'un autre ensemble en Java en utilisant la méthode containsAll(). Nous avons commencé par créer un exemple de base avec HashSet pour démontrer la fonctionnalité principale de containsAll(). Cette méthode offre un moyen simple de déterminer si un éventuel sous-ensemble est bien inclus dans un ensemble plus large.

Ensuite, nous avons exploré comment tester cette fonctionnalité avec différents types d'ensembles, en comprenant que containsAll() fonctionne de manière cohérente pour diverses implémentations de l'interface Set. Enfin, nous avons abordé les considérations importantes concernant la gestion des ensembles vides et nuls lors des vérifications de sous-ensembles, afin d'assurer un code robuste et exempt d'erreurs.

Connexe Java Cours
Java pour débutants

Java pour débutants

java
Exercices de programmation Java

Exercices de programmation Java

java
Insertion en bloc de données dans un emploi du temps de cours

Insertion en bloc de données dans un emploi du temps de cours

java