I Java är en oföränderlig lista en lista som inte kan ändras när den väl har skapats. Ett försök att lägga till, ta bort eller ändra element i listan efter att den har skapats ger ett undantag.
Den främsta fördelen med att använda oföränderliga listor är att de ger trådsäkerhet och gör koden mer robust. Eftersom listan inte kan ändras efter att den har skapats, finns det ingen risk för att flera trådar försöker ändra den samtidigt och orsakar problem. Dessutom kan oföränderliga listor enkelt delas mellan olika programdelar utan rädsla för att oavsiktligt ändras.
Sammantaget kan användning av oföränderliga listor i Java förbättra säkerheten och robustheten för ett program, särskilt i flertrådiga miljöer där delade datastrukturer kan orsaka problem.
Klassdeklaration
I Java är ImmutableList klass är en del av Guava bibliotek, som tillhandahåller flera oföränderliga samlingsklasser. Att använda ImmutableList , importerar vi först com.google.common.collect paketet som innehåller ImmutableList klass.
Klassdeklarationen av ImmutableList enligt följande:
public abstract class ImmutableList extends ImmutableCollection implements List
ImmutableList förlänger ImmutableCollection klass och implementerar Lista gränssnitt. Det är en generisk klass, vilket betyder att vi kan skapa en ImmutableList av vilken datatyp som helst. De OCH i deklarationen representerar typparametern, som vi kan ersätta med vilket klass- eller gränssnittsnamn som helst.
Klasshierarki
De ImmutableList klass implementerar Lista gränssnitt och representerar en lista som inte kan ändras när den väl har skapats.
Klasshierarkin av ImmutableList enligt följande:
java.lang.Object com.google.common.collect.ImmutableCollection com.google.common.collect.ImmutableList
Här, ImmutableCollection är en abstrakt klass som ger en skelettimplementering av ImmutableCollection gränssnitt, vilket ImmutableList sträcker sig.
Sammantaget ImmutableList klass ger ett bekvämt och effektivt sätt att skapa och använda oföränderliga listor i Java.
Skapar ImmutableList
Det finns olika sätt att skapa en ImmutableList i Java, beroende på vilken version av Java du använder och vilka bibliotek du har tillgängliga. Här är några exempel:
1. Med Java 9 of()-metoden:
Java 9 introducerade en ny metod som heter of() i List-gränssnittet, som skapar oföränderliga listor mer kortfattat och läsbart. Metoden of() är en fabriksmetod som tar ett variabelt antal argument och returnerar en oföränderlig lista som innehåller dessa element. Den kan användas med vilken klass som helst som implementerar List-gränssnittet, inklusive ArrayList, LinkedList och ImmutableList. En fördel med att använda metoden of() är att den är mycket mer kortfattad och ger säkerhet vid kompilering genom att utföra typslutledning på argumenten, vilket säkerställer att endast objekt av rätt typ läggs till i listan. Sammantaget förenklar metoden of() skapandet av oföränderliga listor i Java.
Stegen för att hitta lösningen nämns nedan.
- Importera List-klassen från Java.util-paketet: Vilket gör att programmet kan använda List-gränssnittet för att skapa och manipulera listor med objekt.
- Skapa en oföränderlig lista med Java 9 fabriksmetoden: Koden använder metoden List.of() för att skapa en oföränderlig lista med strängar med fyra element.
- Försök att modifiera listan: Programmet försöker lägga till ett element till den oföränderliga listan med metoden add(), vilket inte är tillåtet på oföränderliga listor. Som ett resultat fångar programmet UnsupportedOperationException som kastas av metoden add() och skriver ut ett meddelande som indikerar att listan inte kan ändras.
Filnamn: 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.'); } } } Produktion:
Fruits: [apple, banana, orange, grape] Cannot modify immutable List.
2. Använda klassen ImmutableList.Builder från Guava-biblioteket:
Lägga till element i listan i en flytande stil, vilket gör det bekvämt att stegvis skapa en lista.
Oavsett vilken metod som används kan den resulterande ImmutableList nås och itereras som vilken annan lista som helst, men dess innehåll kan inte ändras.
java int till sträng
Här är den stegvisa lösningen för den givna koden:
- Importera de obligatoriska klasserna: Importera List-gränssnittet och klassen ImmutableList från paketet com.google.common.collect.
- Skapa en oföränderlig lista med hjälp av builder: Skapa en oföränderlig lista med ImmutableList-byggaren. Använd metoden add() för att lägga till element i listan, och anrop metoden build() för att skapa en oföränderlig lista.
- Skapa en oföränderlig lista från en befintlig lista: Skapa ett Listobjekt med de önskade elementen. Anropa sedan metoden ImmutableList.copyOf() och skicka listan som en parameter för att skapa en oföränderlig lista.
- Lägga till fler element: Använd ImmutableList-byggaren för att lägga till fler element med metoden addAll() och anrop build()-metoden för att skapa en oföränderlig lista.
- Skriv ut listorna: Använd metoden System.out.println() för att skriva ut innehållet i de oföränderliga listorna.
Genomförande:
Filnamn: 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); } } Produktion:
Immutable List 1: [Welcome, to, home] Immutable List 2: [Welcome, to, home, Think] Immutable List 3: [Welcome, to, home, Think, Big]
3. Genom att använda metoden of() i klassen ImmutableList
Metoden of() för klassen ImmutableList i Guava-biblioteket låter dig skapa en oföränderlig lista med ett fast antal element. När listan väl har skapats kan du inte lägga till, ta bort eller ändra dess element.
Filnamn: 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); } } Produktion:
Fruits: [apple, banana, orange, grape]
4. Genom att använda metoden copyOf().
I Java skapar metoden copyOf() en ny array som kopierar en befintlig array med en angiven längd. Metoden tar två argument: arrayen som ska kopieras och längden på den nya arrayen.
Filnamn: 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); } } Produktion:
Immutable List 1: [Java, Python, C++] Immutable List 2: [Learning, Web, Development, is, Fun]
5. UnsupportedOperationException
Programmet illustrerar att skapa en oföränderlig lista i Java med metoden Collections.unmodifiableList. Dessutom visar den hur man hanterar UnsupportedOperationException som kastas när man försöker ändra listan.
Stegen för att hitta lösningen nämns nedan:
- Först skapar vi en föränderlig ArrayList som innehåller några initiala element med hjälp av av metod, som returnerar en oföränderlig lista. Vi passerar sedan detta ArrayList till Collections.unmodifiableList metod, som returnerar en oföränderlig vy av listan.
- Vi försöker modifiera den oföränderliga listan med hjälp av Lägg till ta bort , och uppsättning Eftersom listan är oföränderlig kommer ett försök att modifiera den att kasta en UnsupportedOperationException .
- Vi fångar UnsupportedOperationException som slängs och skriv ut ett meddelande till konsolen som anger vilken operation som försökte utföras och som misslyckades.
Observera att Collections.unmodifiableList metoden skapar bara en oföränderlig vy av den ursprungliga listan. Den oföränderliga vyn kommer att återspegla dessa ändringar om den ursprungliga listan ändras. För att skapa en verkligt oföränderlig lista som inte kan ändras på något sätt, kan du använda en anpassad implementering av Lista gränssnitt som ger ett undantag när man försöker ändra listan.
Genomförande:
Filnamn: 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()); } } } Produktion:
UnsupportedOperationException: null UnsupportedOperationException: null UnsupportedOperationException: null
6. Collections.unmodifiableList()
Collections.unmodifiableList() är en metod i Java Collections Framework som skapar en omodifierbar vy av en befintlig lista. Man kan dra slutsatsen att försök att modifiera den oförändrade listan kommer att leda till att ett UnsupportedOperationException inträffar. Den ursprungliga listan kan fortfarande ändras och alla ändringar kommer att återspeglas i den oförändrbara listan.
Programmet visar hur man använder metoden Collections.unmodifiableList() för att generera en oföränderlig representation av en föränderlig lista.
Stegen för att hitta lösningen nämns nedan:
fjädermoduler
- Skapa en föränderlig lista mutableList och lägg till några element till den med hjälp av Lägg till() metod för ArrayList
- Skapa en oföränderlig vy av den föränderliga listan mutableList använda unmodifiableList() metod och tilldela den till variabeln oförändrad lista .
- Försök att ändra den oförändrade listan oförändrad lista använda Lägg till() Eftersom den omodifierbara listan är skrivskyddad kommer detta att kasta en UnsupportedOperationException . Ett meddelande skrivs ut till konsolen efter att detta undantag har upptäckts.
- Ändra den ursprungliga föränderliga listan mutableList genom att lägga till ett annat element med hjälp av Lägg till()
- Skriv ut både de föränderliga och oföränderliga listan till konsolen för att visa att den oföränderliga listan återspeglar ändringarna som gjorts i den ursprungliga föränderliga listan.
Filnamn: 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] } } Produktion:
Attempt to modify unmodifiableList failed: null mutableList: [apple, banana, orange, pear] unmodifiableList: [apple, banana, orange, pear]
Fördelar med ImmutableList
ImmutableList har flera fördelar, inklusive: