Ensemble Java

Set est une interface dans le Java Collection Framework. Vous pouvez utiliser Java Set pour implémenter des collections non ordonnées avec des éléments uniques. Dans cet article, nous allons voir cette interface et ses implémentations dans le langage Java, les méthodes pour travailler avec un ensemble, et aussi donner quelques exemples.

Qu'est-ce que l'ensemble Java

Set est une interface du Java Collection Framework, mais Set n'est pas une collection ordonnée, contrairement à List . Cela signifie que les éléments Java Set sont conservés sans ordre particulier. Il n'y a donc aucun contrôle sur la position où vous pouvez insérer un élément. De plus, vous ne pouvez pas accéder aux éléments par leur index. Mathématiquement, un ensemble est une collection d'éléments uniques. En fait, il s'agit d'une Collection non ordonnée (unordered Collection), dans laquelle des éléments identiques ne peuvent pas être stockés. Si vous ajoutez intentionnellement un élément en double à un Set , cette action sera ignorée et le Set ne changera pas. Cependant, il est permis d'y stocker un élément nul.

Définir les implémentations

Java Set est une interface, vous devez donc utiliser l'une de ses implémentations pour créer des objets. Ce sont HashSet , TreeSet et LinkedHashSet . Dans Set s, chaque élément est stocké dans une seule instance, et différentes implémentations de Set utilisent un ordre différent pour stocker les éléments. Dans un HashSet , l'ordre des éléments est déterminé par un algorithme complexe. Si l'ordre de stockage est important pour vous, utilisez un conteneur TreeSet , qui stocke les objets triés par ordre croissant dans l'ordre de comparaison, ou un LinkedHashSet, qui stocke les éléments dans un ordre supplémentaire. Les ensembles sont souvent utilisés pour les tests d'appartenance afin que vous puissiez facilement vérifier si un objet appartient à un ensemble donné. Ainsi, dans la pratique, une implémentation de HashSet optimisée pour une recherche rapide est généralement choisie. HashSet est une collection qui utilise leurs valeurs de hachage renvoyées par la méthode hashCode() pour stocker des éléments en interne. Autrement dit, à l'intérieur du HashSet<E> , l' objet HashMap<E, Object> est stocké, qui stocke les valeurs du HashSet sous forme de clés. L'utilisation de codes de hachage vous permet de rechercher, d'ajouter et de supprimer rapidement des éléments d'un Set . LinkedHashSet est un HashSetqui stocke également des éléments dans une liste chaînée. Un HashSet normal ne maintient pas l'ordre des éléments. Premièrement, officiellement, il n'existe tout simplement pas, et deuxièmement, même l'ordre interne peut changer radicalement lorsqu'un seul élément est ajouté. Et vous pouvez obtenir un itérateur de LinkedHashSet et l'utiliser pour parcourir tous les éléments dans l'ordre exact dans lequel ils ont été ajoutés au LinkedHashSet . Pas souvent, mais parfois cela peut être très nécessaire. Un TreeSet est une collection qui stocke des éléments sous la forme d'un arbre ordonné par valeurs. À l'intérieur du TreeSet<E> se trouve un TreeMap<E, Object> qui stocke toutes ces valeurs. Et ce TreeMaputilise un arbre binaire équilibré rouge-noir pour stocker les éléments. Par conséquent, il a des opérations add() , remove() , contains() très rapides .

Créer un objet défini

Pour créer un Set Object, vous pouvez utiliser l'un des formulaires suivants :

Set<Integer> intSet = new HashSet<>();
Set<String> vSet = new HashSet<>();
Set mySet = new LinkedHashSet();
HashSet<String> myHashset = new HashSet<>();

Voici un exemple simple, où nous créons 2 Set s, HashSet et LinkedHashSet , et ajoutons dans chacun 5 éléments. Nous pouvons utiliser la méthode add() pour cela.

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

public class HashSetTest {
    public static void main(String[] args) {
        Set mySet = new HashSet();
        Set mySet2 = new LinkedHashSet();
//adding some string elements
        mySet.add("Stuart");
        mySet.add("Alex");
        mySet.add("Johnny");
        mySet.add("Igor");
        mySet.add("Bel");
        System.out.println(mySet);
        mySet2.add("Stuart");
        mySet2.add("Alex");
        mySet2.add("Johnny");
        mySet2.add("Igor");
        mySet2.add("Bel");
        System.out.println(mySet2);
    }
}

Voici la sortie du programme : Comme nous l'avons mentionné ci-dessus, HashSet ne maintient pas l'ordre des éléments, mais LinkedHashSet le fait. C'est LinkedHashSet qui nous a donné les éléments dans l'ordre où nous les avons écrits dans l'ensemble.

Méthodes d'ensemble Java

Voici quelques-unes des méthodes importantes de Java Set :

• addition booléenne(E e) . Ajoute l'élément spécifié à l'ensemble s'il n'est pas déjà présent (opération facultative).

• booléen remove(Object o) . Supprime l'élément spécifié de cet ensemble s'il est présent (opération facultative).

• booléen removeAll(Collection c) . Supprime de cet ensemble tous ses éléments contenus dans la collection spécifiée (opération facultative).

• boolean keepAll(Collection c) . Conserve uniquement les éléments de cet ensemble qui sont contenus dans la collection spécifiée (opération facultative).

• annuler clear() . Supprime tous les éléments de l'ensemble.

• Itérateur iterator() . Renvoie un itérateur sur les éléments de cet ensemble.

• taille int() . il est utilisé pour obtenir le nombre d'éléments dans le Set.

• booléen isEmpty() . pour vérifier si Set est vide ou non.

• boolean contains(Object o) . Renvoie true si ce Set contient l'élément spécifié.

• Itérateur iterator() . Renvoie un itérateur sur les éléments de cet ensemble. Les éléments sont retournés sans ordre particulier.

• Objet[] versTableau() . Renvoie un tableau contenant tous les éléments de cet ensemble. Si cet ensemble donne des garanties quant à l'ordre dans lequel ses éléments sont renvoyés par son itérateur, cette méthode doit renvoyer les éléments dans le même ordre.

Les méthodes sont similaires à celles de ArrayList , sauf que la méthode add(Object o) n'ajoute un objet à l'ensemble que s'il n'y est pas déjà. La valeur de retour de la méthode est true si l'objet a été ajouté, et false sinon. Il existe également des méthodes héritées de l'interface Collection<> : parallelStream() , removeIf() , stream() et forEach() héritées de l'interface java.lang.Iterable .

Exemple d'opérations principales Java Set

Dans cet exemple, nous créons un tableau de chaînes, puis le transmettons à mySet à l'aide de l' opération Arrays.asList . Ensuite, nous supprimons quelques éléments supplémentaires et en ajoutons quelques autres. Dans ce cas, l'un des éléments de l'ensemble existe déjà : il ne sera pas ajouté. Nous allons également essayer les opérations de vérification du vide isEmpty() , déterminer la taille de l'ensemble size() et effacer l'ensemble de tous les éléments clear() .

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

public class HashSetTest2 {
   public static void main(String[] args) {
       //creating a string Array with some names
       String [] friends =  {"Stuart", "Ivy", "Johnny", "Alex", "Igor", "Tanya"};
       //creating a new set and adding elements from string array into it
       Set<String> mySet = new HashSet<>(Arrays.asList(friends));
       System.out.println(mySet);
       //removing two elements from the set
       mySet.remove("Igor");
       mySet.remove("Stuart");

       System.out.println(mySet);

       //adding 2 new Elements into set
       mySet.add("Dasha");
       mySet.add("Alex"); //it's second Alex, can't be added
       System.out.println(mySet);
       //cheking the size of mySet
       int size = mySet.size();
       System.out.println("The quantity of set's elements = " + size);
       //Checking if the set is empty
       System.out.println("Is mySet empty? " + mySet.isEmpty());
       //checking if some elements are in set
       System.out.println("Is Igor in set? " + mySet.contains("Igor"));
       System.out.println("Is Johnny in set? "+ mySet.contains("Johnny"));
       //deleting all elements from the set
       mySet.clear();
       System.out.println("Is mySet empty now? " + mySet.isEmpty());

   }
}

La sortie du programme est ici :

Exemple avec LinkedHashSet et défini sur Array

Écrivons un autre programme. Dans celui-ci, nous allons créer un ensemble basé sur le LinkedHashSet , y ajouter des éléments, puis convertir l'ensemble en tableau.

import java.util.Arrays;
import java.util.LinkedHashSet;
import java.util.Set;
   public class LinkedHashSet3 {
       public static void main(String[] args) {
           Set<String> set = new LinkedHashSet<>();
           set.add("C");
           set.add("D");
           set.add("E");
           set.add("F");
           set.add("G");
           set.add("A");
           set.add("B");
           System.out.println(set);
           set.remove("F");// removing an element from our set
           set.remove("C sharp");//trying to remove element that isn't in set
           System.out.println(set.remove("C sharp"));
           System.out.println("Print our set with elements removed: ");
           System.out.println(set);

//set to array
           String strArray[] = set.toArray(new String[set.size()]);
           System.out.println("New Array from set: ");
           System.out.println(Arrays.toString(strArray));
           System.out.println(strArray[0]);

       }
   }

Voici la sortie du programme :

Définir l'exemple avec l'itérateur

Créons un ensemble, puis imprimons-le à l'aide d'un itérateur, puis supprimons-en tous les nombres pairs, également à l'aide d'un itérateur.

import java.util.*;

public class SetTest5
{
   public static void main(String[] args)
   {

       Set<Integer> mySet = new HashSe<>();
       for(int i = 0; i < 10; i++)
           mySet.add(i);

       Iterator iterator = mySet.iterator();

       //simple iteration
       while(iterator.hasNext()){
           int i = (int) iterator.next();
       }
       System.out.println(" " + mySet);

       //modification of mySet using iterator - removing all even numbers
       iterator = mySet.iterator();
       while(iterator.hasNext()){
           int x = (int) iterator.next();
           if(x%2 == 0) iterator.remove();
       }
       System.out.println(mySet);

       }
}

La sortie du programme est ici :

Exemple avec TreeSet

Si le tri est important pour vous, utilisez l'implémentation TreeSet . Dans ce court exemple, nous allons remplir l'ensemble avec les noms d'amis, comme dans les exemples précédents. Cependant, dans un TreeSet trié , les éléments seront immédiatement écrits dans l'ordre trié. Dans ce cas, les noms seront affichés par ordre alphabétique.

import java.util.Set;
import java.util.TreeSet;
public class TreeSetTest {

   public static void main(String[] args) {

       Set mySet = new TreeSet<>();
       mySet.add("Stuart");
       mySet.add("Alex");
       mySet.add("Johnny");
       mySet.add("Igor");
       mySet.add("Bel");
       System.out.println(mySet);

   }

La sortie est :

Brève conclusion

• L'interface Java Set fait partie de Java Collections Framework.

• Classes implémentées : AbstractSet , ConcurrentHashMap.KeySetView , ConcurrentSkipListSet , CopyOnWriteArraySet , EnumSet , HashSet , JobStateReasons , LinkedHashSet , TreeSet .

• Les implémentations Set les plus populaires sont HashSet , LinkedHashSet et TreeSet .

• L'ordre des éléments HashSet est déterminé par un algorithme complexe. Si l'ordre de stockage est important pour vous, utilisez un conteneur TreeSet , qui stocke les objets triés par ordre croissant dans l'ordre de comparaison, ou un LinkedHashSet , qui stocke les éléments dans l'ordre d'addition.

• Le plus souvent, les ensembles sont utilisés pour tester l'appartenance. C'est-à-dire vérifier si un objet appartient à un ensemble donné au sens mathématique. Ainsi, le plus souvent de toutes les implémentations de Set dans la pratique, HashSet est généralement choisi. Cette implémentation est optimisée pour une recherche rapide.

• Vous ne pouvez pas ajouter d'éléments en double à un ensemble, vous pouvez donc utiliser des implémentations de l' interface Set pour stocker des éléments uniques.

• Set vous permet d'ajouter un seul élément nul.

• Set n'est pas une liste et ne prend pas en charge les index ou les positions de ses éléments.