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

1946

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]
Alex Spurling
fonte
8
O que você deseja que a representação seja para objetos que não sejam strings? O resultado de chamar toString? Entre aspas ou não?
Jon Skeet
3
Sim, os objetos seriam representados pelo método toString () e sem aspas (apenas editei o exemplo de saída).
Alex Spurling
2
Na prática, intimamente relacionado a stackoverflow.com/questions/29140402/…
Raedwald
1
Essa saída estranha não é necessariamente o local da memória. É o hashCode()hexadecimal. Veja Object#toString().
4castle
1
Para imprimir uma matriz unidimensional ou multidimensional no java8, verifique stackoverflow.com/questions/409784/…
akhil_mittal

Respostas:

2605

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 ]
RAnders00
fonte
3
E se tivermos uma matriz de strings e quisermos uma saída simples; like:, String[] array = {"John", "Mahta", "Sara"}e queremos essa saída sem colchetes e vírgulas John Mahta Sara:?
Hengameh 29/08/2015
3
@Hengameh: Existem várias outras maneiras de fazer isso, mas a minha favorita é essa: javahotchocolate.com/notes/java.html#arrays-tostring .
22815 Russ Bateman
5
Para sua informação, Arrays.deepToString()aceita apenas uma Object [](ou uma matriz de classes que se estendem Object, como Integer, por exemplo , para que não funcione em uma matriz primitiva de tipo int []. Mas Arrays.toString(<int array>)funciona bem para matrizes primitivas.
Marcus
4
@Hengameh Existe um método dedicado a isso. System.out.println(String.join(" ", new String[]{"John", "Mahta", "Sara"}))irá imprimir John Mahta Sara.
user8397947
2
@dorukayhan Na verdade, você pode omitir a instanciação explícita da matriz aqui: String.join(" ", "John", "Mahta", "Sara")o .join(...)método leva a matriz como um parâmetro vararg .
Amadán 18/08/19
354

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));
Sistema límbico
fonte
E se tivermos uma matriz de strings e quisermos uma saída simples; like:, String[] array = {"John", "Mahta", "Sara"}e queremos essa saída sem colchetes e vírgulas John Mahta Sara:?
Hengameh 29/08/2015
1
@Hengameh apenas armazenar Arrays.toString (array) para uma cadeia variável e, em seguida, remover o aparelho por substituir método de Java
Naveed Ahmad
12
@Hengameh Hoje em dia com Java 8: String.join(" ", Arrays.asList(array)). doc
Justin
106

É 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 ) );
Russ Bateman
fonte
E se tivermos uma matriz de strings e quisermos uma saída simples; gostar:String[] array = {"John", "Mahta", "Sara"}e queremos essa saída sem colchetes e vírgulas John Mahta Sara:?
Hengameh 29/08/2015
3
@ Hengameh, acho que esse é outro tópico. Você pode manipular essa String com as operações comuns de string posteriormente ... Como Arrays.toString (myarray) .replace ("[", "(")) e assim por diante.
OddDev
91

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
*/
Eric Baker
fonte
50
Ou menos complicado, #Arrays.stream(strArray).forEach(System.out::println);
Alexis C.
9
Isso é desajeitado. Deve ser System.out::printlnqual é uma referência do método Java 8. Seu código produz uma lambda desnecessária.
Boris, a Aranha
2
Simplesmente ignorar o Arrays.asListe façaArrays.stream(strArray).forEach(System.out::println)
Justin
1
@AlexisC. Porque também pode ser usado com outros objetos além de matrizes.
Yassin Hajaj 27/03
1
@YassinHajaj Both. Por exemplo, se você deseja ter um fluxo de intervalo sobre a matriz, a maneira idiomática usando Stream.ofseria .skip(n).limit(m). A implementação atual não retorna um fluxo SIZED, retornando Arrays.stream(T[], int, int), resultando em melhores desempenhos de divisão, se você deseja executar operações em paralelo. Além disso, se você tiver um int[], poderá acidentalmente usar o Stream.ofque retornará a Stream<int[]>com um único elemento, enquanto Arrays.streamo fornecerá IntStreamdiretamente.
Alexis C.
41

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!".

laylaylom
fonte
40

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

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

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

Ross
fonte
38
Infelizmente, isso funciona apenas com matrizes de objetos, não com matrizes de primitivas.
Alex Spurling
34

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);
YoYo
fonte
33

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

akhil_mittal
fonte
E se tivermos uma matriz de strings e quisermos uma saída simples; like:, String[] array = {"John", "Mahta", "Sara"}e queremos essa saída sem colchetes e vírgulas John Mahta Sara:?
Hengameh 29/08/2015
28

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.

Rhyous
fonte
3
Talvez use System.getProperty ("line.separator"); em vez de \ r \ n, também é adequado para não-Windows.
Scooter
você pode usar System.lineSeparator () agora
Novaterata 7/17
20
for(int n: someArray) {
    System.out.println(n+" ");
}
somedude
fonte
6
Dessa forma, você acaba com um espaço vazio;)
Matthias
1
@ matthiad .. essa linha evitará terminar com espaço vazio System.out.println (n + (someArray.length == n)? "": "");
Muhammad Suleman
3
Pior maneira de fazer isso.
NameNotFoundException
@MuhammadSuleman Isso não funciona, porque esse é um loop for-each. né o valor real da matriz, não o índice. Para um loop for regular, também seria (someArray.length - 1) == i, porque quebra quando ié igual ao comprimento da matriz.
Radiodef 6/08
17

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]

  1. Usando toString()

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

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

  1. 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

Affy
fonte
13

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

Andrew_Dublin
fonte
4
Imprime "1, 2, 3, 4, 5" como saída, e também vírgula após o último elemento.
icza 10/03/14
Qual é a solução para não ter vírgula após o último elemento?
Mona Jalal
3
Você pode substituir o código dentro do loop por #System.out.print(intArray[i]); if(i != intArray.length - 1) System.out.print(", ");
Nepoxx 16/07
2
Você também pode usar System.out.print(i + (i < intArray.length - 1 ? ", " : ""));para combinar essas duas linhas.
precisa saber é o seguinte
Você pode usar um StringBuilder e truncar a vírgula à direita. int [] intArray = novo int [] {1, 2, 3, 4, 5}; final StringBuilder sb = novo StringBuilder (); for (int i: intArray) {sb.append (intArray [i]). append (","); } if (sb.length ()> 0) {sb.setLength (sb.length () - 1); } System.out.println (sb.toString ()); Isso gera "1, 2, 3, 4, 5".
Rick Ryker
8

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.

Debosmit Ray
fonte
2
você deseja executar essas ifcondições em todos os objetos?
sidgate
+1 apenas para a ideia, mas com base no comentário anterior, podemos modificar as implementações da matriz diretamente, em vez de depender do Objectpai comum? Podemos trabalhar essa idéia mais adiante? . Não que eu ache que modificar o comportamento padrão do java.lang * objetos é algo que eu encorajaria ...
YoYo
8

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
} 
Greesh Kumar
fonte
1
Converter uma matriz em uma lista simplesmente para fins de impressão não parece uma decisão muito engenhosa; e, como a mesma classe tem uma toString(..), me derrota por que alguém faria isso.
Debosmit Ray
8

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));
suatCoskun
fonte
1
Isso imprimirá cada elemento da matriz em uma linha separada, para que não atenda aos requisitos.
precisa
se você quiser imprimir todos os elementos da matriz na mesma linha, use apenas print em vez de println, ou seja, int [] intArray = new int [] {1, 2, 3, 4, 5}; Arrays.stream (intArray) .forEach (System.out :: print); antotherway sem referência de método, use int [] intArray = new int [] {1, 2, 3, 4, 5}; System.out.println (Arrays.toString (intArray));
suatCoskun
6

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
Roam
fonte
5

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));
Jean Logeart
fonte
Isto é o que eu faço. Com isso, você pode imprimir estruturas arbitrariamente complexas, desde que sejam codificáveis ​​para JSON. Eu sempre me certifico de usar "bonita". Seu segundo exemplo faz isso? Eu acho que você precisa marcar uma opção "bonita" para conseguir isso.
10249 Steve Steve
5

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
Dylan Black
fonte
5

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);
     }
Ravi Patel
fonte
4

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

Mohamed Idris
fonte
4

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);
hasham.98
fonte
@firephil System.out.println (a [i]); é usado com o loop for ordinário, onde o índice "i" é criado e o valor em cada índice é impresso. Eu usei "para cada" loop. Experimente, espero que você entenda meu ponto.
hasham.98
Sim, este é o caminho mais curto para a variedade de impressão
Manjitha teshara
3
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);
        }
      }
    }
SamTebbs33
fonte
3

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>
Haim Raman
fonte
Adicionar uma dependência por causa de algo trivial que é feito em duas linhas de código é um antipadrão gritante.
jurez
commons-lang3 é uma dependência muito popular, e observe que essa resposta foi quando a maioria das pessoas não usou o java 8
Haim Raman
2

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.
Peter Lawrey
fonte
1
// 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]
fjnk
fonte
1

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]
shellhub
fonte
Isso é melhor que a resposta aceita, pois oferece mais controle sobre o delimitador, prefixo e sufixo. No entanto, eu removia o supérfluo toString()na final System.out.println()e o usava em joiner.add(element.toString())vez de adicionar a string vazia. Essa solução também funciona para matrizes de tipos não primitivos, de maneira uniforme.
precisa
Meu mau, element.toString()interior joiner.add()é apenas para tipos não primitivos. Você ainda precisa usar Integer.toString(element)construções semelhantes a tipos primitivos. Pessoalmente, usei foreach loop em for (int element : array) joiner.add(Integer.toString(element));vez de streams, mas essa é a questão do gosto.
John McClane
0

No java 8:

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

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}
Pradip Karki
fonte
0

// 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 + "");
TEJVEER SINGH
fonte
Isso não parece responder à pergunta.
usuário
-1

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,

insira a descrição da imagem aqui

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,

insira a descrição da imagem aqui

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,

insira a descrição da imagem aqui

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

GT_hash
fonte
matriz int [] = {1, 2, 3, 4, 5}; para (int i: matriz) System.out.println (i);
Manjitha teshara
tente isso eu acho que este é o caminho mais curto para imprimir série
Manjitha teshara
"o endereço de memória cuja matriz (matriz numérica) declarada é impressa" Isso não é verdade, o código de objeto do sistema hash e isso pode ser baseado em muitas coisas, incluindo endereço de memória, mas isso pode mudar mais tarde e o código hash não mudança. E atualmente é principalmente um número aleatório. gotofinal.dev/java/2017/10/08/java-default-hashcode.html
GotoFinal 14/01