W Javie lista niezmienna to lista, której po utworzeniu nie można modyfikować. Próba dodania, usunięcia lub zmodyfikowania elementów na liście po jej utworzeniu spowoduje zgłoszenie wyjątku.
Podstawową zaletą używania list niezmiennych jest to, że zapewniają one bezpieczeństwo wątków i sprawiają, że kod jest bardziej niezawodny. Ponieważ listy nie można modyfikować po jej utworzeniu, nie ma ryzyka, że wiele wątków będzie próbowało ją zmodyfikować jednocześnie i spowodować problemy. Ponadto niezmienne listy można łatwo udostępniać różnym częściom programu bez obawy, że zostaną przypadkowo zmodyfikowane.
Ogólnie rzecz biorąc, używanie niemutowalnych list w Javie może poprawić bezpieczeństwo i niezawodność programu, szczególnie w środowiskach wielowątkowych, gdzie współdzielone struktury danych mogą powodować problemy.
Deklaracja klasy
W Javie tzw Niezmienna lista klasa jest częścią Gujawa biblioteka, która udostępnia kilka niezmiennych klas kolekcji. Używać Niezmienna lista , najpierw importujemy plik com.google.common.collect pakiet zawierający Niezmienna lista klasa.
Deklaracja klasy Niezmienna lista następująco:
public abstract class ImmutableList extends ImmutableCollection implements List
Niezmienna lista rozciąga Kolekcja niezmienna klasę i implementuje Lista interfejs. Jest to klasa ogólna, co oznacza, że możemy utworzyć Niezmienna lista dowolnego typu danych. The I w deklaracji reprezentuje parametr typu, który możemy zastąpić dowolną nazwą klasy lub interfejsu.
ciąg porównawczy
Hierarchia klas
The Niezmienna lista klasa implementuje Lista interfejs i reprezentuje listę, której po utworzeniu nie można modyfikować.
Hierarchia klas Niezmienna lista następująco:
java.lang.Object com.google.common.collect.ImmutableCollection com.google.common.collect.ImmutableList
Tutaj, Kolekcja niezmienna jest klasą abstrakcyjną, która zapewnia szkieletową implementację klasy Kolekcja niezmienna interfejs, który Niezmienna lista rozciąga się.
Ogólnie rzecz biorąc, Niezmienna lista class zapewnia wygodny i skuteczny sposób tworzenia i używania niezmiennych list w Javie.
Tworzenie listy niezmiennej
Istnieją różne sposoby tworzenia listy ImmutableList w Javie, w zależności od używanej wersji Java i dostępnych bibliotek. Oto kilka przykładów:
1. Używając metody Java 9 of():
W Javie 9 wprowadzono nową metodę o nazwie of() w interfejsie List, która tworzy niezmienne listy w bardziej zwięzły i czytelny sposób. Metoda of() jest metodą fabryczną, która pobiera zmienną liczbę argumentów i zwraca niezmienną listę zawierającą te elementy. Można go używać z dowolną klasą implementującą interfejs List, w tym ArrayList, LinkedList i ImmutableList. Jedną z zalet stosowania metody of() jest to, że jest ona znacznie bardziej zwięzła i zapewnia bezpieczeństwo w czasie kompilacji, przeprowadzając wnioskowanie o typie na argumentach, zapewniając, że do listy dodawane będą tylko obiekty prawidłowego typu. Ogólnie rzecz biorąc, metoda of() upraszcza tworzenie niezmiennych list w Javie.
Poniżej opisano kroki prowadzące do znalezienia rozwiązania.
- Zaimportuj klasę List z pakietu Java.util: co pozwala programowi używać interfejsu List do tworzenia list obiektów i manipulowania nimi.
- Utwórz niezmienną listę, korzystając z metody fabrycznej Java 9: W kodzie zastosowano metodę List.of(), aby utworzyć niezmienną listę ciągów znaków zawierającą cztery elementy.
- Próba modyfikacji listy: Program próbuje dodać element do niezmiennej listy przy użyciu metody add(), co jest niedozwolone w przypadku list niezmiennych. W rezultacie program przechwytuje wyjątek UnsupportedOperationException zgłoszony przez metodę add() i wypisuje komunikat informujący, że listy nie można modyfikować.
Nazwa pliku: 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.'); } } } Wyjście:
Fruits: [apple, banana, orange, grape] Cannot modify immutable List.
2. Korzystając z klasy ImmutableList.Builder z biblioteki Guava:
Dodawanie elementów do listy w płynnym stylu, co ułatwia stopniowe tworzenie listy.
Niezależnie od użytej metody, do wynikowej listy ImmutableList można uzyskać dostęp i ją iterować jak każdą inną listę, ale jej zawartości nie można modyfikować.
Oto krokowe rozwiązanie dla danego kodu:
- Zaimportuj wymagane klasy: Zaimportuj interfejs List i klasę ImmutableList z pakietu com.google.common.collect.
- Utwórz niezmienną listę za pomocą konstruktora: Utwórz niezmienną listę za pomocą konstruktora ImmutableList. Użyj metody add(), aby dodać elementy do listy i wywołaj metodę build(), aby utworzyć niezmienną listę.
- Utwórz niezmienną listę z istniejącej listy: Utwórz obiekt List z żądanymi elementami. Następnie wywołaj metodę ImmutableList.copyOf(), przekazując List jako parametr, aby utworzyć niezmienną listę.
- Dodawanie kolejnych elementów: Użyj konstruktora ImmutableList, aby dodać więcej elementów za pomocą metody addAll() i wywołaj metodę build() w celu utworzenia niezmiennej listy.
- Wydrukuj listy: Użyj metody System.out.println(), aby wydrukować zawartość niezmiennych list.
Realizacja:
Nazwa pliku: 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); } } Wyjście:
Immutable List 1: [Welcome, to, home] Immutable List 2: [Welcome, to, home, Think] Immutable List 3: [Welcome, to, home, Think, Big]
3. Korzystając z metody of() klasy ImmutableList
Metoda of() klasy ImmutableList w bibliotece Guava umożliwia utworzenie niezmiennej listy ze stałą liczbą elementów. Po utworzeniu Listy nie można dodawać, usuwać ani modyfikować jej elementów.
Nazwa pliku: 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); } } Wyjście:
Fruits: [apple, banana, orange, grape]
4. Przy pomocy metody copyOf().
W Javie metoda copyOf() tworzy nową tablicę, która kopiuje istniejącą tablicę o określonej długości. Metoda przyjmuje dwa argumenty: tablicę, która ma zostać skopiowana oraz długość nowej tablicy.
Nazwa pliku: 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); } } Wyjście:
Immutable List 1: [Java, Python, C++] Immutable List 2: [Learning, Web, Development, is, Fun]
5. Wyjątek UnsupportedOperationException
Program ilustruje tworzenie niezmiennej listy w Javie przy użyciu metody Collections.unmodifyingList. Ponadto pokazano, jak obsługiwać wyjątek UnsupportedOperationException zgłaszany podczas próby zmodyfikowania listy.
Poniżej opisano kroki prowadzące do znalezienia rozwiązania:
- Najpierw tworzymy plik mutable Lista tablic zawierający pewne elementy początkowe przy użyciu metody z metoda, która zwraca niezmienną listę. Następnie przekazujemy to Lista tablic do Kolekcje.niemodyfikowalna lista metoda, która zwraca niezmienny widok listy.
- Próbujemy zmodyfikować niezmienną listę za pomocą Dodaj usuń , I ustawić Ponieważ lista jest niezmienna, próba jej modyfikacji spowoduje wyrzucenie komunikatu Nieobsługiwany wyjątek operacji .
- Łapiemy Nieobsługiwany wyjątek operacji który jest generowany i wyświetla komunikat na konsoli wskazujący, która operacja została podjęta i zakończyła się niepowodzeniem.
Należy pamiętać, że Kolekcje.niemodyfikowalna lista Metoda tworzy jedynie niezmienny widok oryginalnej listy. Niezmienny widok będzie odzwierciedlał te zmiany, jeśli oryginalna lista zostanie zmodyfikowana. Aby utworzyć naprawdę niezmienną listę, której nie można w żaden sposób modyfikować, możesz użyć niestandardowej implementacji metody Lista interfejs, który zgłasza wyjątek podczas próby modyfikacji listy.
Realizacja:
Nazwa pliku: 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()); } } } Wyjście:
UnsupportedOperationException: null UnsupportedOperationException: null UnsupportedOperationException: null
6. Kolekcje.niemodyfikowalnaList()
Kolekcje.niemodyfikowalnaList() to metoda w Java Collections Framework, która tworzy niemodyfikowalny widok istniejącej listy. Można wywnioskować, że próba modyfikacji niemodyfikowalnej listy doprowadzi do wystąpienia wyjątku UnsupportedOperationException. Oryginalną Listę można nadal modyfikować, a wszelkie zmiany zostaną odzwierciedlone na niemodyfikowalnej Liście.
Program pokazuje, jak wykorzystać metodę Collections.unmodibleList() do wygenerowania niemodyfikowalnej reprezentacji modyfikowalnej listy.
Poniżej opisano kroki prowadzące do znalezienia rozwiązania:
- Utwórz listę zmienną lista zmienna i dodaj do niego kilka elementów za pomocą dodać() metoda Lista tablic
- Utwórz niemodyfikowalny widok modyfikowalnej listy lista mutable używając niemodyfikowalna lista() metodę i przypisz ją do zmiennej niemodyfikowalna lista .
- Spróbuj zmodyfikować listę, której nie można modyfikować niemodyfikowalna lista używając dodać() Ponieważ niemodyfikowalna lista jest tylko do odczytu, spowoduje to wyrzucenie Nieobsługiwany wyjątek operacji . Po przechwyceniu tego wyjątku na konsoli jest drukowany komunikat.
- Zmodyfikuj oryginalną listę modyfikowalną lista mutable dodając kolejny element za pomocą metody dodać()
- Wydrukuj w konsoli zarówno listę modyfikowalną, jak i niemodyfikowalną, aby pokazać, że lista niemodyfikowalna odzwierciedla zmiany wprowadzone w oryginalnej liście modyfikowalnej.
Nazwa pliku: NiemodyfikowalnaListaPrzykład.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] } } Wyjście:
Attempt to modify unmodifiableList failed: null mutableList: [apple, banana, orange, pear] unmodifiableList: [apple, banana, orange, pear]
Zalety ImmutableList
ImmutableList ma kilka zalet, w tym: