¿Cuál es la forma más sencilla de imprimir una matriz de Java?
Pregunta
En Java, las matrices no anulan toString()
, por lo que si intenta imprimir una directamente, obtendrá el className + @ + el hexadecimal de hashCode
de 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, queremos algo más como [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]
Solución
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 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
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
Matriz:int[] intArray = { 7, 9, 5, 1, 3 }; System.out.println(Arrays.toString(intArray));
Salida:
[7, 9, 5, 1, 3 ]
Otros consejos
Siempre verifique primero las bibliotecas estándar. Prueba:
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 saberlo, ya que " siempre verifique las bibliotecas estándar primero " 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 ) );
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));
(Por supuesto, esto también funciona en 1.5+).
A partir de Java 8, también se podría aprovechar el método join()
proporcionado por Clase de cadena para imprimir elementos de matriz, sin los corchetes, y separados por un delimitador de elección (que es el espacio carácter para el ejemplo que se muestra a continuación):
String[] greeting = {"Hey", "there", "amigo!"};
String delimiter = " ";
String.join(delimiter, greeting)
El resultado será " ¡Hola amigo! " ;.
Arrays.toString
Como respuesta directa, la solución provista por varios, incluido @Esko , utilizando Arrays.toString
y Arrays.deepToString
, es simplemente lo mejor.
Java 8 - Stream.collect (join ()), Stream.forEach
A continuación, trato de enumerar algunos de los otros métodos sugeridos, intentando mejorar un poco, y la adición más notable es el uso de Stream.collect
, usando un operador < código> unirse Collector
, para imitar lo que está haciendo 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 utilizado Arrays.toString (array)
para imprimir una matriz dimensional y Arrays.deepToString (array)
para matrices multidimensionales.
Java 8
Ahora tenemos la opción de Stream
y lambda
para imprimir la matriz.
Imprimiendo una matriz tridimensional:
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);
}
La salida es:
[1, 2, 3, 4, 5]
[Juan, María, Bob]
1
2
3
4
5
John
Maria
Bob
Imprimir matriz multidimensional
En caso de que queramos imprimir matrices multidimensionales, podemos utilizar 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 < int [] >
y luego el método flatMapToInt ()
asigna cada elemento de flujo con el contenido de un flujo mapeado producido al aplicar la función de mapeo provista a cada elemento.
La salida es:
[[11, 12], [21, 22], [31, 32, 33]]
[[John, Bravo], [Mary, Lee], [Bob, Johnson]]
11
12
21
22
31
32
33
John
Bravo
Maria
Lee
Bob
Johnson
Arrays.deepToString (arr)
solo imprime en una línea.
int[][] table = new int[2][2];
Para lograr 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 método Arrays.deepToString (arr)
debería tomar una cadena de separación, pero desafortunadamente no lo hace.
for(int n: someArray) {
System.out.println(n+" ");
}
Diferentes formas de imprimir arrays en Java:
-
Forma 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]
-
Usando
toString()
String[] array = new String[] { "One", "Two", "Three", "Four" }; System.out.println(Arrays.toString(array));
Salida: [Uno, Dos, Tres, Cuatro]
-
Imprimir 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: Acceso Una matriz
Usar el ciclo regular para es la forma más sencilla de imprimir matrices en mi opinión. Aquí tiene un código de ejemplo basado en su intArray
for (int i = 0; i < intArray.length; i++) {
System.out.print(intArray[i] + ", ");
}
Da salida como tuya 1, 2, 3, 4, 5
Me encontré con este post 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.
La impresión de una matriz da directamente la representación interna y el código de hash. Ahora, todas las clases tienen Object
como tipo padre. Entonces, ¿por qué no hackear el Object.toString ()
? Sin modificación, la clase de Objeto 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 clases agregando lo siguiente a la línea de comando: -Xbootclasspath / p: target / classes
.
Ahora, con la disponibilidad de deepToString (..)
desde Java 5, el toString (..)
se puede cambiar fácilmente a deepToString (.. )
para agregar compatibilidad con matrices que contienen otras matrices.
Encontré que este es un truco muy útil y sería genial si Java pudiera simplemente agregar esto. Entiendo los problemas potenciales de tener matrices muy grandes ya que las representaciones de cadena podrían ser problemáticas. Tal vez pase algo como un System.out
o un PrintWriter
para tales eventualidades.
Siempre debería funcionar con la versión de JDK que utilice:
System.out.println(Arrays.asList(array));
Funcionará si el Array
contiene Objetos. Si el Array
contiene tipos primitivos, puede usar clases de envoltorio en lugar de almacenar el primitivo directamente como ...
Ejemplo:
int[] a = new int[]{1,2,3,4,5};
Reemplázalo con:
Integer[] a = new Integer[]{1,2,3,4,5};
Actualización:
¡Sí! esto es para mencionar que convertir una matriz en una matriz de objetos O para usar la matriz del Objeto es costoso y puede ralentizar la ejecución. Sucede por la naturaleza del java llamado autoboxing.
Por lo tanto, solo para fines de impresión, no debe utilizarse. 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
- transmisión:
Arrays.stream(intArray).forEach
-
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 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);
Otra forma sin referencia de método es usar:
int[] intArray = new int[] {1, 2, 3, 4, 5};
System.out.println(Arrays.toString(intArray));
Hay una forma adicional si su matriz es de tipo char []:
char A[] = {'a', 'b', 'c'};
System.out.println(A); // no other arguments
impresiones
abc
Para agregar a todas las respuestas, la impresión del 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 intentado es este:
int x[] = {1,2,3};
String printableText = Arrays.toString(x).replaceAll("[\\[\\]]", "").replaceAll(", ", "\n");
System.out.println(printableText);
Se imprimirá
1
2
3
No se requieren bucles en este enfoque y es mejor solo para arreglos pequeños
Podrías recorrer la matriz, imprimiendo cada elemento, mientras haces un bucle. 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
Hay una forma siguiente de imprimir Array
// 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);
}
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);
}
}
}
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>
También se puede utilizar para cada bucle para imprimir elementos de matriz:
int array[] = {1, 2, 3, 4, 5};
for (int i:array)
System.out.println(i);
Esto está marcado como un duplicado para imprimiendo 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 firmar
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]
En java 8:
Arrays.stream(myArray).forEach(System.out::println);
Hay varias formas de imprimir elementos de una matriz. En primer lugar, explicaré 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 la 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,
Puede ver una cadena desconocida impresa ... Como mencioné anteriormente, se imprime la dirección de la memoria cuya matriz (matriz numérica) declarada. Si desea mostrar elementos en la matriz, puede usar " para bucle " , como esto ..
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,
Bien, elementos impresos con éxito de una matriz de dimensión ... Ahora voy a considerar la matriz de dos dimensiones ... Declararé la matriz de dos dimensiones como " número2 " e imprima los elementos utilizando " Arrays.deepToString () " keyword.Antes de usarlo, 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));
}
}
considera la salida,
Al mismo tiempo, utilizando dos para bucles, se pueden imprimir elementos 2D ... ¡Gracias!
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]
Si utilizamos Commons.Lang library , 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}
Si desea imprimir, evalúe el contenido de la matriz de manera que pueda usar Arrays.toString
jshell> String[] names = {"ram","shyam"};
names ==> String[2] { "ram", "shyam" }
jshell> Arrays.toString(names);
$2 ==> "[ram, shyam]"
jshell>