Matrice immutabile in Java

Esiste un'alternativa immutabile agli array primitivi in ​​Java? Realizzare un array primitivo finalnon impedisce in realtà di fare qualcosa del genere

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

Voglio che gli elementi dell'array siano immutabili.

Non con array primitivi. Dovrai utilizzare un elenco o qualche altra struttura di dati:

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

La mia raccomandazione è di non usare un array o un unmodifiableListma di usare Guava 's ImmutableList , che esiste a questo scopo.

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

Come altri hanno notato, non è possibile avere array immutabili in Java.

Se hai assolutamente bisogno di un metodo che restituisca un array che non influenza l'array originale, allora dovresti clonare l'array ogni volta:

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

Ovviamente questo è piuttosto costoso (poiché ne creerai una copia completa ogni volta che chiami il getter), ma se non riesci a cambiare l'interfaccia (per usare un List esempio) e non puoi rischiare che il client cambi i tuoi interni, allora potrebbe essere necessario.

Questa tecnica si chiama fare una copia difensiva.

C'è un modo per creare un array immutabile in Java:

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

Le matrici con 0 elementi (ovviamente) non possono essere mutate.

Questo può effettivamente tornare utile se si utilizza il List.toArraymetodo per convertire Listun array. Poiché anche un array vuoto occupa un po 'di memoria, è possibile salvare l'allocazione di memoria creando un array vuoto costante e passandolo sempre al toArraymetodo. Questo metodo allocherà un nuovo array se l'array che passi non ha abbastanza spazio, ma se lo fa (l'elenco è vuoto), restituirà l'array che hai passato, permettendoti di riutilizzarlo ogni volta che chiami toArrayun svuotare 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

Un'altra risposta

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

Come di Java 9 è possibile utilizzare List.of(...), JavaDoc .

Questo metodo restituisce un valore immutabile Listed è molto efficiente.

Se è necessario (per motivi di prestazioni o per risparmiare memoria) 'int' nativo invece di 'java.lang.Integer', probabilmente è necessario scrivere la propria classe wrapper. Esistono varie implementazioni IntArray in rete, ma nessuna (ho scoperto) era immutabile: Koders IntArray , Lucene IntArray . Ce ne sono probabilmente altri.

Da Guava 22, dal pacchetto com.google.common.primitivesè possibile utilizzare tre nuove classi, che hanno un footprint di memoria inferiore rispetto a ImmutableList.

• ImmutableIntArray
• ImmutableLongArray
• ImmutableDoubleArray

Hanno anche un costruttore. Esempio:

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

oppure, se la dimensione è nota al momento della compilazione:

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

Questo è un altro modo per ottenere una vista immutabile di un array per primitive Java.

No, non è possibile. Tuttavia, si potrebbe fare qualcosa del genere:

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

Ciò richiede l'uso di wrapper, ed è un elenco, non un array, ma è il più vicino che otterrai.

In alcune situazioni, sarà più leggero utilizzare questo metodo statico dalla libreria di Google Guava: List<Integer> Ints.asList(int... backingArray)

Esempi:

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

Se si desidera evitare sia la mutabilità che il pugilato, non c'è via d'uscita. Ma puoi creare una classe che contiene un array primitivo e fornisce un accesso di sola lettura agli elementi tramite i metodi.

Il metodo of (E ... elements) in Java9 può essere usato per creare un elenco immutabile usando solo una riga:

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

Il metodo sopra riportato restituisce un elenco immutabile contenente un numero arbitrario di elementi. E l'aggiunta di qualsiasi numero intero a questo elenco comporterebbe java.lang.UnsupportedOperationExceptionun'eccezione. Questo metodo accetta anche un singolo array come argomento.

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

Mentre è vero che Collections.unmodifiableList()funziona, a volte potresti avere una grande libreria con metodi già definiti per restituire array (ad es String[].). Per evitare di romperli, puoi effettivamente definire array ausiliari che memorizzeranno i valori:

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

Testare:

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

Non perfetto, ma almeno hai "matrici pseudo immutabili" (dal punto di vista della classe) e questo non romperà il codice correlato.

Bene ... le matrici sono utili per passare come costanti (se lo fossero) come parametri varianti.