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

En Java, las matrices no anulan a toString() , por lo que si intenta imprimir una directamente, obtendrá className + @ + el hex del hashCode de la matriz, como se define por Object.toString() :

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

Pero generalmente desearíamos algo más como [1, 2, 3, 4, 5] . ¿Cuál es la forma más simple 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] 

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

Ejemplos:

Arreglo 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 matriz:

 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 Array:

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

Salida:

 [7, 9, 5, 1, 3 ] 

Siempre verifique primero las bibliotecas estándar. Tratar:

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

o si su matriz contiene otras matrices como elementos:

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

Sin embargo, es bueno saber que, como “siempre verifique primero las bibliotecas estándar”, nunca me habría tropezado con el truco de Arrays.toString( myarray )

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

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

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 */ 

Si está utilizando Java 1.4, puede hacer lo siguiente:

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

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

A partir de Java 8, también se podría aprovechar el método join() 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á “Hey there amigo!”.

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

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

Para obtener una tabla para imprimir como una tabla bidimensional, tenía que hacer esto:

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

Parece que el Arrays.deepToString(arr) debería tomar una cadena de separación, pero desafortunadamente no es así.

Arrays.toString

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

Java 8 – Stream.collect (joining ()), Stream.forEach

A continuación, bash enumerar algunos de los otros métodos sugeridos, intentando mejorar un poco, y la adición más notable es el uso del operador Stream.collect , que usa un Collector joining , para imitar lo que está haciendo el String.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 de Java 8 podríamos haber usado Arrays.toString(array) para imprimir una matriz dimensional y Arrays.deepToString(array) para matrices multidimensionales. Tenemos la opción de Stream y lambda en Java 8 que también se puede usar para imprimir la matriz.

Impresión de una 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); } 

El resultado es:

[1, 2, 3, 4, 5]
[John, Mary, Bob]
1
2
3
4
5
John
María
Chelín

Impresión de matriz multidimensional En caso de que deseemos 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); } 

Ahora, el punto a observar es que el método Arrays.stream(T[]) , que en el caso de int[] nos devuelve Stream y luego el método flatMapToInt() correlaciona cada elemento de la secuencia con los contenidos de un mapa flujo producido al aplicar la función de mapeo 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
María
Sotavento
Chelín
Johnson

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

Diferentes formas de imprimir matrices en Java:

  1. Manera simple

     List list = new ArrayList(); 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. Usar toString()

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

Salida: [Uno, dos, tres, cuatro]

  1. Impresión de matriz 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: Acceda a una matriz

Usar el bucle regular for es la forma más sencilla de imprimir matriz, en mi opinión. 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 tuyo 1, 2, 3, 4, 5

Me encontré con esta publicación en Vanilla #Java recientemente. No es muy conveniente escribir Arrays.toString(arr); , luego importando 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 da la representación interna y el hashCode. Ahora, todas las clases tienen Object como parent-type. Entonces, ¿por qué no hackear 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 modded puede simplemente agregarse a la ruta de clase agregando lo siguiente a la línea de comando: -Xbootclasspath/p:target/classes .

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

Me pareció un truco bastante útil y sería genial si Java simplemente pudiera agregar esto. Entiendo los posibles problemas con tener matrices muy grandes, ya que las representaciones de cadenas podrían ser problemáticas. Tal vez pase algo como un System.out o un PrintWriter para tales eventualidades.

Siempre debería funcionar cualquiera que sea la versión de JDK que use:

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

Funcionará si la Array contiene objetos. Si la Array contiene tipos primitivos, puede usar clases de contenedor en su lugar, almacenar la primitiva directamente como …

Ejemplo:

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

Reemplazarlo por:

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

Actualización:

¡Sí! se debe mencionar que convertir una matriz en una matriz de objetos O usar la matriz del Objeto es costoso y puede ralentizar 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 toma una matriz como parámetro e imprime el formato deseado como

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

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

  1. stream: Arrays.stream(intArray).forEach
  2. referencia de 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 print lugar de println es decir,

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

Otra forma sin referencia al método solo use:

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

Hay una forma adicional si tu matriz es del tipo char []:

 char A[] = {'a', 'b', 'c'}; System.out.println(A); // no other arguments 

huellas dactilares

 abc 

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

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 arreglos pequeños

Puede recorrer el conjunto e imprimir cada elemento mientras realiza un ciclo. 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 
 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); } } } 

Usar 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

 org.apache.commons commons-lang3 3.3.2 

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

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

Hay una manera siguiente de imprimir la 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); } 
 // 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] 

Esto está marcado 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 desea imprimirlo como hexadecimal.

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

o si desea 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. 

En java 8:

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

Hay varias maneras 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. Estos 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,

enter image description here

Puede ver una cadena desconocida impresa. Como mencioné anteriormente, la dirección de memoria cuya matriz (array numérico) está declarada está impresa. Si desea visualizar elementos en la matriz, puede 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 

Ahora mira la salida,

enter image description here

Ok, elementos impresos con éxito de una matriz de dimensiones ... 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 esa matriz Deberá 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,

enter image description here

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

Si desea imprimir, evalúe el contenido de Array de esa manera, puede usar Arrays.toString

 jshell> String[] names = {"ram","shyam"}; names ==> String[2] { "ram", "shyam" } jshell> Arrays.toString(names); $2 ==> "[ram, shyam]" jshell> 

Podría usar Arrays.toString()

 String[] array = { "a", "b", "c" }; System.out.println(Arrays.toString(array)); 

La forma más sencilla de imprimir una matriz es usar un for-loop:

 // initialize array for(int i=0;i