Ensemble immuable en Java

1. Introduction

Dans ce tutoriel, nous allons examiner différentes façons de construire un ensemble immuable en Java.

Mais d'abord, comprenons l'ensemble immuable et voyons pourquoi nous en avons besoin.

2. Qu'est-ce qu'un ensemble immuable?

En général, un objet immuable ne changera pas son état interne une fois que nous l'avons créé. Cela le rend thread-safe par défaut. La même logique s'applique aux ensembles immuables.

Supposons que nous ayons une instance HashSet avec des valeurs. Le rendre immuable créera une version «lecture seule» de notre ensemble. Ainsi, toute tentative de modification de son état lèvera une exception UnsupportedOperationException .

Alors, pourquoi en avons-nous besoin?

Certes, le cas d'utilisation le plus courant d'un ensemble immuable est un environnement multi-thread. Ainsi, nous pouvons partager des données immuables à travers les threads sans nous soucier de la synchronisation.

En attendant, il y a un point important à garder à l'esprit: l' immuabilité ne concerne que l'ensemble et non ses éléments . De plus, nous pouvons modifier les références d'instance des éléments de l'ensemble sans problème.

3. Créer des ensembles immuables dans Core Java

Avec seulement les classes Java de base à notre disposition, nous pouvons utiliser les collections . unmodifiableSet () pour envelopper le Set d' origine .

Tout d'abord, créons une instance HashSet simple et initialisons-la avec des valeurs String :

Set set = new HashSet(); set.add("Canada"); set.add("USA");

Ensuite, terminons avec Collections . unmodifiableSet ():

Set unmodifiableSet = Collections.unmodifiableSet(set);

Enfin, pour nous assurer que notre instance unmodifiableSet est immuable, créons un cas de test simple:

@Test(expected = UnsupportedOperationException.class) public void testUnmodifiableSet() { // create and initialize the set instance Set unmodifiableSet = Collections.unmodifiableSet(set); unmodifiableSet.add("Costa Rica"); }

Comme prévu, le test se déroulera avec succès. En outre, l' opération add () est interdite sur l' instance unmodifiableSet et lèvera une exception UnsupportedOperationException .

Maintenant, changeons l' instance d' ensemble initiale en lui ajoutant la même valeur:

set.add("Costa Rica");

De cette façon, nous modifions indirectement l'ensemble non modifiable. Ainsi, lorsque nous imprimons l' instance unmodifiableSet :

[Canada, USA, Costa Rica]

Comme nous pouvons le voir, l' élément "Costa Rica" est également présent dans unmodifiableSet.

4. Créer des ensembles immuables dans Java 9

Depuis Java 9, la méthode de fabrique statique Set.of (elements) est disponible pour créer des ensembles immuables:

Set immutable = Set.of("Canada", "USA");

5. Créer des ensembles immuables dans Guava

Une autre façon de construire un ensemble immuable consiste à utiliser la classe ImmutableSet de Guava . Il copie les données existantes dans une nouvelle instance immuable. Par conséquent, les données dans ImmutableSet ne changeront pas lorsque nous modifierons l' ensemble d' origine .

Comme pour l'implémentation Java principale, toute tentative de modification de l'instance immuable créée lèvera une exception UnsupportedOperationException .

Maintenant, explorons différentes manières de créer des instances immuables.

5.1. Utilisation d' ImmutableSet. copie de()

En termes simples, l' ImmutableSet . copyOf () renvoie une copie de tous les éléments de l'ensemble:

Set immutable = ImmutableSet.copyOf(set);

Ainsi, après avoir modifié l'ensemble initial, l'instance immuable restera la même:

[Canada, USA]

5.2. Utiliser ImmutableSet .of ()

De même, avec la méthode ImmutableSet.of () , nous pouvons créer instantanément un ensemble immuable avec les valeurs données:

Set immutable = ImmutableSet.of("Canada", "USA");

Lorsque nous ne spécifions aucun élément, ImmutableSet.of () retournera un ensemble immuable vide.

Cela peut être comparé à Set .of () de Java 9 .

6. Conclusion

Dans cet article rapide, nous avons discuté des ensembles immuables dans le langage Java. De plus, nous avons montré comment créer des ensembles immuables à l'aide de l'API Collections du noyau Java, Java 9 et de la bibliothèque Guava.

Enfin, comme d'habitude, le code complet de cet article est disponible à l'adresse over sur GitHub.