En Java, una lista inmutable es una lista que no se puede modificar una vez creada. Un intento de agregar, eliminar o modificar elementos en la Lista después de su creación generará una excepción.
El principal beneficio de utilizar listas inmutables es que proporcionan seguridad para los subprocesos y hacen que el código sea más sólido. Dado que la Lista no se puede modificar una vez creada, no hay riesgo de que varios subprocesos intenten modificarla simultáneamente y causen problemas. Además, las listas inmutables se pueden compartir fácilmente entre diferentes partes del programa sin temor a que se modifiquen involuntariamente.
En general, el uso de listas inmutables en Java puede mejorar la seguridad y la solidez de un programa, especialmente en entornos multiproceso donde las estructuras de datos compartidas pueden causar problemas.
bloquear anuncios de youtube android
Declaración de clase
En Java, el Lista inmutable La clase es parte del Guayaba biblioteca, que proporciona varias clases de colección inmutables. Usar Lista inmutable , primero importamos el com.google.common.collect el paquete que contiene el Lista inmutable clase.
La declaración de clase de Lista inmutable es como sigue:
public abstract class ImmutableList extends ImmutableCollection implements List
Lista inmutable extiende el Colección inmutable clase e implementa el Lista interfaz. Es una clase genérica, lo que significa que podemos crear una Lista inmutable de cualquier tipo de datos. El Y en la declaración representa el parámetro de tipo, que podemos reemplazar con cualquier nombre de clase o interfaz.
Jerarquía de clases
El Lista inmutable clase implementa el Lista interfaz y representa una lista que no se puede modificar una vez creada.
La jerarquía de clases de Lista inmutable es como sigue:
java.lang.Object com.google.common.collect.ImmutableCollection com.google.common.collect.ImmutableList
Aquí, Colección inmutable es una clase abstracta que proporciona una implementación esquelética del Colección inmutable interfaz, que Lista inmutable se extiende.
En general, el Lista inmutable La clase proporciona una manera conveniente y eficiente de crear y usar listas inmutables en Java.
Creando una lista inmutable
Hay diferentes formas de crear una ImmutableList en Java, según la versión de Java que esté utilizando y las bibliotecas que tenga disponibles. Aquí hay unos ejemplos:
1. Usando el método Java 9 de():
Java 9 introdujo un nuevo método llamado of() en la interfaz List, que crea listas inmutables de manera más concisa y legible. El método of() es un método de fábrica que toma un número variable de argumentos y devuelve una lista inmutable que contiene esos elementos. Se puede utilizar con cualquier clase que implemente la interfaz List, incluidas ArrayList, LinkedList e ImmutableList. Una ventaja de usar el método of() es que es mucho más conciso y proporciona seguridad en tiempo de compilación al realizar inferencia de tipos en los argumentos, asegurando que solo se agreguen a la Lista objetos del tipo correcto. En general, el método of() simplifica la creación de listas inmutables en Java.
Los pasos para encontrar la solución se mencionan a continuación.
si no en bash shell
- Importe la clase List del paquete Java.util: que permite al programa usar la interfaz List para crear y manipular listas de objetos.
- Cree una lista inmutable utilizando el método de fábrica de Java 9: el código utiliza el método List.of() para crear una lista inmutable de cadenas con cuatro elementos.
- Intentar modificar la lista: el programa intenta agregar un elemento a la lista inmutable utilizando el método add(), que no está permitido en listas inmutables. Como resultado, el programa detecta la excepción UnsupportedOperationException lanzada por el método add() e imprime un mensaje indicando que la lista no se puede modificar.
Nombre del archivo: 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.'); } } } Producción:
Fruits: [apple, banana, orange, grape] Cannot modify immutable List.
2. Usando la clase ImmutableList.Builder de la biblioteca Guava:
Agregar elementos a la Lista con un estilo fluido, lo que hace que sea conveniente para crear una lista de forma incremental.
Independientemente del método utilizado, se puede acceder a la ImmutableList resultante y se puede iterar como cualquier otra lista, pero su contenido no se puede modificar.
Aquí está la solución paso a paso para el código dado:
- Importe las clases requeridas: importe la interfaz List y la clase ImmutableList del paquete com.google.common.collect.
- Cree una lista inmutable usando el constructor: cree una lista inmutable usando el constructor ImmutableList. Utilice el método add() para agregar elementos a la Lista y llame al método build() para crear una lista inmutable.
- Cree una lista inmutable a partir de una lista existente: cree un objeto Lista con los elementos deseados. Luego llame al método ImmutableList.copyOf(), pasando la Lista como parámetro, para crear una lista inmutable.
- Agregar más elementos: use el constructor ImmutableList para agregar más elementos usando el método addAll() y llame al método build() para crear una lista inmutable.
- Imprima las listas: utilice el método System.out.println() para imprimir el contenido de las listas inmutables.
Implementación:
Nombre del archivo: 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); } } Producción:
Immutable List 1: [Welcome, to, home] Immutable List 2: [Welcome, to, home, Think] Immutable List 3: [Welcome, to, home, Think, Big]
3. Utilizando el método of() de la clase ImmutableList
El método of() de la clase ImmutableList en la biblioteca Guava le permite crear una lista inmutable con un número fijo de elementos. Una vez creada la Lista, no se pueden agregar, eliminar ni modificar sus elementos.
Nombre del archivo: 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); } } Producción:
Fruits: [apple, banana, orange, grape]
4. Mediante el uso del método copyOf()
En Java, el método copyOf() crea una nueva matriz que copia una matriz existente con una longitud especificada. El método toma dos argumentos: la matriz que se va a copiar y la longitud de la nueva matriz.
Nombre del archivo: ImmutableListExample.java
Ups conceptos en 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); } } Producción:
Immutable List 1: [Java, Python, C++] Immutable List 2: [Learning, Web, Development, is, Fun]
5. Excepción de operación no admitida
El programa ilustra la creación de una lista inmutable en Java utilizando el método Collections.unmodifiableList. Además, muestra cómo manejar la excepción UnsupportedOperationException que se genera al intentar modificar la lista.
Los pasos para encontrar la solución se mencionan a continuación:
- Primero, creamos un mutable. Lista de arreglo que contiene algunos elementos iniciales utilizando el de método, que devuelve una lista inmutable. Luego pasamos esto Lista de arreglo hacia Colecciones.lista no modificable método, que devuelve una vista inmutable de la Lista.
- Intentamos modificar la Lista inmutable usando el agregar eliminar , y colocar Dado que la Lista es inmutable, intentar modificarla arrojará un Excepción de operación no admitida .
- atrapamos el Excepción de operación no admitida que se lanza e imprime un mensaje en la consola indicando qué operación se intentó y no tuvo éxito.
Tenga en cuenta que el Colecciones.lista no modificable El método solo crea una vista inmutable de la Lista original. La vista inmutable reflejará esos cambios si se modifica la Lista original. Para crear una lista verdaderamente inmutable que no se puede modificar de ninguna manera, puede utilizar una implementación personalizada del Lista interfaz que arroja una excepción al intentar modificar la Lista.
unix vs ventanas
Implementación:
Nombre del archivo: 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()); } } } Producción:
UnsupportedOperationException: null UnsupportedOperationException: null UnsupportedOperationException: null
6. Colecciones.listainmodificable()
Colecciones.listainmodificable() es un método en Java Collections Framework que crea una vista no modificable de una lista existente. Se puede inferir que intentar modificar la Lista no modificable provocará una excepción UnsupportedOperationException. La Lista original aún se puede modificar y cualquier cambio se reflejará en la Lista no modificable.
El programa muestra cómo utilizar el método Collections.unmodifiableList() para generar una representación no modificable de una lista mutable.
Los pasos para encontrar la solución se mencionan a continuación:
- Crear una lista mutable lista mutable y agregarle algunos elementos usando el agregar() método de la Lista de arreglo
- Crear una vista no modificable de la lista mutable lista mutable utilizando el Lista no modificable() método y asignarlo a la variable Lista no modificable .
- Intentar modificar la lista no modificable Lista no modificable utilizando el agregar() Dado que la Lista no modificable es de sólo lectura, esto arrojará un Excepción de operación no admitida . Se imprime un mensaje en la consola después de detectar esta excepción.
- Modificar la lista mutable original lista mutable agregando otro elemento usando el agregar()
- Imprima las listas mutables y no modificables en la consola para mostrar que la Lista no modificable refleja los cambios realizados en la Lista mutable original.
Nombre del archivo: 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] } } Producción:
Attempt to modify unmodifiableList failed: null mutableList: [apple, banana, orange, pear] unmodifiableList: [apple, banana, orange, pear]
Ventajas de la lista inmutable
ImmutableList tiene varias ventajas, que incluyen: