una - matrices en java netbeans




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

Arrays.toString

Como respuesta directa, la solución provista por varios, incluido @Esko , utilizando los métodos Arrays.toString y Arrays.deepToString , es simplemente la 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 del operador Stream.collect , utilizando un Collector joining , para imitar lo que hace 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);

En Java, los arreglos no reemplazan a toString() , así que si intentas imprimir uno directamente, obtienes el className + @ + el hex del hashCode del arreglo, como lo define Object.toString() :

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

Pero generalmente 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]

Antes de Java 8, podríamos haber utilizado 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 utilizar para imprimir la matriz.

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

La salida es:

[1, 2, 3, 4, 5]
[John, Mary, Bob]
1
2
3
4
5
Juan
María
Mover

Impresión de matriz multidimensional En caso de que queramos 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<int[]> y luego el método flatMapToInt() mapea cada elemento de stream con el contenido de un mapeado. flujo 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
Juan
Bravo
María
Sotavento
Mover
Johnson


Desde Java 5 puede usar Arrays.toString(arr) para arreglos simples o Arrays.deepToString(arr) para arreglos anidados. Tenga en cuenta que la versión del Object[] llama a .toString() en cada objeto de la matriz. La salida incluso está decorada de la manera exacta en que lo estás pidiendo.

Ejemplos:

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

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 ]

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]

Utilicé la siguiente dependencia

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

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

  1. stream: 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 de 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 de método solo usa:

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

En java 8:

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

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

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 define una matriz, asigne un conjunto de bloques de memoria auxiliar. en la memoria RAM. Esos bloques de memoria se toman una unidad ..

Ok, voy a 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 memoria cuya matriz (matriz numérica) declarada. Si desea mostrar elementos en la matriz, puede usar "for loop", 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, he imprimido con éxito los elementos 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 imprimiré los elementos utilizando la palabra clave "Arrays.deepToString ()". Antes de usarla 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,

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


Me encontré con este post en Vanilla #Java recientemente. No es muy conveniente escribir Arrays.toString(arr); , luego importando java.util.Arrays; todo el tiempo.

Tenga en cuenta, esto no es una solución permanente de ninguna manera. Solo un hack 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 el tipo padre. Entonces, ¿por qué no hackear el Object.toString() ? Sin modificación, la clase 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 comandos: -Xbootclasspath/p:target/classes .

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

Descubrí que esto 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.


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

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

Podrías usar Arrays.toString()

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

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


Siempre debería funcionar con la versión de JDK que uses:

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

Funcionará si la Array contiene objetos. Si la Array contiene tipos primitivos, puede usar clases de envoltorio en lugar de almacenar la primitiva 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 si 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 de Java llamada 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
} 

Sin embargo, es bueno saberlo, ya que para "comprobar siempre las bibliotecas estándar primero" nunca me hubiera topado con el truco de Arrays.toString( myarray )

--desde que estaba concentrado en el tipo de myarray para ver cómo hacer esto. No quería tener que recorrer la cosa: quería una llamada fácil para que saliera similar a lo que veo en el depurador Eclipse y myarray.toString () simplemente no lo estaba haciendo.

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

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


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

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

Para obtener una tabla para imprimir 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) debería tomar una cadena separadora, pero desafortunadamente no lo hace.


Diferentes formas de imprimir arrays 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] [[Quinta, Sexta], [Séptima, Octava]]

Recurso: Accede a una matriz


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

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




printing