Inicialize um array no construtor em Java

Ao criar um objeto Java, inicialize um campo de array no construtor se seu conteúdo inicial depender dos argumentos do construtor ou de outra configuração. Se os valores padrão de Java forem adequados, basta alocar o campo. Um array declarado como variável local dentro do construtor só fica disponível enquanto esse construtor está em execução; ele não passa a fazer parte do estado do objeto.

Inicializar um campo de array em um construtor Java

Declare o array como um campo de instância e, em seguida, atribua a ele uma referência de array no construtor. O construtor é executado para cada novo objeto, então pode definir o campo com base nas entradas daquele objeto ou preparar valores calculados para ele.

O campo de array e o array para o qual ele aponta são coisas distintas: o campo armazena uma referência, enquanto o array contém os elementos. Criar o array com new int[size] aloca seus elementos e atribui um valor padrão a cada um. Atribuir um array local a um campo, como em this.values = values, armazena essa referência; faça uma cópia se o objeto precisar ter conteúdo independente.

Usar os valores padrão de Java em um array

Java atribui valores padrão aos campos de instância antes da execução do corpo do construtor. Quando o construtor cria um array, Java também inicializa seus elementos: elementos de tipos numéricos primitivos começam em zero (0 para tipos inteiros e 0.0 para float e double), elementos char começam em \u0000, elementos boolean são false, e elementos de referência, como String, são null.

Por exemplo, private int[] values = new int[3]; cria um campo de instância com três elementos de valor zero. Você também pode declarar private int[] values; e atribuir values = new int[3]; no construtor; os elementos ainda começam em zero. Não adicione um laço para atribuir esses mesmos valores, a menos que a atribuição atenda a algum outro requisito.

Atribuir valores específicos no construtor

Use um inicializador de array para definir um conteúdo fixo ou receba valores como parâmetros do construtor quando cada objeto deve começar com o conteúdo fornecido por quem o criou. Por exemplo, this.values = new int[] {1, 2, 3}; atribui esses três valores ao campo. Um construtor com parâmetros pode atribuir ou copiar a entrada, dependendo de as alterações posteriores feitas no array de quem chamou também deverem afetar o objeto.

O exemplo a seguir reúne várias abordagens em uma única classe. Ele cria um campo preenchido com valores padrão, copia os valores fornecidos, preenche outro campo com um único valor, calcula valores com base nos índices e usa um array local durante a construção. O programa exibe cada array para que você possa adaptar os trechos adequados à sua classe.

import java.util.Arrays;

public class ArraySetup {
    private final int[] defaults = new int[3];
    private final int[] supplied;
    private final int[] repeated = new int[3];
    private final int[] calculated = new int[3];

    public ArraySetup(int[] source) {
        supplied = Arrays.copyOf(source, source.length);
        Arrays.fill(repeated, 7);
        Arrays.setAll(calculated, index -> (index + 1) * 2);

        int[] local = {4, 5};
        System.out.println("Local: " + Arrays.toString(local));
    }

    public static void main(String[] args) {
        int[] input = {3, 6, 9};
        ArraySetup item = new ArraySetup(input);
        System.out.println("Defaults: " + Arrays.toString(item.defaults));
        System.out.println("Supplied: " + Arrays.toString(item.supplied));
        System.out.println("Repeated: " + Arrays.toString(item.repeated));
        System.out.println("Calculated: " + Arrays.toString(item.calculated));
    }
}

Criar um array localmente no construtor

Uma declaração como int[] local = {4, 5}; dentro de um construtor cria uma variável local. O código desse construtor pode usar a variável, mas outros métodos não podem acessá-la depois que o construtor termina. Se o array deve fazer parte do estado do objeto criado, atribua-o a um campo de instância, por exemplo, this.values = new int[] {4, 5};.

Um array local ainda pode ser útil como entrada temporária durante a criação de um campo ou em um cálculo necessário apenas durante a configuração. Tenha clara a diferença: o objeto array pode continuar acessível se um campo ou outro objeto armazenar sua referência, mas uma variável local do construtor, por si só, não o mantém disponível.

Usar Arrays.copyOf(), Arrays.fill() ou Arrays.setAll()

Escolha o método auxiliar de acordo com como o conteúdo é determinado. Arrays.copyOf(source, source.length) cria um array separado com os elementos de origem. Se o tamanho solicitado for menor ou maior, ele copia o que couber; os elementos adicionais de uma cópia maior recebem o valor padrão do tipo. Em arrays de objetos, a cópia é superficial: as referências são copiadas, mas os objetos referenciados não são duplicados.

Use Arrays.fill(array, value) quando todos os elementos devem receber o mesmo valor. Use Arrays.setAll(array, index -> expression) quando cada valor for calculado a partir do índice. No exemplo, a operação de preenchimento atribui 7 a todos os elementos do array, enquanto a função baseada no índice atribui números pares consecutivos. Esses métodos atualizam o array recebido; eles não criam um array substituto.

Escolher uma abordagem de inicialização

Use um array de tamanho definido e conte com os valores padrão quando eles forem o estado inicial desejado. Use um inicializador de array para um conjunto pequeno e fixo de valores, ou parâmetros do construtor quando quem cria o objeto escolhe o conteúdo. Copie um array de entrada quando o objeto precisar de sua própria estrutura de array; use Arrays.fill() para repetir um valor e Arrays.setAll() para gerar valores com base nos índices. Declare o array como campo de instância sempre que ele precisar continuar disponível como parte do estado do objeto após a construção.