In Java ist eine unveränderliche Liste eine Liste, die nach ihrer Erstellung nicht mehr geändert werden kann. Ein Versuch, Elemente in der Liste hinzuzufügen, zu entfernen oder zu ändern, nachdem sie erstellt wurde, löst eine Ausnahme aus.
Der Hauptvorteil der Verwendung unveränderlicher Listen besteht darin, dass sie Thread-Sicherheit bieten und den Code robuster machen. Da die Liste nach ihrer Erstellung nicht mehr geändert werden kann, besteht nicht die Gefahr, dass mehrere Threads versuchen, sie gleichzeitig zu ändern und Probleme verursachen. Darüber hinaus können unveränderliche Listen problemlos zwischen verschiedenen Programmteilen geteilt werden, ohne dass eine unbeabsichtigte Änderung befürchtet werden muss.
Insgesamt kann die Verwendung unveränderlicher Listen in Java die Sicherheit und Robustheit eines Programms verbessern, insbesondere in Multithread-Umgebungen, in denen gemeinsame Datenstrukturen Probleme verursachen können.
Klassenerklärung
In Java ist das Unveränderliche Liste Klasse ist ein Teil der Guave Bibliothek, die mehrere unveränderliche Sammlungsklassen bereitstellt. Benutzen Unveränderliche Liste , importieren wir zunächst die com.google.common.collect das Paket, das die enthält Unveränderliche Liste Klasse.
Die Klassendeklaration von Unveränderliche Liste ist wie folgt:
public abstract class ImmutableList extends ImmutableCollection implements List
Unveränderliche Liste erweitert die Unveränderliche Sammlung Klasse und implementiert die Aufführen Schnittstelle. Es handelt sich um eine generische Klasse, was bedeutet, dass wir eine erstellen können Unveränderliche Liste eines beliebigen Datentyps. Der UND in der Deklaration stellt den Typparameter dar, den wir durch einen beliebigen Klassen- oder Schnittstellennamen ersetzen können.
tostring-Methode Java
Klassenhierarchie
Der Unveränderliche Liste Klasse implementiert die Aufführen Schnittstelle und stellt eine Liste dar, die nach der Erstellung nicht mehr geändert werden kann.
Die Klassenhierarchie von Unveränderliche Liste ist wie folgt:
MySQL-Spaltentyp ändern
java.lang.Object com.google.common.collect.ImmutableCollection com.google.common.collect.ImmutableList
Hier, Unveränderliche Sammlung ist eine abstrakte Klasse, die eine Skelettimplementierung von bereitstellt Unveränderliche Sammlung Schnittstelle, die Unveränderliche Liste erweitert.
Insgesamt ist die Unveränderliche Liste Die Klasse bietet eine bequeme und effiziente Möglichkeit, unveränderliche Listen in Java zu erstellen und zu verwenden.
Erstellen einer unveränderlichen Liste
Es gibt verschiedene Möglichkeiten, eine ImmutableList in Java zu erstellen, abhängig von der von Ihnen verwendeten Java-Version und den verfügbaren Bibliotheken. Hier sind einige Beispiele:
1. Verwendung der Java 9 of()-Methode:
Mit Java 9 wurde eine neue Methode namens of() in der List-Schnittstelle eingeführt, die unveränderliche Listen präziser und lesbarer erstellt. Die of()-Methode ist eine Factory-Methode, die eine variable Anzahl von Argumenten entgegennimmt und eine unveränderliche Liste mit diesen Elementen zurückgibt. Es kann mit jeder Klasse verwendet werden, die die List-Schnittstelle implementiert, einschließlich ArrayList, LinkedList und ImmutableList. Ein Vorteil der Verwendung der of()-Methode besteht darin, dass sie viel prägnanter ist und Sicherheit zur Kompilierungszeit bietet, indem sie eine Typinferenz für die Argumente durchführt und so sicherstellt, dass nur Objekte des richtigen Typs zur Liste hinzugefügt werden. Insgesamt vereinfacht die of()-Methode die Erstellung unveränderlicher Listen in Java.
Die Schritte zum Finden der Lösung sind unten aufgeführt.
- Importieren Sie die List-Klasse aus dem Java.util-Paket: Dadurch kann das Programm die List-Schnittstelle zum Erstellen und Bearbeiten von Objektlisten verwenden.
- Erstellen Sie eine unveränderliche Liste mit der Java 9-Factory-Methode: Der Code verwendet die List.of()-Methode, um eine unveränderliche Liste von Zeichenfolgen mit vier Elementen zu erstellen.
- Versuch, die Liste zu ändern: Das Programm versucht, mithilfe der Methode add() ein Element zur unveränderlichen Liste hinzuzufügen, was bei unveränderlichen Listen nicht zulässig ist. Infolgedessen fängt das Programm die von der add()-Methode ausgelöste UnsupportedOperationException ab und gibt eine Meldung aus, die angibt, dass die Liste nicht geändert werden kann.
Dateiname: 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.'); } } } Ausgabe:
Fruits: [apple, banana, orange, grape] Cannot modify immutable List.
2. Verwendung der ImmutableList.Builder-Klasse aus der Guava-Bibliothek:
Fügen Sie der Liste Elemente in einem fließenden Stil hinzu, was das schrittweise Erstellen einer Liste erleichtert.
Unabhängig von der verwendeten Methode kann auf die resultierende ImmutableList wie auf jede andere Liste zugegriffen und sie iteriert werden, ihr Inhalt kann jedoch nicht geändert werden.
Hier ist die schrittweise Lösung für den angegebenen Code:
Cassidy Hutchinson Bildung
- Importieren Sie die erforderlichen Klassen: Importieren Sie die List-Schnittstelle und die ImmutableList-Klasse aus dem Paket com.google.common.collect.
- Erstellen Sie mit dem Builder eine unveränderliche Liste: Erstellen Sie mit dem Builder „ImmutableList“ eine unveränderliche Liste. Verwenden Sie die Methode add(), um Elemente zur Liste hinzuzufügen, und rufen Sie die Methode build() auf, um eine unveränderliche Liste zu erstellen.
- Erstellen Sie eine unveränderliche Liste aus einer vorhandenen Liste: Erstellen Sie ein Listenobjekt mit den gewünschten Elementen. Rufen Sie dann die Methode ImmutableList.copyOf() auf und übergeben Sie die Liste als Parameter, um eine unveränderliche Liste zu erstellen.
- Weitere Elemente hinzufügen: Verwenden Sie den ImmutableList-Builder, um mithilfe der Methode addAll() weitere Elemente hinzuzufügen, und rufen Sie die Methode build() auf, um eine unveränderliche Liste zu erstellen.
- Drucken Sie die Listen: Verwenden Sie die Methode System.out.println(), um den Inhalt der unveränderlichen Listen zu drucken.
Implementierung:
Dateiname: 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); } } Ausgabe:
Immutable List 1: [Welcome, to, home] Immutable List 2: [Welcome, to, home, Think] Immutable List 3: [Welcome, to, home, Think, Big]
3. Durch Verwendung der of()-Methode der ImmutableList-Klasse
Mit der Methode of() der Klasse ImmutableList in der Guava-Bibliothek können Sie eine unveränderliche Liste mit einer festen Anzahl von Elementen erstellen. Sobald die Liste erstellt wurde, können Sie ihre Elemente nicht mehr hinzufügen, entfernen oder ändern.
Dateiname: ImmutableListExample.java
Java-Auswahlsortierung
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); } } Ausgabe:
Fruits: [apple, banana, orange, grape]
4. Durch Verwendung der Methode copyOf()
In Java erstellt die Methode copyOf() ein neues Array, das ein vorhandenes Array mit einer angegebenen Länge kopiert. Die Methode benötigt zwei Argumente: das zu kopierende Array und die Länge des neuen Arrays.
Dateiname: 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); } } Ausgabe:
Immutable List 1: [Java, Python, C++] Immutable List 2: [Learning, Web, Development, is, Fun]
5. UnsupportedOperationException
Das Programm veranschaulicht das Erstellen einer unveränderlichen Liste in Java mithilfe der Methode Collections.unmodifiableList. Darüber hinaus wird gezeigt, wie mit der UnsupportedOperationException umgegangen wird, die beim Versuch, die Liste zu ändern, ausgelöst wird.
Die Schritte zum Finden der Lösung sind unten aufgeführt:
- Zuerst erstellen wir ein Veränderliches Anordnungsliste enthält einige Anfangselemente mit dem von Methode, die eine unveränderliche Liste zurückgibt. Das geben wir dann weiter Anordnungsliste zum Collections.unmodifiableList Methode, die eine unveränderliche Ansicht der Liste zurückgibt.
- Wir versuchen, die unveränderliche Liste mithilfe von zu ändern hinzufügen, entfernen , Und Satz Da die Liste unveränderlich ist, wird beim Versuch, sie zu ändern, eine Fehlermeldung ausgegeben UnsupportedOperationException .
- Wir fangen das UnsupportedOperationException Das wird ausgelöst und gibt eine Meldung an die Konsole aus, die angibt, welcher Vorgang versucht wurde und nicht erfolgreich war.
Notiere dass der Collections.unmodifiableList Die Methode erstellt lediglich eine unveränderliche Ansicht der ursprünglichen Liste. Die unveränderliche Ansicht spiegelt diese Änderungen wider, wenn die ursprüngliche Liste geändert wird. Um eine wirklich unveränderliche Liste zu erstellen, die auf keinen Fall geändert werden kann, können Sie eine benutzerdefinierte Implementierung von verwenden Aufführen Schnittstelle, die eine Ausnahme auslöst, wenn versucht wird, die Liste zu ändern.
Implementierung:
Dateiname: 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()); } } } Ausgabe:
UnsupportedOperationException: null UnsupportedOperationException: null UnsupportedOperationException: null
6. Collections.unmodifiableList()
Collections.unmodifiableList() ist eine Methode im Java Collections Framework, die eine nicht änderbare Ansicht einer vorhandenen Liste erstellt. Daraus kann geschlossen werden, dass der Versuch, die nicht veränderbare Liste zu ändern, zum Auftreten einer UnsupportedOperationException führt. Die ursprüngliche Liste kann weiterhin geändert werden, und alle Änderungen werden in der nicht änderbaren Liste widergespiegelt.
Das Programm zeigt, wie die Methode Collections.unmodifiableList() verwendet wird, um eine nicht veränderbare Darstellung einer veränderbaren Liste zu generieren.
Git Pull Origin Master
Die Schritte zum Finden der Lösung sind unten aufgeführt:
- Erstellen Sie eine veränderbare Liste veränderliche Liste und fügen Sie einige Elemente hinzu, indem Sie die verwenden hinzufügen() Methode der Anordnungsliste
- Erstellen Sie eine nicht veränderbare Ansicht der veränderbaren Liste veränderliche Liste Verwendung der unmodifizierbareListe() Methode und weisen Sie sie der Variablen zu unmodifizierbare Liste .
- Versuchen Sie, die nicht veränderbare Liste zu ändern unmodifizierbare Liste Verwendung der hinzufügen() Da die nicht veränderbare Liste schreibgeschützt ist, wird dadurch ein Fehler ausgelöst UnsupportedOperationException . Nach dem Abfangen dieser Ausnahme wird eine Meldung an die Konsole ausgegeben.
- Ändern Sie die ursprüngliche veränderbare Liste veränderliche Liste durch Hinzufügen eines weiteren Elements mithilfe der hinzufügen()
- Geben Sie sowohl die veränderbare als auch die nicht veränderbare Liste auf der Konsole aus, um zu zeigen, dass die nicht veränderbare Liste die an der ursprünglichen veränderbaren Liste vorgenommenen Änderungen widerspiegelt.
Dateiname: 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] } } Ausgabe:
Attempt to modify unmodifiableList failed: null mutableList: [apple, banana, orange, pear] unmodifiableList: [apple, banana, orange, pear]
Vorteile von ImmutableList
ImmutableList bietet mehrere Vorteile, darunter: