¿Cómo crear una lista inmutable en Java?

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

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

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.

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.

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.

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

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