¿Cómo crear una lista inmutable en Java?

5 minutos de lectura

Necesito convertir el objeto de la lista mutable en una lista inmutable. ¿Cuál es la forma posible en Java?

public void action() {
    List<MutableClass> mutableList = Arrays.asList(new MutableClass("san", "UK", 21), new MutableClass("peter", "US", 34));
    List<MutableClass> immutableList = immutateList(mutableList);
}

public List<MutableClass> immutateList(List<MutableClass> mutableList){
    //some code here to make this beanList immutable
    //ie. objects and size of beanList should not be change.
    //ie. we cant add new object here.
    //ie. we cant remove or change existing one.
}

MutableClass

final class MutableClass {
    final String name;    
    final String address;
    final int age;
    MutableClass(String name, String address, int age) {
        this.name = name;
        this.address = address;
        this.age = age;
    }
}

  • Lo que tiene allí no es inmutable, porque puede llamar muy fácilmente al método .add(Object o). Cree una subclase de ArrayList, anule los métodos .add(..) y haga que tenga una implementación vacía o que lance una excepción no verificada. Y haga que esa clase sea final, para que no pueda subclasificarla y cambiar la implementación.

    – Stultuske

    20 de mayo de 2015 a las 11:28

  • Podría envolver la lista en otro objeto y solo implementar la interfaz Iterable

    –Kenneth Clark

    20 de mayo de 2015 a las 11:29

  • Respuesta a su pregunta: stackoverflow.com/questions/10750791/…

    – Gary SEBASTIANI

    20 mayo 2015 a las 11:30


  • @dubey-theHarcourtians, debe ver la respuesta completa de este enlace, que le da la respuesta 3 líneas debajo

    – Gary SEBASTIANI

    20 mayo 2015 a las 11:36

  • Estoy seguro de que esta pregunta ha sido respondida antes, pero no es un duplicado de stackoverflow.com/questions/10750791/…

    – Físico loco

    20 mayo 2015 a las 18:18

avatar de usuario
aiobe

Una vez que su beanList ha sido inicializado, usted puede hacer

beanList = Collections.unmodifiableList(beanList);

para hacerlo inmodificable. (Ver colección Inmutable vs No modificable)

Si tiene métodos internos que deberían poder modificar la lista y métodos públicos que no deberían permitir la modificación, le sugiero que lo haga.

// public facing method where clients should not be able to modify list    
public List<Bean> getImmutableList(int size) {
    return Collections.unmodifiableList(getMutableList(size));
}

// private internal method (to be used from main in your case)
private List<Bean> getMutableList(int size) {
    List<Bean> beanList = new ArrayList<Bean>();
    int i = 0;

    while(i < size) {
        Bean bean = new Bean("name" + i, "address" + i, i + 18);
        beanList.add(bean);
        i++;
    }
    return beanList;
}

(Su Bean los objetos ya parecen inmutables.)


Como nota al margen: si está utilizando Java 8+, su getMutableList se puede expresar de la siguiente manera:

return IntStream.range(0,  size)
                .mapToObj(i -> new Bean("name" + i, "address" + i, i + 18))
                .collect(Collectors.toCollection(ArrayList::new));

En JDK8:

List<String> stringList = Arrays.asList("a", "b", "c");
stringList = Collections.unmodifiableList(stringList);

En JDK 9:

List stringList = List.of("a", "b", "c");

referencia

avatar de usuario
físico loco

Usar Collections.unmodifiableList(). Pasas en tu original ArrayList y devuelve una lista que arroja una excepción si intenta agregar, eliminar o cambiar elementos. Por ejemplo, use return Collections.unmodifiableList(beanList); en vez de return beanList; al final de getImmutableList(). main() lanzará una excepción. los Collections La clase tiene métodos para todos los otros tipos de colección comunes además de List también.

avatar de usuario
tonyhoan

Desde Java 10 en adelante, List.copyOf(Collection) se puede usar para devolver una lista no modificable de la colección dada. Del código fuente de List.copyOf método:

  • si la colección dada es una lista no modificable, List.copyOf() no creará una copia.

  • si la colección dada es mutable y modificada, la lista devuelta no reflejará dichas modificaciones. Es decir, son independientes.

avatar de usuario
donald raab

Si está abierto a usar una biblioteca de terceros, Colección Eclipses le permite convertir de MutableList a ImmutableList y de regreso.

MutableList<String> mutable = Lists.mutable.with("a", "b", "c");
ImmutableList<String> immutable = mutable.toImmutable();
MutableList<String> mutableAgain = immutable.toList();

Esto también funciona con colecciones primitivas.

MutableCharList mutable = CharLists.mutable.with('a', 'b', 'c');
ImmutableCharList immutable = mutable.toImmutable();
MutableCharList mutableAgain = immutable.toList();

si tienes un ArrayList como el mutable Listlo siguiente funcionará.

List<String> mutable = new ArrayList<>(Arrays.asList("a", "b", "c"));
ImmutableList<String> immutable = Lists.immutable.withAll(mutable);
List<String> mutableAgain = immutable.toList();

Nota: Soy un confirmador de Eclipse Collections.

avatar de usuario
Noman Ajtar

Creando una lista inmutable vacía antes de java SE 9

Antes de Java 9, tenemos que usar el método no modificableList() de la clase Collections para crear una lista inmutable.

List<String> noElementList = new ArrayList<String>();
List<String> immuList = Collections.unmodifiableList(noElementList);

Creación de una lista inmutable no vacía antes de Java SE 9

List<String> list = new ArrayList<String>();
list.add("Atto");
list.add("Rick");
list.add("Shalini");
List<String> immuList = Collections.unmodifiableList(list);

Java 9: ​​creación de una lista inmutable utilizando el método de fábrica estático de ()

List<String> immuList = List.of();

Java 9: ​​creación de una lista inmutable no vacía

List<String> immuList = List.of("Atto", "Rick", "Shalini");

avatar de usuario
Saurabh

Hágalo inmutable en lugar de usar directamente una Lista no modificable en la lista, ya que de lo contrario, la lista original aún se puede cambiar.

Básicamente, la colección no modificable es una vista, por lo que indirectamente aún podría ‘modificarse’ desde alguna otra referencia que sea modificable. Además, como es solo una vista de solo lectura de otra colección, cuando la colección de origen cambia, la colección no modificable siempre se presentará con los valores más recientes.

Sin embargo, la colección inmutable se puede tratar como una copia de solo lectura de otra colección y no se puede modificar. En este caso, cuando la colección de origen cambia, la colección inmutable no refleja los cambios.

List<String> immutableList=Collections.unmodifiableList(
                            new ArrayList<String>(modifiableList));

Usando guayaba:

import java.util.*; 
import com.google.common.collect.ImmutableList; 
ImmutableList<String> iList = ImmutableList.copyOf(list); 

¿Ha sido útil esta solución?

Esta web utiliza cookies propias y de terceros para su correcto funcionamiento y para fines analíticos y para mostrarte publicidad relacionada con sus preferencias en base a un perfil elaborado a partir de tus hábitos de navegación. Al hacer clic en el botón Aceptar, acepta el uso de estas tecnologías y el procesamiento de tus datos para estos propósitos. Configurar y más información
Privacidad