logo

TechCodeview

Elenco immutabile in Java

In Java, un elenco immutabile è un elenco che non può essere modificato una volta creato. Un tentativo di aggiungere, rimuovere o modificare elementi nell'elenco dopo la sua creazione genererà un'eccezione.

Il vantaggio principale dell'utilizzo di elenchi immutabili è che garantiscono la sicurezza del thread e rendono il codice più robusto. Poiché l'elenco non può essere modificato dopo la sua creazione, non vi è alcun rischio che più thread tentino di modificarlo contemporaneamente e causino problemi. Inoltre, gli elenchi immutabili possono essere facilmente condivisi tra diverse parti del programma senza timore di essere modificati involontariamente.

Confronto di stringhe Java

Nel complesso, l'utilizzo di elenchi immutabili in Java può migliorare la sicurezza e la robustezza di un programma, soprattutto in ambienti multi-thread in cui le strutture dati condivise possono causare problemi.

Dichiarazione di classe

In Giava, il Lista immutabile la classe fa parte di Guaiava libreria, che fornisce diverse classi di raccolte immutabili. Usare Lista immutabile , importiamo prima il file com.google.common.collect il pacco contenente il Lista immutabile classe.

La dichiarazione di classe di Lista immutabile è come segue:

 public abstract class ImmutableList extends ImmutableCollection implements List

Lista immutabile estende il Collezione immutabile classe e implementa il file Elenco interfaccia. È una classe generica, il che significa che possiamo creare un file Lista immutabile di qualsiasi tipo di dati. IL E nella dichiarazione rappresenta il parametro di tipo, che possiamo sostituire con qualsiasi nome di classe o interfaccia.

Gerarchia di classi

IL Lista immutabile la classe implementa il file Elenco interfaccia e rappresenta un elenco che non può essere modificato una volta creato.

La gerarchia di classi di Lista immutabile è come segue:

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

Qui, Collezione immutabile è una classe astratta che fornisce un'implementazione essenziale di Collezione immutabile interfaccia, che Lista immutabile si estende.

Nel complesso, il Lista immutabile fornisce un modo comodo ed efficiente per creare e utilizzare elenchi immutabili in Java.

Creazione di ImmutableList

Esistono diversi modi per creare un ImmutableList in Java, a seconda della versione di Java che stai utilizzando e delle librerie disponibili. Ecco alcuni esempi:

1. Utilizzando il metodo Java 9 of():

Java 9 ha introdotto un nuovo metodo chiamato of() nell'interfaccia List, che crea elenchi immutabili in modo più conciso e leggibile. Il metodo of() è un metodo factory che accetta un numero variabile di argomenti e restituisce un elenco immutabile contenente tali elementi. Può essere utilizzato con qualsiasi classe che implementa l'interfaccia List, inclusi ArrayList, LinkedList e ImmutableList. Un vantaggio dell'utilizzo del metodo of() è che è molto più conciso e fornisce sicurezza in fase di compilazione eseguendo l'inferenza del tipo sugli argomenti, garantendo che solo gli oggetti del tipo corretto vengano aggiunti all'elenco. Nel complesso, il metodo of() semplifica la creazione di elenchi immutabili in Java.

I passaggi per trovare la soluzione sono menzionati di seguito.

  1. Importa la classe List dal pacchetto Java.util: che consente al programma di utilizzare l'interfaccia List per creare e manipolare elenchi di oggetti.
  2. Crea un elenco immutabile utilizzando il metodo factory Java 9: ​​il codice utilizza il metodo List.of() per creare un elenco immutabile di stringhe con quattro elementi.
  3. Tentativo di modificare l'elenco: il programma tenta di aggiungere un elemento all'elenco immutabile utilizzando il metodo add(), che non è consentito sugli elenchi immutabili. Di conseguenza, il programma intercetta l'UnsupportedOperationException lanciata dal metodo add() e stampa un messaggio che indica che l'elenco non può essere modificato.

Nome del file: 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.'); } } }

Produzione: 

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

2. Utilizzando la classe ImmutableList.Builder dalla libreria Guava:

Aggiunta di elementi all'elenco in uno stile fluido, rendendolo conveniente per la creazione incrementale di un elenco.

Indipendentemente dal metodo utilizzato, è possibile accedere e scorrere l'ImmutableList risultante come qualsiasi altro elenco, ma il suo contenuto non può essere modificato.

Ecco la soluzione graduale per il codice indicato:

  1. Importa le classi richieste: importa l'interfaccia List e la classe ImmutableList dal pacchetto com.google.common.collect.
  2. Crea un elenco immutabile utilizzando il builder: crea un elenco immutabile utilizzando il builder ImmutableList. Utilizza il metodo add() per aggiungere elementi all'elenco e chiama il metodo build() per creare un elenco immutabile.
  3. Crea un elenco immutabile da un elenco esistente: crea un oggetto Elenco con gli elementi desiderati. Quindi chiama il metodo ImmutableList.copyOf(), passando List come parametro, per creare un elenco immutabile.
  4. Aggiunta di più elementi: utilizza il builder ImmutableList per aggiungere più elementi utilizzando il metodo addAll() e chiama il metodo build() per creare un elenco immutabile.
  5. Stampa gli elenchi: utilizza il metodo System.out.println() per stampare il contenuto degli elenchi immutabili.

Implementazione:

Nome del file: 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); } }

Produzione: 

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

3. Utilizzando il metodo of() della classe ImmutableList

Il metodo of() della classe ImmutableList nella libreria Guava consente di creare una lista immutabile con un numero fisso di elementi. Una volta creata la Lista non è possibile aggiungere, rimuovere o modificare i suoi elementi.

Nome del file: 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); } }

Produzione: 

 Fruits: [apple, banana, orange, grape]

4. Utilizzando il metodo copyOf()

In Java, il metodo copyOf() crea un nuovo array che copia un array esistente con una lunghezza specificata. Il metodo accetta due argomenti: l'array da copiare e la lunghezza del nuovo array.

Nome del file: ImmutableListExample.java

è una relazione 
 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); } }

Produzione: 

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

5. Eccezione operazione non supportata

Il programma illustra la creazione di un elenco immutabile in Java utilizzando il metodo Collections.unmodifyingList. Inoltre, mostra come gestire l'UnsupportedOperationException che viene generata quando si tenta di modificare List.

hashing nella struttura dei dati

I passaggi per trovare la soluzione sono menzionati di seguito:

  1. Per prima cosa creiamo un oggetto mutabile Lista di array contenente alcuni elementi iniziali utilizzando il file Di metodo, che restituisce un elenco immutabile. Quindi passiamo questo Lista di array al Collections.unmodifyingList metodo, che restituisce una visualizzazione immutabile dell'elenco.
  2. Tentiamo di modificare l'elenco immutabile utilizzando il file Aggiungi Rimuovi , E impostato Poiché l'elenco è immutabile, il tentativo di modificarlo genererà un errore Eccezione operazione non supportata .
  3. Prendiamo il Eccezione operazione non supportata che viene lanciato e stampa un messaggio sulla console indicando quale operazione è stata tentata e non ha avuto successo.

Si noti che il Collections.unmodifyingList Il metodo crea solo una visualizzazione immutabile dell'elenco originale. La vista immutabile rifletterà tali modifiche se l'elenco originale viene modificato. Per creare un elenco veramente immutabile che non può essere modificato in alcun modo, puoi utilizzare un'implementazione personalizzata di Elenco interfaccia che genera un'eccezione quando si tenta di modificare l'elenco.

Implementazione:

Nome del file: 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()); } } }

Produzione: 

 UnsupportedOperationException: null UnsupportedOperationException: null UnsupportedOperationException: null

6. Collections.unmodifyingList()

Collections.unmodifyingList() è un metodo nel Java Collections Framework che crea una vista immodificabile di un elenco esistente. Si può dedurre che il tentativo di modificare l'elenco non modificabile porterà al verificarsi di un'eccezione UnsupportedOperationException. L'Elenco originale può ancora essere modificato e qualsiasi modifica si rifletterà nell'Elenco non modificabile.

Il programma mostra come utilizzare il metodo Collections.unmodifyingList() per generare una rappresentazione immodificabile di un elenco mutabile.

I passaggi per trovare la soluzione sono menzionati di seguito:

  1. Crea un elenco modificabile mutableList e aggiungi alcuni elementi utilizzando il file aggiungere() metodo del Lista di array
  2. Crea una vista immodificabile dell'elenco modificabile mutableList usando il Lista immodificabile() metodo e assegnarlo alla variabile Lista immodificabile .
  3. Tentare di modificare l'elenco non modificabile Lista immodificabile usando il aggiungere() Poiché l'elenco non modificabile è di sola lettura, verrà generato un file Eccezione operazione non supportata . Viene stampato un messaggio sulla console dopo aver rilevato questa eccezione.
  4. Modifica l'elenco modificabile originale mutableList aggiungendo un altro elemento utilizzando il comando aggiungere()
  5. Stampa sia l'elenco mutabile che quello immodificabile sulla console per mostrare che l'elenco immodificabile riflette le modifiche apportate all'elenco mutabile originale.

Nome del file: EsempioListaImmodificabile.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] } }

Produzione: 

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

Vantaggi di ImmutableList

ImmutableList presenta diversi vantaggi, tra cui:

    Sicurezza del thread:Poiché ImmutableList è immutabile, è intrinsecamente thread-safe. Più thread possono accedere allo stesso elenco senza alcun rischio di interferenza tra thread o incoerenza della memoria.Sicurezza:Gli elenchi immutabili sono meno soggetti a vulnerabilità della sicurezza. Ad esempio, se un utente malintenzionato tenta di modificare l'elenco aggiungendo o rimuovendo elementi, non può farlo poiché l'elenco è immutabile.Prestazione:Poiché gli elenchi immutabili sono di sola lettura, possono essere memorizzati nella cache per prestazioni migliori. Se è necessario accedere a un elenco più volte, utilizzare un elenco immutabile invece di crearne uno nuovo ogni volta può aiutare a evitare spese generali.Prevedibilità:Poiché gli elenchi immutabili non possono essere modificati, il loro comportamento è prevedibile. Alcuni vantaggi derivanti dall'utilizzo di elenchi immutabili stanno eliminando la necessità di una programmazione difensiva e rendendo più semplice ragionare sul codice.Semplifica la codifica:Gli elenchi immutabili semplificano la codifica eliminando la necessità di sincronizzazione, copia difensiva e gestione manuale della memoria soggetta a errori. Il risultato di questo approccio è un codice più semplice da mantenere e con un aspetto più pulito.Facilita i test:Gli elenchi immutabili sono più facili da testare poiché il loro contenuto non cambia. L'approccio semplifica la scrittura di test che coprano tutti gli scenari possibili e i casi limite.