Java - Array de arrays

 
Vista:
sin imagen de perfil
Val: 14
Ha aumentado su posición en 8 puestos en Java (en relación al último mes)
Gráfica de Java

Array de arrays

Publicado por Raúl (7 intervenciones) el 02/08/2020 16:55:49
Hola a tod@s!
Tengo varios arrays bidimensionales de tipo String y lo que quiero hacer es lo siguiente: quiero guardarlos en otro array, de forma que cada uno sea un elemento del nuevo array. ¿Cómo creo ese array de arrays? ¿Y cómo hago para recorrerlo?
Muchas gracias y un saludo!
Valora esta pregunta
Me gusta: Está pregunta es útil y esta claraNo me gusta: Está pregunta no esta clara o no es útil
0
Responder
Imágen de perfil de Kabuto
Val: 3.428
Oro
Ha mantenido su posición en Java (en relación al último mes)
Gráfica de Java

Array de arrays

Publicado por Kabuto (1381 intervenciones) el 02/08/2020 20:19:38
Puedes crear un array tridimensional.
Es algo muy poco común, primero porque rara vez se necesita una estructura de este tipo.
Y también porque gestionar una array 3D es algo.., si no más complicado, al menos si más confuso.
Y en realidad, hay alternativas menos confusas y más óptimas.

Mira, este es un ejemplo de una matriz de tres dimensiones de 2x3x4, lo cuál significa que contendrá 2 matrices de 3x4

Para recorrerlo, pues se anidan tres bucles:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
public class Array3D {
 
 
	public static void main(String[] args) {
 
		String[][][] arr3D = new String[2][3][4];
 
		//Matrices 3x4
		String[][] matriz1 = new String[][]{{"Matriz1_00", "Matriz1_01", "Matriz1_02", "Matriz1_03"},
			{"Matriz1_10", "Matriz1_11", "Matriz1_12", "Matriz1_13"},
			{"Matriz1_20", "Matriz1_21", "Matriz1_22", "Matriz1_23"}};
 
		String[][] matriz2 = new String[][]{{"Matriz2_00", "Matriz2_01", "Matriz2_02", "Matriz2_03"},
			{"Matriz2_10", "Matriz2_11", "Matriz2_12", "Matriz2_13"},
			{"Matriz2_20", "Matriz2_21", "Matriz2_22", "Matriz2_23"}};
 
		arr3D[0] = matriz1;
		arr3D[1] = matriz2;
 
		for (int i = 0; i < arr3D.length; i++) {
			for (int j = 0; j < arr3D[0].length; j++) {
				for (int z = 0; z < arr3D[0][0].length; z++) {
					System.out.print(arr3D[i][j][z] + " ");
				}
				System.out.println();
			}
			System.out.println();
		}
 
 
	}
 
}

Al ejecutar, vemos en pantalla que se muestran correctamente todos los elementos:
1
2
3
4
5
6
7
Matriz1_00 Matriz1_01 Matriz1_02 Matriz1_03
Matriz1_10 Matriz1_11 Matriz1_12 Matriz1_13
Matriz1_20 Matriz1_21 Matriz1_22 Matriz1_23
 
Matriz2_00 Matriz2_01 Matriz2_02 Matriz2_03
Matriz2_10 Matriz2_11 Matriz2_12 Matriz2_13
Matriz2_20 Matriz2_21 Matriz2_22 Matriz2_23

Pero fíjate lo lioso que es tener que gestionar 3 indices, y simplemente lo que hago es mostrar en pantalla. Si se quisieran hacer computos u otras tareas podría ser aún más complicado.

Como dije, hay otras alternativas, y consiste en aplicar Programación Orientada Objetos.
Seguramente nos será más cómodo crear una clase que modele una matriz, con la ventaja añadida de que podemos añadirle todos los métodos que necesitemos y dotarla de funcionalidades que no nos da una "matriz primitiva".

De este modo, podemos crear un array de una dimensión y guardar ahí todos los objetos creados con nuestra clase "matriz".
Con la ventaja además de que cada objeto puede tener unas dimensiones distintas a las de los demás.
En el caso del array tridimensional que he puesto antes, todas las matrices han de tener las mismas dimensiones, pero si hacemos una clase POO evitamos esta limitación.

Por ejemplo, esta podría ser una clase que gestiona una matriz, con algunos métodos básicos que pueden ser útiles.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
public class MatrizStrings {
 
	private String[][] matriz;
 
	public MatrizStrings(int dim1, int dim2) {
		matriz = new String[dim1][dim2];
	}
 
	public void setElemento(String elem, int pos1, int pos2) {
		matriz[pos1][pos2] = elem;
	}
 
	public String consultaDimensiones() {
		return "Dims: " + matriz.length + "x" + matriz[0].length;
	}
 
	public boolean contieneElemento(String elem) {
		for (int i = 0; i < matriz.length; i++)
			for (int j = 0; j < matriz[0].length; j++)
				if (matriz[i][j].equals(elem))
					return true; //Elemento encontrado
 
		//Si los bucles han terminado sin retornar true, es que contiene dicho elemento
		return false;
	}
 
	public void mostrarMatriz() {
		for (int i = 0; i < matriz.length; i++) {
			for (int j = 0; j < matriz[0].length; j++)
				System.out.print(matriz[i][j] + " ");
			System.out.println();
		}
	}
}

Y aquí una clase main para probar esta clase. En ella creo un array simple con 50 objetos instanciados a partir de esta clase, donde les doy dimensiones al azar.
Muestro estas dimensiones y luego renuevo el primer objeto con unas dimensiones más pequeñas para poder hacer un ejemplo de como inserto datos, muestro en pantalla su contenido y consulto si tiene determinados elementos:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
public class GestionMatrices {
 
	public static void main(String[] args) {
 
		Random azar = new Random();
 
		MatrizStrings[] misMatrices = new MatrizStrings[50];
 
		for (int i = 0; i < 50; i++)
			misMatrices[i] = new MatrizStrings(azar.nextInt(50) + 1, azar.nextInt(50) + 1);
 
		System.out.println("Dimensiones de las matrices generadas");
 
		for (int i = 0; i < 50; i++)
			System.out.println(misMatrices[i].consultaDimensiones());
 
		misMatrices[0] = new MatrizStrings(2, 2);
 
		misMatrices[0].setElemento("Elem_00", 0, 0);
		misMatrices[0].setElemento("Elem_01", 0, 1);
		misMatrices[0].setElemento("Elem_10", 1, 0);
		misMatrices[0].setElemento("Elem_11", 1, 1);
 
		System.out.println("\nElementos de la nueva matriz:\n");
		misMatrices[0].mostrarMatriz();
 
		System.out.println();
 
		if (misMatrices[0].contieneElemento("Elem_00"))
			System.out.println("Sí contiene elemento: \"Elem_00\"");
		else
			System.out.println("No contiene elemento: \"Elem_00\"");
 
		if (misMatrices[0].contieneElemento("Elem_23"))
			System.out.println("Sí contiene elemento: \"Elem_23\"");
		else
			System.out.println("No contiene elemento: \"Elem_23\"");
 
	}
 
}

Al ejecutarlo, en pantalla vemos las funcionalidades que le hemos dado a nuestra clase Matriz.
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
Dimensiones de las matrices generadas
Dims: 28x34
Dims: 6x37
Dims: 42x18
Dims: 29x11
Dims: 4x19
Dims: 12x16
Dims: 40x49
Dims: 44x42
Dims: 14x3
Dims: 24x9
Dims: 32x4
Dims: 18x41
Dims: 21x27
Dims: 19x31
Dims: 18x7
Dims: 21x25
Dims: 38x19
Dims: 34x27
Dims: 22x17
Dims: 33x12
Dims: 13x38
Dims: 33x42
Dims: 12x41
Dims: 28x44
Dims: 46x19
Dims: 18x13
Dims: 12x15
Dims: 31x33
Dims: 31x35
Dims: 20x45
Dims: 13x42
Dims: 7x18
Dims: 3x12
Dims: 26x11
Dims: 35x23
Dims: 43x4
Dims: 32x18
Dims: 38x15
Dims: 22x37
Dims: 39x46
Dims: 7x35
Dims: 33x37
Dims: 11x29
Dims: 19x43
Dims: 19x21
Dims: 25x29
Dims: 33x30
Dims: 2x25
Dims: 19x44
Dims: 28x21
 
Elementos de la nueva matriz:
 
Elem_00 Elem_01
Elem_10 Elem_11
 
Sí contiene elemento: "Elem_00"
No contiene elemento: "Elem_23"

Y podríamos darle muchas más funcionalidades, un método para ordenar sus elementos alfabéticamente, otro para retornar una determinada fila o columna de la matriz,..,lo que queramos.


Por esto digo que los arrays tridimensionales son algo muy poco común, porque cualquier clase POO es más sencilla de gestionar y nos da posibilidades infinitas.
Valora esta respuesta
Me gusta: Está respuesta es útil y esta claraNo me gusta: Está respuesta no esta clara o no es útil
1
Comentar
sin imagen de perfil
Val: 14
Ha aumentado su posición en 8 puestos en Java (en relación al último mes)
Gráfica de Java

Array de arrays

Publicado por Raúl (7 intervenciones) el 02/08/2020 21:52:48
Gracias Kabuto por tu pronta y detallada respuesta. Pero buscaba algo más sencillo.
Tengo una serie de arrays (bidimensionales) y quiero guardarlos en otro distinto (también bidimensional). De forma que los del mismo tipo vayan en la misma fila. Pero ¿cómo los guardo? No sé si puede hacerse. Después necesito recorrer la fila que yo desee de ese array.
Gracias.
Valora esta respuesta
Me gusta: Está respuesta es útil y esta claraNo me gusta: Está respuesta no esta clara o no es útil
0
Comentar
Imágen de perfil de Kabuto
Val: 3.428
Oro
Ha mantenido su posición en Java (en relación al último mes)
Gráfica de Java

Array de arrays

Publicado por Kabuto (1381 intervenciones) el 03/08/2020 00:16:41
A ver, esto es como la película de Inception.
Si en un sueño, te pones a soñar también, estás teniendo un doble sueño.

Pues lo mismo.
Si guardas matrices de dos dimensiones, dentro de otra matriz que a su vez también tiene dos dimensiones, pues estás construyendo una estructura de 4 dimensiones, lo que se conoce como un "hipercubo". Es decir, para apuntar a un elemento concreto, vas a necesitar 4 indices.

¿Se puede hacer? Sí. De hecho, puedes hacer una estructura de montones de dimensiones.

¿Es sencillo? No, ya expliqué que con tres dimensiones la cosa se vuelve confusa, pues tu ahora me hablas de cuatro dimensiones.

¿Es óptimo? No, ya no solo porque el código para manejarlo resultará muy enmarañado, si no porque además una estructura de este tipo implica usar gran cantidad de recursos del sistema. Por aquí alguien comenta cómo al crear un array 4D , nada más comenzar el programa ya devora 1.4GB de RAM

¿Se da uso en el mundo real? En casos muy concretos y específicos: estadísticas complejas, modelos de física avanzada,...


¿Hay otra alternativa?
Sí, lo que he explicado. Construir una clase orientada a objetos, para aprovecharse de las innumerables ventajas que proporciona el poder encapsular dentro de ella métodos para gestionar la matriz y poder trabajar con ella como si fuera un elemento sencillo.
A mi no se me ocurre nada más sencillo, ni lógico, que usar POO.

Solo hay esas dos posibilidades: una clase POO, o pelearse con un hipercubo.

Y si hay otra, la desconozco y me encantaría que alguien la aportase.
Valora esta respuesta
Me gusta: Está respuesta es útil y esta claraNo me gusta: Está respuesta no esta clara o no es útil
0
Comentar

Array de arrays

Publicado por Tom (1831 intervenciones) el 03/08/2020 11:21:48
@Kabuto ... en mi opinión el problema está en que @Raúl se explica fatal.
@Raul Esto es demasiado vago: "Tengo una serie de arrays (bidimensionales) y quiero guardarlos en otro distinto (también bidimensional). De forma que los del mismo tipo vayan en la misma fila"
Valora esta respuesta
Me gusta: Está respuesta es útil y esta claraNo me gusta: Está respuesta no esta clara o no es útil
0
Comentar
sin imagen de perfil
Val: 14
Ha aumentado su posición en 8 puestos en Java (en relación al último mes)
Gráfica de Java

Array de arrays

Publicado por Raúl (7 intervenciones) el 04/08/2020 13:51:16
Gracias Kabuto, intentaré crear la clase.
Tom, no puedo decir lo mismo. De hecho podías no contestar y quedabas mejor
Valora esta respuesta
Me gusta: Está respuesta es útil y esta claraNo me gusta: Está respuesta no esta clara o no es útil
0
Comentar