20261118 Test_array_1 - Contenido educativo
Ajuste de pantallaEl ajuste de pantalla se aprecia al ver el vídeo en pantalla completa. Elige la presentación que más te guste:
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
uy
00:03:25
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
1
00:11:18
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
2.
00:12:22
Pues 2 más i, que es lo que vale el i en la segunda iteración,
00:12:23
3.
00:12:27
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
8
00:19:04
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
6
00:21:08
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
9
00:24:28
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
6
00:26:50
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
A
00:29:18
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
A
00:33:31
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
- Ciclo formativo de grado básico
- 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