Matriz inmutable en Java

¿Existe una alternativa inmutable a las matrices primitivas en Java? Hacer una matriz primitiva en finalrealidad no impide que uno haga algo como

final int[] array = new int[] {0, 1, 2, 3};
array[0] = 42;

Quiero que los elementos de la matriz sean inmutables.

No con matrices primitivas. Deberá usar una Lista o alguna otra estructura de datos:

List<Integer> items = Collections.unmodifiableList(Arrays.asList(0,1,2,3));

Mi recomendación es no utilizar una matriz o una unmodifiableListsino utilizar guayaba 's ImmutableList , que existe para este fin.

ImmutableList<Integer> values = ImmutableList.of(0, 1, 2, 3);

Como otros han señalado, no puede tener matrices inmutables en Java.

Si necesita absolutamente un método que devuelva una matriz que no influya en la matriz original, deberá clonar la matriz cada vez:

public int[] getFooArray() {
  return fooArray == null ? null : fooArray.clone();
}

Obviamente, esto es bastante costoso (ya que creará una copia completa cada vez que llame al getter), pero si no puede cambiar la interfaz (para usar un Listpor ejemplo) y no puede arriesgarse a que el cliente cambie sus componentes internos, entonces Puede ser necesario.

Esta técnica se llama hacer una copia defensiva.

Hay una forma de hacer una matriz inmutable en Java:

final String[] IMMUTABLE = new String[0];

Las matrices con 0 elementos (obviamente) no se pueden mutar.

En realidad, esto puede ser útil si está utilizando el List.toArraymétodo para convertir Lista en una matriz. Dado que incluso una matriz vacía ocupa algo de memoria, puede guardar esa asignación de memoria creando una matriz vacía constante y siempre pasándola al toArraymétodo. Ese método asignará una nueva matriz si la matriz que pasa no tiene suficiente espacio, pero si la tiene (la lista está vacía), devolverá la matriz que pasó, permitiéndole reutilizar esa matriz cada vez que llametoArray a un vaciar List.

final static String[] EMPTY_STRING_ARRAY = new String[0];

List<String> emptyList = new ArrayList<String>();
return emptyList.toArray(EMPTY_STRING_ARRAY); // returns EMPTY_STRING_ARRAY

Otra respuesta

static class ImmutableArray<T> {
    private final T[] array;

    private ImmutableArray(T[] a){
        array = Arrays.copyOf(a, a.length);
    }

    public static <T> ImmutableArray<T> from(T[] a){
        return new ImmutableArray<T>(a);
    }

    public T get(int index){
        return array[index];
    }
}

{
    final ImmutableArray<String> sample = ImmutableArray.from(new String[]{"a", "b", "c"});
}

A partir de Java 9 puede usar List.of(...), JavaDoc .

Este método devuelve un inmutable Listy es muy eficiente.

Si necesita (por razones de rendimiento o para ahorrar memoria) 'int' nativo en lugar de 'java.lang.Integer', entonces probablemente deba escribir su propia clase de contenedor. Hay varias implementaciones de IntArray en la red, pero ninguna (encontré) era inmutable: Koders IntArray , Lucene IntArray . Probablemente hay otros.

Desde Guava 22, desde el paquete com.google.common.primitivespuede usar tres nuevas clases, que tienen una huella de memoria más baja en comparación con ImmutableList.

• ImmutableIntArray
• InmutableLongArray
• InmutableDoubleArray

También tienen un constructor. Ejemplo:

int size = 2;
ImmutableLongArray longArray = ImmutableLongArray.builder(size)
  .add(1L)
  .add(2L)
  .build();

o, si el tamaño se conoce en tiempo de compilación:

ImmutableLongArray longArray = ImmutableLongArray.of(1L, 2L);

Esta es otra forma de obtener una vista inmutable de una matriz para primitivas Java.

No, esto no es posible. Sin embargo, uno podría hacer algo como esto:

List<Integer> temp = new ArrayList<Integer>();
temp.add(Integer.valueOf(0));
temp.add(Integer.valueOf(2));
temp.add(Integer.valueOf(3));
temp.add(Integer.valueOf(4));
List<Integer> immutable = Collections.unmodifiableList(temp);

Esto requiere el uso de contenedores, y es una Lista, no una matriz, pero es lo más cercano que obtendrá.

En algunas situaciones, será más ligero usar este método estático de la biblioteca Google Guava: List<Integer> Ints.asList(int... backingArray)

Ejemplos:

• List<Integer> x1 = Ints.asList(0, 1, 2, 3)
• List<Integer> x1 = Ints.asList(new int[] { 0, 1, 2, 3})

Si desea evitar la mutabilidad y el boxeo, no hay forma de salir de la caja. Pero puede crear una clase que contenga una matriz primitiva dentro y proporcione acceso de solo lectura a los elementos a través de métodos.

El método of (E ... elements) en Java9 se puede usar para crear una lista inmutable usando solo una línea:

List<Integer> items = List.of(1,2,3,4,5);

El método anterior devuelve una lista inmutable que contiene un número arbitrario de elementos. Y agregar cualquier número entero a esta lista resultaría en una java.lang.UnsupportedOperationExceptionexcepción. Este método también acepta una sola matriz como argumento.

String[] array = ... ;
List<String[]> list = List.<String[]>of(array);

Si bien es cierto que Collections.unmodifiableList()funciona, a veces puede tener una gran biblioteca con métodos ya definidos para devolver matrices (por ejemplo String[]). Para evitar romperlos, puede definir matrices auxiliares que almacenarán los valores:

public class Test {
    private final String[] original;
    private final String[] auxiliary;
    /** constructor */
    public Test(String[] _values) {
        original = new String[_values.length];
        // Pre-allocated array.
        auxiliary = new String[_values.length];
        System.arraycopy(_values, 0, original, 0, _values.length);
    }
    /** Get array values. */
    public String[] getValues() {
        // No need to call clone() - we pre-allocated auxiliary.
        System.arraycopy(original, 0, auxiliary, 0, original.length);
        return auxiliary;
    }
}

Probar:

    Test test = new Test(new String[]{"a", "b", "C"});
    System.out.println(Arrays.asList(test.getValues()));
    String[] values = test.getValues();
    values[0] = "foobar";
    // At this point, "foobar" exist in "auxiliary" but since we are 
    // copying "original" to "auxiliary" for each call, the next line
    // will print the original values "a", "b", "c".
    System.out.println(Arrays.asList(test.getValues()));

No es perfecto, pero al menos tiene "matrices pseudoinmutables" (desde la perspectiva de la clase) y esto no romperá el código relacionado.

Bueno ... las matrices son útiles para pasar como constantes (si lo fueran) como parámetros de variantes.