Matriz imutável em Java

Existe uma alternativa imutável para as matrizes primitivas em Java? Criar um array primitivo finalnão impede que alguém faça algo como

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

Eu quero que os elementos da matriz sejam imutáveis.

Não com matrizes primitivas. Você precisará usar uma lista ou outra estrutura de dados:

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

Minha recomendação é não usar uma matriz ou uma, unmodifiableListmas usar o ImmutableList do Guava , que existe para esse fim.

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

Como outros observaram, você não pode ter matrizes imutáveis ​​em Java.

Se você precisar absolutamente de um método que retorne uma matriz que não influencie a matriz original, será necessário cloná-la sempre:

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

Obviamente, isso é bastante caro (como você cria uma cópia completa toda vez que chama o getter), mas se você não pode alterar a interface (para usar um Listpor exemplo) e não pode arriscar que o cliente altere seus internos, pode ser necessário.

Essa técnica é chamada de fazer uma cópia defensiva.

Há uma maneira de criar uma matriz imutável em Java:

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

Matrizes com 0 elementos (obviamente) não podem ser mutadas.

Isso pode ser útil se você estiver usando o List.toArraymétodo para converter um Listem uma matriz. Como até mesmo uma matriz vazia ocupa um pouco de memória, você pode salvar essa alocação de memória criando uma matriz vazia constante e sempre passando-a para o toArraymétodo Esse método alocará uma nova matriz se a matriz que você passar não tiver espaço suficiente, mas se tiver (a lista está vazia), ela retornará a matriz que você passou, permitindo que você reutilize essa matriz sempre que você chamar toArrayum vazio 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

Outra resposta

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 você pode usar List.of(...), JavaDoc .

Este método retorna um imutável Liste é muito eficiente.

Se você precisar (por motivos de desempenho ou economizar memória) nativo 'int' em vez de 'java.lang.Integer', provavelmente precisará escrever sua própria classe de wrapper. Existem várias implementações do IntArray na rede, mas nenhuma (eu achei) era imutável: Koders IntArray , Lucene IntArray . Provavelmente existem outros.

Desde o Guava 22, do pacote, com.google.common.primitivesvocê pode usar três novas classes, com menor espaço de memória em comparação com o ImmutableList.

• ImmutableIntArray
• ImmutableLongArray
• ImmutableDoubleArray

Eles também têm um construtor. Exemplo:

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

ou, se o tamanho for conhecido em tempo de compilação:

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

Essa é outra maneira de obter uma visão imutável de uma matriz para primitivas Java.

Não, isso não é possível. No entanto, alguém poderia fazer algo assim:

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

Isso requer o uso de wrappers e é uma lista, não uma matriz, mas é o mais próximo que você vai chegar.

Em algumas situações, será mais leve usar esse método estático da biblioteca do Google Guava: List<Integer> Ints.asList(int... backingArray)

Exemplos:

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

Se você deseja evitar a mutabilidade e o boxe, não há como sair da caixa. Mas você pode criar uma classe que contenha uma matriz primitiva dentro e forneça acesso somente leitura aos elementos via método (s).

O método of (E ... elements) em Java9 pode ser usado para criar uma lista imutável usando apenas uma linha:

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

O método acima retorna uma lista imutável que contém um número arbitrário de elementos. E adicionar qualquer número inteiro a esta lista resultaria em java.lang.UnsupportedOperationExceptionexceção. Este método também aceita uma única matriz como argumento.

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

Embora seja verdade que Collections.unmodifiableList()funciona, às vezes você pode ter uma biblioteca grande com métodos já definidos para retornar matrizes (por exemplo String[]). Para evitar quebrá-los, você pode realmente definir matrizes auxiliares que armazenarão os 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;
    }
}

Testar:

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

Não é perfeito, mas pelo menos você tem "matrizes pseudo-imutáveis" (da perspectiva da classe) e isso não quebra o código relacionado.

Bem ... matrizes são úteis para passar como constantes (se fossem) como parâmetros de variantes.