1. Arraysclase

Como señalamos anteriormente, las matrices son muy útiles y se usan con frecuencia en la programación.

Los creadores de Java notaron rápidamente que los programadores de Java a menudo escriben el mismo código cuando trabajan con arreglos. Por ejemplo, copie parte de una matriz a otra matriz, codifique para llenar cada celda de una matriz con el mismo valor, muestre el contenido de una matriz en un formato conveniente, etc.

Es por eso que crearon la Arraysclase especial (su nombre completo es java.util.Arrays), poniendo en ella las acciones más populares relacionadas con matrices.

Tiene muchos métodos para cada ocasión, pero primero consideraremos solo 10 de ellos, los más simples y los más utilizados.


2.Arrays.toString()

El primer método que veremos se llama Arrays.toString(). Pero primero, un poco de historia.

Cada matriz en Java tiene un toString()método, que devuelve una 'representación textual de la matriz'. Puede obtener una representación textual de una matriz utilizando la siguiente declaración:

String str = name.toString();

Donde namees el nombre de la variable de matriz y stres el nombre de la variable que almacenará la representación de cadena de la matriz.

Pero si intenta imprimir la matriz en la pantalla usando el método, lo más probable es que vea algo como esto:System.out.println(name)

I@37afeb11

La primera letra Isignifica que es una intmatriz, y los símbolos posteriores @son la dirección de la matriz en la memoria. Por un lado, esta es precisamente la información almacenada en la variable del array, pero por otro, esperábamos algo diferente, ¿no?

¡Queríamos ver los valores en la matriz! Y esa es exactamente la razón por la que se les ocurrió el Arrays.toString()método: mostrar los valores de una matriz. Lo llamamos así:

String str = Arrays.toString(name);

Ejemplos:

int[] array = {1, 2, 3};
String str = Arrays.toString(array);
La strvariable contendrá la cadena:
"[1, 2, 3]"
int[] array = {};
String str = Arrays.toString(array);
La strvariable contendrá la cadena:
"[]"
String[] array = {"Hi", "How's", "life?"};
String str = Arrays.toString(array);
La strvariable contendrá la cadena:
"[Hi, How's, life?]"


3.Arrays.deepToString()

Pero si intenta convertir una matriz bidimensional en un using the Arrays.toString()método de cadena (para mostrarlo), verá algo familiar:

[I@37afeb11, I@37afeb21, I@37afeb31]

Todo esto se debe a que las celdas de una matriz bidimensional almacenan referencias a matrices unidimensionales. ¿Y cómo se convierten las matrices unidimensionales en una cadena? Exactamente como ves arriba.

¿Qué se puede hacer? ¿Cómo mostramos correctamente una matriz bidimensional?

Con este fin, la Arraysclase tiene otro método especial: deepToString(). Llamarlo se ve así:

String str = Arrays.deepToString(name);

A este método se le pueden pasar matrices bidimensionales, unidimensionales, tridimensionales o, en general, de cualquier dimensión, y siempre mostrará los elementos de la matriz.
Nota: el Arrays.deepToString()método no funciona con matrices unidimensionales de primitivas (por ejemplo, int[]).

Ejemplos:

Integer[] array = {1, 2, 3};
String str = Arrays.deepToString(array);
La strvariable contendrá la cadena:
"[1, 2, 3]"
int[][] array = { {1, 1}, {2, 2}, {3, 3} };
String str = Arrays.deepToString(array);
La strvariable contendrá la cadena:
"[[1, 1], [2, 2], [3, 3]]"
int[][][] array = { {{1, 2, 3}, {1}}, {{}} };
String str = Arrays.deepToString(array);
La strvariable contendrá la cadena:
"[[[1, 2, 3], [1]], [[]]]"


4.Arrays.equals()

Descubrimos cómo mostrar matrices en la pantalla, pero ¿qué pasa con la comparación de matrices?

Para comparar cadenas, tenemos métodos equalsy equalsIgnoreCase, pero ¿qué métodos tienen los arreglos?

La buena noticia es que las matrices tienen un equalsmétodo. La mala noticia es que no compara el contenido de las matrices. El equalsmétodo de matrices hace lo mismo que el ==operador: compara referencias. Ejemplos:

Ejemplos:

int[] x1 = {1, 2, 3};
int[] x2 = {1, 2, 3};
boolean b = x1 == x2;


false(las referencias no son iguales)
int[] x1 = {1, 2, 3};
int[] x2 = {1, 2, 3};
x1.equals(x2);
El equalsmétodo de arrayssimplemente compara las referencias de dos arreglos.

false(las referencias no son iguales)

¿Qué se puede hacer? ¿Cómo comparamos matrices en función de su contenido?

Y de nuevo Arraysviene a nuestro rescate, o más concretamente, su Arrays.equals()método. Así es como lo llamamos:

Arrays.equals(name1, name2)

El método devuelve truesi las matrices tienen la misma longitud y sus elementos son iguales. De lo contrario, vuelve false.

Ejemplos:

int[] x1 = {1, 2, 3};
int[] x2 = {1, 2, 3};
x1.equals(x2);
El equalsmétodo de arrays simplemente compara las referencias de dos arreglos.

false(las referencias no son iguales)
int[] x1 = {1, 2, 3};
int[] x2 = {1, 2, 3};
Arrays.equals(x1, x2);


true(los contenidos son iguales)
int[] x1 = {1, 2, 3};
int[] x2 = {1, 2, 3, 4};
Arrays.equals(x1, x2);


false(los contenidos de las matrices son diferentes)

5.Arrays.deepEquals()

Y, como probablemente ya haya adivinado, el Arrays.equalsmétodo no funcionará correctamente para arreglos bidimensionales: trata los arreglos bidimensionales como un arreglo unidimensional cuyos elementos son direcciones de arreglos unidimensionales.

Así, para comparar correctamente arreglos multidimensionales ( n = 1, 2, 3,...), idearon el Arrays.deepEquals()método. Llamarlo se ve así:

Arrays.deepEquals(name1, name2)

El método vuelvetruesi las matrices tienen la misma longitud y sus elementos son iguales. De lo contrario, vuelvefalse. Si los elementos dentro de la matriz también son matrices, entonces Arrays.deepEquals()se usa el método para compararlos, y así sucesivamente.

Ejemplos:

int[][] x1 = {{1, 2, 3}, {4, 5, 6}};
int[][] x2 = {{1, 2, 3}, {4, 5, 6}};
x1.equals(x2);
El equalsmétodo de arrays simplemente compara las referencias de dos arreglos.

false(las referencias no son iguales)
int[][] x1 = {{1, 2, 3}, {4, 5, 6}};
int[][] x2 = {{1, 2, 3}, {4, 5, 6}};
Arrays.equals(x1, x2);
El Arrays.equalsmétodo comparará y como matrices unidimensionales que almacenan referencias. Contienen diferentes referencias. (los contenidos de las matrices no son iguales) x1x2
false
int[][] x1 = {{1, 2, 3}, {4, 5, 6}};
int[][] x2 = {{1, 2, 3}, {4, 5, 6}};
Arrays.deepEquals(x1, x2);


true(los contenidos son iguales)