I Java er en uforanderlig liste en liste som ikke kan endres når den først er opprettet. Et forsøk på å legge til, fjerne eller endre elementer i listen etter at den er opprettet, vil gi et unntak.
Den primære fordelen med å bruke uforanderlige lister er at de gir trådsikkerhet og gjør koden mer robust. Siden listen ikke kan endres etter at den er opprettet, er det ingen risiko for at flere tråder prøver å endre den samtidig og forårsaker problemer. I tillegg kan uforanderlige lister enkelt deles mellom ulike programdeler uten frykt for å bli utilsiktet modifisert.
Totalt sett kan bruk av uforanderlige lister i Java forbedre sikkerheten og robustheten til et program, spesielt i flertrådede miljøer der delte datastrukturer kan forårsake problemer.
Klasseerklæring
I Java er Uforanderlig liste klasse er en del av Guava bibliotek, som tilbyr flere uforanderlige samlingsklasser. Å bruke Uforanderlig liste , importerer vi først com.google.common.collect pakken som inneholder Uforanderlig liste klasse.
Klasseerklæringen til Uforanderlig liste er som følgende:
public abstract class ImmutableList extends ImmutableCollection implements List
Uforanderlig liste utvider ImmutableCollection klasse og implementerer Liste grensesnitt. Det er en generisk klasse, som betyr at vi kan lage en Uforanderlig liste av enhver datatype. De OG i deklarasjonen representerer typeparameteren, som vi kan erstatte med et hvilket som helst klasse- eller grensesnittnavn.
localdatetime java
Klassehierarki
De Uforanderlig liste klasse implementerer Liste grensesnitt og representerer en liste som ikke kan endres når den først er opprettet.
Klassehierarkiet til Uforanderlig liste er som følgende:
java.lang.Object com.google.common.collect.ImmutableCollection com.google.common.collect.ImmutableList
Her, ImmutableCollection er en abstrakt klasse som gir en skjelettmessig implementering av ImmutableCollection grensesnitt, som Uforanderlig liste strekker.
Samlet sett Uforanderlig liste klasse gir en praktisk og effektiv måte å lage og bruke uforanderlige lister i Java.
Oppretter ImmutableList
Det er forskjellige måter å lage en ImmutableList i Java, avhengig av hvilken versjon av Java du bruker og bibliotekene du har tilgjengelig. Her er noen eksempler:
1. Ved å bruke Java 9 of()-metoden:
Java 9 introduserte en ny metode kalt of() i List-grensesnittet, som lager uforanderlige lister mer konsist og lesbart. Of()-metoden er en fabrikkmetode som tar et variabelt antall argumenter og returnerer en uforanderlig liste som inneholder disse elementene. Den kan brukes med enhver klasse som implementerer List-grensesnittet, inkludert ArrayList, LinkedList og ImmutableList. En fordel med å bruke of()-metoden er at den er mye mer kortfattet og gir kompileringssikkerhet ved å utføre typeslutning på argumentene, og sikre at bare objekter av riktig type legges til listen. Totalt sett forenkler of()-metoden opprettelsen av uforanderlige lister i Java.
Fremgangsmåten for å finne løsningen er nevnt nedenfor.
- Importer List-klassen fra Java.util-pakken: Som lar programmet bruke List-grensesnittet til å lage og manipulere lister over objekter.
- Lag en uforanderlig liste ved å bruke Java 9-fabrikkmetoden: Koden bruker List.of()-metoden for å lage en uforanderlig liste over strenger med fire elementer.
- Forsøk på å endre listen: Programmet prøver å legge til et element til den uforanderlige listen ved å bruke add()-metoden, som ikke er tillatt på uforanderlige lister. Som et resultat fanger programmet UnsupportedOperationException kastet av add()-metoden og skriver ut en melding som indikerer at listen ikke kan endres.
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.'); } } } Produksjon:
Fruits: [apple, banana, orange, grape] Cannot modify immutable List.
2. Bruke ImmutableList.Builder-klassen fra Guava-biblioteket:
Legge til elementer i listen i en flytende stil, noe som gjør det praktisk å lage en liste trinnvis.
Uavhengig av metoden som brukes, kan den resulterende ImmutableList nås og itereres over som enhver annen liste, men innholdet kan ikke endres.
java array skive
Her er den trinnvise løsningen for den gitte koden:
- Importer de nødvendige klassene: Importer List-grensesnittet og ImmutableList-klassen fra com.google.common.collect-pakken.
- Opprett en uforanderlig liste ved hjelp av byggeren: Opprett en uforanderlig liste ved hjelp av ImmutableList-byggeren. Bruk add()-metoden for å legge til elementer i listen, og kall build()-metoden for å lage en uforanderlig liste.
- Opprett en uforanderlig liste fra en eksisterende liste: Lag et Listeobjekt med de ønskede elementene. Deretter kaller du ImmutableList.copyOf()-metoden, og sender Listen som en parameter, for å lage en uforanderlig liste.
- Legge til flere elementer: Bruk ImmutableList-byggeren til å legge til flere elementer ved å bruke addAll()-metoden, og kall build()-metoden for å lage en uforanderlig liste.
- Skriv ut listene: Bruk System.out.println()-metoden for å skrive ut innholdet i de uforanderlige listene.
Gjennomføring:
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); } } Produksjon:
Immutable List 1: [Welcome, to, home] Immutable List 2: [Welcome, to, home, Think] Immutable List 3: [Welcome, to, home, Think, Big]
3. Ved å bruke of()-metoden i klassen ImmutableList
Of()-metoden til ImmutableList-klassen i Guava-biblioteket lar deg lage en uforanderlig liste med et fast antall elementer. Når listen er opprettet, kan du ikke legge til, fjerne eller endre 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); } } Produksjon:
Fruits: [apple, banana, orange, grape]
4. Ved bruk av copyOf()-metoden
I Java oppretter copyOf()-metoden en ny matrise som kopierer en eksisterende matrise med en spesifisert lengde. Metoden tar to argumenter: matrisen som skal kopieres og lengden på den nye matrisen.
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); } } Produksjon:
Immutable List 1: [Java, Python, C++] Immutable List 2: [Learning, Web, Development, is, Fun]
5. UnsupportedOperationException
Programmet illustrerer å lage en uforanderlig liste i Java ved å bruke Collections.unmodifiableList-metoden. I tillegg viser den hvordan du håndterer UnsupportedOperationException som blir kastet når du prøver å endre listen.
Trinnene for å finne løsningen er nevnt nedenfor:
- Først lager vi en foranderlig ArrayList som inneholder noen innledende elementer ved å bruke av metode, som returnerer en uforanderlig liste. Da passerer vi dette ArrayList til Collections.unmodifiableList metode, som returnerer en uforanderlig visning av listen.
- Vi prøver å endre den uforanderlige listen ved å bruke Legg til fjern , og sett Siden listen er uforanderlig, vil forsøk på å endre den kaste en UnsupportedOperationException .
- Vi fanger UnsupportedOperationException som kastes og skrive ut en melding til konsollen som indikerer hvilken operasjon som ble forsøkt og mislyktes.
Merk at Collections.unmodifiableList metoden oppretter bare en uforanderlig visning av den originale listen. Den uforanderlige visningen vil reflektere disse endringene hvis den opprinnelige listen endres. For å lage en virkelig uforanderlig liste som ikke kan endres på noen måte, kan du bruke en tilpasset implementering av Liste grensesnitt som gir et unntak når du forsøker å endre listen.
linux-filer
Gjennomføring:
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()); } } } Produksjon:
UnsupportedOperationException: null UnsupportedOperationException: null UnsupportedOperationException: null
6. Collections.unmodifiableList()
Collections.unmodifiableList() er en metode i Java Collections Framework som lager en ikke-modifiserbar visning av en eksisterende liste. Det kan utledes at forsøk på å endre den ikke-modifiserbare listen vil føre til at det oppstår et UnsupportedOperationException. Den opprinnelige listen kan fortsatt endres, og eventuelle endringer vil reflekteres i den ikke-modifiserbare listen.
Programmet viser hvordan du kan bruke metoden Collections.unmodifiableList() for å generere en ikke-modifiserbar representasjon av en mutbar liste.
Trinnene for å finne løsningen er nevnt nedenfor:
- Lag en foranderlig liste mutableList og legg til noen elementer ved å bruke Legg til() metoden for ArrayList
- Lag en uforanderlig visning av den mutbare listen mutableList bruker unmodifiableList() metoden og tilordne den til variabelen unmodifiable List .
- Forsøk å endre den ikke-modifiserbare listen unmodifiableList bruker Legg til() Siden den ikke-modifiserbare listen er skrivebeskyttet, vil dette kaste en UnsupportedOperationException . En melding skrives ut til konsollen etter å ha fanget dette unntaket.
- Endre den opprinnelige mutable listen mutableList ved å legge til et annet element ved å bruke Legg til()
- Skriv ut både de mutbare og de ikke-modifiserbare listene til konsollen for å vise at den ikke-modifiserbare listen gjenspeiler endringene som er gjort i den originale mutable listen.
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] } } Produksjon:
Attempt to modify unmodifiableList failed: null mutableList: [apple, banana, orange, pear] unmodifiableList: [apple, banana, orange, pear]
Fordeler med ImmutableList
ImmutableList har flere fordeler, inkludert: