Saltar navegación

20250930 ProgEstr-Operadores_5 - 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 30 de septiembre de 2025 por Raquel G.

2 visualizaciones

Más información Transcripción

Descargar la transcripción

descansar un poco, pero antes de ese primer descansito, antes de ese primer descansito vamos a intentar entender esto, ¿vale? 00:00:00
A ver 00:00:13
Vámonos aquí 00:00:15
Entonces 00:00:20
Bueno, el programa de antes 00:00:22
Hemos puesto una cadena igual a Luis 00:00:36
Otro nombre igual a Luis 00:00:38
Y hemos hecho la condición 00:00:40
Nombre 1 igual a nombre 2 00:00:42
Hemos imprimido lo que sale y nos ha salido true 00:00:43
Y habéis dicho 00:00:46
Y habéis pensado 00:00:49
Claro, porque son ellos 00:00:50
pero no debería de salir 00:00:51
el true, debería de salir el false 00:00:54
¿por qué? 00:00:55
que ahí te ha salido el false 00:00:58
¿vale? pues eso ya empieza 00:01:00
a asustarnos ¿verdad? porque uno ha salido 00:01:02
el true, otro ha salido el false 00:01:03
vale, vamos a entender que está pasando con el tipo string 00:01:05
solo con la idea 00:01:08
de empezar poco a poco 00:01:10
a familiarizarnos un poquito 00:01:12
más con el concepto de objeto 00:01:14
porque desde ya 00:01:15
en los primeros ejercicios que hagamos 00:01:17
vais a tener que no usar ese doble igual 00:01:19
para ver si una cadena es igual a otra 00:01:22
porque no funciona correctamente 00:01:25
bueno, funciona perfectísimamente 00:01:27
pero no según la intuición 00:01:29
no según como intuimos 00:01:31
funciona muy bien 00:01:31
lo que funcionamos mal en todo caso 00:01:32
lo haríamos nosotros 00:01:34
vale, pues a ver 00:01:34
tipos primitivos 00:01:36
sabemos perfectamente como funcionan 00:01:37
yo declaro una variable cualquiera 00:01:40
de cualquier tipo primitivo 00:01:43
automáticamente aparece en la RAM 00:01:45
un espacio en memoria 00:01:48
para guardar el dato que sea 00:01:50
con el tamaño correspondiente 00:01:52
y cuando ahora yo hago 00:01:53
n igual a 3, por ejemplo, hago esa sentencia 00:01:55
automáticamente 00:01:58
el 3 va aquí y ya está 00:02:00
que ahora ya hago 00:02:01
pues 00:02:04
otro numerito m 00:02:05
igual a n más 2 00:02:07
pues ya sabemos que la máquina virtual 00:02:09
coge el n 00:02:12
tiene un 3, lo suma, el resultado 00:02:13
lo guarda en la variable m y ya está 00:02:16
Vale. ¿Qué pasa cuando la variable que declaro no es de tipo primitivo, sino de tipo string? Por ejemplo, así. Pues esta variable es un poquito especial, aunque la estamos usando como cualquier otra. Es igual a la cadena que sea. Esta variable es especial, porque esta variable no es de tipo primitivo, sino que es de tipo objeto. 00:02:18
¿qué pasa cuando 00:02:44
la máquina virtual se encuentra que declaramos 00:02:47
una variable de tipo objeto? 00:02:49
pues automáticamente asume 00:02:51
que va a necesitar un espacio gordote 00:02:53
para ella, claro 00:02:55
porque una variable de tipo objeto 00:02:57
va a tener muchas cosas dentro 00:02:58
esta en particular, la string 00:03:00
va a tener muchos caracteres 00:03:03
tampoco es tanto, a menos que fueran 00:03:05
3.000 caracteres, va a tener muchos caracteres 00:03:07
pero habrá variables objeto que tengan 00:03:09
muchas más cosas dentro, números, caracteres 00:03:11
de todo vale pues espacio gordote para ello y para facilitar la gestión de la memoria el acceso a 00:03:13
ella y todo eso además crea en memoria un espacio que es simplemente el que contiene la dirección de 00:03:22
memoria donde está el espacio gordote donde ya está el dato donde está ya la cadena el dato 00:03:34
entonces, todo esto 00:03:42
aparece en memoria 00:03:47
una variable pequeñita 00:03:48
para guardar una dirección 00:03:50
de memoria, ¿vale? ya sabéis 00:03:53
de sistemas informáticos o de donde sea 00:03:55
lo intuís, que la memoria 00:03:57
RAM son un montón de posiciones 00:03:59
una tras otra 00:04:01
donde puede haber datos 00:04:02
y cada una de esas posiciones tiene una dirección 00:04:04
lógicamente, cada posición tiene una dirección 00:04:06
bueno 00:04:08
pues, como resultado 00:04:10
de declarar esto, la máquina 00:04:13
virtual hace aparecer 00:04:15
un espacio grandote para guardar 00:04:16
el dato y luego hace aparecer 00:04:19
otro pequeño espacio donde guarda 00:04:21
la dirección de memoria donde está 00:04:23
el espacio grandote. 00:04:25
Todo esto aparece. 00:04:27
Sin embargo, con una variable 00:04:29
primitiva solamente 00:04:31
ha aparecido el espacio para el dato. 00:04:33
Mi dirección de memoria y nada, 00:04:35
el espacio para el dato. Y n 00:04:37
se refiere al espacio para el dato. 00:04:38
N se refiere a este. 00:04:40
Pero sin embargo, en este caso, S, que es el único identificador que tenemos del que disponemos S, no se refiere al espacio grandote. S se refiere a la dirección de memoria. 00:04:43
entonces cuando la máquina virtual 00:05:03
ve ese 00:05:05
entiende que ese es la dirección de memoria 00:05:07
y a través de la dirección 00:05:10
de memoria ya llega al dato 00:05:12
vale, todo esto 00:05:13
se crea cuando declaramos 00:05:15
la variable string por el hecho de ser 00:05:18
objeto y pasaría 00:05:20
con cualquier otra variable que fuera objeto 00:05:21
no hace falta que fuera string, creo cualquier variable 00:05:23
que sea objeto y se crea 00:05:26
el espacio grandote para el 00:05:27
dato y un pequeño 00:05:30
espacio que guarda la dirección de memoria 00:05:32
del espacio grande 00:05:34
ahora el asunto es, muy bien, todo esto 00:05:35
ha aparecido, y ahora cuando usamos 00:05:38
esta variable 00:05:40
¿cómo actúa la máquina virtual que está pasando 00:05:41
por dentro? 00:05:44
bueno, pues 00:05:46
ahora nosotros hacemos 00:05:47
igual a ola 00:05:52
por ejemplo, s igual a 00:05:54
ola, pues ¿qué es lo que 00:05:58
hace la máquina virtual? 00:06:00
la máquina virtual 00:06:01
ve la S 00:06:02
ve que es una dirección de memoria 00:06:04
entonces dice 00:06:07
ah, te refieres 00:06:09
como esto es una dirección de memoria 00:06:11
te refieres a que quieres hacer 00:06:13
esta asignación 00:06:15
al trozo de memoria 00:06:16
al que yo estoy apuntando 00:06:19
te refieres a eso, ah, vale, vale 00:06:21
porque tú eres una dirección de memoria 00:06:23
luego no puede ser que quieras meter la cadena 00:06:25
aquí, porque esto está pensado 00:06:27
para meter direcciones de memoria 00:06:29
No puede ser que quieras meter la cadena aquí 00:06:31
Te refieres a que la quieres meter 00:06:33
A donde tú apuntas 00:06:35
Ah, vale, entonces mete aquí el hola 00:06:37
Todo eso lo haces 00:06:39
Y que nosotros tengamos que preocuparnos por ello 00:06:41
Lógicamente, nosotros lo 00:06:43
Hacemos una asignación, es igual a hola 00:06:45
Pero el hola 00:06:47
No va aquí, no va a lo que se llama ese 00:06:49
El hola va 00:06:52
Al trozo de memoria 00:06:53
Que viene apuntado por esta dirección 00:06:55
Y eso es así 00:06:57
y no tenemos que tenerlo presente en la cabeza 00:07:00
todo el rato 00:07:01
pero 00:07:02
que eso sea así 00:07:04
se pone de manifiesto 00:07:07
a veces ya así en algunas situaciones 00:07:09
que es en la anterior que hemos dicho 00:07:11
vale, entonces 00:07:13
esto está entendido, ¿no? 00:07:15
que esto funciona por dentro así 00:07:17
no es lo mismo una variable objeto, que son dos cosas 00:07:18
el cacho grande para el dato 00:07:21
y el cacho pequeño 00:07:24
que es la dirección de memoria 00:07:26
que lleva el dato 00:07:27
y la variable primitiva 00:07:28
que es solo el cacho pal dado 00:07:31
es distinto 00:07:32
vale, pues entonces ahora, entendido que esto es distinto 00:07:34
vamos a hacer ahora dos variables 00:07:37
string 00:07:39
vale, pues entonces 00:07:39
ahora me hago yo aquí 00:07:52
variable string 00:07:54
y ya de paso que me creo s1 00:07:56
pues le pongo hola 00:07:59
ya de paso 00:08:02
¿qué está pasando en memoria? 00:08:03
todo eso que hemos dicho 00:08:06
se crea un espacio 00:08:07
que se llama S1 que en realidad 00:08:10
es una dirección 00:08:12
que me lleva al espacio 00:08:14
grandote y en este espacio 00:08:16
grandote ahora sí que pone 00:08:18
hola, vale, todo eso 00:08:20
ha pasado, porque el hola ha ido aquí 00:08:22
ahora vamos a 00:08:24
crear otra variable 00:08:26
es lo que hemos hecho antes con nombre1 y nombre2 00:08:27
lo mismo, str 00:08:30
igual a hola también 00:08:34
Vale, pues ¿qué se desencadena como consecuencia de toda esta sentencia? Pues ese 2 hace aparecer un espacio aquí que en realidad es una dirección de memoria que me lleva a un espacio grandote donde ahora ya sí se guarda este hola con el que hemos inicializado. 00:08:36
hola, vale 00:09:00
y la situación de memoria 00:09:04
es esta, vale 00:09:07
ahora vamos a hacer esta condición 00:09:08
esta condición 00:09:11
que sería 00:09:19
igual a S2 00:09:22
que es la que hemos hecho antes 00:09:25
vale 00:09:27
entonces, ¿qué hace la máquina virtual? 00:09:28
me estás dando 00:09:34
S1 doble igual a S2 00:09:35
Pues yo comparo S1 con S2 00:09:37
Y S1 y S2 son 00:09:40
La dirección de memoria 00:09:42
Es esto 00:09:44
Esta dirección es la dirección de aquí 00:09:45
Y esta es la dirección de aquí 00:09:52
Son dos variables distintas 00:09:54
Hombre, lo que pasa es que ahora casualmente 00:09:55
Tienen el mismo texto puesto 00:09:58
Pero si yo a una la cambio 00:09:59
Y ahora hago S2 igual a Dios 00:10:01
Pues S2 cambia 00:10:03
Entonces cuando yo haga esta condición 00:10:04
S1, ¿quién es? 00:10:08
S1 es lo que hay aquí, esta dirección 00:10:10
Y S2, ¿quién es? Lo que hay aquí 00:10:12
Es igual 00:10:14
Es igual, son dos direcciones de memoria distintas 00:10:15
Esta es la dirección de este trozo 00:10:18
Y esta es la dirección de este otro trozo 00:10:20
Con lo cual, esta condición 00:10:23
False 00:10:29
Tal cual, es falso 00:10:30
¿Vale? Ahora veremos por qué nos ha dado cruz en esta prueba 00:10:32
Es falso 00:10:35
Entonces, esta es la conclusión que tenemos que sacar 00:10:37
Ahora, cuando nosotros queremos ver si una cadena es igual a otra, es decir, si una variable string es igual que otra variable string, nunca lo hacemos con este operador, nunca, porque este operador al ser las variables string objetos, lo que me compara son las dos direcciones, las dos direcciones son distintas. 00:10:40
entonces si yo quiero ver 00:11:03
si una cadena es igual a otra 00:11:05
lo que realmente quiero ver es si el contenido 00:11:07
del espacio grandote 00:11:09
es el contenido de este otro espacio grandote 00:11:11
y eso nunca 00:11:14
lo voy a hacer con este operador 00:11:15
con este operador comparo 00:11:17
directamente si esta cadena 00:11:19
perdón, si esto es igual a esto 00:11:21
y esto es esta dirección 00:11:23
y eso es esta dirección, con lo cual esto 00:11:25
es falso 00:11:27
¿vale? 00:11:29
¿cómo podemos hacer entonces 00:11:30
ver si una cadena es igual a otra? 00:11:34
ahora lo hacemos 00:11:36
por si tenemos que hacerlo en algún primer ejercicio 00:11:37
ahora ya sé que 00:11:40
me haréis la pregunta 00:11:42
si tú dices que eso es falso 00:11:43
pero lo hemos ejecutado ya 00:11:45
¿por qué? 00:11:48
claro, porque por la gestión 00:11:52
que hace, pero eso 00:11:53
de esa gestión debemos olvidarla 00:11:55
porque escapa de nuestro control 00:11:56
la gestión que hace 00:11:58
para una primera cantidad de string 00:12:00
java, entonces tú 00:12:02
te haces dos string 00:12:04
que los dos son 00:12:06
y los inicializas con el mismo valor 00:12:08
entonces él por ahorrar 00:12:10
memoria, al segundo le da 00:12:12
la misma dirección y lo hace que 00:12:14
apunte a este también, porque ha dicho 00:12:16
como les has dado el mismo valor 00:12:18
¿para qué te voy a dar otro grandote? 00:12:20
y hago 00:12:23
apuntar a este hola, ¿para qué? 00:12:24
entonces, por eso 00:12:27
de puñetera casualidad por esta gestión 00:12:28
en esta situación me ha salido true 00:12:31
pero si yo ahora cambiara ese 2 y la pusiera 00:12:33
adiós, ahora ya sí que no podría 00:12:37
economizar, a esta dirección le daría 00:12:40
otra 00:12:43
y luego lo volviera a cambiar a hola 00:12:44
pues ya a lo mejor ya no lo vuelve a cambiar aquí 00:12:48
y ya se queda apuntando a otra, entonces ya me saldría falso 00:12:51
¿vale? entonces en función 00:12:54
de la casuística concreta 00:12:57
de mi programa, puede dar 00:12:59
la puñetera casualidad de que él 00:13:01
para economizar, haya 00:13:03
gestionado, oye, si estás poniendo 00:13:05
hola también al grandote, pues tiro 00:13:07
este a la basura y hago que este apunte aquí 00:13:09
si luego me lo cambias 00:13:11
pues ya lo deshago 00:13:13
entonces de puñetera casualidad puede haber ocurrido 00:13:14
que las direcciones sean iguales 00:13:17
pero yo no debería contar nunca con ello 00:13:18
porque exige que tenga cierto control 00:13:20
de cómo funciona el buffer, que eso es hasta 00:13:23
el 24 horas string 00:13:24
entonces 00:13:25
desde ya 00:13:26
olvidémonos, aunque de puñetera 00:13:29
casualidad pueda funcionar a veces por esta gestión 00:13:32
olvidémonos de 00:13:34
comparar si una cadena 00:13:36
es igual a otra y un objeto 00:13:38
en general con el doble igual, nunca 00:13:40
nunca jamás 00:13:41
porque nos creemos que estamos haciendo la condición 00:13:43
de que esta sea igual a esta 00:13:46
y no 00:13:47
estamos haciendo que esta dirección 00:13:49
sea igual a esta y no es lo que queremos 00:13:52
ver si esta dirección es igual a esta 00:13:54
Lo que queremos es ver si este contenido es igual a este 00:13:55
Entonces, si necesitamos 00:13:58
Ver si un contenido es igual a otro 00:14:01
¿Cómo lo podemos hacer? 00:14:03
¿Lo podemos hacer? Venga, sí, lo podemos hacer 00:14:05
Eso 00:14:06
Vale 00:14:08
Ahora 00:14:15
Aunque lo anterior 00:14:17
Funcione 00:14:22
Aunque lo anterior 00:14:24
Funcione de casualidad 00:14:31
Y ese casualidad 00:14:35
No lo he usado bien 00:14:36
No es que sea de casualidad 00:14:38
Es por las razones que os he dicho 00:14:39
No es que la máquina virtual lo haga funcionarse de la gana y no 00:14:40
Aunque lo diga de casualidad 00:14:42
¿Eh? 00:14:46
Sí 00:14:48
Nunca debemos 00:14:49
Debemos 00:14:52
Nunca debemos 00:14:59
Comparar así cadenas 00:15:02
Así la igualdad 00:15:05
de string 00:15:09
porque nos arriesgamos 00:15:11
a que en la gran mayoría de los casos 00:15:14
el resultado sea erróneo 00:15:16
esto nunca jamás 00:15:17
¿cómo lo podemos hacer? 00:15:20
podemos 00:15:24
hacerlo 00:15:24
¿cómo lo hacemos? 00:15:26
bueno, pues podemos, si es que necesitamos 00:15:28
vale, como lo hemos dejado apuntado 00:15:30
lo decimos, aunque 00:15:36
por ejemplo, yo quiero la condición 00:15:38
de que nombre1 sea igual a 00:15:40
nombre2 00:15:42
y la quiero ya bien hecha, no así, quiero la condición 00:15:43
del espacio al que apunta nombre 1, quiero que sea 00:15:48
quiero que me diga si es igual que el espacio al que apunta nombre 2 00:15:51
pues lo tengo que hacer así, nombre 1 00:15:55
y como nombre 1 es un objeto 00:16:01
recordad que los objetos pueden llamar a funciones que hacen cosas 00:16:05
de hecho aquí ha llamado a len, pues también puede llamar 00:16:09
a una función que hace cosas 00:16:14
que es la función equals 00:16:16
que si tú le pasas 00:16:18
otro string 00:16:23
todo este código de aquí 00:16:24
es capaz de acceder al espacio gordote 00:16:26
acceder al espacio gordote 00:16:29
ver si son iguales 00:16:30
y si son iguales te devuelve true y si no false 00:16:31
esto ya sí que sí 00:16:34
esto ya sí que sí 00:16:37
si yo tengo nombre 1 00:16:40
que en realidad es una dirección de memoria 00:16:42
que me apunta al espacio gordote 00:16:45
que tiene el dato 00:16:46
tengo nombre 2 00:16:48
que en realidad es una dirección de memoria 00:16:50
que me apunta 00:16:54
a este que tiene el dato 00:16:55
pues nombre 1 00:16:57
punto equals nombre 2 00:17:01
ya es un código más largo que te hace 00:17:03
nombre 1 00:17:05
vete a su espacio gordote 00:17:06
este 00:17:08
nombre 2 00:17:09
vete al gordote 00:17:10
este 00:17:11
son iguales lo que hay aquí 00:17:11
es la misma cadena 00:17:13
Sí, es la misma, las dos son hola 00:17:15
Te devuelvo true 00:17:17
No es la misma, una es Pepito y otra es Juanito 00:17:18
Te devuelvo false 00:17:21
¿Vale? 00:17:22
Esto ya sí que sí podemos contar 00:17:24
Con que nos va a dar 00:17:26
Si una cadena de texto es igual a 1 00:17:28
Pero sin embargo esto otro 00:17:30
Nombre 1 00:17:33
Igual a nombre 2 00:17:35
Eso nunca 00:17:37
El doble igual solamente para 00:17:38
Comparar 00:17:42
Números y caraceres 00:17:44
¿Vale? 00:17:47
No objetos 00:17:50
¿Por qué te da true entonces? 00:17:50
Porque 00:18:02
Porque nombre 1 y nombre 2 00:18:03
A ver, en esta misma situación 00:18:08
Yo creo que os debería dar 00:18:09
Si es la misma 00:18:11
Os debería dar true a todos 00:18:12
Si es la misma 00:18:14
Porque en esta 00:18:15
¿Dónde estoy? 00:18:15
Aquí 00:18:17
Yo acabo de crear las variables 00:18:17
Esas variables todavía no vienen 00:18:19
de no, entonces 00:18:21
es su creación inicial 00:18:23
entonces cuando creo la segunda 00:18:25
me dice, uy ya tengo una que se llama Luis 00:18:27
pues que aproveche esa dirección 00:18:29
pero si esa variable viene de antes 00:18:31
ya tiene una dirección creada 00:18:33
para otro dato, entonces ya no aprovecha 00:18:35
el mismo, entonces en función de lo que haya pasado 00:18:37
antes 00:18:39
claro, porque ahí 00:18:40
claro, ahí viene el stream 00:18:46
de otro sitio, entonces 00:18:49
para la primero ha hecho una dirección 00:18:50
para la segunda he hecho otra 00:18:52
entonces por eso es a lo que voy 00:18:54
que en función de la situación 00:18:56
puede reutilizar la dirección 00:18:58
o puede no reutilizarla 00:19:01
entonces como se nos escapa del control 00:19:02
cada situación 00:19:04
jamás comparamos con doble igual y ya está 00:19:06
nunca, no lo vais a ver en ningún sitio 00:19:08
jamás, de hecho 00:19:10
prácticamente 00:19:12
nadie sabe 00:19:13
que la gestión de stream 00:19:16
para una primera cantidad de stream 00:19:18
la economiza de esta manera 00:19:20
prácticamente nadie lo sabe 00:19:22
porque es algo que no se pone de manifiesto nunca 00:19:26
nadie usa esto con doble igual y se encuentra 00:19:28
que le sale true 00:19:30
no es una curiosidad que casi 00:19:31
podríais olvidar desde ya 00:19:34
y quedaros con la pauta de que si verse una 00:19:35
cadena es igual 00:19:38
para ver si una cadena es igual que otra 00:19:39
siempre con igual 00:19:42
siempre 00:19:44
para ver si es distinto 00:19:44
tendrías que poner el no delante 00:19:49
Pero es que eso es el operador lógico 00:19:52
Que todavía no lo hemos visto 00:19:53
Es un operador lógico 00:19:54
Vale, entonces vamos a ver 00:19:58
Para callarme yo un rato 00:20:00
Y para ver si 00:20:01
Materias:
Programación
Niveles educativos:
▼ Mostrar / ocultar niveles
  • Formación Profesional
    • Ciclo formativo de grado superior
      • Primer Curso
Subido por:
Raquel G.
Licencia:
Todos los derechos reservados
Visualizaciones:
2
Fecha:
30 de septiembre de 2025 - 18:53
Visibilidad:
Clave
Centro:
IES ROSA CHACEL
Duración:
20′ 03″
Relación de aspecto:
1.78:1
Resolución:
1920x1080 píxeles
Tamaño:
383.80 MBytes

Del mismo autor…

Ver más del mismo autor

EducaMadrid, Plataforma Educativa de la Comunidad de Madrid

Plataforma Educativa EducaMadrid