Saltar navegación

Activa JavaScript para disfrutar de los vídeos de la Mediateca.

Clase 13-11-23 - 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 13 de noviembre de 2023 por Raquel G.

5 visualizaciones

Más información Transcripción

Descargar la transcripción

Vale, pues vamos a entender un poquito por dentro esto de los Arrays, ¿vale? 00:00:00
Entonces, venced la pérdida mental, porfa, e intentad escuchar. 00:00:06
Porque uno podría hacer ejercicios de Arrays, por lo que hemos visto hasta ahora, 00:00:10
y podría llegar hasta aprobar algún examen, pero vamos, duraría dos, tres diarios. 00:00:16
Las cosas hay que entenderlas, hay que entenderlas para no caerse 00:00:21
en cuanto uno da un paso fuera de lo básico. 00:00:26
Bueno, pues entonces, ¿qué estamos haciendo en realidad cuando declaramos, 00:00:31
qué es lo que está pasando, quiero decir, 00:00:36
qué es lo que está pasando en realidad cuando declaramos un Array? 00:00:38
Pongo siempre el ejemplo de enteros porque es el más sencillo, 00:00:41
el que estamos más acostumbrados a los números, 00:00:44
pero me da igual que el Array sea de enteros que de números decimales, me da lo mismo. 00:00:46
Bueno, vamos a suponer que hemos declarado aquí un Array de números, 00:00:50
y además hemos dicho que para usarlo tenemos que definir un tamaño en memoria, 00:00:55
que eso no hay otra, antes de yo poder usarlo. 00:01:02
Y eso lo hacemos de esta manera, new, espacio, el tipo de dato, y ahora aquí el tamaño. 00:01:05
Vamos a suponer que es 20, bueno, pues 20. 00:01:13
Vale, ¿qué está pasando físicamente en memoria principal? 00:01:16
Pues en la memoria RAM, automáticamente la máquina virtual reserva un espacio, 00:01:19
reserva un espacio para tantas posiciones, tantas como hayamos dicho aquí. 00:01:28
¿Vale? 00:01:37
Sí, Daniel, para tantas como hayamos dicho aquí, si hemos dicho 20, para 20. 00:01:39
Y además sabemos que esta puedo acceder a ella mediante el nombre número 0, 00:01:50
a esta podré acceder mediante el nombre número 1, y así a todas, 00:01:58
hasta esta final, a la que podré acceder con el nombre números, ¿qué? 00:02:05
19. 00:02:14
¿Vale? 00:02:17
Vale, entonces números 0, números 1, números 2, ya sabemos lo que es, 00:02:19
pero ¿y números? 00:02:23
¿Números qué es? 00:02:24
Números es algo, para la máquina virtual es algo, porque de hecho aquí 00:02:25
lo hemos usado para hacer esta asignación, lo hemos usado. 00:02:29
Es decir, no nos estamos limitando a usar, ah bueno, que no estáis viendo ahí nada. 00:02:34
Vale. 00:02:40
Es decir, la variable número suelta ya es algo. 00:02:41
Números 0 tenemos claro lo que es. 00:02:44
Cuando yo escribo números 0, tenemos claro lo que es, es este espacio, este espacio. 00:02:46
Y si yo le asigno 7, ya sabemos que asignamos 7 a este espacio. 00:02:54
Si yo escribo números 3, también tengo claro lo que es. 00:02:58
Números 3 es este espacio, 0, 1, 2, 3, este, este es números 3. 00:03:04
Y si yo le asigno aquí cualquier cosa, pues por ejemplo, números 0 por 3, 00:03:10
por ejemplo, pues sé que a números 3, que es este, le estoy asignando lo que tenga este, 00:03:17
que es números 0 multiplicado por 3. 00:03:22
Vale, hasta ahí es lo que hemos estado usando. 00:03:24
Una vez declarado un array y reservado su espacio, hemos usado sus posiciones individuales. 00:03:27
¿Vale? Eso es lo que nosotros ya, hasta ahora, hemos estado usando 00:03:33
y se supone que tenemos ya entendido y clarísimo cómo funciona. 00:03:37
Vale, pero siguiente salto. 00:03:42
¿Y la variable números ella sola quién es? 00:03:45
¿Esta variable números quién es? 00:03:50
Porque ya la hemos usado en el ejemplo que hemos puesto antes, porque yo tenía dos arrays 00:03:52
y a números 1 le he asignado números 2. 00:03:56
Esto lo he hecho. 00:04:01
Y el compilador lo ha parecido muy bien. 00:04:03
Ha dado un error, pero habrá que ver porque lo ha dado, 00:04:05
pero números 1 es una variable igual. 00:04:07
En este caso, números. 00:04:11
Entonces, la pregunta que nos hacemos es 00:04:13
¿y este término, números solo, sin el 0, sin el 1, sin el 2, a qué se refiere? 00:04:17
Porque con el 0, con el 1, con el 2, ya sabemos a qué se refiere a estas posiciones, 00:04:23
a estas posiciones, ya lo sabemos. 00:04:27
Pero números ella solita, ¿números a qué se refieren? 00:04:29
Pues números ella sola, sin índice, sin índice, números, es también una variable, 00:04:34
un espacio en memoria, también lo es, también lo es, es un espacio en memoria. 00:04:39
¿Y este espacio en memoria qué tiene? 00:04:44
Pues tiene una dirección de memoria, tiene una dirección, 00:04:47
y la dirección que tiene es la dirección donde está colocado el array. 00:04:52
Luego, en realidad, lo que físicamente está apareciendo en la memoria RAM 00:04:58
cuando hacemos esto es 00:05:02
un espacio para guardar una dirección de memoria. 00:05:06
Este espacio se llama números, este espacio se llama números. 00:05:09
Y luego está apareciendo, después de hacer esto, 00:05:14
está apareciendo un espacio con 20 posiciones, las que sean, 00:05:17
y la dirección de memoria, la dirección donde está este espacio, 00:05:20
colgando a partir de él, está contenida aquí. 00:05:25
Esto es lo que físicamente ha aparecido. 00:05:28
Lo que pasa es que a nosotros lo que nos interesa son estas posiciones 00:05:31
que es donde están nuestros datos. 00:05:33
Es esto lo que nos interesa. 00:05:35
Por eso nosotros usamos números 0, números 1, números 2, 00:05:37
porque nos interesan estas posiciones. 00:05:39
¿Vale? 00:05:41
Esta variable números por sí misma, 00:05:42
ella, lo que tiene es la dirección de memoria, 00:05:44
entonces esa variable en sí, esta dirección me da igual. 00:05:47
Esta dirección me da igual. 00:05:49
Lo que pasa es que la máquina virtual 00:05:51
necesita que esto esté montado así. 00:05:53
Porque cuando yo le digo a la máquina virtual, le digo 00:05:56
números 0 igual a 1, 00:06:02
cuando yo le digo esto, 00:06:04
ella físicamente lo que hace es 00:06:06
coge números, 00:06:09
coge números, 00:06:11
coge números, 00:06:13
coge números, 00:06:15
se va a esta dirección de memoria, 00:06:17
a través de esta dirección de memoria, 00:06:19
viaja hasta aquí. 00:06:21
Ahora suma tanto como el índice, 00:06:23
que es 0, se queda aquí, 00:06:25
que es 3, baja hasta 3. 00:06:27
O sea, cuando yo digo esto, 00:06:29
en realidad se desencadena toda esa acción. 00:06:31
La máquina virtual viaja a esta dirección 00:06:33
que está recogida aquí, 00:06:35
viaja a esta dirección, 00:06:37
a través de esta dirección viaja hasta aquí, 00:06:39
y a través del índice ya viaja hasta donde toca. 00:06:41
Todo eso es lo que hace. 00:06:43
Para nosotros es muy sencillo, 00:06:45
para nosotros es números 3 igual a 1, 00:06:47
ya sabemos que el efecto final es este. 00:06:49
Pero lo que está ocurriendo físicamente es esto que digo, 00:06:51
y la estructura que hay en memoria montada 00:06:53
es esta, 00:06:55
es esta, 00:06:57
es esta, ¿vale? 00:06:59
Bueno, pues entonces, 00:07:03
el saber que esto es así, 00:07:05
que esto está así montado, 00:07:07
nos permite ya entender muchas cosas 00:07:09
que pasan con array y trabajar con cosas. 00:07:11
Por ejemplo, 00:07:13
vamos a ver el caso de antes. 00:07:15
Yo tenía números 1 00:07:17
que era un array 00:07:19
de 10 posiciones. 00:07:21
Vale, pues ya está, 00:07:23
el ejercicio que hemos hecho antes. 00:07:25
Pues en el ejercicio que hemos hecho antes, 00:07:31
esta sería la estructura que se queda montada. 00:07:33
Aparece una variable en memoria, 00:07:35
números 1, 00:07:37
que tiene una dirección de memoria. 00:07:39
La dirección que se va a suponer, 00:07:41
donde está todo esto es la dirección de memoria, 00:07:43
pues yo qué sé, 00:07:45
dirección de memoria 37, 00:07:47
por poner cualquier chorrado. 00:07:49
Pues entonces, esta variable 00:07:51
tendrá la dirección de memoria 00:07:53
y guardadita, una dirección de memoria, 00:07:55
ahí guardada la tiene. 00:07:57
Entonces la dirección de memoria, 00:07:59
la máquina virtual, 00:08:01
la selecciona automáticamente la que le da la gana 00:08:03
en función de donde vea 00:08:05
a ella que hay espacio. 00:08:07
No le decimos nosotros donde tiene que colocar 00:08:09
este array, a partir de qué dirección, 00:08:11
lo selecciona ella automáticamente. 00:08:13
Aquí tengo espacio, lo coloco aquí el array 00:08:15
y ahora la dirección a partir 00:08:17
de la cual lo he colocado la pongo aquí, 00:08:19
en ese espacio. 00:08:21
Bueno, pues con esta declaración 00:08:23
hemos montado esta estructura. 00:08:25
Vamos a hacer ahora la otra 00:08:27
que teníamos. 00:08:29
La otra que teníamos 00:08:31
era esta. 00:08:33
Números2 00:08:37
igual a 00:08:39
newIn de 5. 00:08:41
Este segundo array tenía sólo 00:08:43
5 posiciones, 5. 00:08:45
Entonces al tener sólo 5 00:08:47
la estructura que se queda en memoria 00:08:49
es esta. 00:08:51
Números 00:08:53
Se le asigna 00:08:57
la dirección de memoria, la dirección que sea, 00:08:59
la que la máquina virtual encuentre que le interesa. 00:09:01
Yo qué sé, imaginaos que es esta. 00:09:03
Y esta dirección de memoria 00:09:05
le lleva a un espacio 00:09:07
en memoria RAM, en este caso 00:09:09
con 5 posiciones sólo. 00:09:11
¿Vale? Y este espacio 00:09:15
estará a partir de la dirección 72. 00:09:17
Bueno, pues esta es la estructura 00:09:19
que se ha montado como 00:09:21
consecuencia de hacer esta sentencia de aquí. 00:09:23
¿Vale? Está la variable 00:09:25
números2 con una dirección 00:09:27
y esta dirección lleva a donde están 00:09:29
ya las posiciones. Entonces cuando hagamos 00:09:31
números2 de 0 00:09:33
sabemos que es esta, porque la máquina virtual 00:09:35
cogerá números2, viajará hasta aquí 00:09:37
y sería la 0. Cuando hagamos números2 de 1 00:09:39
pues sabemos que es esta. ¿Vale? 00:09:41
Pero lo que está en memoria es todo esto de aquí. 00:09:43
Bueno, pues ahora vamos a 00:09:45
hacer esa sentencia 00:09:47
que hemos hecho ahí probando. 00:09:49
La sentencia que hemos hecho 00:09:51
era esta. Bueno, vamos a suponer que 00:09:53
hemos rellenado los estos, los hemos rellenado 00:09:55
este tiene 7, 3, 4 00:09:57
menos 1, 2, 5 00:09:59
yo que sé, cualquier cosa. 00:10:01
Y este tiene 7, 3, 4 00:10:03
menos 1, 5. 00:10:05
Vale. 00:10:07
Eh... 00:10:09
Ahora vamos a hacer esa sentencia que hemos probado. 00:10:11
A números2 00:10:15
a números1 00:10:17
creo que era 00:10:19
sí, a números1 00:10:21
asígnale 00:10:23
números2 00:10:27
¿Vale? Esta es la sentencia que hemos probado. 00:10:29
¿Qué hemos dicho? 00:10:31
La sentencia para el compilador maravillosa 00:10:33
porque son dos variables del mismo 00:10:35
tipo. Las dos son de tipo 00:10:37
a raíz de enteros. Números1 es a raíz de 00:10:39
enteros y números2 es a raíz de enteros. 00:10:41
Luego el compilador asigna una variable a otra 00:10:43
que son del mismo tipo, fenomenal. 00:10:45
Vale, luego esa sentencia es estupenda. Y ahora la pregunta 00:10:47
es, ¿pero qué está pasando físicamente 00:10:49
cuando hacemos la sentencia? 00:10:51
Bueno, ahora ya sabemos que 00:10:53
números1 es una variable que tiene esta dirección de memoria 00:10:55
y números2 es esta 00:10:57
otra que tiene esta dirección de memoria. 00:10:59
Entonces, si yo hago, oye, 00:11:01
a números1 asígnale números2 00:11:03
¿qué estoy haciendo? Pues 00:11:05
a números1 le piso 00:11:07
esta dirección que tenía, fuera, la basura 00:11:09
y le asigno la que 00:11:11
tiene números2, que 00:11:13
es esta. 00:11:15
Esto es lo que estoy haciendo si hago esto. 00:11:17
¿Verdad? A esto 00:11:19
le piso lo que 00:11:21
tenía y le asigno esta. 00:11:23
Con lo cual este enlace se rompió. 00:11:25
Esto desapareció. 00:11:27
Y automáticamente números1 00:11:29
empieza a apuntar 00:11:31
al mismo sitio 00:11:33
que el otro. 00:11:35
¿Vale? Esto es lo que estamos 00:11:37
haciendo. No es que estemos copiando el 00:11:39
contenido de este array en este array. 00:11:41
No estamos haciendo eso 00:11:43
cuando hacemos esta sentencia. 00:11:45
Lo que hacemos es, oye, ojo, 00:11:47
a la dirección de memoria que tenía 00:11:49
números1, písala 00:11:51
llevaba un array, llevaba un array 00:11:53
pues písala y asígnala la dirección 00:11:55
que tenía números2, que es esta. 00:11:57
Entonces ahora las dos tienen la misma dirección, esta y esta 00:11:59
las dos. Luego los dos arrays 00:12:01
llevan al mismo sitio. 00:12:03
Luego ahora son físicamente el mismo. 00:12:05
Los he convertido en físicamente 00:12:07
el mismo, que es este. ¿Y este 00:12:09
qué le ha pasado? 00:12:11
Se ha quedado sin nadie 00:12:13
que le apunte. Ahí sigue. 00:12:15
En memoria reservado. 00:12:17
Pero no hay absolutamente ninguna 00:12:19
variable que le apunte. Conclusión, este array 00:12:21
es inaccesible. 00:12:23
Nunca jamás, desde el programa, nunca 00:12:25
jamás se va a poder acceder aquí. 00:12:27
Se queda absolutamente inaccesible. 00:12:29
Entonces, 00:12:31
precisamente para que las cosas inaccesibles 00:12:33
no estén ahí 00:12:35
engrosando la memoria, ocupando memoria 00:12:37
porque tiene una memoria ocupada, la máquina virtual 00:12:39
no puede disponer de ella. 00:12:41
Pues como se ha quedado inaccesible, esto ya es un agujero 00:12:43
negro. Es imposible 00:12:45
llegar aquí. No hay ninguna variable 00:12:47
que tenga una dirección de memoria que lleve aquí. 00:12:49
Pues como esto se ha quedado en agujero negro, 00:12:51
existe en Java, 00:12:55
la máquina virtual de Java tiene un pequeño proceso 00:12:57
que es el que se llama 00:12:59
el recolector de basura 00:13:01
o el garbage collector. 00:13:03
Y el recolector de basura es un proceso que está 00:13:05
cada pocos milisegundos 00:13:07
tirando a la basura 00:13:09
todo lo que se ha quedado colgando 00:13:11
de la nada, sin nadie que le apunte. 00:13:13
Pues después de haber hecho esta 00:13:15
sentencia, este 00:13:17
se ha quedado colgando de la nada. 00:13:19
Inaccesible, se acabó. Esto no se va a poder 00:13:21
usar nunca. Entonces el recolector 00:13:23
de basura, el solito, va detectando 00:13:25
estas situaciones 00:13:27
y dice, ah, fuera, este inaccesible 00:13:29
a la basura, lo tira 00:13:31
y ya hace disponible esa memoria 00:13:33
para los futuros 00:13:35
usos de la máquina virtual. 00:13:37
El recolector de basura lo tiró. 00:13:41
Y ahora ya, números 00:13:43
1 y números 2 son físicamente 00:13:45
lo mismo. Tengo dos variables 00:13:47
distintas, pero 00:13:49
las dos tienen la misma dirección de memoria 00:13:51
y las dos llevan al mismo sitio. 00:13:53
Claro, por eso cuando 00:13:55
en nuestro código hemos recorrido ahora 00:13:57
números 1, lo hemos recorrido 00:13:59
hasta 10, creyendo que recorríamos esto. 00:14:01
Pues no. 00:14:03
Cuando nos hemos pasado del 5, 00:14:05
no se ha salido una raíz y no se ha salido un exception, 00:14:07
porque números 1, después de haber hecho esta asignación, 00:14:09
ahora es este. 00:14:11
Ahora es este. 00:14:13
Entonces ya no podemos pasarnos de ahí, 00:14:15
porque ahora es este físicamente. 00:14:17
Por eso nos ha salido la raíz e índice 00:14:19
va a un excepción. 00:14:21
¿Vale? 00:14:23
Entonces, 00:14:25
importantísimo entender 00:14:27
que esto por sí mismo, eso solo, 00:14:29
sin un índice puesto asociado, 00:14:31
sin un índice puesto 00:14:33
como este, 0, 1, 2, eso, 00:14:35
es una variable también, 00:14:37
pero es una variable que lo que tiene es una dirección. 00:14:39
Y a través de esa dirección, 00:14:41
poniendo yo ya aquí el índice que sea, 00:14:43
ya puedo acceder 00:14:45
a una posición. 00:14:47
¿Vale? 00:14:49
Entonces, acostumbrémonos a este concepto 00:14:51
de dirección de memoria. 00:14:53
¿Por qué? 00:14:55
Ahora ya, cuando empecemos a ver las clases 00:14:57
y objetos, ya todo lo que vamos a manejar son objetos. 00:14:59
Y los objetos son direcciones 00:15:01
de memoria. 00:15:03
Y de entender bien toda la complejidad que va por debajo, 00:15:05
se deriva 00:15:07
que nuestros programas 00:15:09
que compilarán perfectamente 00:15:11
y estarán todos estupendos, valgan para algo 00:15:13
o no valgan para nada. 00:15:15
De que entendamos bien esa complejidad. 00:15:17
Bueno, pues, 00:15:19
¿esto está entendido? 00:15:21
Sí, seguro. 00:15:23
Bueno, pues en esta situación, 00:15:27
este se fue a la basura porque el conductor de basura 00:15:29
ha dicho, oye, te has quedado 00:15:31
sin nadie 00:15:33
que te referencie. 00:15:35
Sin nadie, pues tú fuera, no vales para nada. 00:15:37
¿Vale? 00:15:39
Entonces, ahora ya, 00:15:41
después de esa situación, se nos ha quedado 00:15:43
esta y esta. 00:15:45
¿Vale? 00:15:47
Imaginaos que ahora digo yo, oye, pues 00:15:49
ahora quiero que números 2 00:15:51
me apunten, 00:15:53
no quiero yo que apunten los dos al mismo. 00:15:55
Vaya desperdicio de memoria. 00:15:57
Pues, por ejemplo, 00:15:59
si quiero que números 2 ahora 00:16:01
me apunte a otro array distinto que me voy a crear. 00:16:03
Puedo hacerlo sin ningún problema. 00:16:05
Imaginaos que ahora hacemos esto. 00:16:07
Cada vez que yo haga 00:16:11
esto, 00:16:13
por ejemplo, 00:16:15
es decir, 00:16:17
imaginaos que a una variable array 00:16:19
que yo tengo declarada, le vuelvo a hacer 00:16:21
otro new int, porque me da la gana, le vuelvo a hacer 00:16:23
otro new int. ¿Vale? Pues le vuelvo a hacer otro new int. 00:16:25
Pues, ¿qué pasa cada vez que 00:16:27
hacemos un new int? 00:16:29
Cada vez que hacemos un new int, 00:16:31
se crea un espacio en memoria. 00:16:33
En este caso, de dos posiciones, 00:16:35
la 0 y la 1. 00:16:37
Y este espacio en memoria se queda apuntado 00:16:39
por números 2. 00:16:41
Imaginaos que este espacio en memoria, pues, 00:16:43
se ha creado ahí, con la posición 0 y la 1. 00:16:45
¿Vale? El new int 00:16:47
lo que hace es crear espacio en memoria. 00:16:49
Y ahora, 00:16:51
el espacio en memoria, la dirección, 00:16:53
se guarda 00:16:55
en la variable que esté aquí, números 2. 00:16:57
Con lo cual, números 2, ahora ya 00:16:59
dejaría de tener la dirección 00:17:01
del otro, empezaría a tener 00:17:03
la de este que acabo de crear. 00:17:05
Con lo cual, este enlace se rompe. 00:17:09
Y ahora, números 2, 00:17:11
empieza a apuntar a este. 00:17:13
¿Vale? Empieza a apuntar aquí. 00:17:17
Porque yo he 00:17:19
creado un espacio, ese espacio está en una 00:17:21
dirección, y esa dirección se guarda en la variable 00:17:23
que yo ponga aquí. 00:17:25
Y ahora ya tendría números 1 apuntando a este. 00:17:27
Y números 2 00:17:29
apuntando a este otro. 00:17:31
¿Vale? Más o menos. 00:17:39
Es decir, 00:17:41
vamos a recopilar un poco. 00:17:43
Vamos a revisar entonces 00:17:45
qué estamos haciendo realmente cuando hacemos 00:17:47
esta sentencia. 00:17:49
Ahora ya vamos a analizarla un poco mejor. 00:17:51
Esta de aquí. 00:17:57
Esta, que es la que hemos 00:17:59
plantado siempre a Capón, cuando queríamos 00:18:01
usar un array de números 00:18:03
2, 3, 4, 5, 6, 7, 00:18:05
8, 9, 10, 11, 00:18:07
12, 13, 14, 15, 00:18:09
16, 17, 18, 19, 00:18:11
cuando queríamos usar un array 00:18:13
de emperos o lo que fuera de x posiciones. 00:18:15
¿Pues qué estamos haciendo? 00:18:17
Bueno, pues la primera parte, 00:18:19
esta, 00:18:21
uno la podría poner suelta, así. 00:18:23
Es decir, en realidad podríamos hacer 00:18:27
primero la declaración del array. 00:18:29
Imaginaos que yo hago esta 00:18:31
primera parte sin más. 00:18:33
Bueno, pues con esta primera parte 00:18:35
que estamos declarando, 00:18:37
una variable números, 00:18:39
una variable números, 00:18:41
pensada 00:18:43
para contener una dirección 00:18:45
de memoria. 00:18:47
Y esta dirección de memoria, 00:18:57
¿ahora mismo a dónde estaría apuntando? 00:18:59
A nada, porque mientras yo no 00:19:01
creo un espacio, 00:19:03
esta variable números 00:19:05
se ha creado, ha aparecido, 00:19:07
pensada para contener la dirección de memoria, 00:19:09
pero ahora mismo, mientras yo no le haga el newInt, 00:19:11
no apunta a nada. 00:19:13
Esto se le llama 00:19:15
apuntar a null. 00:19:17
¿Vale? 00:19:19
De hecho, si hiciérais ahora, solamente 00:19:21
con esta sentencia, luego un system out 00:19:23
de números, se pondría null. 00:19:25
Se diría, oye, ¿qué tiene esta variable 00:19:27
de números? Tiene null, una dirección de memoria 00:19:29
que es null, no apunta a nada. 00:19:31
Vale, entonces con este array 00:19:33
no podemos hacer nada, obviamente, 00:19:35
porque es una dirección de memoria que apunta a nada. 00:19:37
Aquí no hay espacio ni nada. 00:19:39
Ahora queremos crear el espacio. 00:19:41
Pues para crear el espacio, 00:19:43
ahora ya sí que hay que hacer el newEste. 00:19:45
Números 00:19:55
igual 00:19:59
a newInt 00:20:01
de 3, por ejemplo. 00:20:03
Vale. 00:20:05
Ahora ya, con newInt, 00:20:07
ya se crea el espacio. 00:20:09
Vale, con esto se crea. 00:20:11
Ala, muy bien, ya tenemos el espacio, en este caso, 00:20:13
para 3. 00:20:15
Este espacio la máquina virtual decide crearlo 00:20:17
donde le pete. 00:20:19
Imaginaos que lo crea en esta dirección. 00:20:21
Ahí lo crea. 00:20:23
Y ahora la dirección de memoria donde está ese 00:20:25
espacio creado, la guarda 00:20:27
en la variable que hay aquí. 00:20:29
Vale, pues como resultado de esta sentencia, 00:20:31
no solo se crea el espacio, 00:20:33
sino que esta dirección, ahora ya, 00:20:35
se guarda ahí. 00:20:37
Eso significa 00:20:41
que este array ha dejado ya de apuntar 00:20:43
a null, y este array empieza 00:20:45
a apuntar aquí. 00:20:47
Y ya podemos empezar a trabajar. 00:20:49
Ahora ya, números 0 es alguien, 00:20:51
números 1 es alguien, números 2 es alguien. 00:20:53
Antes de hacer esto, números 0 es nada. 00:20:57
Ahora veremos lo que es. Error, nada. 00:20:59
Pero una vez hecho esto, 00:21:01
ahora ya sí, porque ya hay espacio en memoria. 00:21:03
Entonces, 00:21:05
¿que lo hago en dos líneas separadas o en una? 00:21:07
Me da igual. 00:21:09
Más cómodo en una, ¿no? Más cómodo. 00:21:11
Pero entended que son dos ideas. 00:21:13
Dos ideas. 00:21:15
Esto declara la variable 00:21:17
con la dirección de memoria de donde va a estar 00:21:19
el array, pero mientras el array no esté creado, 00:21:21
esto apunta a null. 00:21:23
Y ahora esto ya sí que 00:21:25
crea el espacio. Esto ya sí. 00:21:27
¿Vale? 00:21:31
Entonces, con esta variable se puede trabajar 00:21:33
por separado, pero se puede trabajar sabiendo que es una 00:21:35
dirección de memoria. Que ahora me dicen, 00:21:37
oye, hazte una copia de este array. 00:21:39
O sea, yo podría hacer esto, por ejemplo, 00:21:41
int 00:21:43
números 2 00:21:49
y a números 2, oye, asígnale 00:21:51
números. 00:21:53
Pues esto es una sentencia 00:21:55
perfectamente normal. ¿Qué estoy haciendo 00:21:57
aquí? Declarar una 00:21:59
variable números 2 00:22:01
así, pensada 00:22:07
para contener un array. Luego esto es una dirección 00:22:09
de memoria. Está pensada 00:22:11
para una dirección de memoria. Vale. 00:22:13
Y ahora, a esta variable números 2 00:22:15
que tiene una dirección de memoria, ¿qué le 00:22:17
asignamos? La dirección 00:22:19
que está en números. ¿Vale? Muy 00:22:21
bien. Le asignamos lo que tiene números. 00:22:23
Que tiene 23. Muy bien. 00:22:25
Le asignamos el 23. 00:22:27
¿Eso qué significa? Que números 2 00:22:29
automáticamente se queda 00:22:31
apuntando aquí. Luego 00:22:33
con esta sentencia estoy 00:22:35
creando dos direcciones de memoria 00:22:37
que me llevan al mismo array. 00:22:39
¿Vale? 00:22:43
¿Qué implicaciones tiene esto? 00:22:45
Que si yo hago 00:22:47
números de 0 00:22:49
igual a 3. 00:22:51
Pues está claro. 00:22:53
Números de 0 se apunta un 3. 00:22:55
Y ahora muestro 00:22:57
números 2 00:23:03
de 0 00:23:05
Uno podría pensar, oye, que 00:23:07
números 2, yo no le he dado ningún valor. 00:23:09
A ver, es que números 2 tiene una dirección 00:23:11
de números. Luego te apunta al mismo sitio. Luego 00:23:13
si muestras esto, números 2 de 0 te va 00:23:15
a dar el 3 también. Porque es el mismo 00:23:17
físicamente. Es el mismo. 00:23:19
¿Vale? Entonces 00:23:21
como números 2 00:23:23
tiene la copia de esta dirección 00:23:25
todos los cambios que yo haga a través 00:23:27
de números 00:23:29
los voy a poder acceder a través de números 2 00:23:31
también. Porque los dos apuntan 00:23:33
al mismo lado. Los dos apuntan al mismo sitio. 00:23:35
¿Vale? 00:23:39
Bueno, pues es muy importante entender esto 00:23:41
y que lo reviséis y que lo 00:23:43
tengáis muy muy claro y entendido. Es la 00:23:45
base, en realidad, de la programación 00:23:47
frente a objetos. Esta idea 00:23:49
entender que una cosa es la dirección de memoria 00:23:51
donde están los datos y otra cosa 00:23:53
son los datos. 00:23:55
¿Vale? Y que a unos datos se puede 00:23:57
acceder desde un montón 00:23:59
de variables siempre y cuando 00:24:01
esa tengan la misma dirección. 00:24:03
¿Vale? 00:24:07
Vale, pues... 00:24:11
Si... 00:24:17
A ver... 00:24:21
Ahora... 00:24:33
... 00:24:51
Vale, pues entonces, el ejercicio en el que estábamos. 00:25:03
En el que estábamos. 00:25:15
Ahora ya entendemos 00:25:17
lo que ha pasado, ¿verdad? 00:25:19
Después de haber copiado 00:25:21
en números 1 y números 2 00:25:23
la dirección números 00:25:25
1 me apunta al mismo sitio que números 00:25:27
2. Con lo cual, números 1 y números 00:25:29
2 ahora son lo mismo. 00:25:31
Luego este 10 era el problema. 00:25:33
Ahora, números 1 00:25:35
solo me llega hasta 5. Solo me 00:25:37
llega hasta 5. Si yo intento 00:25:39
recorrerlo hasta 10, me pasa lo que me ha pasado. 00:25:41
Que cuando me rebaso 00:25:43
de la posición 4... 00:25:45
¿Vale? 00:25:47
Ese ha sido el problema. 00:25:49
Vamos a ponerlo aquí. 00:25:51
Ahora, números 00:25:55
1 y 00:25:57
números 2 apuntan 00:26:01
al mismo sitio. 00:26:05
Luego, números 00:26:11
1 solo tiene 00:26:13
5 posiciones. 00:26:15
¿Vale? Entonces, si yo quiero recorrer 00:26:19
números 1 00:26:21
tiene que tener 5. 00:26:23
Ahora ya esto no me da error 00:26:27
de ejecución. 00:26:29
Ese es el primer array que hemos hecho, con posiciones aleatorias. 00:26:31
Ese es el segundo que hemos 00:26:33
hecho, con posiciones aleatorias. 00:26:35
Luego, hemos ido 00:26:37
posición por posición copiando 00:26:39
uno en otro. Aquí no hemos 00:26:41
alterado las direcciones de memoria y nada. 00:26:43
Números 2 sigue apuntando a este array 00:26:45
y números 1 a este. 00:26:47
Lo que hemos hecho ha sido ir copiando las posiciones. 00:26:49
Pero es distinto ir copiando posiciones una tras otra 00:26:51
que ¡paf! de golpe mueve la dirección 00:26:53
entera. Ahora, 00:26:55
hemos asignado directamente números 1 y números 2. 00:26:57
Pues ahora ya, números 00:26:59
1 y números 2 son lo mismo. 00:27:01
Van al mismo sitio. 00:27:03
Y hemos mostrado el mismo array 00:27:05
dos veces. 00:27:07
Vamos a poner aquí otro ejemplo. 00:27:13
Ejemplo 4. 00:27:25
Ejemplo 5. 00:27:27
Solo tiene 5 posiciones. 00:27:41
Vamos a hacer rápidamente 00:27:57
eso que hemos visto en 00:27:59
la pizarra. Yo tengo mis dos 00:28:01
arrays. Ahora mismo solo son 00:28:03
direcciones de memoria que no apuntan a nada. 00:28:05
Vamos a mostrar a ver 00:28:07
qué me sale que tienen. 00:28:09
Números 1. 00:28:11
¿Vale? 00:28:13
¿Qué me dice? 00:28:15
Números 1 no está 00:28:17
inicializada. 00:28:19
Es una dirección de memoria pero que 00:28:21
apunta a null. No está inicializada. 00:28:23
Entonces, 00:28:25
vamos a inicializarla. 00:28:27
Pues venga, números 1 igual. 00:28:29
Le vamos a asignar 00:28:31
un array de 00:28:33
10 posiciones, por ejemplo. 00:28:35
Ahora ya, 00:28:37
números 1 ya apunta a un 00:28:39
espacio de 10 posiciones 00:28:41
consecutivas a las que pueda acceder 00:28:43
con 0, 1, 2. 00:28:45
¿Y ahora qué vamos a hacer con números 2? 00:28:47
A números 2 le vamos a asignar 00:28:49
números 1. 00:28:51
Luego, números 2 y números 1 00:28:55
apuntan al mismo sitio. 00:28:57
Números 1 y números 00:29:01
se han 00:29:05
quedado apuntando 00:29:07
al mismo sitio. 00:29:11
Vamos a comprobarlo. 00:29:15
Vamos a asignar valores a números 1 00:29:17
y luego vamos a recorrer números 2. 00:29:19
Vamos a rellenar 00:29:21
números 1. 00:29:23
Pues venga, 00:29:25
tras i sea menor que 00:29:31
10, era. 00:29:33
En lugar de por teclado 00:29:35
vamos a rellenarlo con números aleatorios. 00:29:37
Números 1 00:29:41
de i 00:29:43
le vamos a asignar 00:29:45
y le vamos a 00:29:47
asignar 00:29:49
punto random 00:29:53
por 50, números aleatorios 00:29:55
entre 0 y 50. 00:29:57
Hacemos el casting entero 00:30:01
para que... 00:30:03
Vale, el array 00:30:07
números 1 de 10 posiciones está relleno. 00:30:09
Es el único que hemos 00:30:11
rellenado. Ahora 00:30:13
vamos a recorrer el segundo. 00:30:15
Vamos a mostrar lo que tiene 00:30:17
para ver lo que tiene. 00:30:21
En otro bucle 00:30:27
fuera aparte para que el programa quede más claro. 00:30:29
La arrastraron. 00:30:41
Números de i 00:30:45
seguido de 00:30:47
un espacio. 00:30:49
Vale, y pongo 00:30:59
los asteriscos. 00:31:01
Vale, pues a ver. 00:31:03
He rellenado el primero. 00:31:05
Y lo he mostrado. 00:31:07
Vale, pues voy a mostrar el segundo 00:31:11
también. Vamos a mostrarle al segundo. 00:31:13
Que no le hemos rellenado, ni hemos hecho nada 00:31:15
al segundo. 00:31:17
Solo hemos rellenado con esto el primero. 00:31:19
Vamos a mostrar el segundo. 00:31:21
Vale, pues lo hemos mostrado. 00:31:27
Ahora, lo hemos rellenado con 00:31:29
esto el primero. Vamos a mostrar el segundo. 00:31:31
Hago este mismo bucle. 00:31:37
Mostramos el segundo. 00:31:45
Vale, a ver que pasa. 00:31:55
Vale, veis lo que hemos hecho. 00:31:57
No hemos rellenado el primero. 00:31:59
Y sin haber hecho nada 00:32:01
con el segundo, salvo esta asignación, 00:32:03
salvo esta. 00:32:05
Lo mostramos ahora. 00:32:07
Y veis, efectivamente, 00:32:13
a través de números 2, llegamos 00:32:17
al mismo sitio. Llegamos al mismo 00:32:19
array. 00:32:21
Llegamos al mismo. 00:32:23
Este es número 2. 00:32:25
Este es número 1. 00:32:27
Son exactamente el mismo, porque 00:32:29
después de haber hecho esta asignación, 00:32:31
las dos direcciones de memoria 00:32:33
son la misma. 00:32:35
Las dos direcciones van al mismo lado. 00:32:37
Me da igual acceder al array 00:32:39
desde números 1 que desde números 2. 00:32:41
Me da igual. Estoy accediendo a la misma 00:32:43
zona de memoria. 00:32:45
Desde el momento en que he asignado una a la otra. 00:32:47
Estoy accediendo a la misma zona de memoria. 00:32:51
¿Vale? 00:32:57
¿Entendido esto? 00:33:01
Bueno, antes de que os pongáis 00:33:05
a hacer ejercicios, 00:33:07
solo una cosita más 00:33:09
para que sea más cómodo. 00:33:11
Es una tontería. 00:33:13
Aunque nos quedan unas cuantas cosas de array. 00:33:15
Vale, cuando recorremos 00:33:17
un array, ya hemos dicho 00:33:19
que la forma más 00:33:21
práctica y rápida de hacerlos con un 00:33:23
for, porque el for ya me permite 00:33:25
aquí declarar de forma rápida una variable 00:33:27
que empieza variando cero, la voy incrementando 00:33:29
y llego hasta donde yo quiera. 00:33:31
Bueno, pues ya esa variable, ya esa 00:33:33
me vale como índice. 00:33:35
Entonces el for es la forma más práctica 00:33:37
de recorrer un array. 00:33:39
Porque ya esa variable me vale como índice. 00:33:41
Pero el problema es que yo me tengo que 00:33:43
acordar, cuando pongo aquel numerito, 00:33:45
me tengo que acordar 00:33:47
del tamaño que tenía el array. 00:33:49
Para acordarme me tengo que ir arriba 00:33:51
y declarar. Tengo que acordar. 00:33:53
Bueno, eso a veces 00:33:55
vale. Pues el mayor 00:33:57
problema que tiene es que me tengo que ir a ver 00:33:59
uy, ¿cuántos tenía? Diez. 00:34:01
Pero es que hay veces que si el programa consta de varias 00:34:03
partes, como ya veremos, son 00:34:05
funciones aparte, es que es imposible. 00:34:07
Yo físicamente, mirando 00:34:09
mi código, no voy a poder saber 00:34:11
de qué tamaño se declaró 00:34:13
ese array. Hay veces que no voy a poder saberlo. 00:34:15
Porque la parte del código a la que tengo 00:34:17
acceso, es distinta a la 00:34:19
parte del código en la que se declaró. 00:34:21
Eso nos va a ocurrir enseguida, cuando ya tengamos 00:34:23
varias clases. Luego, una situación 00:34:25
así, que ponemos aquí, 00:34:27
es decir, sería 00:34:31
interesante que hubiera una manera 00:34:33
de, dado una variable array, 00:34:35
una dirección de memoria, saber 00:34:37
yo qué tamaño 00:34:39
tiene el array al que apunta. 00:34:41
Sería ideal si eso existiera. 00:34:43
Pues existe. 00:34:45
Si yo tengo una variable array como números 00:34:47
pues tengo una posibilidad 00:34:51
que es esta, 00:34:53
que es 00:34:55
sacar el tamaño 00:34:57
que hay reservado 00:34:59
para ese array números 1. 00:35:01
Entonces, desde el momento que yo 00:35:03
pongo nombre de un array, 00:35:05
.length, 00:35:07
esto es el tamaño 00:35:09
que se reservó cuando se le declaró. 00:35:11
El tamaño que se reservó. 00:35:13
¿Que se reservó 100? Es 100. 00:35:15
Si se reservó 30, será 30. 00:35:17
No tengo que irme aquí a buscar esto. 00:35:19
No tengo que irme a buscarlo. 00:35:21
Es fundamental, porque habrá veces que ni siquiera 00:35:23
tengamos acceso a esa sentencia. 00:35:25
Pero nos da igual. 00:35:27
Entonces, esto es muy cómodo 00:35:29
para hacer recorridos de 00:35:31
for, porque no tengo que andar yo aquí arrastrando 00:35:33
el número. Pongo números 1.length 00:35:35
y ya está, o aquí igual. 00:35:37
Aquí pongo números 2.length 00:35:39
y ya está, ya lo tengo. 00:35:47
De hecho, si ejecutamos 00:35:49
este código, nos va a dar lo mismo. 00:35:51
¿Vale? Porque números 00:35:53
length, números 2.length 00:35:55
¿Vale? Entonces aquí 00:35:57
de nuevo nos liéis. 00:35:59
Uno podría decir, oye, pero números 2. 00:36:01
Yo a números 2 no le hice ningún new. 00:36:03
No le hice ningún ya. 00:36:05
Pero es que a números 2 le hemos asignado números 1. 00:36:07
Con lo cual, números 2 y números 1 00:36:09
es que son lo mismo. 00:36:11
Como son lo mismo, números 2.length 00:36:13
será lo mismo que números 1.length 00:36:15
porque son lo mismo, gracias a esta 00:36:17
asignación que le hemos hecho. 00:36:19
¿Vale? 00:36:25
Pues vamos a subir una primera hoja 00:36:27
de ejercicios. 00:36:29
Subido por:
Raquel G.
Licencia:
Todos los derechos reservados
Visualizaciones:
5
Fecha:
13 de noviembre de 2023 - 13:33
Visibilidad:
Público
Centro:
IES ROSA CHACEL
Relación de aspecto:
1.78:1
Resolución:
1280x720 píxeles
Tamaño:
696.08 MBytes

Del mismo autor…

Ver más del mismo autor

EducaMadrid, Plataforma Educativa de la Comunidad de Madrid

Plataforma Educativa EducaMadrid