Java EnumSet

Dans ce tutoriel, nous allons apprendre la classe EnumSet Java et ses différentes méthodes à l'aide d'exemples.

La classe EnumSet du cadre de collections Java fournit une implémentation de collection d'éléments d'énumération unique.

Avant d'apprendre EnumSet, assurez-vous de comprendreJava Enums.

Il implémenteInterface Set.

Création d'EnumSet

Pour créer un ensemble d'énumérations, nous devons d'abord importer le paquet java.util.EnumSet.

Contrairement aux autres implémentations de collections, les ensembles d'énumérations n'ont pas de constructeur public. Nous devons utiliser des méthodes prédéfinies pour créer un ensemble d'énumérations.

1.Utilisation de allOf(Size)

La méthode allOf() crée un ensemble d'énumérations contenant toutes les valeurs de l'énumération spécifiée Size. Par exemple,

import java.util.EnumSet;
class Main {
　　　　//Un ensemble d'énumérations nommé Size
　　　　enum Size {
　　　　　　　　SMALL, MEDIUM, LARGE, EXTRALARGE
　　　　}
　　　　
　　　　public static void main(String[] args) {
　　　　　　　　//Créer un EnumSet en utilisant allOf()
　　　　　　　　EnumSet<Size> sizes = EnumSet.allOf(Size.class);
　　　　　　　　System.out.println("EnumSet: ")　+　sizes);
　　　　}
}

Résultat de la sortie

EnumSet: [SMALL, MEDIUM, LARGE, EXTRALARGE]

Remarque de déclaration

EnumSet<Size> sizes = EnumSet.allOf(Size.class);

Ici, Size.class représente l'énumération Size que nous avons créée.

2.Utilisation de noneOf(Size)

La méthode noneOf() crée un ensemble d'énumérations vide. Par exemple,

import java.util.EnumSet;
class Main {
　　　　　//Un ensemble d'énumérations nommé Size
　　　　enum Size {
　　　　　　　　SMALL, MEDIUM, LARGE, EXTRALARGE
　　　　}
　　　　public static void main(String[] args) {
　　　　　　　　//　Créer un EnumSet en utilisant noneOf()
　　　　　　　　EnumSet<Size> sizes = EnumSet.noneOf(Size.class);
　　　　　　　　System.out.println("EnumSet vide: "　+　sizes);
　　　　}
}

Résultat de la sortie

EnumSet vide : []

Ici, nous avons créé un ensemble d'énumérations vide nommé sizes.

Remarque：Nous ne pouvons insérer que des éléments de type énumération Size dans le programme ci-dessus. Cela est dû au fait que nous avons créé un ensemble d'énumérations vide en utilisant l'énumération Size.

3.Utilisation de range(e1,e2méthode)

La méthode range() crée un ensemble d'énumérations contenant e1et e2toutes les valeurs des énumérations entre eux, y compris ces deux valeurs. Par exemple

import java.util.EnumSet;
class Main {
　　　　enum Size {
　　　　　　　　SMALL, MEDIUM, LARGE, EXTRALARGE
　　　　}
　　　　public static void main(String[] args) {
　　　　　　　　//Création d'un EnumSet à l'aide de range()
　　　　　　　　EnumSet<Size> sizes = EnumSet.range(Size.MEDIUM, Size.EXTRALARGE);
　　　　　　　　System.out.println("EnumSet: ")　+　sizes);
　　　　}
}

Résultat de la sortie

EnumSet: [MEDIUM, LARGE, EXTRALARGE]

4.Utiliser la méthode of()

La méthode of() crée un ensemble d'enumérations contenant des éléments spécifiés. Par exemple,

import java.util.EnumSet;
class Main {
　　　　enum Size {
　　　　　　　　SMALL, MEDIUM, LARGE, EXTRALARGE
　　　　}
　　　　public static void main(String[] args) {
　　　　　　　　//Utiliser of() avec un seul paramètre
　　　　　　　　EnumSet<Size> sizes1　= EnumSet.of(Size.MEDIUM);
　　　　　　　　System.out.println("EnumSet1: "　+　sizes1);
　　　　　　　　EnumSet<Size> sizes2　= EnumSet.of(Size.SMALL, Size.LARGE);
　　　　　　　　System.out.println("EnumSet2: "　+　sizes2);
　　　　}
}

Résultat de la sortie

EnumSet1: [MEDIUM]
EnumSet2: [SMALL, LARGE]

Méthodes de l'EnumSet

Insérer l'élément dans l'EnumSet

• add() - Insérer la valeur d'enumeration spécifiée dans l'ensemble d'enumérations

• addAll() - Insérer tous les éléments du jeu spécifié dans le jeu

Par exemple,

import java.util.EnumSet;
class Main {
　　　　enum Size {
　　　　　　　　SMALL, MEDIUM, LARGE, EXTRALARGE
　　　　}
　　　　public static void main(String[] args) {
　　　　　　　　//Créer un EnumSet en utilisant allOf()
　　　　　　　　EnumSet<Size> sizes1　= EnumSet.allOf(Size.class);
　　　　　　　　//Créer un EnumSet en utilisant noneOf()
　　　　　　　　EnumSet<Size> sizes2　= EnumSet.noneOf(Size.class);
　　　　　　　　//Ajouter des éléments en utilisant la méthode add
　　　　　　　　sizes2.add(Size.MEDIUM);
　　　　　　　　System.out.println("EnumSet utilise la méthode add() : ")　+　sizes2);
　　　　　　　　//Utiliser la méthode addAll()
　　　　　　　　sizes2.addAll(sizes1);
　　　　　　　　System.out.println("EnumSet utilise la méthode addAll() : ")　+　sizes2);
　　　　}
}

Résultat de la sortie

EnumSet utilise la méthode add() : [MEDIUM]
EnumSet utilise la méthode addAll() : [SMALL, MEDIUM, LARGE, EXTRALARGE]

Dans l'exemple ci-dessus, nous avons utilisé la méthode addAll() pour insérer sizes1Tous les éléments de l'ensemble d'enumérations sont insérés dans sizes2de l'ensemble d'enumérations.

Nous pouvons également utiliser addAll() pour insérer des éléments d'autres collections (comme ArrayList, LinkedList, etc.) dans l'ensemble d'enumérations. Cependant, toutes les collections doivent avoir le même type d'enumeration.

Accéder aux éléments de l'EnumSet

Pour accéder aux éléments d'un ensemble d'enumérations, nous pouvons utiliser la méthode iterator(). Pour utiliser cette méthode, nous devons importer le paquet java.util.Iterator. Par exemple,

import java.util.EnumSet;
import java.util.Iterator;
class Main {
　　　　enum Size {
　　　　　　　　SMALL, MEDIUM, LARGE, EXTRALARGE
　　　　}
　　　　public static void main(String[] args) {
　　　　　　　　//Créer un EnumSet en utilisant allOf()
　　　　　　　　EnumSet<Size> sizes = EnumSet.allOf(Size.class);
　　　　　　　　Iterator<Size> iterate = sizes.iterator();
　　　　　　　　System.out.print("EnumSet: ");
　　　　　　　　while(iterate.hasNext()) {
　　　　　　　　　　　　System.out.print(iterate.next());
　　　　　　　　　　　　System.out.print(", ");
　　　　　　　　}
　　　　}
}

Résultat de la sortie

EnumSet: SMALL, MEDIUM, LARGE, EXTRALARGE,

Remarques:

• hasNext() - Si l'élément suivant existe dans l'ensemble d'ensembles, renvoie true

• next()　 - Retourne l'élément suivant de l'ensemble d'ensembles

Supprimez l'élément de l'EnumSet

• remove() - Supprimez l'élément spécifié de l'ensemble d'ensembles

• removeAll() - Supprimez tous les éléments d'un ensemble d'ensembles

Par exemple,

import java.util.EnumSet;
class Main {
　　　　enum Size {
　　　　　　　　SMALL, MEDIUM, LARGE, EXTRALARGE
　　　　}
　　　　public static void main(String[] args) {
　　　　　　　　//Utilisez allOf() pour créer un EnumSet
　　　　　　　　EnumSet<Size> sizes = EnumSet.allOf(Size.class);
　　　　　　　　System.out.println("EnumSet: ")　+　sizes);
　　　　　　　　//　Utilisez remove()
　　　　　　　　boolean value1　= sizes.remove(Size.MEDIUM);
　　　　　　　　System.out.println("Est-ce que MEDIUM a été supprimé ? ")　+　value1);
　　　　　　　　//　Utilisez removeAll()
　　　　　　　　boolean value2　= sizes.removeAll(sizes);
　　　　　　　　System.out.println("Tous les éléments ont-ils été supprimés ? ")　+　value2);
　　　　}
}

Résultat de la sortie

EnumSet: [SMALL, MEDIUM, LARGE, EXTRALARGE]
Est-ce que MEDIUM a été supprimé ? true
Tous les éléments ont-ils été supprimés ? true

Autres méthodes

Interfaces that are cloneable and serializable

The EnumSet class also implements the Cloneable and Serializable interfaces.

Cloneable interface (Cloneable)

It allows the EnumSet class to create a copy of the instance of the class.

Serializable interface (Serializable)

Every time you need to transmit a Java object over the network, you need to convert the object into bits or bytes. This is because Java objects cannot be transmitted over the network.

The Serializable interface allows classes to be serialized. This means that Serializable can convert the objects of the implemented class into bits or bytes.

Why choose EnumSet?

The enumeration set provides a more efficient way to store enumeration values than other set implementations (such as HashSet, TreeSet).

The enumeration set only stores the enumeration values of specific enumerations. Therefore, the JVM already knows all possible values of the collection.

That's why enumeration sets are implemented internally as bit sequences. Bits specify whether an element appears in the enumeration set.

If the element exists in the collection, open the corresponding bit.