În Java, o listă imuabilă este o listă care nu poate fi modificată odată ce este creată. O încercare de a adăuga, elimina sau modifica elemente din Listă după ce aceasta este creată va genera o excepție.
Avantajul principal al utilizării listelor imuabile este că oferă siguranță firelor și fac codul mai robust. Deoarece Lista nu poate fi modificată după ce este creată, nu există riscul ca mai multe fire să încerce să o modifice simultan și să provoace probleme. În plus, listele imuabile pot fi partajate cu ușurință între diferite părți ale programului, fără teama de a fi modificate neintenționat.
În general, utilizarea listelor imuabile în Java poate îmbunătăți siguranța și robustețea unui program, în special în mediile cu mai multe fire în care structurile de date partajate pot cauza probleme.
Declarație de clasă
În Java, Lista imuabilă clasa face parte din Guava bibliotecă, care oferă mai multe clase de colecție imuabile. A folosi Lista imuabilă , mai întâi importăm com.google.common.collect pachetul care conține Lista imuabilă clasă.
Declarația de clasă a Lista imuabilă este după cum urmează:
public abstract class ImmutableList extends ImmutableCollection implements List
Lista imuabilă extinde ImmutableColelection clasa și implementează Listă interfață. Este o clasă generică, ceea ce înseamnă că putem crea o clasă Lista imuabilă de orice tip de date. The ȘI în declarație reprezintă parametrul tip, pe care îl putem înlocui cu orice nume de clasă sau interfață.
Ierarhia claselor
The Lista imuabilă clasa implementează Listă interfață și reprezintă o listă care nu poate fi modificată odată creată.
Ierarhia de clasă a Lista imuabilă este după cum urmează:
java.lang.Object com.google.common.collect.ImmutableCollection com.google.common.collect.ImmutableList
Aici, ImmutableColelection este o clasă abstractă care oferă o implementare scheletică a ImmutableColelection interfață, care Lista imuabilă se extinde.
În general, Lista imuabilă class oferă o modalitate convenabilă și eficientă de a crea și de a utiliza liste imuabile în Java.
Se creează ImmutableList
Există diferite moduri de a crea o listă Immutable în Java, în funcție de versiunea de Java pe care o utilizați și de bibliotecile pe care le aveți la dispoziție. Aici sunt cateva exemple:
1. Folosind metoda Java 9 of():
Java 9 a introdus o nouă metodă numită of() în interfața Listă, care creează liste imuabile mai concis și mai ușor de citit. Metoda of() este o metodă din fabrică care ia un număr variabil de argumente și returnează o listă imuabilă care conține acele elemente. Poate fi folosit cu orice clasă care implementează interfața Listă, inclusiv ArrayList, LinkedList și ImmutableList. Un avantaj al utilizării metodei of() este că este mult mai concisă și oferă siguranță la timp de compilare prin efectuarea de inferențe de tip asupra argumentelor, asigurându-se că numai obiectele de tipul corect sunt adăugate la Listă. În general, metoda of() simplifică crearea de liste imuabile în Java.
Pașii pentru găsirea soluției sunt menționați mai jos.
do while loop java
- Importați clasa List din pachetul Java.util: care permite programului să folosească interfața List pentru a crea și manipula liste de obiecte.
- Creați o listă imuabilă folosind metoda din fabrică Java 9: Codul folosește metoda List.of() pentru a crea o listă imuabilă de șiruri de caractere cu patru elemente.
- Încercarea de a modifica Lista: Programul încearcă să adauge un element la lista imuabilă folosind metoda add(), care nu este permisă pe listele imuabile. Ca rezultat, programul prinde UnsupportedOperationException aruncat de metoda add() și tipărește un mesaj care indică faptul că lista nu poate fi modificată.
Nume de fișier: 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.'); } } } Ieșire:
Fruits: [apple, banana, orange, grape] Cannot modify immutable List.
2. Folosind clasa ImmutableList.Builder din biblioteca Guava:
Adăugarea de elemente la Listă într-un stil fluent, făcându-l convenabil pentru crearea progresivă a unei liste.
Indiferent de metoda utilizată, lista ImmutableList rezultată poate fi accesată și repetată ca orice altă listă, dar conținutul său nu poate fi modificat.
Iată soluția în trepte pentru codul dat:
- Importați clasele necesare: importați interfața List și clasa ImmutableList din pachetul com.google.common.collect.
- Creați o listă imuabilă folosind constructorul: creați o listă imuabilă folosind generatorul ImmutableList. Utilizați metoda add() pentru a adăuga elemente la Listă și apelați metoda build() pentru a crea o listă imuabilă.
- Creați o listă imuabilă dintr-o listă existentă: creați un obiect Listă cu elementele dorite. Apoi apelați metoda ImmutableList.copyOf(), trecând Lista ca parametru, pentru a crea o listă imuabilă.
- Adăugarea mai multor elemente: utilizați generatorul ImmutableList pentru a adăuga mai multe elemente folosind metoda addAll() și apelați metoda build() pentru a crea o listă imuabilă.
- Imprimați listele: utilizați metoda System.out.println() pentru a imprima conținutul listelor imuabile.
Implementare:
Nume de fișier: 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); } } Ieșire:
Immutable List 1: [Welcome, to, home] Immutable List 2: [Welcome, to, home, Think] Immutable List 3: [Welcome, to, home, Think, Big]
3. Prin utilizarea metodei of() din clasa ImmutableList
Metoda of() a clasei ImmutableList din biblioteca Guava vă permite să creați o listă imuabilă cu un număr fix de elemente. Odată creată Lista, nu puteți adăuga, elimina sau modifica elementele acesteia.
Nume de fișier: 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); } } Ieșire:
Fruits: [apple, banana, orange, grape]
4. Prin utilizarea metodei copyOf().
În Java, metoda copyOf() creează o nouă matrice care copiază o matrice existentă cu o lungime specificată. Metoda are două argumente: matricea care trebuie copiată și lungimea noii matrice.
Nume de fișier: 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); } } Ieșire:
Immutable List 1: [Java, Python, C++] Immutable List 2: [Learning, Web, Development, is, Fun]
5. UnsupportedOperationException
Programul ilustrează crearea unei liste imuabile în Java folosind metoda Collections.unmodifiableList. În plus, arată cum să gestionați UnsupportedOperationException care este aruncată atunci când încercați să modificați Lista.
Pașii pentru găsirea soluției sunt menționați mai jos:
- În primul rând, creăm un mutabil ArrayList conţinând unele elemente iniţiale folosind de metoda, care returnează o listă imuabilă. Apoi trecem asta ArrayList la Colecții.unmodiableList metoda, care returnează o vizualizare imuabilă a Listei.
- Încercăm să modificăm lista imuabilă folosind adauga, elimina , și a stabilit Deoarece Lista este imuabilă, încercarea de a o modifica va genera un UnsupportedOperationException .
- Prindem UnsupportedOperationException care este aruncat și imprimați un mesaj pe consolă care indică ce operațiune a fost încercată și nu a reușit.
Rețineți că Colecții.unmodiableList metoda creează doar o vizualizare imuabilă a listei originale. Vizualizarea imuabilă va reflecta acele modificări dacă lista originală este modificată. Pentru a crea o listă cu adevărat imuabilă care nu poate fi modificată prin niciun mijloc, puteți utiliza o implementare personalizată a Listă interfață care aruncă o excepție atunci când încearcă să modifice Lista.
Implementare:
Nume de fișier: 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()); } } } Ieșire:
UnsupportedOperationException: null UnsupportedOperationException: null UnsupportedOperationException: null
6. Collections.unmodiableList()
Collections.unmodiableList() este o metodă din cadrul Java Collections Framework care creează o vizualizare nemodificabilă a unei liste existente. Se poate deduce că încercarea de a modifica Lista nemodificabilă va duce la apariția unei excepții UnsupportedOperationException. Lista originală poate fi în continuare modificată, iar orice modificări se vor reflecta în Lista nemodificabilă.
Programul arată cum să utilizați metoda Collections.unmodifiableList() pentru a genera o reprezentare nemodificabilă a unei liste mutabile.
Pașii pentru găsirea soluției sunt menționați mai jos:
- Creați o listă mutabilă mutableList și adăugați-i câteva elemente folosind adăuga() metoda de ArrayList
- Creați o vizualizare nemodificabilă a listei mutabile mutableList folosind unmodiableList() metoda și atribuiți-o variabilei nemodificabilList .
- Încercați să modificați lista nemodificabilă nemodificabilList folosind adăuga() Deoarece Lista nemodificabilă este doar în citire, aceasta va arunca un UnsupportedOperationException . Un mesaj este tipărit pe consolă după capturarea acestei excepții.
- Modificați lista originală mutabilă mutableList prin adăugarea unui alt element folosind adăuga()
- Tipăriți atât listele modificabile, cât și cele nemodificabile pe consolă pentru a arăta că Lista nemodificabile reflectă modificările aduse listei modificabile inițiale.
Nume de fișier: 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] } } Ieșire:
Attempt to modify unmodifiableList failed: null mutableList: [apple, banana, orange, pear] unmodifiableList: [apple, banana, orange, pear]
Avantajele ImmutableList
ImmutableList are mai multe avantaje, printre care: