Tableau immuable en Java

Existe-t-il une alternative immuable aux tableaux primitifs en Java? Créer un tableau primitif finaln'empêche pas en fait de faire quelque chose comme

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

Je veux que les éléments du tableau soient inchangeables.

Pas avec les tableaux primitifs. Vous devrez utiliser une liste ou une autre structure de données:

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

Ma recommandation est de ne pas utiliser un tableau ou un unmodifiableListmais d'utiliser goyave de ImmutableList , qui existe à cet effet.

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

Comme d'autres l'ont noté, vous ne pouvez pas avoir de tableaux immuables en Java.

Si vous avez absolument besoin d'une méthode qui renvoie un tableau qui n'influence pas le tableau d'origine, vous devez cloner le tableau à chaque fois:

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

Évidemment, cela coûte assez cher (car vous créerez une copie complète à chaque fois que vous appelez le getter), mais si vous ne pouvez pas changer l'interface (pour utiliser un Listpar exemple) et que vous ne pouvez pas risquer que le client change vos données internes, alors cela peut être nécessaire.

Cette technique s'appelle faire une copie défensive.

Il existe une façon de créer un tableau immuable en Java:

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

Les tableaux avec 0 élément (évidemment) ne peuvent pas être mutés.

Cela peut en fait être utile si vous utilisez la List.toArrayméthode pour convertir un Listen tableau. Puisque même un tableau vide prend de la mémoire, vous pouvez enregistrer cette allocation de mémoire en créant un tableau vide constant et en le passant toujours à la toArrayméthode. Cette méthode allouera un nouveau tableau si le tableau que vous passez n'a pas assez d'espace, mais si c'est le cas (la liste est vide), il renverra le tableau que vous avez passé, vous permettant de réutiliser ce tableau à chaque fois que vous appelez toArrayun vide 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

Une autre réponse

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 vous pouvez utiliser List.of(...), JavaDoc .

Cette méthode retourne un immuable Listet est très efficace.

Si vous avez besoin (pour des raisons de performances ou pour économiser de la mémoire) natif 'int' au lieu de 'java.lang.Integer', alors vous devrez probablement écrire votre propre classe wrapper. Il existe diverses implémentations d'IntArray sur le net, mais aucune (j'ai trouvé) n'était immuable: Koders IntArray , Lucene IntArray . Il y en a probablement d'autres.

Depuis Guava 22, à partir de package, com.google.common.primitivesvous pouvez utiliser trois nouvelles classes, qui ont une empreinte mémoire inférieure à ImmutableList.

• ImmutableIntArray
• ImmutableLongArray
• ImmuableDoubleArray

Ils ont également un constructeur. Exemple:

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

ou, si la taille est connue au moment de la compilation:

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

C'est une autre façon d'obtenir une vue immuable d'un tableau pour les primitives Java.

Non, ce n'est pas possible. Cependant, on pourrait faire quelque chose comme ceci:

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

Cela nécessite l'utilisation de wrappers, et c'est une liste, pas un tableau, mais c'est le plus proche que vous obtiendrez.

Dans certaines situations, il sera plus léger d'utiliser cette méthode statique de la bibliothèque Google Guava: List<Integer> Ints.asList(int... backingArray)

Exemples:

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

Si vous voulez éviter à la fois la mutabilité et la boxe, il n'y a aucun moyen de sortir de la boîte. Mais vous pouvez créer une classe qui contient un tableau primitif et fournit un accès en lecture seule aux éléments via des méthodes.

La méthode of (E ... elements) en Java9 peut être utilisée pour créer une liste immuable en utilisant juste une ligne:

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

La méthode ci-dessus renvoie une liste immuable contenant un nombre arbitraire d'éléments. Et ajouter n'importe quel entier à cette liste entraînerait une java.lang.UnsupportedOperationExceptionexception. Cette méthode accepte également un seul tableau comme argument.

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

Bien qu'il soit vrai que cela Collections.unmodifiableList()fonctionne, vous pouvez parfois avoir une grande bibliothèque avec des méthodes déjà définies pour renvoyer des tableaux (par exemple String[]). Pour éviter de les casser, vous pouvez en fait définir des tableaux auxiliaires qui stockeront les valeurs:

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

Tester:

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

Pas parfait, mais au moins vous avez des "pseudo tableaux immuables" (du point de vue de la classe) et cela ne cassera pas le code associé.

Eh bien .. les tableaux sont utiles pour passer en tant que constantes (si elles l'étaient) en tant que paramètres de variantes.