Como Imprimir um Array em Java

Passar um array diretamente para System.out.println quase nunca imprime o que você deseja — você obtém algo como [I@1b6d3586 em vez dos elementos. Arrays não sobrescrevem toString(), então a versão padrão de Object imprime o tipo e um hash de identidade. Este capítulo apresenta as correções idiomáticas: Arrays.toString para arrays planos, Arrays.deepToString para arrays aninhados, String.join para delimitadores personalizados e um loop manual quando você precisa de controle total.

Por que uma impressão simples falha

O toString() padrão que um array herda de Object retorna uma assinatura de classe mais um código hash — não o conteúdo:

int[] numbers = {3, 1, 4};
System.out.println(numbers);       // [I@1b6d3586
System.out.println("" + numbers);  // same reference string

O [I significa "array de int"; o hexadecimal após @ é o hash de identidade, que muda entre execuções. Concatenar o array em uma string não ajuda, pois a concatenação também chama toString(). A solução é pedir a um método auxiliar que formate os elementos para você.

Arrays.toString para uma dimensão

java.util.Arrays.toString percorre um array de uma dimensão e retorna uma string legível e separada por vírgulas entre colchetes:

int[] numbers = {3, 1, 4, 1, 5};
System.out.println(Arrays.toString(numbers)); // [3, 1, 4, 1, 5]

String[] words = {"alpha", "beta"};
System.out.println(Arrays.toString(words));   // [alpha, beta]

Ele é sobrecarregado para cada tipo de array primitivo (int[], double[], boolean[], …) e para Object[], portanto funciona com qualquer array plano que você passar. Para arrays de objetos, ele chama o próprio toString() de cada elemento.

Arrays.deepToString para arrays aninhados

Arrays.toString vai apenas um nível de profundidade. Em um array 2D, ele formata o array externo mas imprime cada array interno como uma referência. Use Arrays.deepToString para percorrer recursivamente todos os níveis:

int[][] grid = {{1, 2}, {3, 4}};
System.out.println(Arrays.toString(grid));     // [[I@..., [I@...]
System.out.println(Arrays.deepToString(grid)); // [[1, 2], [3, 4]]

Use deepToString sempre que o array contiver outros arrays — matrizes, arrays irregulares, arrays de arrays de objetos.

Formatação personalizada

Quando o padrão com colchetes não é o formato desejado, String.join une um String[] (ou qualquer CharSequence iterável) com um delimitador de sua escolha e sem colchetes ao redor:

String[] words = {"alpha", "beta", "gamma"};
System.out.println(String.join(" | ", words)); // alpha | beta | gamma

Para arrays não string ou saída completamente personalizada, um loop com um StringBuilder oferece controle total sobre separadores, prefixos e formatação por elemento. Streams são outra opção: Arrays.stream(arr).mapToObj(String::valueOf).collect(Collectors.joining(", ")).

Um exemplo executável

O programa abaixo contrasta as abordagens: Arrays.toString em int[] e String[] planos, a diferença rasa vs. profunda em um array 2D, String.join para um delimitador personalizado e um StringBuilder construído manualmente. A linha shallow verifica se o toString raso do array 2D ainda contém referências internas, então imprime true de forma estável em vez de um hash variável por execução.

O que observar na execução:

• toString: [3, 1, 4, 1, 5] mostra Arrays.toString convertendo um int[] plano em texto legível com colchetes.
• words: [alpha, beta, gamma] confirma que o mesmo método funciona em arrays de objetos chamando o toString() de cada elemento.
• shallow: true prova que Arrays.toString em um array 2D deixa os arrays internos como referências [[I@..., razão pela qual o resultado começa com [[I@.
• deep: [[1, 2], [3, 4]] mostra Arrays.deepToString percorrendo recursivamente os arrays aninhados para imprimir cada elemento.
• joined: alpha | beta | gamma e manual: {3; 1; 4; 1; 5} mostram String.join e um loop com StringBuilder produzindo saída sem colchetes e com delimitador personalizado.

Prática