logo

TechCodeview

Liste immuable en Java

En Java, une liste immuable est une liste qui ne peut pas être modifiée une fois créée. Une tentative d'ajout, de suppression ou de modification d'éléments dans la liste après sa création lèvera une exception.

Le principal avantage de l’utilisation de listes immuables est qu’elles assurent la sécurité des threads et rendent le code plus robuste. Étant donné que la liste ne peut pas être modifiée après sa création, il n'y a aucun risque que plusieurs threads tentent de la modifier simultanément et provoquent des problèmes. De plus, les listes immuables peuvent être facilement partagées entre différentes parties du programme sans craindre d'être modifiées involontairement.

Dans l'ensemble, l'utilisation de listes immuables en Java peut améliorer la sécurité et la robustesse d'un programme, en particulier dans les environnements multithread où les structures de données partagées peuvent poser des problèmes.

Déclaration de classe

En Java, le Liste immuable la classe fait partie du Goyave bibliothèque, qui fournit plusieurs classes de collection immuables. Utiliser Liste immuable , nous importons d'abord le com.google.common.collect le paquet contenant le Liste immuable classe.

La déclaration de classe de Liste immuable est comme suit:

 public abstract class ImmutableList extends ImmutableCollection implements List

Liste immuable prolonge le Collection immuable classe et implémente la Liste interface. C'est une classe générique, ce qui signifie que nous pouvons créer une Liste immuable de tout type de données. Le ET dans la déclaration représente le paramètre de type, que nous pouvons remplacer par n'importe quel nom de classe ou d'interface.

carte java

Hiérarchie des classes

Le Liste immuable la classe implémente le Liste interface et représente une liste qui ne peut pas être modifiée une fois créée.

La hiérarchie des classes de Liste immuable est comme suit:

 java.lang.Object com.google.common.collect.ImmutableCollection com.google.common.collect.ImmutableList

Ici, Collection immuable est une classe abstraite qui fournit une implémentation squelettique de Collection immuable interface, qui Liste immuable s'étend.

Dans l'ensemble, le Liste immuable La classe fournit un moyen pratique et efficace de créer et d’utiliser des listes immuables en Java.

Création d'une liste immuable

Il existe différentes manières de créer une ImmutableList en Java, selon la version de Java que vous utilisez et les bibliothèques dont vous disposez. Voici quelques exemples:

1. Utilisation de la méthode Java 9 of() :

Java 9 a introduit une nouvelle méthode appelée of() dans l'interface List, qui crée des listes immuables de manière plus concise et lisible. La méthode of() est une méthode d'usine qui prend un nombre variable d'arguments et renvoie une liste immuable contenant ces éléments. Il peut être utilisé avec n'importe quelle classe qui implémente l'interface List, notamment ArrayList, LinkedList et ImmutableList. L'un des avantages de l'utilisation de la méthode of() est qu'elle est beaucoup plus concise et offre une sécurité au moment de la compilation en effectuant une inférence de type sur les arguments, garantissant ainsi que seuls les objets du type correct sont ajoutés à la liste. Dans l’ensemble, la méthode of() simplifie la création de listes immuables en Java.

Les étapes pour trouver la solution sont mentionnées ci-dessous.

  1. Importez la classe List à partir du package Java.util : qui permet au programme d'utiliser l'interface List pour créer et manipuler des listes d'objets.
  2. Créez une liste immuable à l'aide de la méthode d'usine Java 9 : le code utilise la méthode List.of() pour créer une liste immuable de chaînes avec quatre éléments.
  3. Tentative de modification de la Liste : Le programme tente d'ajouter un élément à la liste immuable à l'aide de la méthode add(), ce qui n'est pas autorisé sur les listes immuables. En conséquence, le programme intercepte l'exception UnsupportedOperationException levée par la méthode add() et imprime un message indiquant que la liste ne peut pas être modifiée.

Nom de fichier: ImmutableListExample.java

 // Import the required List class from the Java.util package import java.util.List; // Define the class name public class ImmutableListExample { public static void main(String[] args) { // Create an immutable list using the Java 9 factory of() method List fruits = List.of('apple', 'banana', 'orange', 'grape'); // Print the elements of the List System.out.println('Fruits: ' + fruits); // Try to modify the List (will throw UnsupportedOperationException) try { fruits.add('pineapple'); } catch (UnsupportedOperationException ex) { System.out.println('Cannot modify immutable list.'); } } }

Sortir: 

 Fruits: [apple, banana, orange, grape] Cannot modify immutable List.

2. Utilisation de la classe ImmutableList.Builder de la bibliothèque Guava :

Ajout d'éléments à la liste dans un style fluide, ce qui facilite la création progressive d'une liste.

Quelle que soit la méthode utilisée, la ImmutableList résultante est accessible et itérable comme n'importe quelle autre liste, mais son contenu ne peut pas être modifié.

