Qual é a maneira mais simples de imprimir uma matriz Java?

Em Java, as matrizes não substituem toString(), portanto, se você tentar imprimir uma diretamente, obtém o className+ '@' + o hexadecimal da hashCodematriz, conforme definido por Object.toString():

int[] intArray = new int[] {1, 2, 3, 4, 5};
System.out.println(intArray);     // prints something like '[I@3343c8b3'

Mas geralmente, nós realmente queremos algo mais parecido [1, 2, 3, 4, 5]. Qual é a maneira mais simples de fazer isso? Aqui estão alguns exemplos de entradas e saídas:

// Array of primitives:
int[] intArray = new int[] {1, 2, 3, 4, 5};
//output: [1, 2, 3, 4, 5]

// Array of object references:
String[] strArray = new String[] {"John", "Mary", "Bob"};
//output: [John, Mary, Bob]

Desde o Java 5, você pode usar Arrays.toString(arr)ou Arrays.deepToString(arr)para matrizes dentro de matrizes. Observe que a Object[]versão chama.toString() cada objeto na matriz. A saída é decorada da maneira exata que você está perguntando.

Exemplos:

• Matriz simples:

  String[] array = new String[] {"John", "Mary", "Bob"};
  System.out.println(Arrays.toString(array));

  Resultado:

  [John, Mary, Bob]

• Matriz aninhada:

  String[][] deepArray = new String[][] {{"John", "Mary"}, {"Alice", "Bob"}};
  System.out.println(Arrays.toString(deepArray));
  //output: [[Ljava.lang.String;@106d69c, [Ljava.lang.String;@52e922]
  System.out.println(Arrays.deepToString(deepArray));

  Resultado:

  [[John, Mary], [Alice, Bob]]

• double Matriz:

  double[] doubleArray = { 7.0, 9.0, 5.0, 1.0, 3.0 };
  System.out.println(Arrays.toString(doubleArray));

  Resultado:

  [7.0, 9.0, 5.0, 1.0, 3.0 ]

• int Matriz:

  int[] intArray = { 7, 9, 5, 1, 3 };
  System.out.println(Arrays.toString(intArray));

  Resultado:

  [7, 9, 5, 1, 3 ]

Sempre verifique as bibliotecas padrão primeiro.

import java.util.Arrays;

Então tente:

System.out.println(Arrays.toString(array));

ou se sua matriz contiver outras matrizes como elementos:

System.out.println(Arrays.deepToString(array));

É bom saber, no entanto, que para "sempre verifique as bibliotecas padrão primeiro", eu nunca teria tropeçado no truque de Arrays.toString( myarray )

- desde que eu estava me concentrando no tipo de matriz para ver como fazer isso. Eu não queria ter que repetir a coisa: eu queria uma ligação fácil para que ela saísse semelhante ao que vejo no depurador Eclipse e no myarray.toString () simplesmente não estava fazendo isso.

import java.util.Arrays;
.
.
.
System.out.println( Arrays.toString( myarray ) );

No JDK1.8, você pode usar operações agregadas e uma expressão lambda:

String[] strArray = new String[] {"John", "Mary", "Bob"};

// #1
Arrays.asList(strArray).stream().forEach(s -> System.out.println(s));

// #2
Stream.of(strArray).forEach(System.out::println);

// #3
Arrays.stream(strArray).forEach(System.out::println);

/* output:
John
Mary
Bob
*/

A partir do Java 8, também é possível aproveitar o join()método fornecido pela classe String para imprimir elementos da matriz, sem os colchetes, e separados por um delimitador de escolha (que é o caractere de espaço do exemplo mostrado abaixo):

String[] greeting = {"Hey", "there", "amigo!"};
String delimiter = " ";
String.join(delimiter, greeting) 

A saída será "Olá amigo!".

Se você estiver usando o Java 1.4, poderá:

System.out.println(Arrays.asList(array));

(Isso funciona em 1.5+ também, é claro.)

Arrays.toString

Como uma resposta directa, a solução é fornecida por vários, incluindo @Esko , usando a Arrays.toStringeArrays.deepToString métodos , é simplesmente a melhor.

Java 8 - Stream.collect (join ()), Stream.forEach

Abaixo, tento listar alguns dos outros métodos sugeridos, tentando melhorar um pouco, com a adição mais notável sendo o uso do Stream.collectoperador, usando a , para imitar o que está fazendo.joining CollectorString.join

int[] ints = new int[] {1, 2, 3, 4, 5};
System.out.println(IntStream.of(ints).mapToObj(Integer::toString).collect(Collectors.joining(", ")));
System.out.println(IntStream.of(ints).boxed().map(Object::toString).collect(Collectors.joining(", ")));
System.out.println(Arrays.toString(ints));

String[] strs = new String[] {"John", "Mary", "Bob"};
System.out.println(Stream.of(strs).collect(Collectors.joining(", ")));
System.out.println(String.join(", ", strs));
System.out.println(Arrays.toString(strs));

DayOfWeek [] days = { FRIDAY, MONDAY, TUESDAY };
System.out.println(Stream.of(days).map(Object::toString).collect(Collectors.joining(", ")));
System.out.println(Arrays.toString(days));

// These options are not the same as each item is printed on a new line:
IntStream.of(ints).forEach(System.out::println);
Stream.of(strs).forEach(System.out::println);
Stream.of(days).forEach(System.out::println);

Antes do Java 8

Poderíamos ter usado Arrays.toString(array)para imprimir uma matriz dimensional eArrays.deepToString(array) para matrizes multidimensionais.

Java 8

Agora temos a opção de Streamelambda imprimir a matriz.

Imprimindo uma matriz dimensional:

public static void main(String[] args) {
    int[] intArray = new int[] {1, 2, 3, 4, 5};
    String[] strArray = new String[] {"John", "Mary", "Bob"};

    //Prior to Java 8
    System.out.println(Arrays.toString(intArray));
    System.out.println(Arrays.toString(strArray));

    // In Java 8 we have lambda expressions
    Arrays.stream(intArray).forEach(System.out::println);
    Arrays.stream(strArray).forEach(System.out::println);
}

A saída é:

[1, 2, 3, 4, 5]
[John, Mary, Bob]
1
2
3
4
5
John
Mary
Bob

Impressão de matriz multidimensional Para o caso de querermos imprimir matriz multidimensional, podemos usar Arrays.deepToString(array)como:

public static void main(String[] args) {
    int[][] int2DArray = new int[][] { {11, 12}, { 21, 22}, {31, 32, 33} };
    String[][] str2DArray = new String[][]{ {"John", "Bravo"} , {"Mary", "Lee"}, {"Bob", "Johnson"} };

    //Prior to Java 8
    System.out.println(Arrays.deepToString(int2DArray));
    System.out.println(Arrays.deepToString(str2DArray));

    // In Java 8 we have lambda expressions
    Arrays.stream(int2DArray).flatMapToInt(x -> Arrays.stream(x)).forEach(System.out::println);
    Arrays.stream(str2DArray).flatMap(x -> Arrays.stream(x)).forEach(System.out::println);
} 

Agora, o ponto a ser observado é que o método Arrays.stream(T[]), que em caso de int[]retorno Stream<int[]>e, em seguida, o método flatMapToInt()mapeia cada elemento do fluxo com o conteúdo de um fluxo mapeado produzido aplicando a função de mapeamento fornecida a cada elemento.

A saída é:

[[11, 12], [21, 22], [31, 32, 33]]
[[John, Bravo], [Mary, Lee], [Bob, Johnson]]
11
12
21
22
31
32
33
John
Bravo
Mary
Lee
Bob
Johnson

Arrays.deepToString(arr) só imprime em uma linha.

int[][] table = new int[2][2];

Para realmente obter uma tabela para imprimir como uma tabela bidimensional, tive que fazer o seguinte:

System.out.println(Arrays.deepToString(table).replaceAll("],", "]," + System.getProperty("line.separator")));

Parece que o Arrays.deepToString(arr)método deve ter uma sequência separadora, mas infelizmente não.

for(int n: someArray) {
    System.out.println(n+" ");
}

Maneiras diferentes de imprimir matrizes em Java:

1. Maneira simples

   List<String> list = new ArrayList<String>();
   list.add("One");
   list.add("Two");
   list.add("Three");
   list.add("Four");
   // Print the list in console
   System.out.println(list);

Saída: [Um, Dois, Três, Quatro]

2. Usando toString()

   String[] array = new String[] { "One", "Two", "Three", "Four" };
   System.out.println(Arrays.toString(array));

Saída: [Um, Dois, Três, Quatro]

3. Matriz de impressão de matrizes

   String[] arr1 = new String[] { "Fifth", "Sixth" };
   String[] arr2 = new String[] { "Seventh", "Eight" };
   String[][] arrayOfArray = new String[][] { arr1, arr2 };
   System.out.println(arrayOfArray);
   System.out.println(Arrays.toString(arrayOfArray));
   System.out.println(Arrays.deepToString(arrayOfArray));

Saída: [[Ljava.lang.String; @ 1ad086a [[Ljava.lang.String; @ 10385c1, [Ljava.lang.String; @ 42719c] [[Quinta, Sexta], [Sétima, Oitava]]

Recurso: Acessar uma matriz

O uso regular de loop for é a maneira mais simples de imprimir array na minha opinião. Aqui você tem um código de amostra com base no seu intArray

for (int i = 0; i < intArray.length; i++) {
   System.out.print(intArray[i] + ", ");
}

Dá saída como sua 1, 2, 3, 4, 5

Me deparei com este post no Vanilla #Java recentemente. Não é muito conveniente escrever Arrays.toString(arr);e importar java.util.Arrays;o tempo todo.

Observe que essa não é uma correção permanente, por qualquer meio. Apenas um truque que pode simplificar a depuração.

Imprimir uma matriz diretamente fornece a representação interna e o hashCode. Agora, todas as classes têm Objecto tipo pai. Então, por que não hackear o Object.toString()? Sem modificação, a classe Object fica assim:

public String toString() {
    return getClass().getName() + "@" + Integer.toHexString(hashCode());
}

E se isso for alterado para:

public String toString() {
    if (this instanceof boolean[])
        return Arrays.toString((boolean[]) this);
    if (this instanceof byte[])
        return Arrays.toString((byte[]) this);
    if (this instanceof short[])
        return Arrays.toString((short[]) this);
    if (this instanceof char[])
        return Arrays.toString((char[]) this);
    if (this instanceof int[])
        return Arrays.toString((int[]) this);
    if (this instanceof long[])
        return Arrays.toString((long[]) this);
    if (this instanceof float[])
        return Arrays.toString((float[]) this);
    if (this instanceof double[])
        return Arrays.toString((double[]) this);
    if (this instanceof Object[])
        return Arrays.deepToString((Object[]) this);
    return getClass().getName() + "@" + Integer.toHexString(hashCode());
}

Essa classe modificada pode ser simplesmente adicionada ao caminho da classe adicionando o seguinte à linha de comando: -Xbootclasspath/p:target/classes .

Agora, com a disponibilidade do deepToString(..)Java 5, ele toString(..)pode ser facilmente alterado paradeepToString(..) para adicionar suporte a matrizes que contêm outras matrizes.

Eu achei isso um hack bastante útil e seria ótimo se o Java pudesse simplesmente adicionar isso. Entendo possíveis problemas em ter matrizes muito grandes, pois as representações de cadeia de caracteres podem ser problemáticas. Talvez passe algo como um System.outou um PrintWriterpara tais eventualidades.

Sempre deve funcionar com a versão do JDK usada:

System.out.println(Arrays.asList(array));

Funcionará se Arraycontiver objetos. Se o Arraycontém tipos primitivos, você pode usar as classes wrapper, em vez disso, armazenando o primitivo diretamente como ..

Exemplo:

int[] a = new int[]{1,2,3,4,5};

Substitua por:

Integer[] a = new Integer[]{1,2,3,4,5};

Atualização:

Sim ! deve-se mencionar que a conversão de uma matriz em uma matriz de objetos OU para usar a matriz do objeto é cara e pode retardar a execução. isso acontece pela natureza do java chamada autoboxing.

Portanto, apenas para fins de impressão, não deve ser usado. podemos criar uma função que usa uma matriz como parâmetro e imprime o formato desejado como

public void printArray(int [] a){
        //write printing code
} 

No java 8 é fácil. existem duas palavras-chave

1. corrente: Arrays.stream(intArray).forEach

2. referência de método: ::println

   int[] intArray = new int[] {1, 2, 3, 4, 5};
   Arrays.stream(intArray).forEach(System.out::println);

Se você quiser imprimir todos os elementos do array na mesma linha, use apenas em printvez de printlnie

int[] intArray = new int[] {1, 2, 3, 4, 5};
Arrays.stream(intArray).forEach(System.out::print);

Outra maneira sem referência ao método, basta usar:

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

Há uma maneira adicional se sua matriz for do tipo char []:

char A[] = {'a', 'b', 'c'}; 

System.out.println(A); // no other arguments

impressões

abc

Para adicionar a todas as respostas, imprimir o objeto como uma string JSON também é uma opção.

Usando Jackson:

ObjectWriter ow = new ObjectMapper().writer().withDefaultPrettyPrinter();
System.out.println(ow.writeValueAsString(anyArray));

Usando o Gson:

Gson gson = new Gson();
System.out.println(gson.toJson(anyArray));

Você pode fazer um loop pela matriz, imprimindo cada item, enquanto faz o loop. Por exemplo:

String[] items = {"item 1", "item 2", "item 3"};

for(int i = 0; i < items.length; i++) {

    System.out.println(items[i]);

}

Resultado:

item 1
item 2
item 3

Existem as seguintes maneiras de imprimir a matriz

 // 1) toString()  
    int[] arrayInt = new int[] {10, 20, 30, 40, 50};  
    System.out.println(Arrays.toString(arrayInt));

// 2 for loop()
    for (int number : arrayInt) {
        System.out.println(number);
    }

// 3 for each()
    for(int x: arrayInt){
         System.out.println(x);
     }

Um atalho simplificado que tentei é o seguinte:

    int x[] = {1,2,3};
    String printableText = Arrays.toString(x).replaceAll("[\\[\\]]", "").replaceAll(", ", "\n");
    System.out.println(printableText);

Irá imprimir

1
2
3

Não são necessários loops nesta abordagem e é melhor apenas para pequenas matrizes

O loop for-each também pode ser usado para imprimir elementos da matriz:

int array[] = {1, 2, 3, 4, 5};
for (int i:array)
    System.out.println(i);

public class printer {

    public static void main(String[] args) {
        String a[] = new String[4];
        Scanner sc = new Scanner(System.in);
        System.out.println("enter the data");
        for (int i = 0; i < 4; i++) {
            a[i] = sc.nextLine();
        }
        System.out.println("the entered data is");
        for (String i : a) {
            System.out.println(i);
        }
      }
    }

O uso dos métodos org.apache.commons.lang3.StringUtils.join (*) pode ser uma opção
Por exemplo:

String[] strArray = new String[] { "John", "Mary", "Bob" };
String arrayAsCSV = StringUtils.join(strArray, " , ");
System.out.printf("[%s]", arrayAsCSV);
//output: [John , Mary , Bob]

Eu usei a seguinte dependência

<groupId>org.apache.commons</groupId>
<artifactId>commons-lang3</artifactId>
<version>3.3.2</version>

Está marcado como duplicado para imprimir um byte [] . Nota: para uma matriz de bytes, existem métodos adicionais que podem ser apropriados.

Você pode imprimi-lo como uma String se contiver caracteres ISO-8859-1.

String s = new String(bytes, StandardChars.ISO_8559);
System.out.println(s);
// to reverse
byte[] bytes2 = s.getBytes(StandardChars.ISO_8559);

ou se contiver uma string UTF-8

String s = new String(bytes, StandardChars.UTF_8);
System.out.println(s);
// to reverse
byte[] bytes2 = s.getBytes(StandardChars.UTF_8);

ou se você quiser imprimi-lo como hexadecimal.

String s = DatatypeConverter.printHexBinary(bytes);
System.out.println(s);
// to reverse
byte[] bytes2 = DatatypeConverter.parseHexBinary(s);

ou se você quiser imprimi-lo como base64.

String s = DatatypeConverter.printBase64Binary(bytes);
System.out.println(s);
// to reverse
byte[] bytes2 = DatatypeConverter.parseBase64Binary(s);

ou se você deseja imprimir uma matriz de valores de bytes assinados

String s = Arrays.toString(bytes);
System.out.println(s);
// to reverse
String[] split = s.substring(1, s.length() - 1).split(", ");
byte[] bytes2 = new byte[split.length];
for (int i = 0; i < bytes2.length; i++)
    bytes2[i] = Byte.parseByte(split[i]);

ou se você deseja imprimir uma matriz de valores de bytes não assinados

String s = Arrays.toString(
               IntStream.range(0, bytes.length).map(i -> bytes[i] & 0xFF).toArray());
System.out.println(s);
// to reverse
String[] split = s.substring(1, s.length() - 1).split(", ");
byte[] bytes2 = new byte[split.length];
for (int i = 0; i < bytes2.length; i++)
    bytes2[i] = (byte) Integer.parseInt(split[i]); // might need a range check.

// array of primitives:
int[] intArray = new int[] {1, 2, 3, 4, 5};

System.out.println(Arrays.toString(intArray));

output: [1, 2, 3, 4, 5]

// array of object references:
String[] strArray = new String[] {"John", "Mary", "Bob"};

System.out.println(Arrays.toString(strArray));

output: [John, Mary, Bob]

se você estiver executando o jdk 8.

public static void print(int[] array) {
    StringJoiner joiner = new StringJoiner(",", "[", "]");
    Arrays.stream(array).forEach(element -> joiner.add(element + ""));
    System.out.println(joiner.toString());
}


int[] array = new int[]{7, 3, 5, 1, 3};
print(array);

resultado:

[7,3,5,1,3]

No java 8:

Arrays.stream(myArray).forEach(System.out::println);

Se estiver usando a biblioteca Commons.Lang , poderíamos fazer:

ArrayUtils.toString(array)

int[] intArray = new int[] {1, 2, 3, 4, 5};
String[] strArray = new String[] {"John", "Mary", "Bob"};
ArrayUtils.toString(intArray);
ArrayUtils.toString(strArray);

Resultado:

{1,2,3,4,5}
{John,Mary,Bob}

// Se você imprimir o endereço do elemento do array no console em java.

      int myArrayElement[] = {1,2,3,4,5,6,7,8,9,10};
       Log.i("MyTag",myIntegerNumbers + "");

Existem várias maneiras de imprimir os elementos de uma matriz.Em primeiro lugar, explicarei isso, o que é uma matriz? ... Matriz é uma estrutura de dados simples para armazenar dados ... Quando você define uma matriz, aloca conjunto de blocos de memória auxiliar Esses blocos de memória são usados ​​em uma unidade.

Ok, eu vou criar uma matriz como esta,

class demo{
      public static void main(String a[]){

           int[] number={1,2,3,4,5};

           System.out.print(number);
      }
}

Agora olhe para a saída,

Você pode ver uma string desconhecida impressa. Como eu mencionei antes, o endereço de memória cuja matriz (array numérica) declarada é impressa. Se você deseja exibir elementos na matriz, pode usar "for loop", como este.

class demo{
      public static void main(String a[]){

           int[] number={1,2,3,4,5};

           int i;

           for(i=0;i<number.length;i++){
                 System.out.print(number[i]+"  ");
           }
      }
}

Agora olhe para a saída,

Ok, elementos impressos com êxito de uma matriz de dimensão. Agora, vou considerar uma matriz de duas dimensões. Vou declarar uma matriz de duas dimensões como "número2" e imprimir os elementos usando a palavra-chave "Arrays.deepToString ()". Antes de usar isso Você precisará importar a biblioteca 'java.util.Arrays'.

 import java.util.Arrays;

 class demo{
      public static void main(String a[]){

           int[][] number2={{1,2},{3,4},{5,6}};`

           System.out.print(Arrays.deepToString(number2));
      }
}

considere a saída,

Ao mesmo tempo, usando dois para loops, os elementos 2D podem ser impressos .. Obrigado!