¿Cuál es la forma más sencilla de imprimir una matriz de Java?

1946

En Java, las matrices no se anulan toString(), por lo que si intenta imprimir una directamente, obtendrá el className+ '@' + el hexadecimal hashCodede la matriz, según lo definido por Object.toString():

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

Pero por lo general, en realidad nos gustaría algo más parecido [1, 2, 3, 4, 5]. ¿Cuál es la forma más sencilla de hacer eso? Aquí hay algunos ejemplos de entradas y salidas:

// 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
fuente
8
¿Qué desea que sea la representación para los objetos que no sean cadenas? ¿El resultado de llamar a toString? ¿Entre comillas o no?
Jon Skeet el
3
Sí, los objetos estarían representados por su método toString () y sin comillas (solo editó el resultado de ejemplo).
Alex Spurling
2
En la práctica, estrechamente relacionado con stackoverflow.com/questions/29140402/…
Raedwald
1
Esa salida extraña no es necesariamente la ubicación de la memoria. Es hashCode()en hexadecimal. Ver Object#toString().
4castle
1
Para imprimir una matriz unidimensional o multidimensional en java8, consulte stackoverflow.com/questions/409784/…
akhil_mittal

Respuestas:

2606

Desde Java 5 puede usar Arrays.toString(arr)o Arrays.deepToString(arr)para matrices dentro de matrices. Tenga en cuenta que la Object[]versión llama.toString() a cada objeto en la matriz. La salida incluso está decorada de la manera exacta que está preguntando.

Ejemplos:

  • Matriz simple:

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

    Salida:

    [John, Mary, Bob]
  • Matriz anidada:

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

    Salida:

    [[John, Mary], [Alice, Bob]]
  • double Formación:

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

    Salida:

    [7.0, 9.0, 5.0, 1.0, 3.0 ]
  • int Formación:

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

    Salida:

    [7, 9, 5, 1, 3 ]
RAnders00
fuente
3
¿Qué pasa si tenemos una serie de cadenas y queremos una salida simple? como:, String[] array = {"John", "Mahta", "Sara"}y queremos esta salida sin corchetes y comas John Mahta Sara:?
Hengameh
3
@Hengameh: Hay varias otras formas de hacer esto, pero mi favorita es esta: javahotchocolate.com/notes/java.html#arrays-tostring .
Russ Bateman
55
Para su información, Arrays.deepToString()acepta solo una Object [](o una matriz de clases que se extienden Object, por ejemplo Integer, por lo que no funcionará en una matriz primitiva de tipo int []. Pero Arrays.toString(<int array>)funciona bien para matrices primitivas.)
Marcus
44
@Hengameh Hay un método dedicado a eso. System.out.println(String.join(" ", new String[]{"John", "Mahta", "Sara"}))imprimirá John Mahta Sara.
user8397947
2
@dorukayhan En realidad, puede omitir explícitamente la creación de instancias aquí: String.join(" ", "John", "Mahta", "Sara")porque el .join(...)método toma la matriz como un parámetro vararg .
Amadán
354

Siempre verifique primero las bibliotecas estándar.

import java.util.Arrays;

Entonces intenta:

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

o si su matriz contiene otras matrices como elementos:

System.out.println(Arrays.deepToString(array));
Sistema límbico
fuente
¿Qué pasa si tenemos una serie de cadenas y queremos una salida simple? como:, String[] array = {"John", "Mahta", "Sara"}y queremos esta salida sin corchetes y comas John Mahta Sara:?
Hengameh
1
@Hengameh Simplemente almacene Arrays.toString (matriz) en una variable de cadena y luego elimine las llaves por el método de reemplazo de Java
Naveed Ahmad
12
Hoy en día @Hengameh con Java 8: String.join(" ", Arrays.asList(array)). doc
Justin
106

Sin embargo, es bueno saber que en cuanto a "siempre verifique primero las bibliotecas estándar", nunca me habría topado con el truco de Arrays.toString( myarray )

- dado que me estaba concentrando en el tipo de myarray para ver cómo hacer esto. No quería tener que repetir el proceso: quería una llamada fácil para que saliera similar a lo que veo en el depurador de Eclipse y myarray.toString () simplemente no lo hacía.