Voici la solution étape par étape pour le code donné :

  1. Importez les classes requises : importez l'interface List et la classe ImmutableList à partir du package com.google.common.collect.
  2. Créez une liste immuable à l'aide du générateur : Créez une liste immuable à l'aide du générateur ImmutableList. Utilisez la méthode add() pour ajouter des éléments à la liste et appelez la méthode build() pour créer une liste immuable.
  3. Créez une liste immuable à partir d'une liste existante : Créez un objet List avec les éléments souhaités. Appelez ensuite la méthode ImmutableList.copyOf(), en passant la List en paramètre, pour créer une liste immuable.
  4. Ajout de plus d'éléments : utilisez le générateur ImmutableList pour ajouter plus d'éléments à l'aide de la méthode addAll() et appelez la méthode build() pour créer une liste immuable.
  5. Imprimer les listes : Utilisez la méthode System.out.println() pour imprimer le contenu des listes immuables.

Mise en œuvre:

Nom de fichier: ImmutableListExample.java

 import java.util.List; import com.google.common.collect.ImmutableList; public class ImmutableListExample { public static void main(String[] args) { // Creating an immutable list using the builder ImmutableList immutableList1 = ImmutableListbuilder() .add('Welcome') .add('to') .add('home') .build(); // Creating an immutable list from an existing list List existingList = List.of('Welcome', 'to', 'home', 'Think'); ImmutableList immutableList2 = ImmutableList.copyOf(existingList); // Creating an immutable list from an existing list and adding more elements ImmutableList immutableList3 = ImmutableList.builder() .addAll(existingList) .add('Big') .build(); // Let's print the lists System.out.println('Immutable List 1: ' + immutableList1); System.out.println('Immutable List 2: ' + immutableList2); System.out.println('Immutable List 3: ' + immutableList3); } }

Sortir: 

 Immutable List 1: [Welcome, to, home] Immutable List 2: [Welcome, to, home, Think] Immutable List 3: [Welcome, to, home, Think, Big]

3. En utilisant la méthode of() de la classe ImmutableList

La méthode of() de la classe ImmutableList de la bibliothèque Guava permet de créer une liste immuable avec un nombre fixe d'éléments. Une fois la Liste créée, vous ne pouvez pas ajouter, supprimer ou modifier ses éléments.

Nom de fichier: ImmutableListExample.java

 import com.google.common.collect.ImmutableList; import java.util.List; class ImmutableListExample { public static void main(String[] args) { // Create an immutable list using the Guava library's ImmutableList class ImmutableList fruits = ImmutableList.of('apple', 'banana', 'orange', 'grape'); // Print the contents of the immutable List System.out.println('Fruits: ' + fruits); } }

Sortir: 

 Fruits: [apple, banana, orange, grape]

4. En utilisant la méthode copyOf()

En Java, la méthode copyOf() crée un nouveau tableau qui copie un tableau existant d'une longueur spécifiée. La méthode prend deux arguments : le tableau à copier et la longueur du nouveau tableau.

Nom de fichier: ImmutableListExample.java

 import com.google.common.collect.ImmutableList; import java.util.*; class ImmutableListExample { public static void main(String[] args) { // Create an ArrayList and add elements to it List myArrayList = new ArrayList(); myArrayList.add('Java'); myArrayList.add('Python'); myArrayList.add('C++'); // Create an immutable list using the Guava library's ImmutableList class and the copyOf() method ImmutableList immutableList1 = ImmutableList.copyOf(myArrayList); // Create an array and convert it to a list String[] myArray = {'Learning', 'Web', 'Development', 'is', 'Fun'}; List myList = Arrays.asList(myArray); // Create an immutable list using the Guava library's ImmutableList class and the copyOf() method ImmutableList immutableList2 = ImmutableList.copyOf(myList); // Print the contents of the immutable lists System.out.println('Immutable List 1: ' + immutableList1); System.out.println('Immutable List 2: ' + immutableList2); } }

Sortir: 

 Immutable List 1: [Java, Python, C++] Immutable List 2: [Learning, Web, Development, is, Fun]

5. Exception d'opération non prise en charge

Le programme illustre la création d'une liste immuable en Java à l'aide de la méthode Collections.unmodifiableList. De plus, il montre comment gérer l'exception UnsupportedOperationException levée lors de la tentative de modification de la liste.

Les étapes pour trouver la solution sont mentionnées ci-dessous :

  1. Tout d'abord, nous créons un mutable Liste des tableaux contenant quelques éléments initiaux utilisant le de méthode, qui renvoie une liste immuable. Nous passons ensuite ceci Liste des tableaux au Collections.unmodifiableList méthode, qui renvoie une vue immuable de la liste.
  2. Nous essayons de modifier la liste immuable en utilisant le Ajouter enlever , et ensemble Puisque la liste est immuable, tenter de la modifier générera un Exception d'opération non prise en charge .
  3. Nous attrapons le Exception d'opération non prise en charge qui est lancé et imprime un message à la console indiquant quelle opération a été tentée et a échoué.

Notez que le Collections.unmodifiableList La méthode crée uniquement une vue immuable de la liste d'origine. La vue immuable reflétera ces modifications si la liste d'origine est modifiée. Pour créer une liste véritablement immuable qui ne peut être modifiée par aucun moyen, vous pouvez utiliser une implémentation personnalisée de Liste interface qui lève une exception lors de la tentative de modification de la liste.

Mise en œuvre:

Nom de fichier: ImmutableListExample.java

 import java.util.ArrayList; import java.util.Collections; import java.util.List; public class ImmutableListExample { public static void main(String[] args) { // Create an immutable list using Collections.unmodifiableList List immutableList = Collections.unmodifiableList(new ArrayList(List.of('foo', 'bar', 'baz'))); // Attempt to modify the immutable List using various methods try { immutableList.add('qux'); System.out.println('Successfully added element to immutable list!'); } catch (UnsupportedOperationException e) { System.out.println('UnsupportedOperationException: ' + e.getMessage()); } try { immutableList.remove(0); System.out.println('Successfully removed element from immutable list!'); } catch (UnsupportedOperationException e) { System.out.println('UnsupportedOperationException: ' + e.getMessage()); } try { immutableList.set(0, 'qux'); System.out.println('Successfully modified element in immutable list!'); } catch (UnsupportedOperationException e) { System.out.println('UnsupportedOperationException: ' + e.getMessage()); } } }

Sortir: 

 UnsupportedOperationException: null UnsupportedOperationException: null UnsupportedOperationException: null

6. Collections.unmodifiableList()

Collections.unmodifiableList() est une méthode de Java Collections Framework qui crée une vue non modifiable d'une liste existante. On peut en déduire qu'essayer de modifier la liste non modifiable entraînera l'apparition d'une UnsupportedOperationException. La liste originale peut toujours être modifiée et toute modification sera reflétée dans la liste non modifiable.

Le programme montre comment utiliser la méthode Collections.unmodifiableList() pour générer une représentation non modifiable d'une liste mutable.

Les étapes pour trouver la solution sont mentionnées ci-dessous :

  1. Créer une liste mutable liste mutable et ajoutez-y quelques éléments en utilisant le ajouter() méthode du Liste des tableaux
  2. Créer une vue non modifiable de la liste mutable liste mutable en utilisant le liste non modifiable() méthode et affectez-la à la variable Liste non modifiable .
  3. Tentative de modification de la liste non modifiable Liste non modifiable en utilisant le ajouter() Puisque la liste non modifiable est en lecture seule, cela lancera un Exception d'opération non prise en charge . Un message est imprimé sur la console après avoir détecté cette exception.
  4. Modifier la liste mutable d'origine liste mutable en ajoutant un autre élément à l'aide du ajouter()
  5. Imprimez les listes mutables et non modifiables sur la console pour montrer que la liste non modifiable reflète les modifications apportées à la liste mutable d'origine.

Nom de fichier: UnmodifiableListExample.java

 import java.util.ArrayList; import java.util.Collections; import java.util.List; public class UnmodifiableListExample { public static void main(String[] args) { List mutableList = new ArrayList(); mutableList.add('apple'); mutableList.add('banana'); mutableList.add('orange'); // Create an unmodifiable view of the mutableList List unmodifiableList = Collections.unmodifiableList(mutableList); // Attempt to modify the unmodifiableList will throw UnsupportedOperationException try { unmodifiableList.add('pear'); } catch (UnsupportedOperationException e) { System.out.println('Attempt to modify unmodifiableList failed: ' + e.getMessage()); } // The original mutableList can still be modified mutableList.add('pear'); // The unmodifiableList will reflect the changes made to the original mutableList System.out.println('mutableList: ' + mutableList); // [apple, banana, orange, pear] System.out.println('unmodifiableList: ' + unmodifiableList); // [apple, banana, orange, pear] } }

Sortir: 

 Attempt to modify unmodifiableList failed: null mutableList: [apple, banana, orange, pear] unmodifiableList: [apple, banana, orange, pear]

Avantages de ImmutableList

ImmutableList présente plusieurs avantages, notamment :

    Sécurité des threads :Puisque ImmutableList est immuable, il est intrinsèquement thread-safe. Plusieurs threads peuvent accéder à la même liste sans aucun risque d’interférence de thread ou d’incohérence de la mémoire.Sécurité:Les listes immuables sont moins sujettes aux failles de sécurité. Par exemple, si un attaquant tente de modifier la liste en ajoutant ou en supprimant des éléments, il ne peut pas le faire car la liste est immuable.Performance:Étant donné que les listes immuables sont en lecture seule, elles peuvent être mises en cache pour de meilleures performances. Si une liste doit être consultée plusieurs fois, l'utilisation d'une liste immuable au lieu de créer une nouvelle liste à chaque fois peut permettre d'éviter les frais généraux.Prévisibilité :Puisque les listes immuables ne peuvent pas être modifiées, leur comportement est prévisible. Certains avantages de l’utilisation de listes immuables éliminent le besoin de programmation défensive et facilitent le raisonnement sur le code.Simplifie le codage :Les listes immuables simplifient le codage en éliminant le besoin de synchronisation, de copie défensive et de gestion manuelle de la mémoire sujette aux erreurs. Le résultat de cette approche est un code plus facile à maintenir et ayant une apparence plus propre.Facilite les tests :Les listes immuables sont plus faciles à tester puisque leur contenu ne change pas. Cette approche facilite la rédaction de tests couvrant tous les scénarios possibles et cas extrêmes.