Saltar navegación

20261118 Test_array_1 - 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 18 de noviembre de 2026 por Raquel G.

1 visualizaciones

Descargar la transcripción

Vale, pues esto era lo que estaba, este ya lo hicimos, ¿verdad? 00:00:01
Qué fino. 00:00:10
Vale, ¿dónde está el rotulo? 00:00:11
Esta pregunta ya la resolvimos. 00:00:13
¿Vale? ¿Qué ocurre al ejecutar este código? 00:00:16
Imprime 5, imprime 0, lanzo la excepción, no compila porque AD1 no tiene valor. 00:00:41
Entonces, ¿para qué nos sirvió? 00:00:47
Vale, ¿para qué nos sirvió esta pregunta? 00:00:50
Ahora, esta pregunta nos sirvió para darnos cuenta de que un array no necesita tener todas sus posiciones inicializadas para poder usarlo, ¿vale? Aquí habíamos declarado un array de cuatro posiciones, ahí habíamos declarado un array de cuatro posiciones, ¿vale? 00:00:57
eso es lo que habíamos, joder, pesado, bueno, no hay bueno, sí, aquí habíamos declarado una raíz de cuatro posiciones, 00:01:28
de las cuales habíamos inicializado la 0 aquí, y luego pretendíamos inicializar la 3, que era esta, sumando la posición 0 con lo que había en la 1, 00:01:38
en la 1 no hay nada 00:01:50
entonces una de las opciones era 00:01:52
oye, esto te va a un error de compilación 00:01:54
porque a 1 no tiene nada 00:01:57
no, por defecto la máquina virtual 00:01:58
le da valores 0 00:02:01
a los números, entonces lo que sí que tiene que estar 00:02:03
inicializado es el array 00:02:05
el array lo está 00:02:07
está inicializado con un 00:02:08
espacio en memoria de 4 posiciones 00:02:11
está el array inicializado 00:02:13
porque recordad que 00:02:15
declarar un array 00:02:17
que es esto, esta parte era simplemente crear una variable que se llama a, que está pensada para contener la dirección de memoria, esto es una dirección de RAM, pensada para contener la dirección de memoria RAM, 00:02:19
donde ahora ya sí que sí va a haber un espacio con cuatro casillas para guardar números. 00:02:39
Entonces, esto es lo que tenemos cuando declaramos y creamos un array, ¿vale? 00:02:48
Entonces, esta variable a está inicializada porque apunta a este espacio. 00:02:55
Ahora ya estos valores por defecto, la máquina virtual cuando arranca les da el cero, ¿vale? 00:03:02
luego esto nosotros dimos la opción 5 00:03:07
luego ya veremos abajo 00:03:10
si hemos acertado o no hemos acertado 00:03:12
¿vale? porque 00:03:14
si yo lo inicializo a 5 00:03:15
5 más 0 00:03:18
que es la que tiene por defecto la A1 00:03:20
es 3, 5, vale 00:03:22
esto es lo que habíamos 00:03:24
cancelar 00:03:27
vale, ahora 00:03:30
siguiente pregunta 00:03:32
que 00:03:33
habíamos llegado a hacer 00:03:34
que imprime este fragmento de aquí, vale, esta fue muy interesante, vale, porque nos sirvió precisamente 00:03:37
para poner como ejemplo exactamente que es un array, entonces dijimos aquí declaramos un array 00:03:50
que es esta variable a 00:04:02
que apunta a un espacio de memoria 00:04:04
y aquí vimos 00:04:06
otra manera de crear e inicializar 00:04:08
arrays, que esto ya lo habíamos contado 00:04:10
¿vale? pues esto 00:04:12
hacía un array de tres posiciones 00:04:14
con dos, cuatro y seis 00:04:16
esto es lo que me hace la primera línea 00:04:18
¿qué me hace la segunda línea? 00:04:20
me declara 00:04:23
un array 00:04:24
b o lo que es lo mismo 00:04:26
una variable 00:04:28
así para apuntar a una posición de memoria y ahora en la segunda parte del igual es donde 00:04:30
dices a dónde vas a apuntar, pues en la segunda parte del igual estamos asignando el propio 00:04:37
array A, el mismito, con lo cual al asignarle a B el valor que tiene A, al poner aquí la 00:04:43
misma dirección que hay aquí, al ser las dos la misma dirección, ser las dos la misma, 00:04:52
pues B también está apuntando a este sitio. 00:04:57
Luego A y B son exactamente direcciones de la mismo espacio de memoria. 00:05:02
Luego cuando yo hago B de 1 igual a 10, estoy poniendo el 10 aquí. 00:05:12
Y si ahora imprimo A de 1 más B de 1, 00:05:18
A de 1 tenía 4, porque esta es la posición 0, 00:05:21
la 1 y la 2. A de 1 tenía 4, que es esta. En su momento, ¿verdad? Tenía 4, pero ahora 00:05:27
yo la he cambiado al poner B de 1 igual a 10. Ah, no, perdón, jolín, estoy diciendo 00:05:36
mal, ¿vale? A de 1 tenía 4, pero al poner B de 1 a 10, como A y B son lo mismo, A de 00:05:43
1 ahora tiene 10 también. A y B 00:05:52
son exactamente lo mismo. 00:05:54
¿Vale? Luego al poner B de 1 00:05:56
igual a 10, o lo que es lo mismo poner 10 00:05:58
aquí, A de 1 se ha convertido 00:06:00
en 10 también. Luego esto 00:06:02
es 10 más 10 00:06:04
20. 00:06:06
¿Vale? Eso es lo que dijimos en esta 00:06:08
pregunta. ¿Estaba claro? 00:06:09
Porque esto es 00:06:12
de lo más importante de Arrays. 00:06:13
Porque luego se extiende a cualquier otra 00:06:15
colección de dados y a cualquier 00:06:17
otra situación 00:06:18
de objetos 00:06:20
que un array realmente es 00:06:22
una dirección de memoria 00:06:24
de la cual 00:06:26
ahora ya sí 00:06:28
cuelga un espacio con los datos 00:06:29
¿vale? esta idea es la 00:06:31
básica de la programación orientada a objetos 00:06:34
porque el array es el primer objeto 00:06:36
que estamos viendo en realidad 00:06:38
si dejamos al margen el string 00:06:39
bueno, pues en esta pregunta entonces nosotros 00:06:41
habíamos contestado ya 00:06:44
la 20 00:06:45
¿verdad? 00:06:47
vale, en la pregunta 3 00:06:48
aprendimos 00:06:51
una nueva manera 00:06:52
de declarar arrays, pero esto sí que es una anécdota 00:06:55
extraña, esta pregunta si no hubiera estado 00:06:57
casi mejor, porque yo esto no lo he 00:06:59
visto en la vida 00:07:01
y no creo que se use 00:07:02
para declarar y crear un array 00:07:04
las dos formas que se usan 00:07:06
son 00:07:09
esta y esta 00:07:10
¿vale? pero descubrimos a través de esta 00:07:12
pregunta que esta también es válida 00:07:14
esta también, new int corchetes 00:07:16
y después de los corchetes 00:07:19
poner los datos también 00:07:20
es decir, como si fuera la combinación de las dos 00:07:23
pues esta también es válida 00:07:25
esta sin embargo ya no 00:07:26
eso es lo que descubrimos 00:07:28
que esta también es válida, pero 00:07:31
si la olvidáis tal cual, me da lo mismo 00:07:32
¿vale? 00:07:35
pensad que cuando declaráis un array 00:07:37
para crear ya su tamaño en memoria 00:07:39
o bien lo hacéis de esta manera 00:07:41
en este caso estaréis creando 00:07:43
tres posiciones con valores cero 00:07:45
porque son los por defecto 00:07:47
o lo hacéis de esta, que estáis creando un array 00:07:48
de tres posiciones 00:07:51
ahora ya sí con valores iniciales 00:07:52
dados, el uno, el dos y el tres 00:07:55
vale, bueno 00:07:57
siguiente, la siguiente ya no 00:07:59
la hicimos, creo 00:08:01
la pregunta cuatro 00:08:02
venga 00:08:07
¿qué imprime 00:08:08
este código? 00:08:11
si necesitan de mirar 00:08:13
la respuesta 00:08:15
decidme lo que, pensad un ratín 00:08:15
ejecutadlo en la cabeza 00:08:18
ejecutadlo en la cabeza 00:08:20
y decidme lo que imprime 00:08:24
lo que muestra 00:08:26
por pantalla 00:08:28
este código 00:08:29
de aquí 00:08:32
si es que imprime algo, porque a lo mejor tiene errores de compilación 00:08:33
o de ejecución, es que como no he visto las opciones 00:08:44
de abajo, a lo mejor una de las opciones es 00:08:46
pues tiene errores de compilación, tiene errores de ejecución 00:08:48
no sé 00:08:51
lo que podéis decirme al respecto 00:08:51
es un poco retorcedillo 00:08:55
efectivamente 00:09:07
a lo mejor si lo escribís en un 00:09:08
vale, o sea, está rellenando 00:09:10
un array, ¿verdad? 00:09:12
es decir 00:09:14
primero le da un valor inicial 00:09:15
y luego va cambiando sus valores otra vez 00:09:17
desde la posición 0 hasta la 1 00:09:20
y luego te dice 00:09:22
muestra la 2, vale, inicialmente 00:09:24
el array tiene 00:09:26
estos valores 00:09:28
inicialmente la RAI tiene 00:09:29
1, 2, 3 y 4 00:09:31
y ahora ya se pone a recorrerlo 00:09:34
para cambiarle los valores 00:09:36
y darle otros 00:09:39
que los hace con esta sentencia de aquí 00:09:40
bueno pues 00:09:43
la pregunta es 00:09:44
la posición 2 00:09:46
porque esta es la 0, la 1, la 2 y la 3 00:09:47
¿qué valor acabará teniendo 00:09:51
después de ejecutar ese weekly? 00:09:53
ahí pone ADI 00:10:06
lógicamente 00:10:07
Vamos a hacer una cosa 00:10:08
Decidme todas las posiciones 00:10:30
Con las que creéis que acaba el bucle 00:10:34
Cuando ya ha terminado 00:10:36
Aunque luego aquí solo muestre la segunda 00:10:38
Vamos a 00:10:40
Vale, la posición 0 00:10:41
Una vez finalizado el bucle 00:10:44
¿Qué valor creéis que tendrá? 00:10:46
La posición 0 de la raíz 00:10:48
A ver, la posición 0 00:10:49
se modifica solo en la iteración 0 00:10:57
en la primera iteración 00:11:00
tenemos A de 0 00:11:04
y pasa algo con ese A de 0 00:11:05
¿qué le pasa? 00:11:07
claro, con lo cual 00:11:12
a vueltas de la primera iteración 00:11:13
A de 0 sigue valiendo ¿cuánto? 00:11:15
porque esta sentencia 00:11:18
recordad que es igual que hacer 00:11:19
A de i igual 00:11:21
a A de i más i 00:11:24
esto es lo que está haciendo el bucle 00:11:26
a cada posición la rellena 00:11:28
con su posición 00:11:31
más el valor 00:11:33
del índice 00:11:35
primera iteración 00:11:39
a de 0 se queda 00:11:42
con lo que tenía a de 0 más 0 00:11:43
en la siguiente iteración 00:11:45
¿qué conseguimos? 00:11:50
con la siguiente iteración 00:11:52
cuando y es igual a 1 00:11:53
¿qué es lo que cambia ahí? 00:11:54
venga, que alguien me lo diga, Ronnie 00:11:59
En la segunda iteración, ¿qué es lo que pasa? 00:12:01
¿Qué se modifica en el array? 00:12:04
Muy bien, la posición 1 se carga con lo que tenía antes, 00:12:12
más el propio 1. 00:12:17
¿Qué es lo que tenía antes? 00:12:20
Pues 2 más i, que es lo que vale el i en la segunda iteración, 00:12:23
Vale. 00:12:29
Siguiente iteración, ¿cómo se modifica el array? 00:12:30
Javier, a la posición 3, perdón, a la posición, a A de 2, perdón, se le, se convierte en lo que tenía de 2, que era 3, más 2, 3 más 2, 5, y la 4, pues lo mismo, ¿no? 00:12:33
la posición 3 que es esta 00:12:56
lo que tuviera de antes 00:12:59
4 más el 3 00:13:00
4 más 3, 7 00:13:02
¿verdad? 00:13:03
cuando ya se han completado 00:13:05
las 4 iteraciones 00:13:08
desde 0 mientras a menor que el n 00:13:10
el array termina así 00:13:12
luego la pregunta que me hacen 00:13:14
a de 2 mostraría 5 00:13:16
esa es nuestra 00:13:18
respuesta, a lo mejor se nos ha escapado 00:13:19
algo, no lo sé 00:13:22
vamos a ver si hay alguna 00:13:23
respuesta que sea 5 00:13:26
hay una que es 5 00:13:28
la C, pues vamos a marcar esa 00:13:31
vale, ¿qué ocurre 00:13:33
con este código? vamos a ver primero las opciones 00:13:37
que me da, imprime 8 00:13:39
4, 0 o no compila 00:13:41
vale, pues este código 00:13:42
me están diciendo, a ver 00:13:44
¿cuáles son las posibilidades? 00:13:46
que imprima 8 00:13:49
imprima 4, imprima 0 00:13:50
o error de compilación 00:13:52
que no compile, error de compilación 00:13:54
¿Creéis que habría algún error de compilación? 00:13:57
¿Ese bucle for each está mal escrito? 00:14:08
Con lo que vimos el último día, el lunes, del bucle for each 00:14:12
¿Alguien puede concluir y decirme 00:14:16
Bueno, sintácticamente está bien 00:14:22
No veo nada, raro 00:14:26
O decirme, uy, hay un error de compilación 00:14:28
Y entonces que me lo diga 00:14:31
Venga, que alguien sea valiente y se pronuncie en alguna de las dos líneas 00:14:32
eso está bien, son cuatro líneas 00:14:47
que no son más, cuatro líneas 00:14:49
que sintácticamente están impecables 00:14:50
o decirme, pues no, mira 00:14:53
ya hay un error, hablamos de errores de compilación 00:14:55
solo, ahora ya, si concluimos 00:14:57
que no tiene ningún error de compilación 00:14:59
ahora ya vemos que sale 00:15:00
venga, que alguien sea valiente y me diga 00:15:01
pues yo creo esto 00:15:15
que x no tiene valor 00:15:16
para calcularlo 00:15:20
o sea, dentro del for en el i 00:15:21
no tiene como 00:15:23
no tiene valor 00:15:25
te refieres que cuando se hace 00:15:27
esta expresión 00:15:30
aquí el x todavía no tiene valor 00:15:31
con lo cual te daría el orden de compilación 00:15:34
variable inicializada 00:15:35
si pensamos como funciona 00:15:36
el for each no debería 00:15:40
porque como funciona el for each 00:15:41
el for each funciona 00:15:43
recorre el array que pongamos a la derecha 00:15:46
de los dos puntos 00:15:48
lo recorre 00:15:49
se coge una variable temporal x 00:15:50
si este es nuestro array 00:15:53
que tiene los valores 4, 5 y 6 00:15:56
la variable x en cada iteración 00:16:00
tiene un valor ya asignado 00:16:03
en la primera iteración de este for each 00:16:05
x coge el 4 00:16:08
se copia con el 4 00:16:11
en la segunda iteración del for each 00:16:13
x coge el 5 00:16:16
y en la tercera iteración del for each 00:16:19
x coge el 6 00:16:21
luego en todas las iteraciones 00:16:23
X tiene un valor, siempre está X inicializado, en la primera iteración se copia este 4, en la segunda se copia este 5, en la tercera se copia este 6, entonces el compilador no me va a decir, ojo que X no está inicializado, 00:16:25
por el compilador sabe que en cada vuelta de este for each, x tiene un valor de partida 00:16:43
que es cada uno de los valores del array A de aquí. Luego eso en principio tiene sentido, 00:16:49
o sea, está bien comentarlo, pero a vuelta viendo un poco lo que sabemos del for each, 00:17:00
pues en principio no sería ese el problema. Pero está bien atacado, ¿vale? Porque efectivamente 00:17:05
cuando yo uso una expresión 00:17:17
tengo que asegurarme siempre 00:17:19
de que las variables 00:17:21
que usa están inicializadas 00:17:22
eso es fundamental 00:17:25
porque parece una tontería pero es un error 00:17:26
relativamente habitual que uno use variables 00:17:28
para hacer expresiones que estén inicializadas 00:17:31
pero bueno, en este caso en particular no es el caso 00:17:33
porque x va tomando un valor 00:17:35
de cada iteración 00:17:37
vale, ¿alguien más 00:17:38
podría pronunciarse al respecto? 00:17:41
pues está bien, no le damos más vueltas 00:17:43
en cuanto a compilación, o no, o le puede fallar esto 00:17:45
muy bien 00:17:47
alguien se pronuncia con contundencia 00:17:49
a mí me parece que también 00:17:51
pero todo digo me parece, porque hay muchas cosas 00:17:52
chorradas que podemos no ver 00:17:55
además es una situación típica 00:17:58
cuando algo es demasiado fácil 00:17:59
se nos escapa un detalle que estamos tan acostumbrados 00:18:00
a verlo que ya lo filtramos 00:18:04
y hay veces que se está uno 00:18:05
horas 00:18:07
bueno, ahora ya no, porque lo pasas a la IA 00:18:08
pero antiguamente te podías estar horas 00:18:11
pero si es que esto está perfecto 00:18:13
y era una chorrada que de tanto escribirlo 00:18:15
ya habías automatizado 00:18:17
y ni la veías 00:18:18
entonces podría ocurrirnos que aquí no estemos viendo 00:18:19
una chorrada y que hay un orden de compilación 00:18:23
pero si la hay yo no la veo 00:18:25
tampoco 00:18:26
bueno, pues asumiendo que esto va a compilar y está bien 00:18:27
¿qué creéis que va 00:18:31
a mostrar aquí 00:18:32
como valor de 0? 00:18:34
inicialmente la raíz 00:18:38
es este, 4, 5 y 6 00:18:39
inicialmente es este 00:18:41
¿Tú ves bien desde ahí? 00:18:42
Porque podría pasar que es ordenador 00:18:45
Hay un poco 00:18:46
Reflejo y estoy yo siempre en medio 00:18:47
Vale, pues ahora ya 00:18:50
¿Qué valor creéis 00:18:53
Que acaba teniendo A de 0? 00:18:55
Que A de 0 es este 00:18:57
Vamos a ver, en la primera iteración 00:18:58
Porque tú lo que has hecho es 00:19:09
4, ¿por qué? 00:19:12
Porque es una copia 00:19:19
Claro, es que me da igual 00:19:20
lo que haga yo aquí con la x 00:19:23
todo lo que yo le asigno 00:19:25
a la x 00:19:27
lo estoy asignando a esta variable copia 00:19:28
que se va quedando con las copias 00:19:31
entonces 00:19:32
¿qué estoy haciendo en la primera iteración? 00:19:34
a mi variable x que tiene 4 00:19:36
la estoy multiplicando por 2 00:19:38
vale, la pongo a 8 00:19:40
y ese 8 se queda en esta x 00:19:42
no se queda aquí 00:19:44
se queda en esta x 00:19:46
siguiente iteración 00:19:48
ahora x, este 8 que había 00:19:50
a la basura 00:19:52
ahora este 8 00:19:53
pasa a convertirse 00:19:55
a este 5 de aquí 00:19:58
a esta variable x le asigno 00:19:59
5 por 2, 10 00:20:02
y ese 10 está en esta x 00:20:03
en la raíz ni se ha enterado 00:20:05
siguiente iteración 00:20:06
el 6 es el que ahora se va a la x 00:20:10
ahora tengo 00:20:14
el 6 00:20:16
aquí 00:20:17
ahora tengo el 6 00:20:19
Entonces, ¿qué hago con esta variable x? Le asigno el resultado a multiplicarla por 2, le asigno 12, pero todas las operaciones las estoy asignando a la variable x otra vez, que es una variable local que se crea solo para este bucle y que se va llevando copias del array. 00:20:24
Cuando yo salga de aquí, este array ni se ha enterado, ha servido para ofrecer sus valores a la x, los ha ido ofreciendo, pero si ha habido algún cambio han sido en la variable copia. 00:20:43
luego a de 0 seguirá siendo 4 00:20:53
entonces si hay alguna respuesta 00:20:56
que sea 4 00:20:58
pues yo votaría por esa 00:20:59
yo votaría por esta 00:21:01
vale 00:21:04
que imprime entonces aquí 00:21:09
las opciones son 6, 9, 12 00:21:13
a ver, no, así tan grande 00:21:16
no se ve 00:21:22
vale, 6, 9, 12 o ejecución 00:21:23
o error de ejecución 00:21:26
ups 00:21:27
leches, vale 00:21:30
aquí las opciones eran 00:21:33
imprime 6, imprime 9 00:21:36
imprime 12 00:21:39
o al ejecutarse 00:21:40
da un error 00:21:43
ahora no dice, no propone que haya 00:21:46
un error de compilación, podemos asumir 00:21:50
entonces de partida 00:21:52
que compila, porque ninguna de las 00:21:53
cuatro posibilidades es error de compilación 00:21:56
entonces vamos a subir que compila 00:21:58
Y sí, le vemos buena pinta, no tiene pinta de que haya escrito nada sintácticamente extraño. 00:21:59
¿Por qué puede haber errores de ejecución cuando trabajamos con Arrays? 00:22:06
¿Alguien se acuerda de qué causa puede generarnos una excepción, un error, unas letras rojas cuando ejecutamos un programa o cuando trabajamos con Arrays? 00:22:16
¿Pero por qué? 00:22:27
bueno, dicho de otra manera 00:22:30
el error viene cuando yo 00:22:42
intento acceder a posiciones 00:22:44
del array que no existen 00:22:47
¿vale? aquí 00:22:49
AD1 00:22:50
no me da error de ejecución 00:22:51
porque la posición AD1 existe 00:22:54
porque tengo la 0, la 1, la 2 y la 3 00:22:56
pero si yo pusiera aquí 00:22:59
AD7 00:23:01
ahí esto compilar compila 00:23:02
el compilador no va a meterse en si 00:23:05
el numerito que yo he puesto aquí 00:23:07
está por debajo de esto 00:23:09
no, no llega a eso 00:23:11
pero a la hora de ejecutarse 00:23:13
me daría el famoso array 00:23:15
uy el famoso array 00:23:17
el famoso error array index 00:23:18
out of bounds 00:23:21
exception 00:23:23
entonces si hay error de ejecución 00:23:26
no va a venir de aquí 00:23:31
porque uno está en los límites del array 00:23:33
podría a lo mejor venir de aquí 00:23:37
porque yo aquí estoy dando índices 00:23:39
y es que voy incrementando, decrementando 00:23:42
podría venir por ahí 00:23:44
eso en el caso de que haya error de ejecución 00:23:46
venga, pues pensadlo otro ratito 00:23:49
¿creéis que en alguna de estas 00:23:55
de estos accesos 00:23:59
esto que yo pongo aquí se está saliendo 00:24:00
de los índices del array 00:24:04
si se está saliendo ya lo tenemos claro 00:24:05
error de ejecución 00:24:07
si no se está saliendo 00:24:09
pues que va a acabar habiendo 00:24:11
en AD1 00:24:14
el array es 00:24:14
el array una vez 00:24:19
creado tiene 4 posiciones 00:24:21
y tiene 00:24:23
3, 6 00:24:26
y 12 00:24:29
y empieza siendo 00:24:31
uno 00:24:34
y a partir de ahí se van haciendo 00:24:35
como asignaciones 00:24:38
de posiciones de la rae y le va asignando otras 00:24:40
esto de aquí 00:24:42
vale, vamos a pensar, esta sí que es 00:24:43
bastante retorcida, porque claro, nos mete 00:25:06
en ver 00:25:08
son preguntas efectivamente muy retorcidas 00:25:09
¿qué hace antes? 00:25:11
si este de aquí o este 00:25:13
entonces 00:25:14
yo tendría a pensar, que no sé si estoy equivocada o no 00:25:16
¿qué? 00:25:20
¿qué haría la máquina virtual 00:25:23
cuando se encuentra con esto? 00:25:24
primero 00:25:26
evalúa esto 00:25:27
para obtener el valor 00:25:29
y una vez que lo tiene 00:25:30
se lo asigna a este 00:25:32
¿vale? 00:25:34
entonces en ese caso 00:25:37
y es uno 00:25:38
lo primero que hace es incrementarlo 00:25:39
porque el más está antes del i 00:25:42
¿verdad? 00:25:44
entonces lo primero que hace es incrementar i 00:25:45
no hay problema 00:25:48
y se queda como 2 00:25:49
no hay problema 00:25:52
a de 2 existe 00:25:53
porque yo tengo las 4 posiciones 00:25:56
3, 6, 9 y 12 00:25:58
esta es la posición 0, 1, 2 y 3 00:26:01
he inicializado i igual a 2 00:26:05
primero lo incremento 00:26:07
perdón, he inicializado i igual a 1 00:26:09
primero lo incremento 00:26:12
con lo cual i se queda valiendo 2 00:26:14
y ahora accedo a a de 2 00:26:15
¿verdad? 00:26:17
a de 2 que sería 9 00:26:18
vale, entonces ahora ya 00:26:21
este 9 00:26:24
¿a quién se lo asigno? 00:26:25
pues se lo asigno a a de i 00:26:28
que i seguirá valiendo 2 00:26:31
se lo asigno a de 2 00:26:33
con lo cual 9 00:26:35
se lo asigno a 9 00:26:39
y lo dejo incrementado 00:26:40
y lo dejo incrementado a 3 00:26:43
vale 00:26:45
y ahora el a de 1 00:26:46
en principio no se ha enterado 00:26:49
yo tendría que pensar que hace eso 00:26:51
vamos a ver si 6 es alguna opción 00:26:56
y luego sobre todo cuando le pidamos las respuestas 00:27:00
vamos a ver porque a lo mejor 00:27:02
primero evalúa este índice 00:27:04
para dejar aquí esperando a la A 00:27:06
y luego ya evalúa este valor 00:27:08
vale, hemos dicho que da la opción 6 00:27:11
pues vamos a marcar la opción 6 00:27:15
y ya está 00:27:17
y luego ya vemos que pasa 00:27:23
otra curiosa 00:27:24
interesante 00:27:32
ah, perdón, que no la he envuelto 00:27:32
esta 00:27:38
A, 1, 2 y 3 00:27:38
esto es lo que me hace 00:27:49
la primera línea 00:27:51
¿verdad? la primera línea 00:27:52
me crea un array A 00:27:54
que en realidad es una dirección de memoria 00:27:57
que te lleva aquí 00:27:58
y ahora 00:27:59
me crea otro array 00:28:02
que llama B 00:28:03
es otro array 00:28:04
pues otro 00:28:06
lo que pasa es que le da los mismos 00:28:08
valores, lo inicializa con los mismos 00:28:11
1, 2 y 3 00:28:12
y ahora 00:28:14
hace esta condición 00:28:17
que eso es una condición, ¿verdad? 00:28:19
algo igual a, es una condición 00:28:20
que será por tanto true o false 00:28:22
a ver que imprime, ¿qué creéis 00:28:24
que me dirá 00:28:27
esa condición? 00:28:28
true o false 00:28:30
a ver que opciones nos dice 00:28:31
nos dice true porque tiene 00:28:34
los mismos valores, falso 00:28:38
porque son dos arrays distintos 00:28:40
true porque tiene misma longitud 00:28:41
b no compila 00:28:43
de estas cuatro 00:28:45
¿cuál lo intuís? 00:28:48
la situación que tenemos es esta 00:28:53
recordad 00:28:55
tenemos mi array a 00:28:56
que está colgando 00:29:00
de esta dirección de memoria 00:29:02
con la, no sé que valores eran 00:29:03
pero bueno, eran valores iguales 00:29:05
y mi array b 00:29:07
1, 2, 3 y 4 00:29:08
esta es la situación que tenemos 00:29:14
y ahora la pregunta es 00:29:15
igual a B 00:29:20
¿cuál creéis que es de las 4 anteriores? 00:29:21
true porque 00:29:26
tienen los mismos valores, false porque 00:29:26
son dos arrays distintos, true porque 00:29:28
tienen una longitud, D no compila 00:29:30
¿qué os 00:29:32
dice la intuición? 00:29:34
no compila la podríamos 00:29:55
descartar porque bueno son tres lineas que no tienen 00:29:56
nada raro. Entonces esta la podríamos descartar. 00:29:58
Hombre, la C es bastante absurda. 00:30:05
Ya solo por lo absurdo de la razón 00:30:07
podríamos descartarla. Que dos 00:30:08
arrays tengan la misma longitud 00:30:10
no significa que haya ningún tipo de 00:30:11
igualdad entre ellos. 00:30:14
Esta, por sentido común, la quitaríamos. 00:30:17
Vale, pues de las dos primeras, 00:30:19
que son las interesantes, 00:30:20
¿qué os dice la intuición 00:30:25
de programación que ahora ya 00:30:26
tenéis? 00:30:28
¿Que alguien diga algo? 00:30:41
¿No pasa nada? 00:30:42
Y sobre eso lo comentamos. 00:30:43
¿Tú qué dirías? 00:30:46
¿Que A igual a B me va a dar falso o me va a dar cruz? 00:30:48
Pues muy bien intuido. 00:31:00
Porque A, ¿quién es? 00:31:02
Esta variable que tiene una dirección de memoria. 00:31:04
¿Qué es esta? 00:31:07
Que será la que sea dir1. 00:31:09
Y B, ¿quién es? 00:31:11
Esta variable que tiene esta dirección de memoria, 00:31:12
que es otra distinta. 00:31:15
O sea, es una dirección de memoria 00:31:17
de la que cuelga un array con valores 00:31:19
otra dirección de memoria 00:31:21
de la que cuelga otro array con valores 00:31:23
entonces, lo que sí son iguales 00:31:24
son los contenidos 00:31:27
es decir, si yo hago 00:31:29
a de 0 00:31:30
doble igual 00:31:32
b de 0 00:31:36
esto lógicamente va a ser true 00:31:37
si yo hago 00:31:39
a de 1 doble igual b de 1 00:31:40
también va a ser true 00:31:43
pero cuando comparo a y b 00:31:44
estoy comparando estos valores de aquí 00:31:46
lo que contiene A, que es una dirección de memoria, 00:31:49
y lo que contiene B, que es otra dirección de memoria. 00:31:52
Y son dos direcciones distintas. 00:31:54
¿Vale? Es como si yo tengo esta mesa y esta mesa. 00:32:06
¿Vale? 00:32:10
En esta mesa tengo un alumno que clono 00:32:12
y lo pongo en esa mesa. 00:32:14
Al alumno clonado. 00:32:18
Entonces, la pregunta es, 00:32:20
¿estas dos mesas son la misma? 00:32:22
No. 00:32:24
Esta mesa es esta y esta mesa es esta. 00:32:24
En las dos mesas, ¿hay algo que es igual entre sí? 00:32:26
Pues sí, este alumno es el clon de este, son iguales. 00:32:31
Pero las mesas son diferentes. 00:32:34
Pues aquí es lo mismo, las cajas son distintas. 00:32:36
Están colgadas en direcciones de demora y esta dirección es diferente de esta. 00:32:40
Porque si fuera igual, B también estaría llevándome aquí, que era el caso de antes. 00:32:46
entonces 00:32:52
nosotros marcaríamos la B 00:32:55
y cuando sería la A 00:32:59
cuando sería true 00:33:04
pues en lugar de esto 00:33:06
ahí me cambian el código 00:33:08
y me hacen esta sentencia así 00:33:11
y ahora en lugar de esta 00:33:13
pongo esto 00:33:15
esto tachado y pongo esto 00:33:17
entonces ahora ya sí 00:33:23
A y B son idénticas 00:33:25
son la misma dirección de memoria 00:33:27
entonces ahora ya tendré 00:33:28
que es la dirección 00:33:31
de la raíz de 00:33:34
1, 2, 3, 4, lo que sea 00:33:37
y ahora cuando he declarado B 00:33:39
en lugar de hacer una caja 00:33:41
para él específica, una caja suya 00:33:43
en lugar de hacerlo, lo que le he dado 00:33:45
a B es lo que tiene A 00:33:47
entonces a B le he dado lo que tiene A, con lo cual 00:33:48
B, boom, se va al mismo sitio 00:33:51
entonces si yo cambio esto por esto 00:33:53
ahora ya sí que sería la true 00:33:56
claro, pero porque yo no he creado 00:33:57
una cajita específica para B 00:34:00
para sus propios valores 00:34:02
sino que a B le he dado directamente 00:34:03
lo que contiene A 00:34:06
es decir, la dirección, lo que contiene A 00:34:08
luego B va a apuntar aquí 00:34:10
¿vale? 00:34:12
pero como nuestro caso era este 00:34:18
para este una caja, para este otra 00:34:20
direcciones distintas 00:34:23
aunque contengan lo mismo, pero eso es casualidad 00:34:24
contienen lo mismo 00:34:26
porque es casualidad, yo puedo cambiar la caja 00:34:28
A, la caja B 00:34:30
¿vale? luego en nuestro caso sería 00:34:31
falso, porque son dos 00:34:34
arrays diferentes, aunque casualmente 00:34:36
ahí tienen los mismos valores 00:34:38
venga, vamos a 00:34:39
parar un momentín 00:34:42
Materias:
Programación
Niveles educativos:
▼ Mostrar / ocultar niveles
  • Formación Profesional
    • Ciclo formativo de grado básico
      • Primer Curso
      • Segundo Curso
    • Ciclo formativo de grado medio
      • Primer Curso
      • Segundo Curso
    • Ciclo formativo de grado superior
      • Primer Curso
      • Segundo Curso
Subido por:
Raquel G.
Licencia:
Todos los derechos reservados
Visualizaciones:
1
Fecha:
18 de noviembre de 2026 - 22:46
Visibilidad:
Clave
Centro:
IES ROSA CHACEL
Duración:
34′ 46″
Relación de aspecto:
1.78:1
Resolución:
1920x1080 píxeles
Tamaño:
1.09

Del mismo autor…

Ver más del mismo autor


EducaMadrid, Plataforma Educativa de la Comunidad de Madrid

Plataforma Educativa EducaMadrid