logo

TechCodeview

Llista immutable en Java

A Java, una llista immutable és una llista que no es pot modificar un cop creada. Un intent d'afegir, eliminar o modificar elements a la llista després de crear-la, generarà una excepció.

El principal avantatge d'utilitzar llistes immutables és que proporcionen seguretat de fil i fan que el codi sigui més robust. Com que la llista no es pot modificar després de crear-la, no hi ha risc que diversos fils intentin modificar-la simultàniament i causin problemes. A més, les llistes immutables es poden compartir fàcilment entre diferents parts del programa sense por de ser modificades sense voler.

En general, l'ús de llistes immutables a Java pot millorar la seguretat i la robustesa d'un programa, especialment en entorns multifils on les estructures de dades compartides poden causar problemes.

Declaració de classe

A Java, el Llista Immutable classe forma part de la Guayaba biblioteca, que proporciona diverses classes de col·lecció immutables. Usar Llista Immutable , primer importem el com.google.common.collect el paquet que conté el Llista Immutable classe.

La declaració de classe de Llista Immutable és el següent:

10 ml a oz 
 public abstract class ImmutableList extends ImmutableCollection implements List

Llista Immutable s'estén el Col·lecció Immutable classe i implementa el Llista interfície. És una classe genèrica, el que significa que podem crear un Llista Immutable de qualsevol tipus de dades. El I a la declaració representa el paràmetre de tipus, que podem substituir per qualsevol nom de classe o interfície.

Jerarquia de classes

El Llista Immutable la classe implementa el Llista interfície i representa una llista que no es pot modificar un cop creada.

La jerarquia de classes Llista Immutable és el següent:

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

Aquí, Col·lecció Immutable és una classe abstracta que proporciona una implementació esquelètica del Col·lecció Immutable interfície, que Llista Immutable s'estén.

En general, el Llista Immutable La classe proporciona una manera còmoda i eficient de crear i utilitzar llistes immutables a Java.

Creant ImmutableList

Hi ha diferents maneres de crear una Llista Immutable a Java, depenent de la versió de Java que utilitzeu i de les biblioteques que teniu disponibles. Aquests són alguns exemples:

1. Utilitzant el mètode Java 9 of():

Java 9 va introduir un nou mètode anomenat of() a la interfície de llista, que crea llistes immutables de manera més concisa i llegible. El mètode of() és un mètode de fàbrica que pren un nombre variable d'arguments i retorna una llista immutable que conté aquests elements. Es pot utilitzar amb qualsevol classe que implementi la interfície List, incloent ArrayList, LinkedList i ImmutableList. Un avantatge d'utilitzar el mètode of() és que és molt més concís i proporciona seguretat en temps de compilació mitjançant la realització d'inferències de tipus sobre els arguments, assegurant que només s'afegeixin objectes del tipus correcte a la llista. En general, el mètode of() simplifica la creació de llistes immutables a Java.

Els passos per trobar la solució s'esmenten a continuació.

  1. Importeu la classe List del paquet Java.util: que permet al programa utilitzar la interfície List per crear i manipular llistes d'objectes.
  2. Creeu una llista immutable mitjançant el mètode de fàbrica de Java 9: ​​el codi utilitza el mètode List.of() per crear una llista immutable de cadenes amb quatre elements.
  3. Intenta modificar la llista: el programa intenta afegir un element a la llista immutable mitjançant el mètode add(), que no està permès a les llistes immutables. Com a resultat, el programa captura la UnsupportedOperationException llançada pel mètode add() i imprimeix un missatge que indica que la llista no es pot modificar.

Nom de l'arxiu: ImmutableListExample.java

char tostring 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.'); } } }

Sortida: 

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

2. Utilitzant la classe ImmutableList.Builder de la biblioteca Guava:

Afegir elements a la llista amb un estil fluid, cosa que fa que sigui convenient crear una llista de manera incremental.

Independentment del mètode utilitzat, es pot accedir a la ImmutableList resultant i repetir-la com qualsevol altra llista, però el seu contingut no es pot modificar.

Aquí teniu la solució pas a pas per al codi donat:

  1. Importeu les classes necessàries: importeu la interfície List i la classe ImmutableList del paquet com.google.common.collect.
  2. Creeu una llista immutable mitjançant el constructor: creeu una llista immutable mitjançant el constructor ImmutableList. Utilitzeu el mètode add() per afegir elements a la llista i crideu al mètode build() per crear una llista immutable.
  3. Creeu una llista immutable a partir d'una llista existent: creeu un objecte de llista amb els elements desitjats. A continuació, crideu al mètode ImmutableList.copyOf(), passant la llista com a paràmetre, per crear una llista immutable.
  4. Afegir més elements: utilitzeu el constructor ImmutableList per afegir més elements amb el mètode addAll() i crideu al mètode build() per crear una llista immutable.
  5. Imprimeix les llistes: utilitzeu el mètode System.out.println() per imprimir el contingut de les llistes immutables.

Implementació:

Nom de l'arxiu: ImmutableListExample.java

paràmetre verilog 
 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); } }

Sortida: 

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

3. Mitjançant l'ús del mètode of() de la classe ImmutableList

El mètode of() de la classe ImmutableList a la biblioteca Guava us permet crear una llista immutable amb un nombre fix d'elements. Un cop creada la Llista, no podeu afegir, eliminar ni modificar-ne els elements.

Nom de l'arxiu: 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); } }

Sortida: 

 Fruits: [apple, banana, orange, grape]

4. Mitjançant l'ús del mètode copyOf().

A Java, el mètode copyOf() crea una matriu nova que copia una matriu existent amb una longitud especificada. El mètode pren dos arguments: la matriu que s'ha de copiar i la longitud de la nova matriu.

Nom de l'arxiu: 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); } }

Sortida: 

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

5. UnsupportedOperationException

El programa il·lustra la creació d'una llista immutable a Java mitjançant el mètode Collections.unmodifiableList. A més, mostra com gestionar la UnsupportedOperationException que es llança quan s'intenta modificar la llista.

Els passos per trobar la solució s'esmenten a continuació:

  1. Primer, creem un mutable ArrayList que conté alguns elements inicials utilitzant el de mètode, que retorna una llista immutable. Aleshores passem això ArrayList fins al Collections.unmodifiableList mètode, que retorna una vista immutable de la llista.
  2. Intentem modificar la llista immutable utilitzant el afegir, eliminar , i conjunt Com que la llista és immutable, intentar modificar-la generarà un UnsupportedOperationException .
  3. Agafem el UnsupportedOperationException que es llança i imprimeix un missatge a la consola que indica quina operació s'ha intentat i no ha tingut èxit.

Tingueu en compte que el Collections.unmodifiableList El mètode només crea una vista immutable de la llista original. La vista immutable reflectirà aquests canvis si es modifica la llista original. Per crear una llista realment immutable que no es pugui modificar de cap manera, podeu utilitzar una implementació personalitzada de la Llista interfície que llança una excepció quan s'intenta modificar la llista.

la sessió ha caducat

Implementació:

Nom de l'arxiu: 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()); } } }

Sortida: 

 UnsupportedOperationException: null UnsupportedOperationException: null UnsupportedOperationException: null

6. Collections.unmodiableList()

Collections.unmodiableList() és un mètode del Java Collections Framework que crea una vista no modificable d'una llista existent. Es pot deduir que intentar modificar la llista no modificable provocarà l'aparició d'una UnsupportedOperationException. La llista original encara es pot modificar i qualsevol canvi es reflectirà a la llista no modificable.

El programa mostra com utilitzar el mètode Collections.unmodifiableList() per generar una representació no modificable d'una llista mutable.

Els passos per trobar la solució s'esmenten a continuació:

  1. Creeu una llista mutable mutableList i afegiu-hi alguns elements utilitzant el afegir() mètode de la ArrayList
  2. Creeu una vista no modificable de la llista mutable mutableList utilitzant el UnmodiableList() mètode i assigneu-lo a la variable no modificableList .
  3. Intenteu modificar la llista no modificable no modificableList utilitzant el afegir() Com que la llista no modificable és només de lectura, això generarà un UnsupportedOperationException . S'imprimeix un missatge a la consola després de detectar aquesta excepció.
  4. Modifiqueu la llista mutable original mutableList afegint un altre element utilitzant el afegir()
  5. Imprimiu les llistes mutables i no modificables a la consola per mostrar que la llista no modificable reflecteix els canvis fets a la llista mutable original.

Nom de l'arxiu: 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] } }

Sortida: 

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

Avantatges d'ImmutableList

ImmutableList té diversos avantatges, com ara:

    Seguretat del fil:Com que ImmutableList és immutable, és inherentment segur per a fils. Diversos fils poden accedir a la mateixa llista sense cap risc d'interferència de fils o inconsistència de memòria.Seguretat:Les llistes immutables són menys propenses a les vulnerabilitats de seguretat. Per exemple, si un atacant intenta modificar la llista afegint o eliminant elements, no ho pot fer perquè la llista és immutable.Rendiment:Com que les llistes immutables són només de lectura, es poden emmagatzemar a la memòria cau per obtenir un millor rendiment. Si s'ha d'accedir a una llista diverses vegades, utilitzar una llista immutable en lloc de crear-ne una nova cada vegada pot ajudar a evitar les despeses generals.Predictibilitat:Com que les llistes immutables no es poden modificar, el seu comportament és previsible. Alguns avantatges de l'ús de llistes immutables són l'eliminació de la necessitat de programació defensiva i la facilitació de raonar sobre el codi.Simplifica la codificació:Les llistes immutables simplifiquen la codificació eliminant la necessitat de sincronització, còpia defensiva i gestió de memòria manual propensa a errors. El resultat d'aquest enfocament és un codi que és més fàcil de mantenir i té un aspecte més net.Facilita la prova:Les llistes immutables són més fàcils de provar ja que el seu contingut no canvia. L'enfocament facilita l'escriptura de proves que cobreixen tots els escenaris i casos extrems possibles.