A Java nyelvben a megváltoztathatatlan lista olyan lista, amely létrehozása után nem módosítható. Ha a lista létrehozása után megpróbál elemeket hozzáadni, eltávolítani vagy módosítani, az kivételt eredményez.

A megváltoztathatatlan listák használatának elsődleges előnye, hogy szálbiztonságot nyújtanak, és robusztusabbá teszik a kódot. Mivel a lista létrehozása után nem módosítható, nem áll fenn annak a veszélye, hogy több szál próbálja meg egyszerre módosítani, és problémákat okozzon. Ezenkívül a megváltoztathatatlan listák könnyen megoszthatók a különböző programrészek között anélkül, hogy félnének attól, hogy véletlenül módosíthatók.

Összességében a változtathatatlan listák használata Javaban javíthatja a programok biztonságát és robusztusságát, különösen többszálú környezetekben, ahol a megosztott adatstruktúrák problémákat okozhatnak.

Osztálynyilatkozat

Java nyelven a ImmutableList osztály része a Gujávafa könyvtár, amely több változatlan gyűjtőosztályt biztosít. Használni ImmutableList , először importáljuk a com.google.common.collect a csomagot tartalmazza ImmutableList osztály.

java karakterlánc formátum

Az osztály deklarációja ImmutableList az alábbiak:

 public abstract class ImmutableList extends ImmutableCollection implements List 

ImmutableList kiterjeszti a ImmutableCollection osztályt és megvalósítja a Lista felület. Ez egy általános osztály, ami azt jelenti, hogy létrehozhatunk egy ImmutableList bármilyen adattípusból. A ÉS a deklarációban a type paramétert jelöli, amit tetszőleges osztály- vagy interfésznévvel helyettesíthetünk.

Osztályhierarchia

A ImmutableList osztály valósítja meg a Lista felületet, és egy olyan listát jelent, amely létrehozása után nem módosítható.

Az osztály hierarchiája ImmutableList az alábbiak:

 java.lang.Object com.google.common.collect.ImmutableCollection com.google.common.collect.ImmutableList 

Itt, ImmutableCollection egy absztrakt osztály, amely a ImmutableCollection interfész, amely ImmutableList kiterjed.

Összességében a ImmutableList osztály kényelmes és hatékony módot biztosít megváltoztathatatlan listák létrehozására és használatára Java nyelven.

ImmutableList létrehozása

Az ImmutableList Java nyelven többféleképpen hozható létre, a használt Java verziótól és a rendelkezésre álló könyvtáraktól függően. Íme néhány példa:

1. A Java 9 of() metódus használata:

A Java 9 egy új of() metódust vezetett be a List felületen, amely tömörebben és olvashatóbban hoz létre változatlan listákat. Az of() metódus egy gyári metódus, amely változó számú argumentumot vesz fel, és az ezeket az elemeket tartalmazó változatlan listát ad vissza. Használható minden olyan osztállyal, amely megvalósítja a List interfészt, beleértve az ArrayList-t, a LinkedList-et és az ImmutableList-t. Az of() metódus használatának egyik előnye, hogy sokkal tömörebb, és fordítási idejű biztonságot nyújt azáltal, hogy típuskövetkeztetést hajt végre az argumentumokon, biztosítva, hogy csak a megfelelő típusú objektumok kerüljenek a Listába. Összességében az of() metódus leegyszerűsíti a megváltoztathatatlan listák létrehozását Java-ban.

A megoldás megtalálásának lépései az alábbiakban találhatók.

1. Importálja a List osztályt a Java.util csomagból: Ez lehetővé teszi a program számára, hogy a Lista felületet használja objektumlisták létrehozására és kezelésére.
2. Hozzon létre egy megváltoztathatatlan listát a Java 9 gyári metódusával: A kód a List.of() metódus használatával hozzon létre egy négy elemű karakterláncok megváltoztathatatlan listáját.
3. Kísérlet a lista módosítására: A program az add() metódussal megpróbál egy elemet hozzáadni a megváltoztathatatlan listához, ami nem megengedett a megváltoztathatatlan listákon. Ennek eredményeként a program elkapja az add() metódus által dobott UnsupportedOperationException-t, és kiír egy üzenetet, amely jelzi, hogy a lista nem módosítható.

Fájl név: ImmutableListExample.java

c program kétdimenziós tömbhöz

 // 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.'); } } } 

Kimenet:

véletlen szám 1 és 10 között

 Fruits: [apple, banana, orange, grape] Cannot modify immutable List. 

2. A Guava könyvtár ImmutableList.Builder osztályának használata:

Elemek hozzáadása a listához gördülékeny stílusban, így kényelmessé válik a lista fokozatos létrehozása.

A használt módszertől függetlenül az eredményül kapott ImmutableList elérhető és ismételhető, mint bármely más lista, de a tartalma nem módosítható.

Íme a lépésenkénti megoldás az adott kódhoz:

1. A szükséges osztályok importálása: Importálja a List felületet és az ImmutableList osztályt a com.google.common.collect csomagból.
2. Hozzon létre egy megváltoztathatatlan listát az építő segítségével: Hozzon létre egy megváltoztathatatlan listát az ImmutableList építő segítségével. Használja az add() metódust elemek hozzáadásához a listához, és hívja meg a build() metódust egy megváltoztathatatlan lista létrehozásához.
3. Létrehozhatatlan lista létrehozása egy meglévő listából: Hozzon létre egy Lista objektumot a kívánt elemekkel. Ezután hívja meg az ImmutableList.copyOf() metódust, paraméterként átadva a listát, hogy létrehozzon egy megváltoztathatatlan listát.
4. További elemek hozzáadása: Használja az ImmutableList építőt további elemek hozzáadásához az addAll() metódus használatával, és hívja meg a build() metódust egy megváltoztathatatlan lista létrehozásához.
5. Listák kinyomtatása: Használja a System.out.println() metódust a megváltoztathatatlan listák tartalmának kinyomtatásához.

Végrehajtás:

Fájl név: 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); } } 

Kimenet:

 Immutable List 1: [Welcome, to, home] Immutable List 2: [Welcome, to, home, Think] Immutable List 3: [Welcome, to, home, Think, Big] 

3. Az ImmutableList osztály of() metódusával

A Guava könyvtár ImmutableList osztályának of() metódusa lehetővé teszi egy megváltoztathatatlan lista létrehozását rögzített számú elemmel. A lista létrehozása után nem adhatja hozzá, nem távolíthatja el vagy módosíthatja az elemeit.

Fájl név: ImmutableListExample.java

java parse string to int

 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); } } 

Kimenet:

 Fruits: [apple, banana, orange, grape] 

4. A copyOf() metódus használatával

Java-ban a copyOf() metódus létrehoz egy új tömböt, amely meghatározott hosszúságú meglévő tömböt másol. A metódus két argumentumot használ: a másolandó tömböt és az új tömb hosszát.

Fájl név: 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); } } 

Kimenet:

 Immutable List 1: [Java, Python, C++] Immutable List 2: [Learning, Web, Development, is, Fun] 

5. UnsupportedOperationException

A program szemlélteti egy megváltoztathatatlan lista létrehozását Java nyelven a Collections.unmodifiableList metódussal. Ezenkívül bemutatja, hogyan kell kezelni a lista módosításakor megjelenő UnsupportedOperationException kivételt.

A megoldás megtalálásának lépései az alábbiak:

1. Először létrehozunk egy változót Tömb lista amely néhány kezdeti elemet tartalmaz a nak,-nek metódus, amely egy megváltoztathatatlan listát ad vissza. Akkor ezt átadjuk Tömb lista hoz Collections.unmodifiableList metódus, amely a Lista megváltoztathatatlan nézetét adja vissza.
2. Megkíséreljük módosítani a megváltoztathatatlan listát a Hozzáad eltávolít , és készlet Mivel a Lista változtathatatlan, a módosítási kísérlet egy UnsupportedOperationException .
3. Elkapjuk a UnsupportedOperationException ki kell dobni, és nyomtasson ki egy üzenetet a konzolra, jelezve, hogy melyik műveletet kísérelték meg és az sikertelen volt.

Vegye figyelembe, hogy a Collections.unmodifiableList módszer csak az eredeti lista megváltoztathatatlan nézetét hozza létre. A megváltoztathatatlan nézet tükrözi ezeket a változtatásokat, ha az eredeti listát módosítják. Egy igazán megváltoztathatatlan lista létrehozásához, amely semmilyen módon nem módosítható, használhatja a Lista interfész, amely kivételt dob, amikor megpróbálja módosítani a listát.

Végrehajtás:

Fájl név: ImmutableListExample.java

rend térkép

 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()); } } } 

Kimenet:

 UnsupportedOperationException: null UnsupportedOperationException: null UnsupportedOperationException: null 

6. Collections.unmodifiableList()

Collections.unmodifiableList() egy olyan módszer a Java Collections Frameworkben, amely egy meglévő lista módosíthatatlan nézetét hozza létre. Arra lehet következtetni, hogy a nem módosítható lista módosításának kísérlete UnsupportedOperationException előfordulásához vezet. Az eredeti lista továbbra is módosítható, és a változtatások a nem módosítható listán is megjelennek.

A program bemutatja, hogyan használható a Collections.unmodifiableList() metódus a módosítható lista nem módosítható reprezentációjának előállítására.

A megoldás megtalálásának lépései az alábbiak:

1. Hozzon létre egy változtatható listát mutableList és adjunk hozzá néhány elemet a segítségével add() módszere a Tömb lista
2. Hozzon létre egy nem módosítható nézetet a módosítható listáról mutableList használni a unmodifiableList() módszert, és rendelje hozzá a változóhoz módosíthatatlan lista .
3. Próbálja meg módosítani a nem módosítható listát módosíthatatlan lista használni a add() Mivel a nem módosítható lista csak olvasható, ez egy an UnsupportedOperationException . A kivétel észlelése után a rendszer egy üzenetet nyomtat a konzolra.
4. Módosítsa az eredeti módosítható listát mutableList egy másik elem hozzáadásával a add()
5. Nyomtassa ki mind a módosítható, mind a nem módosítható listákat a konzolra, hogy megmutassa, a nem módosítható lista tükrözi az eredeti módosítható listán végrehajtott módosításokat.

Fájl név: 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] } } 

Kimenet:

 Attempt to modify unmodifiableList failed: null mutableList: [apple, banana, orange, pear] unmodifiableList: [apple, banana, orange, pear] 

Az ImmutableList előnyei

Az ImmutableList számos előnnyel rendelkezik, többek között:

Menetbiztonság:Mivel az ImmutableList megváltoztathatatlan, eleve szálbiztos. Több szál is hozzáférhet ugyanahhoz a listához a szálak interferenciájának vagy a memória inkonzisztenciájának kockázata nélkül.Biztonság:A megváltoztathatatlan listák kevésbé hajlamosak a biztonsági résekre. Például, ha egy támadó megpróbálja módosítani a listát elemek hozzáadásával vagy eltávolításával, ezt nem tudja megtenni, mivel a lista megváltoztathatatlan.Teljesítmény:Mivel a megváltoztathatatlan listák csak olvashatók, a jobb teljesítmény érdekében gyorsítótárazhatók. Ha egy listát többször is el kell érni, akkor a minden alkalommal új lista létrehozása helyett megváltoztathatatlan listát használva elkerülheti a többletköltséget.Előreláthatóság:Mivel a megváltoztathatatlan listák nem módosíthatók, viselkedésük kiszámítható. A megváltoztathatatlan listák használatának néhány előnye, hogy kiküszöböli a védekező programozás szükségességét, és megkönnyíti a kóddal kapcsolatos érvelést.Leegyszerűsíti a kódolást:A változtathatatlan listák leegyszerűsítik a kódolást azáltal, hogy szükségtelenné válik a szinkronizálás, a védekező másolás és a hibákra hajlamos kézi memóriakezelés. Ennek a megközelítésnek az eredménye a könnyebben karbantartható és tisztább megjelenésű kód.Megkönnyíti a tesztelést:A megváltoztathatatlan listákat könnyebb tesztelni, mivel tartalmuk nem változik. A megközelítés megkönnyíti az összes lehetséges forgatókönyvet és szélső esetet lefedő tesztek írását.