Saltar navegación

Arrays2 - Contenido educativo

Ajuste de pantalla

El ajuste de pantalla se aprecia al ver el vídeo en pantalla completa. Elige la presentación que más te guste:

Subido el 15 de noviembre de 2023 por Stefano C.

10 visualizaciones

Más información Transcripción

Descargar la transcripción

Voy a grabar esta clase, por lo tanto, todo lo que digáis estará grabado 00:00:00
Estamos viendo los arrays, que son variables que pueden contener más de un valor 00:00:07
Todos del mismo tipo, un cierto tamaño, un cierto número de valores del mismo tipo 00:00:16
Lo que pasa es que al principio de la creación, cuando creo un array, lo que hago es decirle el tamaño de este array 00:00:23
Cuantas posiciones puede contener, y luego el tamaño de este array se queda fijo, no se puede modificar 00:00:35
Un array se define de un cierto tamaño, este tamaño eventualmente puede ser elegido a tiempo de ejecución 00:00:43
Yo puedo pedir un número al usuario, el usuario me da 5 y yo creo un array de 5 posiciones 00:00:50
Porque no, no tiene que ser creado a tiempo de programación, de cuando hago el código 00:00:58
El tamaño del array puede ser inicializado después, pero una vez que lo he creado, ese es su tamaño y ese se queda 00:01:09
No se puede extender o recortar un array, si no con un método que ahora vemos 00:01:19
Que no es cambiar el tamaño del array, el array es fijo 00:01:25
Aquí os acordáis como se declara, como se inicializa y como se asignan a las celdas 00:01:30
Sostancialmente es una variable, donde después de la variable tiene estas dos corchetes 00:01:37
Que me dicen que posición de esa variable voy a guardar el dato 00:01:42
Entonces en vez de tener la int x es igual a 7 y yo sé que esa x solo puede contener un valor 00:01:46
Entonces le pongo directamente el valor, aquí le tendré que decir a mi array una cierta posición 00:01:53
Como en la posición 0 ponme 16, en la posición 1 ponme 37, etc. 00:01:58
La cosa interesante es que el índice que utilizamos aquí para acceder a las varias celdas del array es un número 00:02:07
Y como tal podemos hacer operaciones sobre él, podemos utilizar una variable 00:02:15
Y sobre todo nosotros la utilizamos en for, con un for lo que puede hacer es recorrer el array 00:02:20
Utilizando una variable y como índice, esta y que vaya desde 0 hasta el final, hasta la última posición del array 00:02:33
Que os recuerdo que es array.length menos 1, la última posición 00:02:42
Si yo tengo un array de 5 posiciones va de 0 a 4, las posiciones posibles 00:02:48
También no es necesario recorrerlo entero, si por alguna razón yo quiero recorrer los primeros 10 celdas de un array 00:02:53
Pues puedo poner que el límite sea 11, o sea menor que 11 o menor o igual que 10 00:03:04
O si quiero empezar en vez de la 0 desde la 3, pues puedo poner aquí igual hasta 13 y seguir adelante 00:03:10
O sea que no necesariamente tengo que recorrerlo siempre entero 00:03:21
Hemos visto también que existe una estructura distinta, que es la estructura for each 00:03:26
La estructura for each me permite, o sea se usa cuando quiero en vez de recorrer todo el array seguramente 00:03:33
Quiero pillar todos los elementos de los arrays y hacer algo sobre estos elementos 00:03:41
Entonces es esta cosa de aquí, esta es equivalente a poner for int i es igual a 1 00:03:48
i es menor que nums.length i++ y luego poner que int i es igual a nums de i 00:03:54
int y es igual a nums de i, sería lo mismo 00:04:01
Pero como esto se hace mucho, el de entrar en todas las celdas de un array 00:04:05
Pillar los valores que están allí dentro y hacer algo con esos valores 00:04:11
Pues existe esta forma aquí para que sea más fácil, más rápido de hacer 00:04:15
Esto sobre todo nos vendrá bien cuando haremos los objetos 00:04:21
Porque aquí en vez de int pillaré un objeto y sobre el objeto haré las operaciones que tengo que hacer sobre el objeto 00:04:26
Lo veremos 00:04:33
Por ahora la única cosa es que tened en cuenta que si utilizáis esto, lo que estáis perdiendo es el índice 00:04:35
Ahora estáis pillando todos los enteros de este array 00:04:43
Pero no sabéis en qué posición del array está el número que habéis pillado en un cierto momento 00:04:47
O os lo guardáis vosotros, creáis aquí un int posición igual a 0 00:04:55
Y cada vez que entráis aquí dentro al final hacéis un pos++ 00:04:59
Pero entonces a ese punto ya os compensa el otro 00:05:02
Lo único es que a veces hay programas en el que quiero saber la posición en la que estoy en el array 00:05:06
Y otras veces no, simplemente quiero hacer algo sobre todos los arrays 00:05:14
Todos los ejercicios que hemos hecho nosotros de calcular la media, de sumar todos los elementos 00:05:18
Pues eso me da igual si está en la posición 0, 1 o 2 00:05:23
Lo que tengo que hacer es hacer algo con todos los elementos 00:05:26
Por lo tanto esto sí nos puede servir 00:05:29
Si yo quiero hacer, por ejemplo, un programa que busca en qué posición está un cierto valor 00:05:31
Que yo le introduzco de un array 00:05:38
Pues entonces necesitaría mantenerme la posición 00:05:40
Saber en qué posición estoy mirando para decir 00:05:45
Mira, he encontrado, tú estabas buscando el valor 5 00:05:47
Lo he encontrado en la posición 3 00:05:49
Y te contesto, mira, estaba en la posición 3 00:05:51
Entonces en este caso es mejor utilizar el otro for 00:05:53
Porque tengo el índice i que va creciendo 00:05:57
Y puedo usar ese índice i para decir cuando lo encuentro pues haz algo con ese índice 00:06:00
¿Me explico? 00:06:04
¿Dudas? 00:06:06
Escribir el contenido de un array 00:06:11
Vale, hemos visto esta cosa de aquí 00:06:13
Este es un comodín, arrays.toString de un array 00:06:19
Que lo que me hace es escribir el contenido de un array 00:06:22
En un formato que es corchete 00:06:26
Todos los contenidos separados por coma, otro corchete 00:06:28
Esto técnicamente lo podéis usar para hacer pruebas 00:06:31
Para, oye, mi programa no está funcionando 00:06:36
Voy a mirar rápidamente que contiene este array en un determinado punto 00:06:38
Y en vez de hacerme un for que vaya en todas las posiciones y haga no sé qué 00:06:44
Pues uso esta cosa aquí 00:06:49
Si el ejercicio os pide de escribir en pantalla el contenido de un array 00:06:51
En teoría no es esto lo que se está pidiendo 00:06:55
¿Vale? 00:06:59
Porque todavía nosotros estamos trabajando con for, while y cosas por el estilo 00:07:00
Entonces quiero ver que sabéis utilizar for, while y sabéis cómo utilizar 00:07:04
¿Es claro? 00:07:08
Vale 00:07:11
Entonces 00:07:14
Una cosa interesante de los arrays 00:07:17
Es que los arrays no funcionan como los tipos primitivos 00:07:20
¿Os acordáis que la última vez hicimos un ejemplo de copiar una variable y copiar un array? 00:07:23
Y vimos que esto funcionaba de forma distinta 00:07:31
A ver si lo tengo 00:07:35
¿Os acordáis que cuando yo tengo una situación como esta? 00:07:40
En la que creo la variable x que vale 8 00:07:44
Luego int y es igual a x 00:07:47
Y cambio x 00:07:50
Y imprimo las dos cosas x e y 00:07:51
X ha cambiado, x valdrá 20 00:07:55
Pero y no 00:07:58
Esto pasa porque 00:08:00
Cuando yo creo x 00:08:06
Estoy creando un espacio de memoria 00:08:08
Dentro de esto pongo por ejemplo 8 00:08:11
Según el ejemplo 00:08:14
¿Vale? 00:08:16
Luego cuando hago int y igual a x 00:08:17
Lo que estoy creando es un nuevo espacio de memoria que se llama y 00:08:20
Y copio lo que está dentro de x 00:08:24
Es decir, esto 00:08:28
Así que cuando luego hago x igual a 20 00:08:30
Lo que estoy haciendo es modificar esta variable 00:08:34
Sin tocar la variable y 00:08:37
¿Si? 00:08:40
Son dos espacios de memoria separados 00:08:41
La copia se ha hecho por valor 00:08:44
Es decir, que el valor que estaba en x 00:08:46
Se ha puesto en el otro espacio de memoria 00:08:48
Por lo tanto, después de esta 00:08:50
De esta instrucción de aquí 00:08:53
Yo tengo dos copias del valor 8 00:08:56
Independientes 00:08:59
Cuando sobre escribo la x 00:09:01
La y no se ve sobre escrita 00:09:04
Son dos cosas separadas 00:09:06
¿Se entiende esto? 00:09:08
En los arrays es distinto 00:09:10
Cuando yo creo 00:09:13
Entonces tengo aquí 00:09:15
Esto por ejemplo 00:09:17
Entonces 00:09:19
Creo un array 00:09:22
De una determinada forma 00:09:25
Luego hago una copia de este array 00:09:27
Y modifico el primero 00:09:29
Si funcionara como las variables normales 00:09:32
Este cambio no afectaría a dos 00:09:38
¿Si? 00:09:41
Serían dos copias 00:09:42
Hay un array que es A1 que contiene 1, 2 y 3 00:09:43
Y A2 que contiene 1, 2 y 3 00:09:46
Cambio en el primero un 100 00:09:48
Pongo un 100 00:09:50
Pues el segundo no se vería afectado 00:09:51
El problema es que los arrays no son tipos primitivos 00:09:53
Son objetos por debajo 00:09:56
Entonces funcionan un poco de forma distinta 00:09:59
Cuando yo creo A1 00:10:02
Estoy creando una variable 00:10:06
Con tres espacios 00:10:09
Un array 00:10:12
Y le pongo 1, 2 y 3 00:10:13
¿Vale? 00:10:17
Cuando ejecuto esta 00:10:18
Osea int A2 es igual a 1 00:10:21
Estoy creando un nuevo array 00:10:24
Pero no se copian estos valores 00:10:29
Lo que se copia es la referencia 00:10:31
En realidad dentro de A1 00:10:34
Hay un puntero a esta estructura de aquí 00:10:37
Y cuando hago esta operación de aquí 00:10:44
De copiar A1 en A2 00:10:46
No estoy copiando el contenido de la estructura 00:10:48
Si no estoy copiando el mismo puntero 00:10:51
Entonces ahora no tengo dos arrays 00:10:59
Tengo un array solo con dos nombres 00:11:01
Esta es como funciona cuando estoy utilizando las referencias 00:11:06
O punteros, si por ejemplo trabajáis en C 00:11:11
C se trabaja mucho con punteros 00:11:14
¿Qué pasa cuando luego en A1 de 0 cambio a 100? 00:11:17
Pues A1 de 0 va a esta estructura 00:11:21
Va en la posición 0 que es esta de aquí 00:11:24
Y sustituye el 1 con un 100 00:11:27
Si ahora escribo A2 de 0 00:11:30
Esto también contiene 100 00:11:34
Antes las dos variables eran independientes 00:11:44
Porque el paso era por valor 00:11:47
Se ha copiado el valor 00:11:49
Mientras ahora se ha pasado la referencia 00:11:51
Por lo tanto estamos trabajando sobre el mismo objeto 00:11:53
Sobre el mismo array 00:11:57
Este es importante 00:11:59
No obstante yo haya modificado solo A1 00:12:09
A2 de 0 vale 100 también 00:12:11
Porque no hay dos arrays 00:12:17
Hay dos referencias al mismo array 00:12:19
Hay un array solo 00:12:22
Y entonces aquí viene la pregunta para vosotros 00:12:25
¿Cómo copio un array? 00:12:28
Entonces hemos llegado a esta conclusión 00:12:37
Cuando yo tengo un array A1 00:12:41
Que tiene 1, 2 y 3 dentro 00:12:44
Si hago una cosa como esta 00:12:47
No estoy copiando el array 00:12:49
Estoy creando una nueva referencia 00:12:51
O sea A2 al mismo array 00:12:53
Los cambios que yo haga en A1 00:12:56
Se verán también si acedo A2 00:12:58
Y los cambios que hago en A2 00:13:01
Se verán también si acedo con A1 00:13:03
¿Por qué? 00:13:07
Porque son el mismo array 00:13:08
No es una copia de un array 00:13:09
Si no es dos referencias 00:13:11
Dos nombres al mismo array 00:13:13
Si quiero copiar el array 00:13:16
Lo que tengo que hacer 00:13:19
Es crearme un nuevo array 00:13:21
Del mismo tamaño que tiene el array original 00:13:23
De esta forma ahora ya tengo dos arrays 00:13:26
Uno es este 00:13:28
Y uno es este otro 00:13:30
Y luego hacer un FOR 00:13:32
Que aceda a todas las posiciones de A1 00:13:34
Y los copie explícitamente dentro de A3 00:13:38
Entonces al final de esto 00:13:41
Tengo una situación 00:13:43
En la que tengo A1 00:13:45
Que es el array original 00:13:47
A2 que es otra referencia al mismo array 00:13:49
Entonces los cambios de A1 00:13:51
Lo verá también A2 00:13:53
Y los cambios de A2 lo verá también A1 00:13:54
Y A3 en vez se ha creado un nuevo array 00:13:56
Por otro lado 00:14:00
Y este nuevo array por otro lado 00:14:02
Se han copiado de uno en uno 00:14:04
Todos los valores que estaban en el A1 00:14:06
Usando el FOR 00:14:08
Por lo tanto ahora tengo dos copias 00:14:10
Del mismo array 00:14:12
A3 referencia esta copia 00:14:15
Y A1 y A2 referencia esta otra copia 00:14:18
Los cambios que se hacen en A1 y A2 00:14:21
No se verán en A3 00:14:23
Los cambios que se harán en A3 00:14:25
No se verán ni en A1 ni en A2 00:14:27
Entonces 00:14:39
Esto es otra forma de verlo 00:14:41
Cuando yo creo 00:14:44
Aquí tengo un array de string 00:14:46
Que se llama X 00:14:48
Pues X apunta esta cosa aquí 00:14:50
En la posición 0 está 1 00:14:52
En la posición 1 está 2 00:14:54
En la posición 2 está 3 00:14:56
Son estos valores de aquí que he puesto 00:14:58
Y estos son todos string 00:15:00
Si yo hago 00:15:02
String array de Y igual a X 00:15:04
Lo que estoy haciendo es 00:15:08
Duplicar las referencias a este array 00:15:10
¿Cuántos arrays hay? 00:15:14
Uno solo 00:15:16
Pero tengo dos nombres para este array 00:15:18
Entonces sería así 00:15:20
Si ahora hago X de 3 igual a 7 00:15:22
Y modifico este valor por 7 00:15:24
Pues también Y de 3 valdrá 7 00:15:27
Porque son referencias al mismo array 00:15:31
¿Se entiende? 00:15:35
¿Cómo copio un array entonces? 00:15:39
Para copiar un array 00:15:41
Yo tengo el array X 00:15:43
Pues string de Y es igual a new 00:15:45
String de 5 00:15:51
¿Vale? 00:15:53
Y esta cosa aquí es más compleja 00:15:55
De lo que dijimos nosotros 00:15:57
¿Vale? 00:15:59
Lo dejamos 00:16:05
Nosotros lo hemos hecho de la otra forma 00:16:07
Esto aquí posiblemente funciona 00:16:09
Pero si os fijáis aquí estoy haciendo un int Y 00:16:11
Mientras deberían ser string 00:16:14
Y entonces es distinto de cómo lo hemos utilizado 00:16:16
Pues esto por ahora no lo miramos 00:16:18
Lo que se ha hecho 00:16:20
Pensándolo en el for que sabemos nosotros 00:16:22
Int Y es igual a 0 00:16:25
Y es menor que X.length 00:16:27
Y más más 00:16:30
Cuando hago esta cosa de aquí 00:16:33
Lo que estoy haciendo es crear un nuevo array 00:16:36
Ahora tengo dos arrays 00:16:39
Y cuando hago el for 00:16:41
Esta es una versión más complicada todavía 00:16:43
Para nosotros que no la entendemos 00:16:46
De este array 00:16:48
Lo que estoy haciendo es copiar los valores 00:16:50
Y cuando hago X de 3 es igual a 7 00:16:52
Modificando este valor de aquí 00:16:55
Este valor de aquí no se ve afectado 00:16:57
Porque son dos arrays distintos 00:16:59
¿Dudas? 00:17:02
La última cosa 00:17:07
Que nos queda para mirar 00:17:09
Es lo siguiente 00:17:19
Imaginaos 00:17:21
Que yo tenga un array 00:17:26
¿Sí? 00:17:33
Normalmente nosotros dentro de este array 00:17:36
¿Qué ponemos? 00:17:39
Int, string, lo que sea 00:17:41
Valores 00:17:43
¿Qué pasa si yo dentro de esta celda 00:17:45
Pongo un array? 00:17:48
¿Sí? 00:17:51
Y dentro de esta 00:17:59
Otro array 00:18:01
Y dentro de esta 00:18:03
Otro array 00:18:05
¿Lo puedo hacer? 00:18:07
Nosotros hemos dicho que 00:18:13
Dentro del array van variables 00:18:15
¿Vale? 00:18:17
Int 00:18:20
¿Sí? 00:18:21
Entonces pongo 3, 7, 5, etc 00:18:22
Pero si en vez de poner un int aquí dentro 00:18:23
Pongo un int array 00:18:25
Int corchetas 00:18:27
Pues entonces quiere decir que cuando hace de aquí 00:18:29
No encuentro un valor concreto 00:18:31
Sino encuentro un puntero 00:18:33
Que me lleva a otro array 00:18:35
Donde dentro están las cosas 00:18:38
¿Esto cómo se llamará? 00:18:42
Pues esto será un array A 00:18:44
Que tiene un puntero 00:18:46
Que llega a esta estructura de aquí 00:18:49
Y luego yo puedo acceder a esta 00:18:51
Con 0, 1, 2, 3, 4 00:18:53
Si por ejemplo accedo a la 1 00:18:56
Dentro no me encuentro ya un valor 00:18:59
Si no me encuentro este array de aquí 00:19:02
Que también serán 00:19:04
0, 1, 2, 3, 4 00:19:06
Y esto se puede hacer 00:19:12
¿Cómo se declara una cosa de ese estilo? 00:19:14
En vez de 00:19:16
En vez de int 00:19:18
Array 00:19:20
Esto sería un array de int 00:19:25
Pues hago un array de array 00:19:27
Esta cosa aquí 00:19:35
Me está diciendo que 00:19:37
Como si fuera una cosa así 00:19:39
Que yo tengo un array 00:19:42
Que dentro no tiene int 00:19:44
Dentro tiene int array 00:19:46
Entonces tengo un array 00:19:48
Que dentro tiene array de int 00:19:50
Por ahora no lo hagamos 00:20:01
Teniendo en cuenta que este de aquí 00:20:04
No sé que son, son referencias 00:20:06
Por lo tanto quien da el valor 00:20:08
Es el valor final 00:20:10
Yo puedo hacer un int array array 00:20:12
Una cosa así 00:20:14
Puedo hacer un string array array 00:20:16
Entonces será un array de apuntadores 00:20:18
Array de string 00:20:20
Ahora hacer que esto sea un int 00:20:22
Esto sea un string 00:20:24
Esto sea una cosa 00:20:26
Pues se puede hacer, sí 00:20:28
Pero por ahora dejámoslo en otro lado 00:20:30
Mejor que no 00:20:32
Es más complejo que eso 00:20:34
Con lo que sabemos hacer nosotros 00:20:36
Con esta cosa aquí 00:20:38
Esto decide los valores finales 00:20:40
Yo estaré trabajando con enteros 00:20:42
Pero no directamente en un array 00:20:44
Sino que tengo antes un array 00:20:46
De este array elijo una posición 00:20:48
Y voy allí 00:20:50
¿Para qué me sirven estas cosas, por ejemplo? 00:20:52
Para hacer matrices 00:20:54
¿Os acordáis de matrices? 00:20:56
Para hacer tablas 00:20:58
Para hacer, no lo sé 00:21:00
Aquí esto represente un alumno 00:21:02
Y en cada alumno tenga 00:21:04
Una serie de notas 00:21:06
Sí 00:21:14
Sí, no 00:21:18
Tiene un qué de parecido 00:21:20
Pero la clave primaria 00:21:22
Puede ser algo más complejo 00:21:24
Mientras aquí es el numerito 00:21:26
Es única, por lo tanto sí 00:21:28
Es un identificador 00:21:30
Es como si tú como clave primaria 00:21:32
De una base de datos 00:21:34
Utilizas una columna 00:21:36
Que es identificador 00:21:38
¿Cuánto tiene que ser? 00:21:40
Pues sí, pero tiene sus diferencias 00:21:42
Esta no es una base de datos 00:21:44
No tiene un gestor sistema de bases de datos 00:21:46
No tiene record infinitos 00:21:48
Tiene los record que has puesto tú 00:21:50
Ahora, esta cosa 00:21:54
¿Quién me prohíbe de aquí dentro 00:21:56
Poner un array? 00:21:58
Nadie 00:22:02
Entonces sería 00:22:04
Array de Array de Array 00:22:06
He hecho 00:22:08
Una matriz tridimensional 00:22:10
Pensando a un cubo 00:22:12
Y yo me voy colocando 00:22:14
En esta línea, esta columna 00:22:16
Esta profundidad 00:22:18
¿Quién me prohíbe de poner 00:22:22
Dentro de este punto 00:22:24
Otro array? 00:22:26
Mientras tenga RAM 00:22:30
Pero para explotarlo con RAM 00:22:34
Lo que pasa es que 00:22:36
Llega un momento en que empieza a hablar 00:22:38
De arrays 00:22:40
N-dimensionales 00:22:42
Multidimensionales 00:22:44
Y empieza a ser un poco complejo de entender 00:22:46
Hasta 3 dimensiones 00:22:48
Nosotros nos lo figuramos como estoy moviéndome en un cubo 00:22:50
Y tengo la X, la Y 00:22:52
Y la Z 00:22:54
Y más o menos 00:22:56
Cuando ya empezamos con 4 dimensiones, 5 dimensiones, 6 dimensiones 00:22:58
Nuestra mente ya empieza a decir 00:23:00
A lo mejor soy un matemático 00:23:02
Que está trabajando con vectores n-dimensionales 00:23:04
Y entonces esto me viene fenomenal 00:23:06
¿Vale? 00:23:08
Pero nosotros 00:23:10
Sufrimos mucho 00:23:12
Es esto 00:23:14
Declaración 00:23:20
Esto es un array bidimensional 00:23:22
Es decir que dentro de una posición 00:23:24
Me encontraré 00:23:26
Otro array 00:23:28
Esto es tridimensional 00:23:30
Esto es 00:23:32
Cuanto quieras dimensional 00:23:34
Puedo hacer lo que me da la gana 00:23:36
¿Cómo inicializo una cosa de ese estilo? 00:23:38
¿Qué hará esta 00:23:40
Inicialización de aquí? 00:23:42
Tendré un array con 4 posiciones 00:23:54
Y en cada una de estas 00:23:56
Posiciones dentro estará un array 00:23:58
Con 2 posiciones 00:24:00
Se puede, pero lo tienes que hacer 00:24:06
Explícitamente 00:24:08
Tú accederás a la posición 2 00:24:10
De este array y decirle 00:24:12
Este es este array de aquí 00:24:14
Asignación 00:24:20
Para acceder y poner un 00:24:22
Número o un string 00:24:24
Ahora tengo dos coordinadas 00:24:26
Tengo que acceder a M1 de 0 00:24:28
Es igual a 3 00:24:30
Porque en M1 de 0 no va 3, va un array 00:24:32
Para poder acceder a un valor concreto 00:24:36
Tengo que acceder a M1 00:24:38
De 0 y estaré 00:24:40
Elegiendo en el primer array 00:24:42
En este array que he pillado 00:24:44
Que es el que está en posición 0 00:24:46
Encontraré otro array 00:24:48
Me voy a la posición 1 00:24:50
Y allí pongo el 100 00:24:52
Cuando hago 00:24:54
Que se yo 00:25:00
Lo que estoy haciendo es 00:25:06
Vete a esta array 00:25:08
Vete a la posición 1 00:25:10
Y aquí estoy encontrando 00:25:12
Este array 00:25:14
Y de este array te vas a la posición 3 00:25:16
0, 1, 2 y 3 00:25:18
Y aquí le pones 00:25:20
7 tendrá aquí 00:25:24
Se puede hacer 00:25:38
Array de array 00:25:40
De esta forma 00:25:42
Esto contesta también a tu pregunta 00:25:44
En la posición 0 de este 00:25:46
De este array externo 00:25:48
Tengo un array de 2 posiciones 00:25:50
Solas 00:25:52
En la segunda posición, en la posición 1 00:25:54
Tengo un array de 3 posiciones 00:25:56
Y en la tercera una posición sola 00:25:58
Entonces estoy haciendo una situación 00:26:00
Donde no todos los 00:26:02
Arrays internos aquí tienen 00:26:04
El mismo tamaño, sino que este aquí 00:26:06
Por ejemplo tiene solo 2 posiciones 00:26:08
Y este tiene 5 00:26:10
Por eso es muy importante luego utilizar 00:26:16
Length 00:26:18
Si yo tengo situación como esta y no se cual es el tamaño de esto 00:26:20
Pues cada vez que entro en una de estas posiciones 00:26:22
Tendré que preguntar 00:26:24
Cuanta es grande el array con el que voy a preguntar 00:26:26
Como se por ejemplo 00:26:28
El tamaño de este array de aquí 00:26:30
De 1 00:26:44
A de 0 00:26:46
Punto length 00:26:48
Porque A de 0 00:26:56
Siendo un array de array es un array 00:26:58
Esta cosa de aquí es un array 00:27:00
Un array entero 00:27:02
Es este array entero 00:27:04
Y si aquí le pregunto 00:27:06
La longitud me dará 00:27:08
1, 2, 3, 4, 5 00:27:10
Si hago 00:27:12
A de 3 00:27:14
Punto length 00:27:18
Me dará 2 00:27:22
Si hago 00:27:28
A de 1, 3 punto length 00:27:30
Que me da 00:27:36
Hola 00:27:42
Explota 00:27:54
Porque este señor no es un array 00:27:56
Y sobre los arrays no se puede llamar length 00:27:58
Sobre lo que no son arrays 00:28:00
Sobre una variable int 00:28:02
No puedo llamar length 00:28:04
Porque no he puesto la paréntesis 00:28:08
Si fuera un string 00:28:10
Y le pusiera length entre paréntesis 00:28:12
Me diría el tamaño de esta string 00:28:14
Pero cuando yo ya he entrado aquí 00:28:16
En este array que es bidimensional 00:28:18
Cuando ya he entrado aquí dentro 00:28:20
No tengo un array 00:28:22
Tengo un valor 00:28:24
Que será int, que será string, que será boolean 00:28:26
Que será lo que yo haya creado 00:28:28
Y con este valor puede hacer lo que se hace sobre ese valor 00:28:30
Si fuera un objeto 00:28:32
Puede hacer todo lo que se puede hacer en un objeto 00:28:34
Si es string que es un objeto 00:28:36
Puedo llamar su método length 00:28:38
Puedo llamar su método substring 00:28:40
Puedo llamar todos los métodos que se pueden llamar substring 00:28:42
Que no conocemos todavía 00:28:44
Porque no hemos visto los objetos 00:28:46
¿Se entiende? 00:28:50
Esto es, lo estoy diciendo ahora 00:28:54
Es más avanzado 00:28:56
Para que se quede grabado 00:28:58
Para que luego en un futuro lo podáis volver a ver 00:29:00
¿Vale? 00:29:02
Pero técnicamente 00:29:04
Esto es un uso más avanzado 00:29:06
De los arrays 00:29:08
Nosotros a lo mejor 00:29:10
En algún momento veremos arrays bidimensionales 00:29:12
Muy probablemente 00:29:14
Improbablemente 00:29:16
Arrays tridimensionales 00:29:18
No mucho más 00:29:20
Pero la idea no es tanto de utilizar 00:29:22
Arrays, arrays bidimensionales y cosas por el estilo 00:29:24
Cuanto entender que es un array 00:29:26
Entender como se usa 00:29:28
Entender que es una estructura de datos 00:29:30
Que puede contenerse en otras celdas 00:29:32
De otros arrays 00:29:34
Y saber cuando una cosa es un array 00:29:36
Y cuando no es un array 00:29:38
Para que yo pueda utilizar sobre los arrays 00:29:40
Lo que puedo usar sobre los arrays 00:29:42
Y que no pueda usar lo que se puede usar sobre los arrays 00:29:44
Si lo que estoy utilizando no es un array 00:29:46
Eso tiene que estar más o menos claro 00:29:48
Antes o después 00:29:50
El discurso que hemos hecho ahora 00:29:52
Si yo tengo A de cero 00:29:54
Esto es un array y por lo tanto puede hacer 00:29:56
Un array 00:29:58
Si yo tengo una cosa así 00:30:00
Esto no es un array y por lo tanto no le puedo llamar 00:30:02
A encima 00:30:04
Así como si fuera un array tridimensional 00:30:08
Cuando yo hago A de cero 00:30:10
Lo que tengo dentro sería un array bidimensional 00:30:12
Si yo tengo esto 00:30:18
¿Vale? 00:30:22
Que es un array tridimensional 00:30:24
En cada una de estas celdas 00:30:26
Hay cinco celdas 00:30:28
Y en cada una de estas cinco celdas 00:30:30
Hay tres celdas en profundidad 00:30:32
Entonces si yo ahora busco 00:30:34
M2 de cero 00:30:36
Lo que obtengo es un array bidimensional 00:30:38
He quitado 00:30:40
La primera de las coordinadas 00:30:42
Y ahora me quedan dos coordinadas 00:30:44
Más para dar 00:30:46
Pero bueno 00:30:48
Por ahora 00:30:50
Fijaos que 00:30:52
Aquí un poquito lo dice 00:30:54
Si yo hago M1 punto length 00:30:56
Pues me está dando el tamaño 00:30:58
De la primera coordinada 00:31:00
Si yo hago M2 00:31:02
De cero punto length 00:31:04
Estaría en M2 00:31:06
He entrado ya aquí y por lo tanto me da esta 00:31:08
longitud de aquí 00:31:10
Si yo hago M2 de cero cero punto length 00:31:12
Habría entrado aquí 00:31:14
Luego ha entrado aquí y me da esta 00:31:16
longitud 00:31:18
Pero bueno 00:31:20
Porque M2 de cero 00:31:24
Y la primera es esta 00:31:28
Entonces si he entrado ya en uno de estos 00:31:30
Entonces 00:31:32
Allí dentro encuentro arrays bidimensionales 00:31:34
De cinco 00:31:36
Cinco por tres 00:31:38
Este array 00:31:40
Son seis 00:31:42
Tablas cinco por tres 00:31:44
Matriz bidimensional 00:31:52
Para tener varias filas 00:31:54
Bla bla bla 00:31:56
Estas cosas de aquí 00:31:58
Os lo explico un poquito 00:32:00
Ya lo hemos dicho antes 00:32:02
Y aquí hay un pequeño ejemplo 00:32:04
Del uso de dos 00:32:06
Arrays multidimensionales 00:32:08
Y cosas por el estilo 00:32:10
Que podéis mirar con calma 00:32:12
Para ver si entendéis algo de eso 00:32:14
Teniendo en cuenta que 00:32:16
Hasta esta transparencia 00:32:18
Autor/es:
Stefano Chiesa
Subido por:
Stefano C.
Licencia:
Reconocimiento
Visualizaciones:
10
Fecha:
15 de noviembre de 2023 - 10:30
Visibilidad:
Clave
Centro:
IES ROSA CHACEL
Duración:
32′ 20″
Relación de aspecto:
4:3 Hasta 2009 fue el estándar utilizado en la televisión PAL; muchas pantallas de ordenador y televisores usan este estándar, erróneamente llamado cuadrado, cuando en la realidad es rectangular o wide.
Resolución:
960x720 píxeles
Tamaño:
115.16 MBytes

Del mismo autor…

Ver más del mismo autor

EducaMadrid, Plataforma Educativa de la Comunidad de Madrid

Plataforma Educativa EducaMadrid