In Java is een onveranderlijke lijst een lijst die niet meer kan worden gewijzigd nadat deze is gemaakt. Een poging om elementen in de lijst toe te voegen, te verwijderen of te wijzigen nadat deze is gemaakt, zal een uitzondering opleveren.
Het belangrijkste voordeel van het gebruik van onveranderlijke lijsten is dat ze threadveiligheid bieden en de code robuuster maken. Omdat de lijst niet kan worden gewijzigd nadat deze is gemaakt, bestaat er geen risico dat meerdere threads deze tegelijkertijd proberen te wijzigen en problemen veroorzaken. Bovendien kunnen onveranderlijke lijsten eenvoudig worden gedeeld tussen verschillende programmaonderdelen, zonder bang te hoeven zijn dat ze onbedoeld worden gewijzigd.
Over het algemeen kan het gebruik van onveranderlijke lijsten in Java de veiligheid en robuustheid van een programma verbeteren, vooral in omgevingen met meerdere threads waar gedeelde datastructuren problemen kunnen veroorzaken.
Klasseverklaring
Op Java is de OnveranderlijkeLijst klasse maakt deel uit van de Guave bibliotheek, die verschillende onveranderlijke verzamelklassen biedt. Gebruiken OnveranderlijkeLijst , importeren we eerst de com.google.common.collect het pakket met de OnveranderlijkeLijst klas.
De klasseverklaring van OnveranderlijkeLijst is als volgt:
public abstract class ImmutableList extends ImmutableCollection implements List
OnveranderlijkeLijst verlengt de Onveranderlijke verzameling klasse en implementeert de Lijst koppel. Het is een generieke klasse, wat betekent dat we een OnveranderlijkeLijst van welk gegevenstype dan ook. De EN in de declaratie vertegenwoordigt de parameter type, die we kunnen vervangen door elke klasse- of interfacenaam.
Klassenhiërarchie
De OnveranderlijkeLijst klasse implementeert de Lijst interface en vertegenwoordigt een lijst die niet meer kan worden gewijzigd nadat deze is gemaakt.
Java niet
De klassenhiërarchie van OnveranderlijkeLijst is als volgt:
java.lang.Object com.google.common.collect.ImmutableCollection com.google.common.collect.ImmutableList
Hier, Onveranderlijke verzameling is een abstracte klasse die een skeletimplementatie biedt van de Onveranderlijke verzameling interface, welke OnveranderlijkeLijst strekt zich uit.
Over het geheel genomen de OnveranderlijkeLijst class biedt een handige en efficiënte manier om onveranderlijke lijsten in Java te maken en te gebruiken.
Onveranderlijke lijst maken
Er zijn verschillende manieren om een ImmutableList in Java te maken, afhankelijk van de versie van Java die u gebruikt en de bibliotheken die u beschikbaar heeft. Hier zijn enkele voorbeelden:
1. Met behulp van de Java 9 of()-methode:
Java 9 introduceerde een nieuwe methode genaamd of() in de List-interface, die onveranderlijke lijsten beknopter en leesbaarder maakt. De of() methode is een fabrieksmethode die een variabel aantal argumenten gebruikt en een onveranderlijke lijst retourneert die deze elementen bevat. Het kan worden gebruikt met elke klasse die de List-interface implementeert, inclusief ArrayList, LinkedList en ImmutableList. Een voordeel van het gebruik van de of()-methode is dat deze veel beknopter is en veiligheid tijdens het compileren biedt door type-inferentie op de argumenten uit te voeren, zodat alleen objecten van het juiste type aan de lijst worden toegevoegd. Over het geheel genomen vereenvoudigt de of() -methode het maken van onveranderlijke lijsten in Java.
Hieronder vindt u de stappen om de oplossing te vinden.
- Importeer de klasse List uit het Java.util-pakket: waarmee het programma de List-interface kan gebruiken om lijsten met objecten te maken en te manipuleren.
- Maak een onveranderlijke lijst met behulp van de Java 9-fabrieksmethode: De code gebruikt de List.of()-methode om een onveranderlijke lijst met tekenreeksen met vier elementen te maken.
- Poging om de lijst te wijzigen: het programma probeert een element aan de onveranderlijke lijst toe te voegen met behulp van de add() -methode, wat niet is toegestaan op onveranderlijke lijsten. Als resultaat vangt het programma de UnsupportedOperationException op die door de add()-methode wordt gegenereerd en drukt een bericht af dat aangeeft dat de lijst niet kan worden gewijzigd.
Bestandsnaam: 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.'); } } } Uitgang:
Fruits: [apple, banana, orange, grape] Cannot modify immutable List.
2. Gebruik de klasse ImmutableList.Builder uit de Guava-bibliotheek:
Elementen aan de lijst toevoegen in een vloeiende stijl, waardoor het handig wordt om stapsgewijs een lijst te maken.
Ongeacht de gebruikte methode kan de resulterende ImmutableList worden benaderd en herhaald zoals elke andere lijst, maar de inhoud ervan kan niet worden gewijzigd.
Hier is de stapsgewijze oplossing voor de gegeven code:
- Importeer de vereiste klassen: Importeer de List-interface en de ImmutableList-klasse uit het com.google.common.collect-pakket.
- Maak een onveranderlijke lijst met behulp van de builder: Maak een onveranderlijke lijst met behulp van de ImmutableList-builder. Gebruik de methode add() om elementen aan de lijst toe te voegen en roep de methode build() aan om een onveranderlijke lijst te maken.
- Maak een onveranderlijke lijst van een bestaande lijst: Maak een Lijstobject met de gewenste elementen. Roep vervolgens de methode ImmutableList.copyOf() aan, waarbij u de List als parameter doorgeeft, om een onveranderlijke lijst te maken.
- Meer elementen toevoegen: gebruik de ImmutableList-builder om meer elementen toe te voegen met behulp van de addAll()-methode, en roep de build()-methode aan om een onveranderlijke lijst te maken.
- Druk de lijsten af: Gebruik de System.out.println() methode om de inhoud van de onveranderlijke lijsten af te drukken.
Implementatie:
Bestandsnaam: 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); } } Uitgang:
Immutable List 1: [Welcome, to, home] Immutable List 2: [Welcome, to, home, Think] Immutable List 3: [Welcome, to, home, Think, Big]
3. Door de methode of() van de klasse ImmutableList te gebruiken
Met de methode of() van de klasse ImmutableList in de Guava-bibliotheek kunt u een onveranderlijke lijst maken met een vast aantal elementen. Zodra de lijst is gemaakt, kunt u de elementen ervan niet meer toevoegen, verwijderen of wijzigen.
Bestandsnaam: 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); } } Uitgang:
Fruits: [apple, banana, orange, grape]
4. Door gebruik te maken van de copyOf()-methode
In Java maakt de methode copyOf() een nieuwe array die een bestaande array met een opgegeven lengte kopieert. De methode heeft twee argumenten nodig: de array die moet worden gekopieerd en de lengte van de nieuwe array.
Bestandsnaam: 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); } } Uitgang:
Immutable List 1: [Java, Python, C++] Immutable List 2: [Learning, Web, Development, is, Fun]
5. Niet-ondersteundeOperationException
Het programma illustreert het maken van een onveranderlijke lijst in Java met behulp van de Collections.unmodifiableList-methode. Bovendien laat het zien hoe u omgaat met de UnsupportedOperationException die wordt gegenereerd wanneer u probeert de lijst te wijzigen.
De stappen om de oplossing te vinden worden hieronder vermeld:
- Eerst creëren we een veranderlijk ArrayLijst met enkele initiële elementen met behulp van de van methode, die een onveranderlijke lijst retourneert. Wij passeren dit dan ArrayLijst naar de Collections.unmodifiableList methode, die een onveranderlijke weergave van de lijst retourneert.
- We proberen de onveranderlijke lijst te wijzigen met behulp van de toevoegen verwijderen , En set Omdat de lijst onveranderlijk is, zal een poging om deze te wijzigen een Niet-ondersteundeOperationException .
- Wij vangen de Niet-ondersteundeOperationException dat wordt gegenereerd en een bericht naar de console afdrukt waarin wordt aangegeven welke bewerking is geprobeerd en niet is gelukt.
Merk op dat de Collections.unmodifiableList methode creëert alleen een onveranderlijke weergave van de originele lijst. De onveranderlijke weergave weerspiegelt deze wijzigingen als de oorspronkelijke lijst wordt gewijzigd. Om een werkelijk onveranderlijke lijst te maken die op geen enkele manier kan worden gewijzigd, kunt u een aangepaste implementatie van de Lijst interface die een uitzondering genereert bij een poging om de lijst te wijzigen.
Implementatie:
Bestandsnaam: 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()); } } } Uitgang:
UnsupportedOperationException: null UnsupportedOperationException: null UnsupportedOperationException: null
6. Collecties.unmodifiableList()
Collecties.unmodifiableList() is een methode in het Java Collections Framework die een niet-wijzigbare weergave van een bestaande lijst creëert. Hieruit kan worden afgeleid dat pogingen om de niet-wijzigbare lijst te wijzigen zullen leiden tot het optreden van een UnsupportedOperationException. De oorspronkelijke lijst kan nog steeds worden gewijzigd en eventuele wijzigingen worden weergegeven in de niet-aanpasbare lijst.
Het programma laat zien hoe u de Collections.unmodifiableList()-methode kunt gebruiken om een niet-wijzigbare representatie van een veranderlijke lijst te genereren.
De stappen om de oplossing te vinden worden hieronder vermeld:
- Maak een veranderlijke lijst veranderlijkeLijst en voeg er enkele elementen aan toe met behulp van de toevoegen() werkwijze van de ArrayLijst
- Maak een niet-wijzigbare weergave van de veranderlijke lijst veranderlijkeLijst de ... gebruiken niet-aanpasbareLijst() methode en wijs deze toe aan de variabele niet-aanpasbareLijst .
- Probeer de niet-wijzigbare lijst te wijzigen niet-aanpasbareLijst de ... gebruiken toevoegen() Omdat de niet-aanpasbare lijst alleen-lezen is, zal dit een Niet-ondersteundeOperationException . Er wordt een bericht naar de console afgedrukt nadat deze uitzondering is opgemerkt.
- Wijzig de oorspronkelijke veranderlijke lijst veranderlijkeLijst door een ander element toe te voegen met behulp van de toevoegen()
- Druk zowel de veranderbare als de niet-wijzigbare lijsten af naar de console om aan te tonen dat de niet-wijzigbare lijst de wijzigingen weergeeft die zijn aangebracht in de oorspronkelijke veranderbare lijst.
Bestandsnaam: 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] } } Uitgang:
Attempt to modify unmodifiableList failed: null mutableList: [apple, banana, orange, pear] unmodifiableList: [apple, banana, orange, pear]
Voordelen van ImmutableList
ImmutableList heeft verschillende voordelen, waaronder: