I Java er en uforanderlig liste en liste, der ikke kan ændres, når den først er oprettet. Et forsøg på at tilføje, fjerne eller ændre elementer i listen, efter at den er oprettet, vil give en undtagelse.
Den primære fordel ved at bruge uforanderlige lister er, at de giver trådsikkerhed og gør koden mere robust. Da listen ikke kan ændres, efter den er oprettet, er der ingen risiko for, at flere tråde forsøger at ændre den samtidigt og forårsager problemer. Derudover kan uforanderlige lister nemt deles mellem forskellige programdele uden frygt for at blive ændret utilsigtet.
Samlet set kan brug af uforanderlige lister i Java forbedre sikkerheden og robustheden af et program, især i multi-threaded miljøer, hvor delte datastrukturer kan forårsage problemer.
Klasseerklæring
I Java er Uforanderlig liste klasse er en del af Guava bibliotek, som tilbyder flere uforanderlige samlingsklasser. At bruge Uforanderlig liste , importerer vi først com.google.common.collect pakken, der indeholder Uforanderlig liste klasse.
Klasseerklæringen af Uforanderlig liste er som følgende:
public abstract class ImmutableList extends ImmutableCollection implements List
Uforanderlig liste udvider Immutable Collection klasse og implementerer Liste interface. Det er en generisk klasse, hvilket betyder, at vi kan skabe en Uforanderlig liste af enhver datatype. Det OG i deklarationen repræsenterer typeparameteren, som vi kan erstatte med et hvilket som helst klasse- eller interfacenavn.
localdatetime java
Klassehierarki
Det Uforanderlig liste klasse implementerer Liste interface og repræsenterer en liste, der ikke kan ændres, når den først er oprettet.
Klassehierarkiet af Uforanderlig liste er som følgende:
java.lang.Object com.google.common.collect.ImmutableCollection com.google.common.collect.ImmutableList
Her, Immutable Collection er en abstrakt klasse, der giver en skeletimplementering af Immutable Collection grænseflade, som Uforanderlig liste strækker sig.
Samlet set Uforanderlig liste klasse giver en praktisk og effektiv måde at oprette og bruge uforanderlige lister i Java.
Oprettelse af ImmutableList
Der er forskellige måder at oprette en ImmutableList på i Java, afhængigt af hvilken version af Java du bruger og de biblioteker du har til rådighed. Her er nogle eksempler:
1. Brug af Java 9 of() metoden:
Java 9 introducerede en ny metode kaldet of() i List-grænsefladen, som skaber uforanderlige lister mere kortfattet og læsbart. of()-metoden er en fabriksmetode, der tager et variabelt antal argumenter og returnerer en uforanderlig liste, der indeholder disse elementer. Det kan bruges med enhver klasse, der implementerer List-grænsefladen, inklusive ArrayList, LinkedList og ImmutableList. En fordel ved at bruge metoden of() er, at den er meget mere kortfattet og giver sikkerhed ved kompilering ved at udføre typeslutning på argumenterne, hvilket sikrer, at kun objekter af den korrekte type føjes til listen. Overordnet set forenkler of()-metoden oprettelsen af uforanderlige lister i Java.
Trinene til at finde løsningen er nævnt nedenfor.
- Importer List-klassen fra Java.util-pakken: Hvilket tillader programmet at bruge List-grænsefladen til at oprette og manipulere lister over objekter.
- Opret en uforanderlig liste ved hjælp af Java 9 fabriksmetoden: Koden bruger List.of() metoden til at oprette en uforanderlig liste over strenge med fire elementer.
- Forsøg på at ændre listen: Programmet forsøger at tilføje et element til den uforanderlige liste ved hjælp af add() metoden, som ikke er tilladt på uforanderlige lister. Som et resultat heraf fanger programmet UnsupportedOperationException, der er smidt af add()-metoden og udskriver en meddelelse, der angiver, at listen ikke kan ændres.
Filnavn: 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. Brug af klassen ImmutableList.Builder fra Guava-biblioteket:
Tilføjelse af elementer til listen i en flydende stil, hvilket gør det praktisk at trinvist oprette en liste.
Uanset den anvendte metode, kan den resulterende ImmutableList tilgås og gentages som enhver anden liste, men dens indhold kan ikke ændres.
java konverter char til int
Her er den trinvise løsning for den givne kode:
- Importer de påkrævede klasser: Importer List-grænsefladen og ImmutableList-klassen fra pakken com.google.common.collect.
- Opret en uforanderlig liste ved hjælp af builder: Opret en uforanderlig liste ved hjælp af ImmutableList builder. Brug add()-metoden til at tilføje elementer til listen, og kald build()-metoden for at oprette en uforanderlig liste.
- Opret en uforanderlig liste fra en eksisterende liste: Opret et Listeobjekt med de ønskede elementer. Kald derefter metoden ImmutableList.copyOf() ved at sende Listen som en parameter for at oprette en uforanderlig liste.
- Tilføjelse af flere elementer: Brug ImmutableList-builderen til at tilføje flere elementer ved hjælp af addAll()-metoden, og kald build()-metoden for at oprette en uforanderlig liste.
- Udskriv listerne: Brug metoden System.out.println() til at udskrive indholdet af de uforanderlige lister.
Implementering:
Filnavn: ImmutableListExample.java
array i java-metoder
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. Ved at bruge of() metoden i klassen ImmutableList
Of()-metoden i klassen ImmutableList i Guava-biblioteket giver dig mulighed for at oprette en uforanderlig liste med et fast antal elementer. Når først listen er oprettet, kan du ikke tilføje, fjerne eller ændre dens elementer.
Filnavn: 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. Ved brug af copyOf() metoden
I Java opretter metoden copyOf() et nyt array, der kopierer et eksisterende array med en specificeret længde. Metoden tager to argumenter: det array, der skal kopieres, og længden af det nye array.
Filnavn: 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. Ikke-understøttet OperationException
Programmet illustrerer oprettelse af en uforanderlig liste i Java ved hjælp af Collections.unmodifiableList-metoden. Derudover viser den, hvordan man håndterer UnsupportedOperationException, der kastes, når man forsøger at ændre listen.
Trinene til at finde løsningen er nævnt nedenfor:
- Først skaber vi en foranderlig ArrayList indeholdende nogle indledende elementer ved hjælp af af metode, som returnerer en uforanderlig liste. Så passerer vi dette ArrayList til Collections.unmodifiableList metode, som returnerer en uforanderlig visning af listen.
- Vi forsøger at ændre den uforanderlige liste ved hjælp af tilføje, fjerne , og sæt Da listen er uforanderlig, vil et forsøg på at ændre den kaste en Ikke understøttet OperationException .
- Vi fanger Ikke understøttet OperationException der kastes og udskrive en besked til konsollen, der angiver, hvilken handling der blev forsøgt og mislykkedes.
Bemærk, at Collections.unmodifiableList metoden skaber kun en uforanderlig visning af den originale liste. Den uforanderlige visning vil afspejle disse ændringer, hvis den oprindelige liste ændres. For at skabe en virkelig uforanderlig liste, der ikke kan ændres på nogen måde, kan du bruge en tilpasset implementering af Liste grænseflade, der kaster en undtagelse, når du forsøger at ændre listen.
nøgle til bærbar indsættelse
Implementering:
Filnavn: 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() er en metode i Java Collections Framework, der skaber en ikke-modificerbar visning af en eksisterende liste. Det kan udledes, at forsøg på at ændre den ikke-modificerbare liste vil føre til forekomsten af en UnsupportedOperationException. Den originale liste kan stadig ændres, og eventuelle ændringer vil blive afspejlet i den ikke-modificerbare liste.
Programmet viser, hvordan man bruger metoden Collections.unmodifiableList() til at generere en ikke-modificerbar repræsentation af en foranderlig liste.
Trinene til at finde løsningen er nævnt nedenfor:
- Opret en foranderlig liste mutableList og tilføje nogle elementer til det ved hjælp af tilføje() metoden til ArrayList
- Opret en ikke-modificerbar visning af den foranderlige liste mutableList bruger unmodificableList() metode og tildele den til variablen unmodificable List .
- Forsøg på at ændre den ikke-modificerbare liste unmodificable List bruger tilføje() Da den ikke-modificerbare liste er skrivebeskyttet, vil dette kaste en Ikke understøttet OperationException . En meddelelse udskrives til konsollen efter at have fanget denne undtagelse.
- Ændre den originale foranderlige liste mutableList ved at tilføje et andet element ved hjælp af tilføje()
- Udskriv både de mutable og de ikke-modificerbare lister til konsollen for at vise, at den ikke-modificerbare liste afspejler de ændringer, der er foretaget på den originale mutable List.
Filnavn: 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]
Fordele ved ImmutableList
ImmutableList har flere fordele, herunder: