Saltar navegación

Arrays2: copia - 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 5 de noviembre de 2025 por Stefano C.

3 visualizaciones

Más información Transcripción

Descargar la transcripción

Voy a grabar esta parte de la clase, por lo tanto, si habláis, me autorizáis a grabar vuestro. 00:00:00
Entonces, nosotros hemos entendido más o menos qué es un array, cómo funciona, grosso modo, 00:00:06
y hemos hecho algunos ejemplos de uso de array. 00:00:12
Entonces, hemos dicho también que el array, en realidad, por debajo, está construido como un objeto. 00:00:16
entonces las variables 00:00:22
que tienen como tipo array 00:00:25
no son 00:00:27
variables que tienen dentro un valor 00:00:29
directamente, mas tienen una referencia 00:00:31
a una zona de memoria donde 00:00:34
está construido el objeto 00:00:35
el array es una variable 00:00:37
es un trozo 00:00:39
de memoria que tiene varios compartimentos 00:00:42
varias celdas 00:00:43
en cada celda tenemos un valor 00:00:45
de un determinado tipo 00:00:48
int, string o lo que sea 00:00:49
Nosotros utilizamos una referencia, una variable que se refiere a este trozo de memoria 00:00:51
Llegamos allí y luego decimos de estas 10 celdas que tengo, pues quiero la celda 5, quiero la celda 7 00:01:00
Y accedemos a esos valores que queremos ver 00:01:05
¿Qué implica esto de la referencia y cosas por el resto? 00:01:08
Imaginaos este trocito de código 00:01:13
O sea, tengo string x que es igual a 1, 2, 3, 4, 5 00:01:15
este es un array, se crea un array 00:01:19
por algún lado, y x se referencia 00:01:21
a este array, y ahora hago 00:01:24
string y es igual a x 00:01:25
entonces 00:01:28
esta cosa de aquí 00:01:30
en realidad 00:01:31
no me está creando una copia 00:01:33
del array, me está 00:01:35
creando dos referencias 00:01:37
al mismo array 00:01:39
entonces si yo ahora hago 00:01:41
x de 3 00:01:44
es igual a 7 00:01:45
o sea 0, 1, 2 y 3, este 4 lo cambio por 7, también y de 3 valdrá 7. 00:01:47
No he hecho una copia del array. 00:01:58
Gráficamente, cuando hago string x1 de 4, 5, tengo una referencia x a este objeto de aquí. 00:02:00
Cuando hago string corchetes y es igual a x, no creo una copia de la estructura. 00:02:09
Lo que estoy haciendo es copiar, es crear una nueva referencia a esta misma estructura. 00:02:15
¿Se entiende? 00:02:24
Entonces, cuando ahora x de 3 es 7, o sea, sustituyo esta parte de aquí, 00:02:25
también y que apunta a la misma estructura verá el cambio. 00:02:31
¿Sí? 00:02:39
O sea, que esta, la parte de aquí, no hace una copia de la rey. 00:02:40
Es importante esto. 00:02:48
Yo digo, ah, me copio la red así, así luego lo puedo cambiar y sigo teniendo los valores originales. 00:02:50
No, no se hace así. 00:02:55
¿Se entiende? 00:02:58
¿Dudas sobre esto? 00:03:00
Así, por conocimiento vuestro futuro, es como se portan absolutamente todos los objetos. 00:03:03
Los objetos son por referencia. 00:03:11
solo los valores, los tipos primitivos 00:03:13
son por valores 00:03:17
o sea, si yo hago lo mismo 00:03:18
con una variable int x 00:03:21
que hago int x es igual a 7 00:03:23
luego hago int y es igual a x 00:03:25
y luego cambio x 00:03:28
y no se ve 00:03:30
¿entendéis? 00:03:32
si yo creo 00:03:36
int x es igual a 7 00:03:37
he creado una variable int con dentro 7 00:03:43
que se llama x. Cuando hago int 00:03:48
y es igual a x 00:03:52
no estoy creando una referencia a esta, 00:03:55
estoy creando una nueva variable que se llama y 00:03:59
que tiene dentro int y se copia este valor. 00:04:02
Si ahora yo hago x es igual a 5 00:04:08
esto se destruye 00:04:12
el de 5 00:04:15
pero Y sigue teniendo 7 00:04:17
¿vale? 00:04:19
esto es porque los tipos primitivos 00:04:20
trabajan por valor 00:04:23
no por referencia 00:04:24
¿ok? 00:04:25
sin embargo 00:04:27
cuando uso un objeto 00:04:28
cuando uso un array 00:04:31
cuando yo copio 00:04:32
el array 00:04:35
¿veis que es de guía? 00:04:36
como antes que ponía 00:04:37
int Y es igual a X 00:04:38
es lo mismo que 00:04:40
¿dónde está? 00:04:41
Es lo mismo que esta cosa de aquí, solo que aquí lo estoy haciendo entre tipos primitivos, mientras aquí lo estoy haciendo entre rays. 00:04:41
Pues esta asignación de aquí no me copia, no me crea una copia de los valores, 00:04:52
sino que me crea una copia de lo que está dentro de la referencia. 00:04:58
Y por lo tanto, estoy apuntando a los mismos valores, al mismo objeto, a la misma estructura. 00:05:02
Si cambio una de estas dos, el cambio se verá reflejado en la otra. 00:05:07
¿Por qué sirve? 00:05:13
Por mil y media cosas. 00:05:15
No es que sirva, es que es como funciona una cosa y la otra. 00:05:17
Luego tú sabes cómo funciona y lo haces funcionar como te da la carta. 00:05:21
Ahora, ¿y qué pasa si yo en vez de quiero que X e Y tengan dos copias que sean distintas 00:05:31
y que si cambio algo en x no se vea en y, ¿vale? 00:05:39
Aquí la cuestión no es a uno sirve, a uno no sirve. 00:05:43
Aquí la cuestión es lo que yo necesito. 00:05:47
Yo pueda que necesite que x y sean dos variables en partes distintas de mi programa 00:05:49
que accedan a la misma estructura. 00:05:56
Lo entenderemos mejor cuando veremos los métodos en la función, ¿vale? 00:05:59
Pero yo puedo necesitar las dos cosas. 00:06:03
Puedo necesitar que x e y apunten a la misma estructura, entonces que cambios en x se reflejen también en y y cambios en y se reflejen también en x. 00:06:06
O puedo necesitar que sean completamente separadas. 00:06:16
Entonces necesito una copia del array. 00:06:19
¿Cómo se hace la otra versión? 00:06:23
Para hacer la otra versión tengo que copiar el array. 00:06:26
¿Cómo se copia el array? 00:06:30
Pues yo tengo mi array original. 00:06:31
Fijaos que cuando creo Y no lo hago igual a X, 00:06:33
mas creo un nuevo array distinto. 00:06:37
Y a este punto con un for recorro todo X 00:06:41
y copio lo que hay X en Y. 00:06:45
Entonces lo que estaría haciendo es 00:06:49
que cuando pillo X creo una estructura con dentro lo que sea. 00:06:52
Ahora, cuando creo Y, me creo una estructura con los mismos números de celdas, pero sin nada dentro, porque aquí habría podido poner el new string de X.lend, por ejemplo, ¿vale? Para hacerlo del mismo tamaño de X. 00:06:57
Y ahora me voy con un for por cada celda de X copiando el contenido de la celda en la misma celda de Y. 00:07:15
Entonces ahora tengo una copia de las dos estructuras. 00:07:24
X apunta a la estructura verde, Y apunta a la estructura azul. 00:07:29
Si yo cambio algo en X y se cambia aquí con 7, pues este cambio no se ve reflejado en azul porque es una estructura distinta. 00:07:33
No son referencias al mismo objeto, no son referencias separadas a objetos separados. 00:07:43
¿Dudas? 00:07:50
Empezaremos con las redes multidimensionales. 00:07:56
Sé que queréis, pero bueno, venga, hoy no. 00:07:58
El concepto de este de aquí es, ahora lo aplicamos, por ejemplo, al problema que decíamos antes. 00:08:03
Es decir, ¿qué pasa si yo he acabado los espacios en una red y quiero un espacio más? 00:08:10
Pues entonces tendré que hacer algo parecido a esto. 00:08:17
O mejor, una combinación de estas dos cosas. 00:08:21
¿Vale? 00:08:24
Porque yo me creo una copia de X, Y. 00:08:24
Que pero en vez de cinco posiciones tenga una más, seis. 00:08:29
¿Vale? 00:08:33
Luego copio todas las primeras cinco celdas en la nueva estructura. 00:08:34
¿Vale? 00:08:39
Me quedará una celda libre que será la que utilizo para añadir el nuevo elemento. 00:08:40
Y a este punto, usando esta cosa de aquí, hago que x, en vez de apuntar a la verde, apunte a la azul. 00:08:46
Y entonces ahora tengo que x apunta a la nueva estructura más grande. 00:08:57
Ya está. Encantado de la vida. 00:09:02
¿Qué pasa con esta estructura de aquí, que antes era referenciada por x y ahora no hay una variable que referencie esta estructura? 00:09:05
¿Entendéis el problema? 00:09:16
yo tengo yo tengo una variable x que tiene dentro una referencia a un objeto así vale lo que hago 00:09:20
es crear una estructura y que apunte a una celda más grande ya una red más grande copio todo lo 00:09:36
que estaba aquí en la parte de arriba lo copio aquí abajo sé que había 1 2 y 3 aquí copio 1 2 00:09:44
y 3, me sobra un hueco. A este punto, haciendo que x es igual a y, lo que estoy haciendo es, 00:09:50
borrando esta cosa de aquí y diciendo que x es igual a lo que apunta y, estoy precisamente 00:10:00
copiando esto aquí dentro. ¿Vale? Y entonces, ahora, x es el nuevo objeto, tiene una celda 00:10:06
libre, fenomenal, he logrado lo que quería yo, 00:10:17
pero la pregunta es, ¿qué pasa 00:10:20
con esto? Porque esto ocupa 00:10:21
memoria. 00:10:25
O sea, sí que lo ha guardado, pero ya no lo hace caso. 00:10:27
Claro, pero ¿yo quiero 00:10:29
que se quede ahí en memoria? 00:10:31
Pues no. El hecho 00:10:34
es que Java, que es 00:10:35
muy amigable desde esta perspectiva, 00:10:37
si tiene un objeto 00:10:39
al que nadie hace referencia, 00:10:41
o sea, que no hay un 00:10:44
handler, no hay un manejador, no hay una 00:10:45
variable que apunta a este objeto, lo marca como que, oye mira, nadie puede acceder a este objeto, 00:10:48
y cada cierto tiempo pasa un señor que se llama el Garbage Collector, que es el recolector de 00:10:54
basura. El Garbage Collector es un procedimiento que hace la Java Virtual Machine, que es ir a 00:11:14
mirar su memoria, mirar el IP, ver si hay objetos al que no se puede acceder porque no tienen 00:11:22
referencias a ello y eso de allí lo quita, diciendo que ahora está memoria libre. El garbage collector 00:11:29
nosotros no tenemos ningún modo de activarlo. Hay una función, system.gc, que lo que te dice es 00:11:36
oye mira si puedes pasa el garbage collector pero será siempre la java virtual machine que decide 00:11:47
cuándo ejecutar normalmente no se ejecuta a menos que no se tienen dos casos o no tengo nada que 00:11:55
hacer hay una parte del programa en que el programa se ha parado no tiene nada que hacer pues como 00:12:06
tengo tiempo libre, procesador libre, pues lanzo el Garbage Collector y limpio un poco. 00:12:10
O si necesito memoria. A mí se me había desequilibrado esta memoria, la he llenado con 00:12:15
objetos, necesito más memoria, pasa un momento el Garbage Collector a ver si se vacía algo y tengo 00:12:22
espacio para reposar. Pero es un proceso, es algo que hace la Llaverton Machine sola, sin que yo 00:12:29
pueda interferir con él. Yo ni puedo solicitarlo, ni puedo garantizar que se ejecute, ni lo 00:12:38
puedo ejecutar. En otros lenguajes de programación demoníacos e infernales, el garbage collector 00:12:44
no existe. Y vosotros tenéis que gestionar la memoria. C++, típicamente los C, necesitan 00:12:54
tanto alocar la memoria como desalojarla, o sea, tú cuando creas un objeto le dices 00:13:02
oye mira necesito este espacio, él te da ese espacio y cuando ya no lo usas más dices 00:13:09
este espacio libéralo, si tú se te olvida liberarlo, pues creas lo que se llama un memory 00:13:15
leak, vale, o sea que tu programa mientras funciona crea objetos que luego no se destruyen 00:13:24
Y por lo tanto, el tamaño en memoria crece y crece y crece hasta que llega el momento 00:13:29
en que tienes demasiados objetos allí y tu programa colapsa. 00:13:35
Java es bueno desde esta perspectiva. 00:13:41
Nosotros ni pedimos memoria ni la quitamos. 00:13:44
Lo hace toda la Java de Tomasch. 00:13:49
Y es un infierno gestionar la memoria. 00:13:51
¿Dudas? 00:13:56
Entonces, vamos a verlo aquí. Imaginámonos que yo tenga un array de enteros, porque es 00:13:57
el más fácil. Aquí. Que es esta cosa aquí. Uno, dos y tres. Y que ahora diga, oye, quiero 00:14:10
insertar un nuevo valor. Tengo int nuevo, que es cuatro. Y lo tengo que insertar en 00:14:23
este array? No puedo. Entonces lo que hago es, necesito que este objeto aquí, porque 00:14:30
luego al final yo lo que quiero hacer es iso ar, perdón, esto sería a raíz de punto 00:14:38
toString de ar, y lo que quiero es ver todos los valores que he metido, 1, 2, 3, y también 00:14:46
este 4 entonces como lo hago pues para hacer esto necesito un nuevo array que será grande como el 00:14:56
array viejo pero un poco más esto por ejemplo es una posición más grande si aquí pusiera por 00:15:14
2 lo que haría es aumentar el tamaño de este array por 2. Ahora, yo tengo dos arrays. Este 00:15:24
que tiene dentro 1, 2 y 3 y este que tiene cuatro posiciones pero está vacío. Lo escribimos. Arrays.tostring 00:15:37
y también que estáis clicando me explica y que estoy clicando que estáis así nuevo 00:15:47
art entonces aquí veremos que esto tiene una posibilidad tres posiciones con escrito 00:16:09
1 2 3 y este de aquí tiene nada 00:16:15
Esto tiene 1, 2 y 3. Esto tiene 4 posiciones con ceros dentro, porque int, si yo no le digo qué es, me pone un cero en automático. 00:16:17
Ahora, lo que voy a hacer es copiar este señor aquí dentro. 00:16:32
Entonces, for inti es igual a cero y menor que r.length y más más, dentro de nuevo array en la posición i, vas a copiar lo que estaba en array en la posición i. 00:16:38
¿Entiende? 00:17:06
después de todo este proceso 00:17:06
si yo escribo 00:17:10
el nuevo rey 00:17:13
vamos con un inciso 00:17:16
una separación 00:17:18
cada vez que los escribo 00:17:21
pongo un número distinto para que se vea 00:17:34
que estoy escribiendo 00:17:37
y aquí esto será el final 00:17:38
entonces 00:17:41
si yo ahora miro y lanzo 00:17:44
En la primera tenía esto con 1, 2, 3 y este de aquí con todo vacío. 00:17:46
Ahora tengo 1, 2, 3 y he copiado 1, 2, 3. 00:17:52
Pero fijaos que ar, esto, sigue siendo una referencia al viejo, al de 3. 00:17:57
Ahora que he creado esto nueva rey, lo que puedo hacer es decir que ar 00:18:06
es igual a nuevaRey. 00:18:14
Esta cosa, lo que me hace es, vale, 00:18:22
la referencia a este objeto de aquí, la pierdo, 00:18:25
y la sustituyo con la referencia a este objeto de aquí, 00:18:28
que ahora es este objeto de aquí. 00:18:31
Por lo tanto, ahora ar, 00:18:33
en la opción 3, 00:18:35
cuando lo escribo, ¿qué me espero de ver? 00:18:38
¿Qué veré aquí? 00:18:43
Lo mismo, dos veces esta cosa de aquí. 00:18:45
Es que en el 3 ya los dos están apuntando al mismo objeto. 00:18:49
Fijaos que si yo ahora cambio 1, por ejemplo, a ar de 3 le pongo el nuevo valor, el que tenía que añadir, este de aquí, ¿os acordáis? 00:18:58
Pues y ahora reescribo los dos 00:19:11
Fijaos que he cambiado solo ar 00:19:17
Nuevo ar no lo he tocado 00:19:27
Pero si yo lo lanzo 00:19:31
En el 4 00:19:35
¿Veis que el 4 se ha añadido tanto en ar como en nuevo ar? 00:19:36
¿Lo veis? 00:19:43
¿Por qué? 00:19:45
Porque ahora estas son dos referencias 00:19:46
al mismo objeto 00:19:50
los cambios que hago aquí 00:19:52
se verán reflejados aquí 00:19:53
y ahora yo 00:19:55
el nuevo ar 00:19:58
esta variable de aquí 00:19:59
me puedo olvidar de ella 00:20:01
y seguir adelante trabajando con ar 00:20:02
¿entiendes? 00:20:05
lo que estoy entendiendo es que 00:20:11
estás copiando 00:20:14
la referencia 00:20:15
en la otra 00:20:18
no tiene la misma referencia 00:20:18
Lo que estamos haciendo es prácticamente la misma cosa entre variables normales, 00:20:22
solo que cuando tú tienes a y b, que son este 7 y este 5, 00:20:31
tú lo que estás haciendo, si haces a es igual a b, lo que estás haciendo es copiar esto aquí dentro. 00:20:39
cuando trabajas con objetos 00:20:45
al hacer x es igual a y 00:20:49
no estás copiando 00:20:51
el objeto, estás copiando 00:20:52
esta referencia 00:20:55
la copias aquí y entonces 00:20:56
ahora este tiene la misma referencia 00:20:58
va aquí también 00:21:01
entonces vamos a hacer 00:21:01
un ejercicito 00:21:13
10 minutos 00:21:14
el que os había dicho antes 00:21:16
esto será 6 00:21:20
Entonces, este me dice 00:21:24
voy a leer números infinitos 00:21:35
desde teclado, ¿vale? 00:21:37
Dame números 00:21:41
Lo pondremos después 00:21:43
Scanner 00:21:46
scan es igual 00:21:49
a new scanner 00:21:51
de System.it 00:21:52
Yo voy a leer números infinitos, números infinitos, números infinitos 00:21:58
hasta que el usuario me ponga un cero. Si el usuario me pone un cero 00:22:03
asumo que ha acabado y que quiere que haga lo que haga. 00:22:07
Y lo que quiero hacer es 00:22:10
lo dejo sencillo, escribir todos los números que me has puesto 00:22:12
pero en pantalla. 00:22:18
Me das números, me das números 00:22:19
Cuando pones cero yo te escribo todos los números 00:22:23
Que me has dado tú 00:22:26
Pero no hay un límite 00:22:26
Si tú sigues dándome números 00:22:28
Yo sigo dándome números 00:22:30
Entonces 00:22:32
Empezamos con 00:22:33
Int 00:22:36
Números 00:22:38
Es igual a 00:22:40
Int 00:22:42
De cero 00:22:43
Esto es una array sin celdas 00:22:47
¿De acuerdo? 00:22:51
Entonces, mi idea es 00:22:55
Cada vez que me ponen un nuevo número 00:22:56
Yo lo que hago es 00:22:59
Aumentar una celda 00:23:00
Ponerlo dentro de este array 00:23:01
Y asociar números a este nuevo array 00:23:03
¿Vale? 00:23:07
Cada vez que me dan un número 00:23:08
Yo creo un nuevo array un poquito más grande 00:23:09
¿Sí? 00:23:12
Empiezo por cero porque no me han dado valores 00:23:13
Mientras que no me han dado valores 00:23:16
Pues, ya está 00:23:18
Y yo sé, cada vez que cuando me dan 00:23:19
un valor nuevo no cabe en el array anterior. Solo me dan un 1 y yo sé que hay 0 plazas. Por lo tanto 00:23:22
lo tengo que extender. Cuando me darán 2 había una plaza sola. Entonces siempre lo extendo. Luego ya 00:23:29
mañana, no, el viernes vemos si mejoramos esta cosa. Yo sé que esto lo tengo que hacer siempre. 00:23:33
Entonces lo que hago es, CISO. Ya lo tengo. Dame un número y aquí tengo dos opciones. O es 0 o es 00:23:39
es un número distinto a cero. Si es cero, he acabado. ¿Sí? Entonces, si, ah, lo leo aquí, int, nuevo, o valor, 00:23:57
val, es igual a scan.nextInt. Leo el nuevo valor. Si val es distinto de cero, hago algo. Si no, he acabado. 00:24:10
esta es más o menos la plana 00:24:29
ahora, esta cosa de aquí 00:24:35
pero no la hago una vez sola 00:24:37
la hago mogollón de veces 00:24:38
entonces, ¿cómo hago para que 00:24:40
esto se haga muchas veces? 00:24:45
huile 00:24:48
ozor 00:24:49
¿por qué huile? 00:24:50
porque no tengo 00:24:53
idea de cuántas veces lo voy a hacer 00:24:55
¿vale? 00:24:57
es, mientras 00:24:59
val 00:25:00
sea distinto 00:25:02
de cero, 00:25:05
trabaja, trabaja, trabaja, 00:25:10
trabaja. ¿Vale? 00:25:11
Entonces, cuidado, pero 00:25:16
este valor yo lo estoy pidiendo aquí. 00:25:18
¿Sí? Entonces 00:25:21
necesitaré una primera 00:25:22
vez pedirlo 00:25:24
fuera. 00:25:26
Yo empiezo. 00:25:29
Te digo, oye, mira, 00:25:30
porque esto sería más un Dubai, pero 00:25:32
yo leo el primer número 00:25:34
que este número es cero 00:25:36
pues aquí dentro no entraré nunca 00:25:38
y llego directamente aquí al final 00:25:40
aquí en la parte final 00:25:42
si tú el primer número que me das es un cero 00:25:43
yo no entraré nunca 00:25:48
en este while y se acabó 00:25:50
ya he acabado 00:25:52
si en vez 00:25:53
no es cero 00:25:55
sí que entraré aquí dentro 00:25:58
pero en vez de pedir 00:26:00
directamente un nuevo valor 00:26:01
haré esta cosa de aquí 00:26:03
ahora veremos que 00:26:07
y luego pido un nuevo valor 00:26:08
ahora este if 00:26:10
ya no me hace falta 00:26:14
¿por qué? porque me lo está haciendo esto 00:26:16
mientras que esta cosa 00:26:18
sea verdadera 00:26:20
pues entonces entra aquí dentro 00:26:21
entonces si yo entro aquí dentro 00:26:23
lo que tengo que hacer es almacenar el nuevo valor 00:26:25
tengo en valor un nuevo valor 00:26:28
lo almaceno 00:26:30
y luego pido el valor siguiente 00:26:31
y vuelvo aquí. 00:26:34
Esto es como un do while hecho un poquito raro. 00:26:36
¿Sí? 00:26:39
Vale. Entonces, 00:26:40
me han dado un valor. Este valor no es 00:26:42
cero. 00:26:44
Lo almaceno. Para almacenar lo que tengo 00:26:45
que hacer, tengo que crear 00:26:48
un array más grande. 00:26:50
¿Vale? Entonces, 00:26:52
int 00:26:53
array 00:26:54
más grande 00:26:56
es igual a 00:26:59
new int 00:27:02
de números 00:27:04
punto length 00:27:06
que sería 0 00:27:08
en este caso al principio 00:27:11
más 1 00:27:12
luego lo copio 00:27:13
por int y es igual a 00:27:16
0 y menor que 00:27:19
números 00:27:21
punto length 00:27:23
y más más 00:27:24
por todas las casillas de 00:27:26
números que podrían ser cero 00:27:28
y por lo tanto esto no lo hago 00:27:31
¿vale? pero 00:27:32
lo que hago es copiar dentro de más grande 00:27:33
de i 00:27:37
lo que hay 00:27:38
en números 00:27:40
de i ¿de acuerdo? 00:27:42
y cuando he acabado 00:27:47
de copiarlo 00:27:49
lo que hago es primero que 00:27:50
números es igual a más grande 00:27:53
y aquí he 00:27:55
completado la copia 00:27:57
he completado el agrandamiento de números 00:27:58
he pillado lo que había 00:28:01
le he añadido una casilla 00:28:02
he metido la referencia a este nuevo objeto 00:28:04
por lo tanto ahora ya números 00:28:07
tiene una celda más 00:28:09
y ahora en la última 00:28:11
celda de números 00:28:13
añado val 00:28:14
¿cómo accedo a la última casilla de números? 00:28:15
números 00:28:24
punto length 00:28:24
menos 1 00:28:26
es igual a val 00:28:28
entonces 00:28:30
me han dicho que tengo un nuevo valor 00:28:33
Vale, perfecto. Entonces me creo una cosa más grande, copio todo lo que tenía antes, asocio la referencia al nuevo objeto más grande, al nuevo array más grande y en su última posición le pongo el valor nuevo que me han puesto. 00:28:36
Y ahora pido otro número. 00:28:51
Si este número será distinto de cero, volveré a hacer esto. 00:28:54
Si este número es igual a cero, llego aquí, salgo y llego a la parte final. 00:29:00
Y en la parte final, ¿qué tengo que decir? 00:29:06
Si eso 00:29:09
Arraiza 00:29:09
Punto toString 00:29:12
Número 00:29:15
Fijaos 00:29:17
Que este 00:29:19
Esta variable de aquí 00:29:21
Solo existe dentro del while 00:29:24
¿Vale? 00:29:26
Hasta que llega al final del while 00:29:28
Cada ciclo, esta variable de aquí se destruye 00:29:29
Porque no me interesa esta variable de aquí 00:29:32
La que me interesa es esta 00:29:34
es esta que me llevo delante 00:29:35
cuando he pasado 00:29:38
este while, más grande 00:29:39
no existe, existe solo 00:29:42
números, y en cada 00:29:43
ciclo del while más grande 00:29:45
apuntará a una nueva estructura 00:29:47
más grande que la anterior 00:29:49
y al final yo haré el cambio, que el número se apunte 00:29:51
a esta nueva estructura 00:29:54
y más grande ya no me interesa 00:29:55
esta x en el de antes. Esta aquí sería x. Le cambio la referencia a este de aquí, que era la 00:30:05
que tenía antes, ahora se lo cambio de nuevo. Mientras y es la que se crea dentro del while, 00:30:15
pero luego no me sirve de nada. Esto lo puedo quitar y a mí lo que me interesa es mantenerme 00:30:21
x, porque al final lo que voy a escribir es números, no más grandes. En este caso, 00:30:27
seguir trabajando con la primera referencia 00:30:34
por lo tanto, mejor en el caso de que 00:30:36
digamos... O sea, que yo quiera copias 00:30:38
y cosas por el estilo. Se puede, ¿no? O sea, 00:30:40
depende del ejercicio. Depende de lo que 00:30:42
quieres hacer. Entonces, ahora yo tengo 00:30:44
el ejercicio, fijaos que 00:30:46
no sé cuántos números voy a poner, 00:30:48
puedo poner cuántos números me da 00:30:51
la gana, esto no me limita, 00:30:52
yo sigo dando números 00:30:55
y él no me ha dicho, ah, no, te podías dar 00:30:56
solo tres números, no. Cuando 00:30:58
pongo un cero, se acaba 00:31:00
y me escribe todos los números 00:31:02
que yo le he puesto hasta ahora. 00:31:04
Si yo lo lanzo 00:31:10
y pongo cero al primero, 00:31:11
es una red vacía. 00:31:14
¡Uy! 00:31:14
Materias:
Programación
Niveles educativos:
▼ Mostrar / ocultar niveles
  • Formación Profesional
    • Ciclo formativo de grado superior
      • Primer Curso
Autor/es:
Stefano Chiesa
Subido por:
Stefano C.
Licencia:
Reconocimiento - No comercial
Visualizaciones:
3
Fecha:
5 de noviembre de 2025 - 12:43
Visibilidad:
Clave
Centro:
IES ROSA CHACEL
Duración:
31′ 23″
Relación de aspecto:
1.78:1
Resolución:
1920x1080 píxeles
Tamaño:
263.38 MBytes

Del mismo autor…

Ver más del mismo autor

EducaMadrid, Plataforma Educativa de la Comunidad de Madrid

Plataforma Educativa EducaMadrid