import java.util.Arrays;
.
.
.
System.out.println( Arrays.toString( myarray ) );
Russ Bateman
fuente
¿Qué pasa si tenemos una serie de cadenas y queremos una salida simple? como:, String[] array = {"John", "Mahta", "Sara"}y queremos esta salida sin corchetes y comas John Mahta Sara:?
Hengameh
3
@Hengameh Creo que ese es otro tema. Puede manipular esta Cadena con las operaciones de cadena comunes después ... Como Arrays.toString (myarray) .replace ("[", "("); y así sucesivamente.
OddDev
91

En JDK1.8 puede usar operaciones agregadas y una expresión 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
fuente
50
O menos engorroso,Arrays.stream(strArray).forEach(System.out::println);
Alexis C.
99
Esto es torpe. Debe ser System.out::printlncuál es una referencia de método Java 8. Su código produce una lambda innecesaria.
Boris the Spider
2
Simplemente omita el Arrays.asListy hagaArrays.stream(strArray).forEach(System.out::println)
Justin
1
@AlexisC. Porque también se puede usar con otros objetos que no sean matrices.
Yassin Hajaj
1
@YassinHajaj Ambos. Por ejemplo, si desea tener una secuencia de rango sobre la matriz, la forma idiomática Stream.ofsería hacerlo .skip(n).limit(m). La implementación actual no devuelve un flujo TAMAÑO mientras que lo Arrays.stream(T[], int, int)hace, lo que conduce a mejores rendimientos divididos si desea realizar operaciones en paralelo. Además, si tiene un int[], puede usar accidentalmente el Stream.ofque devolverá un Stream<int[]>con un solo elemento, mientras que Arrays.streamle dará un IntStreamdirectamente.
Alexis C.
41

Comenzando con Java 8, también se podría aprovechar el join()método proporcionado por la clase String para imprimir elementos de matriz, sin los corchetes, y separados por un delimitador de elección (que es el carácter de espacio para el ejemplo que se muestra a continuación):

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

La salida será "¡Hola amigo!".

laylaylom
fuente
40

Si está utilizando Java 1.4, en su lugar puede hacer:

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

(Esto también funciona en 1.5+, por supuesto).

Ross
fuente
38
Desafortunadamente, esto solo funciona con matrices de objetos, no con matrices de primitivas.
Alex Spurling
34

Arrays.toString

Como respuesta directa, la solución proporcionada por varios, incluido @Esko , utilizando los métodos Arrays.toStringy Arrays.deepToString, es simplemente la mejor.

Java 8: Stream.collect (unión ()), Stream.forEach

A continuación trato de enumerar algunos de los otros métodos sugeridos, intentando mejorar un poco, siendo la adición más notable el uso del Stream.collectoperador, usando a , para imitar lo que está haciendo.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);
Yoyó
fuente
33

Antes de Java 8

Podríamos haber usado Arrays.toString(array)para imprimir una matriz unidimensional y Arrays.deepToString(array)para matrices multidimensionales.

Java 8

Ahora tenemos la opción de Streame lambdaimprimir la matriz.

Impresión de matriz unidimensional:

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

El resultado es:

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

Impresión de matriz multidimensional En caso de que queramos imprimir una matriz multidimensional, podemos utilizarla 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);
} 

Ahora, el punto a observar es que el método Arrays.stream(T[]), que en caso de que int[]nos devuelva, Stream<int[]>y luego el método, flatMapToInt()asigna cada elemento de la secuencia con el contenido de una secuencia asignada producida mediante la aplicación de la función de asignación proporcionada a cada elemento.

El resultado es:

[[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
fuente
¿Qué pasa si tenemos una serie de cadenas y queremos una salida simple? como:, String[] array = {"John", "Mahta", "Sara"}y queremos esta salida sin corchetes y comas John Mahta Sara:?
Hengameh
28

Arrays.deepToString(arr) solo imprime en una línea.

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

Para conseguir que una tabla se imprima como una tabla bidimensional, tuve que hacer esto:

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

Parece que el Arrays.deepToString(arr)método debería tomar una cadena de separación, pero desafortunadamente no lo hace.

Rhyous
fuente
3
Tal vez use System.getProperty ("line.separator"); en lugar de \ r \ n, por lo que también es adecuado para Windows.
Scooter
puede usar System.lineSeparator () ahora
Novaterata
20
for(int n: someArray) {
    System.out.println(n+" ");
}
somedude
fuente
66
De esta manera terminas con un espacio vacío;)
Matthias
1
@ matthiad .. esta línea evitará terminar con un espacio vacío System.out.println (n + (someArray.length == n)? "": "");
Muhammad Suleman
3
La peor forma de hacerlo.
NameNotFoundException
@MuhammadSuleman Eso no funciona, porque este es un ciclo para cada uno. nes el valor real de la matriz, no el índice. Para un ciclo for regular, también lo sería (someArray.length - 1) == i, porque se rompe cuando ies igual a la longitud de la matriz.
Radiodef
17

Diferentes formas de imprimir matrices en Java:

  1. Manera simple

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

Salida: [Uno, Dos, Tres, Cuatro]

  1. Utilizando toString()

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

Salida: [Uno, Dos, Tres, Cuatro]

  1. Matriz de impresión de matrices

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

Salida: [[Ljava.lang.String; @ 1ad086a [[Ljava.lang.String; @ 10385c1, [Ljava.lang.String; @ 42719c] [[Quinto, Sexto], [Séptimo, Octavo]]

Recurso: acceder a una matriz

Affy
fuente
13

En mi opinión, usar el ciclo regular for es la forma más sencilla de imprimir una matriz. Aquí tienes un código de muestra basado en tu intArray

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

Da salida como la suya 1, 2, 3, 4, 5

Andrew_Dublin
fuente
44
Imprime "1, 2, 3, 4, 5" como salida, también imprime una coma después del último elemento.
icza
¿Cuál es la solución para no tener una coma después del último elemento?
Mona Jalal
3
Puede reemplazar el código dentro del bucle conSystem.out.print(intArray[i]); if(i != intArray.length - 1) System.out.print(", ");
Nepoxx
2
También podría usar System.out.print(i + (i < intArray.length - 1 ? ", " : ""));para combinar esas dos líneas.
Nick Suwyn el
Puede usar un StringBuilder y truncar la coma final. int [] intArray = new int [] {1, 2, 3, 4, 5}; StringBuilder final sb = new StringBuilder (); for (int i: intArray) {sb.append (intArray [i]). append (","); } if (sb.length ()> 0) {sb.setLength (sb.length () - 1); } System.out.println (sb.toString ()); Esto genera "1, 2, 3, 4, 5".
Rick Ryker
8

Me encontré con esta publicación en Vanilla #Java recientemente. No es muy conveniente escribir Arrays.toString(arr);, luego importar java.util.Arrays;todo el tiempo.

Tenga en cuenta que esto no es una solución permanente de ninguna manera. Solo un truco que puede simplificar la depuración.

Imprimir una matriz directamente proporciona la representación interna y el hashCode. Ahora, todas las clases tienen Objectcomo tipo padre. Entonces, ¿por qué no hackear el Object.toString()? Sin modificación, la clase Object se ve así:

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

¿Qué pasa si esto se cambia a:

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

Esta clase modificada simplemente se puede agregar a la ruta de clase agregando lo siguiente a la línea de comando: -Xbootclasspath/p:target/classes .

Ahora, con la disponibilidad deepToString(..)desde Java 5, toString(..)se puede cambiar fácilmente adeepToString(..) para agregar soporte para matrices que contienen otras matrices.

Encontré que este es un truco bastante útil y sería genial si Java simplemente pudiera agregar esto. Entiendo posibles problemas con tener matrices muy grandes ya que las representaciones de cadenas podrían ser problemáticas. Tal vez pasar algo como a System.outo a PrintWriterpara tales eventualidades.

Rayo Debosmit
fuente
2
quieres ejecutar estas ifcondiciones en cada objeto?
sidgate
+1 solo por la idea, pero según el comentario anterior, ¿podemos modificar las implementaciones de la matriz directamente en lugar de depender del Objectpadre común? ¿Podemos trabajar esa idea más allá? No es que piense que modificar el comportamiento predeterminado de los objetos java.lang. * Es algo que recomendaría ...
YoYo
8

Siempre debería funcionar cualquier versión de JDK que use:

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

Funcionará si Arraycontiene Objetos. Si Arraycontiene tipos primitivos, puede usar clases de contenedor en lugar de almacenar el primitivo directamente como ...

Ejemplo:

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

Reemplácelo con:

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

Actualización:

Si ! Esto debe mencionarse que convertir una matriz en una matriz de objetos O para usar la matriz del Objeto es costoso y puede retrasar la ejecución. sucede por la naturaleza de java llamada autoboxing.

Por lo tanto, solo para fines de impresión, no debe usarse. podemos hacer una función que tome una matriz como parámetro e imprima el formato deseado como

public void printArray(int [] a){
        //write printing code
} 
Greesh Kumar
fuente
1
Convertir una matriz en una lista simplemente con fines de impresión no parece una decisión muy ingeniosa; y dado que la misma clase tiene un toString(..), me derrota por qué alguien haría esto.
Debosmit Ray
8

En java 8 es fácil. hay dos palabras clave

  1. corriente: Arrays.stream(intArray).forEach
  2. referencia del método: ::println

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

Si desea imprimir todos los elementos en la matriz en la misma línea, simplemente use en printlugar de printlnie

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

Otra forma sin referencia de método solo usa:

int[] intArray = new int[] {1, 2, 3, 4, 5};
System.out.println(Arrays.toString(intArray));
suatCoskun
fuente
1
Esto imprimirá cada elemento de la matriz en una línea separada para que no cumpla con los requisitos.
Alex Spurling
si desea imprimir todos los elementos de la matriz en la misma línea, simplemente use print en lugar de println, es decir, int [] intArray = new int [] {1, 2, 3, 4, 5}; Arrays.stream (intArray) .forEach (System.out :: print); antiderway sin referencia de método solo use int [] intArray = new int [] {1, 2, 3, 4, 5}; System.out.println (Arrays.toString (intArray));
suatCoskun
6

Hay una forma adicional si su matriz es de tipo char []:

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

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

huellas dactilares

abc
Vagar
fuente
5

Para agregar a todas las respuestas, imprimir el objeto como una cadena JSON también es una opción.

Usando Jackson:

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

Usando Gson:

Gson gson = new Gson();
System.out.println(gson.toJson(anyArray));
Jean Logeart
fuente
Esto es lo que hago. Con esto, puede imprimir estructuras arbitrariamente complejas siempre que sean codificables para JSON. Siempre me aseguro de usar "bonita". ¿Tu segundo ejemplo hace eso? Creo que tendrías que hacerle cosquillas a una opción "bonita" para conseguir eso.
Steve
5

Puede recorrer la matriz e imprimir cada elemento a medida que avanza. Por ejemplo:

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

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

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

}

Salida:

item 1
item 2
item 3
Dylan Black
fuente
5

Hay siguientes maneras de imprimir 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
fuente
4

Un atajo simplificado que he probado es este:

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

Imprimirá

1
2
3

No se requieren bucles en este enfoque y es mejor solo para matrices pequeñas

Mohamed Idris
fuente
4

For-each loop también se puede usar para imprimir elementos de la matriz:

int array[] = {1, 2, 3, 4, 5};
for (int i:array)
    System.out.println(i);
hasham.98
fuente
@firephil System.out.println (a [i]); se usa con el ciclo ordinario for, donde se crea el índice "i" y se imprime el valor en cada índice. He usado "para cada" bucle. Pruébalo, espero que entiendas mi punto.
hasham.98
Sí, esta es la forma más corta de imprimir matriz
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
fuente
3

El uso de los métodos org.apache.commons.lang3.StringUtils.join (*) puede ser una opción.
Por ejemplo:

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

Usé la siguiente dependencia

<groupId>org.apache.commons</groupId>
<artifactId>commons-lang3</artifactId>
<version>3.3.2</version>
Haim Raman
fuente
Agregar una dependencia debido a algo trivial que se hace en dos líneas de código es un antipatrón gritador.
jurez
commons-lang3 es una dependencia muy popular, y tenga en cuenta que esta respuesta fue donde la mayoría de la gente no usaba Java 8
Haim Raman
2

Esto se marca como un duplicado para imprimir un byte [] . Nota: para una matriz de bytes hay métodos adicionales que pueden ser apropiados.

Puede imprimirlo como una cadena si contiene 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);

o si contiene una cadena UTF-8

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

o si quieres imprimirlo como hexadecimal.

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

o si quieres imprimirlo como base64.

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

o si desea imprimir una matriz de valores de bytes firmados

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

o si desea imprimir una matriz de valores de bytes sin signo

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

si está ejecutando 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);

salida:

[7,3,5,1,3]
shellhub
fuente
Esto es mejor que la respuesta aceptada, ya que da más control sobre el delimitador, el prefijo y el sufijo. Sin embargo, eliminaría lo superfluo toString()en la final System.out.println()y lo usaría en joiner.add(element.toString())lugar de agregar la cadena vacía. Esta solución también funciona para matrices de tipos no primitivos, de manera uniforme.
John McClane
Lo malo es que el element.toString()interior joiner.add()es solo para tipos no primitivos. Aún necesita usar Integer.toString(element)construcciones similares para tipos primitivos. Personalmente, usé foreach loop en for (int element : array) joiner.add(Integer.toString(element));lugar de streams, pero eso es cuestión de gustos.
John McClane
0

En java 8:

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

Si usa la biblioteca Commons.Lang , podríamos hacer:

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

Salida:

{1,2,3,4,5}
{John,Mary,Bob}
Pradip Karki
fuente
0

// Si imprime la dirección del elemento de matriz en la consola en java.

      int myArrayElement[] = {1,2,3,4,5,6,7,8,9,10};
       Log.i("MyTag",myIntegerNumbers + "");
TEJVEER SINGH
fuente
Esto no parece responder la pregunta.
usuario
-1

Hay varias formas de imprimir elementos de una matriz. En primer lugar, explicaré eso, ¿qué es una matriz? ... La matriz es una estructura de datos simple para almacenar datos ... Cuando defina una matriz, asigne un conjunto de bloques de memoria auxiliar en RAM. Esos bloques de memoria se toman una unidad ..

Ok, crearé una matriz como esta,

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

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

           System.out.print(number);
      }
}

Ahora mira la salida,

ingrese la descripción de la imagen aquí

Puede ver una cadena desconocida impresa ... Como mencioné antes, se imprime la dirección de memoria cuya matriz (matriz de números) declarada. Si desea mostrar elementos en la matriz, puede usar "for loop", de esta manera ...

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]+"  ");
           }
      }
}

Ahora mira la salida,

ingrese la descripción de la imagen aquí

Ok, imprimí correctamente elementos de una matriz de una dimensión ... Ahora voy a considerar una matriz de dos dimensiones ... Declararé una matriz de dos dimensiones como "número2" e imprimiré los elementos usando la palabra clave "Arrays.deepToString ()". Antes de usar eso Tendrá que importar la 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));
      }
}

considerar la salida,

ingrese la descripción de la imagen aquí

Al mismo tiempo, con dos bucles for, se pueden imprimir elementos 2D ... ¡Gracias!

GT_hash
fuente
int array [] = {1, 2, 3, 4, 5}; para (int i: array) System.out.println (i);
Manjitha teshara
intente esto creo que esto es camino más corto para imprimir gama
Manjitha teshara
"la dirección de memoria cuya matriz (matriz de números) declarada está impresa" Eso no es cierto en absoluto, su código de objeto de hash del sistema, y ​​esto puede basarse en muchas cosas, incluida la dirección de memoria, pero esto podría cambiar más adelante y el código de hash no cambio. Y actualmente es principalmente un número aleatorio. gotofinal.dev/java/2017/10/08/java-default-hashcode.html
GotoFinal