1
00:00:00,000 --> 00:00:13,419
descansar un poco, pero antes de ese primer descansito, antes de ese primer descansito vamos a intentar entender esto, ¿vale?

2
00:00:13,419 --> 00:00:15,939
A ver

3
00:00:15,939 --> 00:00:20,879
Vámonos aquí

4
00:00:20,879 --> 00:00:22,039
Entonces

5
00:00:22,039 --> 00:00:36,600
Bueno, el programa de antes

6
00:00:36,600 --> 00:00:38,780
Hemos puesto una cadena igual a Luis

7
00:00:38,780 --> 00:00:40,859
Otro nombre igual a Luis

8
00:00:40,859 --> 00:00:42,140
Y hemos hecho la condición

9
00:00:42,140 --> 00:00:43,679
Nombre 1 igual a nombre 2

10
00:00:43,679 --> 00:00:46,299
Hemos imprimido lo que sale y nos ha salido true

11
00:00:46,299 --> 00:00:49,159
Y habéis dicho

12
00:00:49,159 --> 00:00:50,100
Y habéis pensado

13
00:00:50,100 --> 00:00:51,500
Claro, porque son ellos

14
00:00:51,500 --> 00:00:54,100
pero no debería de salir

15
00:00:54,100 --> 00:00:55,500
el true, debería de salir el false

16
00:00:55,500 --> 00:00:56,920
¿por qué?

17
00:00:58,920 --> 00:01:00,119
que ahí te ha salido el false

18
00:01:00,119 --> 00:01:02,159
¿vale? pues eso ya empieza

19
00:01:02,159 --> 00:01:03,939
a asustarnos ¿verdad? porque uno ha salido

20
00:01:03,939 --> 00:01:05,200
el true, otro ha salido el false

21
00:01:05,200 --> 00:01:08,040
vale, vamos a entender que está pasando con el tipo string

22
00:01:08,040 --> 00:01:10,280
solo con la idea

23
00:01:10,280 --> 00:01:12,180
de empezar poco a poco

24
00:01:12,180 --> 00:01:14,159
a familiarizarnos un poquito

25
00:01:14,159 --> 00:01:15,340
más con el concepto de objeto

26
00:01:15,340 --> 00:01:17,140
porque desde ya

27
00:01:17,140 --> 00:01:19,439
en los primeros ejercicios que hagamos

28
00:01:19,439 --> 00:01:22,920
vais a tener que no usar ese doble igual

29
00:01:22,920 --> 00:01:25,200
para ver si una cadena es igual a otra

30
00:01:25,200 --> 00:01:27,280
porque no funciona correctamente

31
00:01:27,280 --> 00:01:29,739
bueno, funciona perfectísimamente

32
00:01:29,739 --> 00:01:31,019
pero no según la intuición

33
00:01:31,019 --> 00:01:31,900
no según como intuimos

34
00:01:31,900 --> 00:01:32,599
funciona muy bien

35
00:01:32,599 --> 00:01:34,200
lo que funcionamos mal en todo caso

36
00:01:34,200 --> 00:01:34,859
lo haríamos nosotros

37
00:01:34,859 --> 00:01:36,280
vale, pues a ver

38
00:01:36,280 --> 00:01:37,700
tipos primitivos

39
00:01:37,700 --> 00:01:40,459
sabemos perfectamente como funcionan

40
00:01:40,459 --> 00:01:43,459
yo declaro una variable cualquiera

41
00:01:43,459 --> 00:01:45,739
de cualquier tipo primitivo

42
00:01:45,739 --> 00:01:48,480
automáticamente aparece en la RAM

43
00:01:48,480 --> 00:01:50,260
un espacio en memoria

44
00:01:50,260 --> 00:01:52,200
para guardar el dato que sea

45
00:01:52,200 --> 00:01:53,700
con el tamaño correspondiente

46
00:01:53,700 --> 00:01:55,659
y cuando ahora yo hago

47
00:01:55,659 --> 00:01:58,819
n igual a 3, por ejemplo, hago esa sentencia

48
00:01:58,819 --> 00:02:00,299
automáticamente

49
00:02:00,299 --> 00:02:01,579
el 3 va aquí y ya está

50
00:02:01,579 --> 00:02:04,400
que ahora ya hago

51
00:02:04,400 --> 00:02:05,180
pues

52
00:02:05,180 --> 00:02:07,799
otro numerito m

53
00:02:07,799 --> 00:02:09,919
igual a n más 2

54
00:02:09,919 --> 00:02:12,340
pues ya sabemos que la máquina virtual

55
00:02:12,340 --> 00:02:13,240
coge el n

56
00:02:13,240 --> 00:02:16,580
tiene un 3, lo suma, el resultado

57
00:02:16,580 --> 00:02:18,400
lo guarda en la variable m y ya está

58
00:02:18,400 --> 00:02:44,800
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.

59
00:02:44,800 --> 00:02:47,300
¿qué pasa cuando

60
00:02:47,300 --> 00:02:49,659
la máquina virtual se encuentra que declaramos

61
00:02:49,659 --> 00:02:50,900
una variable de tipo objeto?

62
00:02:51,680 --> 00:02:53,259
pues automáticamente asume

63
00:02:53,259 --> 00:02:55,939
que va a necesitar un espacio gordote

64
00:02:55,939 --> 00:02:57,539
para ella, claro

65
00:02:57,539 --> 00:02:58,879
porque una variable de tipo objeto

66
00:02:58,879 --> 00:03:00,979
va a tener muchas cosas dentro

67
00:03:00,979 --> 00:03:03,520
esta en particular, la string

68
00:03:03,520 --> 00:03:05,180
va a tener muchos caracteres

69
00:03:05,180 --> 00:03:07,300
tampoco es tanto, a menos que fueran

70
00:03:07,300 --> 00:03:09,900
3.000 caracteres, va a tener muchos caracteres

71
00:03:09,900 --> 00:03:11,500
pero habrá variables objeto que tengan

72
00:03:11,500 --> 00:03:13,960
muchas más cosas dentro, números, caracteres

73
00:03:13,960 --> 00:03:22,000
de todo vale pues espacio gordote para ello y para facilitar la gestión de la memoria el acceso a

74
00:03:22,000 --> 00:03:34,479
ella y todo eso además crea en memoria un espacio que es simplemente el que contiene la dirección de

75
00:03:34,479 --> 00:03:42,759
memoria donde está el espacio gordote donde ya está el dato donde está ya la cadena el dato

76
00:03:42,759 --> 00:03:47,120
entonces, todo esto

77
00:03:47,120 --> 00:03:48,020
aparece en memoria

78
00:03:48,020 --> 00:03:50,439
una variable pequeñita

79
00:03:50,439 --> 00:03:53,080
para guardar una dirección

80
00:03:53,080 --> 00:03:55,000
de memoria, ¿vale? ya sabéis

81
00:03:55,000 --> 00:03:57,039
de sistemas informáticos o de donde sea

82
00:03:57,039 --> 00:03:59,259
lo intuís, que la memoria

83
00:03:59,259 --> 00:04:01,360
RAM son un montón de posiciones

84
00:04:01,360 --> 00:04:02,240
una tras otra

85
00:04:02,240 --> 00:04:04,060
donde puede haber datos

86
00:04:04,060 --> 00:04:06,740
y cada una de esas posiciones tiene una dirección

87
00:04:06,740 --> 00:04:08,740
lógicamente, cada posición tiene una dirección

88
00:04:08,740 --> 00:04:10,120
bueno

89
00:04:10,120 --> 00:04:13,180
pues, como resultado

90
00:04:13,180 --> 00:04:15,280
de declarar esto, la máquina

91
00:04:15,280 --> 00:04:16,540
virtual hace aparecer

92
00:04:16,540 --> 00:04:19,319
un espacio grandote para guardar

93
00:04:19,319 --> 00:04:21,279
el dato y luego hace aparecer

94
00:04:21,279 --> 00:04:23,220
otro pequeño espacio donde guarda

95
00:04:23,220 --> 00:04:25,060
la dirección de memoria donde está

96
00:04:25,060 --> 00:04:26,060
el espacio grandote.

97
00:04:27,000 --> 00:04:28,199
Todo esto aparece.

98
00:04:29,540 --> 00:04:31,139
Sin embargo, con una variable

99
00:04:31,139 --> 00:04:33,079
primitiva solamente

100
00:04:33,079 --> 00:04:35,139
ha aparecido el espacio para el dato.

101
00:04:35,759 --> 00:04:37,019
Mi dirección de memoria y nada,

102
00:04:37,079 --> 00:04:38,899
el espacio para el dato. Y n

103
00:04:38,899 --> 00:04:40,779
se refiere al espacio para el dato.

104
00:04:40,779 --> 00:04:42,199
N se refiere a este.

105
00:04:43,180 --> 00:05:03,220
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.

106
00:05:03,220 --> 00:05:05,560
entonces cuando la máquina virtual

107
00:05:05,560 --> 00:05:07,339
ve ese

108
00:05:07,339 --> 00:05:10,240
entiende que ese es la dirección de memoria

109
00:05:10,240 --> 00:05:12,019
y a través de la dirección

110
00:05:12,019 --> 00:05:13,920
de memoria ya llega al dato

111
00:05:13,920 --> 00:05:15,980
vale, todo esto

112
00:05:15,980 --> 00:05:18,199
se crea cuando declaramos

113
00:05:18,199 --> 00:05:20,079
la variable string por el hecho de ser

114
00:05:20,079 --> 00:05:21,879
objeto y pasaría

115
00:05:21,879 --> 00:05:23,660
con cualquier otra variable que fuera objeto

116
00:05:23,660 --> 00:05:26,199
no hace falta que fuera string, creo cualquier variable

117
00:05:26,199 --> 00:05:27,699
que sea objeto y se crea

118
00:05:27,699 --> 00:05:30,060
el espacio grandote para el

119
00:05:30,060 --> 00:05:32,160
dato y un pequeño

120
00:05:32,160 --> 00:05:34,379
espacio que guarda la dirección de memoria

121
00:05:34,379 --> 00:05:35,259
del espacio grande

122
00:05:35,259 --> 00:05:38,180
ahora el asunto es, muy bien, todo esto

123
00:05:38,180 --> 00:05:40,300
ha aparecido, y ahora cuando usamos

124
00:05:40,300 --> 00:05:41,079
esta variable

125
00:05:41,079 --> 00:05:44,139
¿cómo actúa la máquina virtual que está pasando

126
00:05:44,139 --> 00:05:44,660
por dentro?

127
00:05:46,220 --> 00:05:47,879
bueno, pues

128
00:05:47,879 --> 00:05:50,500
ahora nosotros hacemos

129
00:05:50,500 --> 00:05:52,060
s

130
00:05:52,060 --> 00:05:54,180
igual a ola

131
00:05:54,180 --> 00:05:58,139
por ejemplo, s igual a

132
00:05:58,139 --> 00:06:00,079
ola, pues ¿qué es lo que

133
00:06:00,079 --> 00:06:01,019
hace la máquina virtual?

134
00:06:01,560 --> 00:06:02,639
la máquina virtual

135
00:06:02,639 --> 00:06:04,420
ve la S

136
00:06:04,420 --> 00:06:07,459
ve que es una dirección de memoria

137
00:06:07,459 --> 00:06:09,639
entonces dice

138
00:06:09,639 --> 00:06:11,259
ah, te refieres

139
00:06:11,259 --> 00:06:13,259
como esto es una dirección de memoria

140
00:06:13,259 --> 00:06:15,699
te refieres a que quieres hacer

141
00:06:15,699 --> 00:06:16,860
esta asignación

142
00:06:16,860 --> 00:06:19,459
al trozo de memoria

143
00:06:19,459 --> 00:06:21,100
al que yo estoy apuntando

144
00:06:21,100 --> 00:06:23,199
te refieres a eso, ah, vale, vale

145
00:06:23,199 --> 00:06:25,079
porque tú eres una dirección de memoria

146
00:06:25,079 --> 00:06:27,699
luego no puede ser que quieras meter la cadena

147
00:06:27,699 --> 00:06:29,600
aquí, porque esto está pensado

148
00:06:29,600 --> 00:06:31,120
para meter direcciones de memoria

149
00:06:31,120 --> 00:06:33,740
No puede ser que quieras meter la cadena aquí

150
00:06:33,740 --> 00:06:35,579
Te refieres a que la quieres meter

151
00:06:35,579 --> 00:06:37,279
A donde tú apuntas

152
00:06:37,279 --> 00:06:39,939
Ah, vale, entonces mete aquí el hola

153
00:06:39,939 --> 00:06:41,879
Todo eso lo haces

154
00:06:41,879 --> 00:06:43,779
Y que nosotros tengamos que preocuparnos por ello

155
00:06:43,779 --> 00:06:45,199
Lógicamente, nosotros lo

156
00:06:45,199 --> 00:06:47,939
Hacemos una asignación, es igual a hola

157
00:06:47,939 --> 00:06:49,759
Pero el hola

158
00:06:49,759 --> 00:06:52,439
No va aquí, no va a lo que se llama ese

159
00:06:52,439 --> 00:06:53,819
El hola va

160
00:06:53,819 --> 00:06:55,339
Al trozo de memoria

161
00:06:55,339 --> 00:06:57,500
Que viene apuntado por esta dirección

162
00:06:57,500 --> 00:07:00,060
Y eso es así

163
00:07:00,060 --> 00:07:01,800
y no tenemos que tenerlo presente en la cabeza

164
00:07:01,800 --> 00:07:02,420
todo el rato

165
00:07:02,420 --> 00:07:04,720
pero

166
00:07:04,720 --> 00:07:07,259
que eso sea así

167
00:07:07,259 --> 00:07:09,360
se pone de manifiesto

168
00:07:09,360 --> 00:07:11,740
a veces ya así en algunas situaciones

169
00:07:11,740 --> 00:07:13,879
que es en la anterior que hemos dicho

170
00:07:13,879 --> 00:07:15,779
vale, entonces

171
00:07:15,779 --> 00:07:16,839
esto está entendido, ¿no?

172
00:07:17,120 --> 00:07:18,899
que esto funciona por dentro así

173
00:07:18,899 --> 00:07:21,759
no es lo mismo una variable objeto, que son dos cosas

174
00:07:21,759 --> 00:07:24,199
el cacho grande para el dato

175
00:07:24,199 --> 00:07:26,339
y el cacho pequeño

176
00:07:26,339 --> 00:07:27,759
que es la dirección de memoria

177
00:07:27,759 --> 00:07:28,500
que lleva el dato

178
00:07:28,500 --> 00:07:31,600
y la variable primitiva

179
00:07:31,600 --> 00:07:32,959
que es solo el cacho pal dado

180
00:07:32,959 --> 00:07:34,839
es distinto

181
00:07:34,839 --> 00:07:37,920
vale, pues entonces ahora, entendido que esto es distinto

182
00:07:37,920 --> 00:07:39,339
vamos a hacer ahora dos variables

183
00:07:39,339 --> 00:07:39,959
string

184
00:07:39,959 --> 00:07:52,259
vale, pues entonces

185
00:07:52,259 --> 00:07:54,379
ahora me hago yo aquí

186
00:07:54,379 --> 00:07:56,379
variable string

187
00:07:56,379 --> 00:07:56,939
s1

188
00:07:56,939 --> 00:07:59,639
y ya de paso que me creo s1

189
00:07:59,639 --> 00:08:02,500
pues le pongo hola

190
00:08:02,500 --> 00:08:03,759
ya de paso

191
00:08:03,759 --> 00:08:06,060
¿qué está pasando en memoria?

192
00:08:06,060 --> 00:08:07,620
todo eso que hemos dicho

193
00:08:07,620 --> 00:08:10,100
se crea un espacio

194
00:08:10,100 --> 00:08:12,339
que se llama S1 que en realidad

195
00:08:12,339 --> 00:08:14,279
es una dirección

196
00:08:14,279 --> 00:08:16,120
que me lleva al espacio

197
00:08:16,120 --> 00:08:18,339
grandote y en este espacio

198
00:08:18,339 --> 00:08:20,360
grandote ahora sí que pone

199
00:08:20,360 --> 00:08:22,259
hola, vale, todo eso

200
00:08:22,259 --> 00:08:24,480
ha pasado, porque el hola ha ido aquí

201
00:08:24,480 --> 00:08:26,139
ahora vamos a

202
00:08:26,139 --> 00:08:27,100
crear otra variable

203
00:08:27,100 --> 00:08:30,420
es lo que hemos hecho antes con nombre1 y nombre2

204
00:08:30,420 --> 00:08:33,409
lo mismo, str

205
00:08:33,409 --> 00:08:34,889
S2

206
00:08:34,889 --> 00:08:36,730
igual a hola también

207
00:08:36,730 --> 00:09:00,710
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.

208
00:09:00,710 --> 00:09:04,889
hola, vale

209
00:09:04,889 --> 00:09:07,169
y la situación de memoria

210
00:09:07,169 --> 00:09:08,769
es esta, vale

211
00:09:08,769 --> 00:09:11,350
ahora vamos a hacer esta condición

212
00:09:11,350 --> 00:09:19,860
esta condición

213
00:09:19,860 --> 00:09:20,539
que sería

214
00:09:20,539 --> 00:09:22,240
S1

215
00:09:22,240 --> 00:09:25,000
igual a S2

216
00:09:25,000 --> 00:09:27,259
que es la que hemos hecho antes

217
00:09:27,259 --> 00:09:28,440
vale

218
00:09:28,440 --> 00:09:32,080
entonces, ¿qué hace la máquina virtual?

219
00:09:34,340 --> 00:09:35,120
me estás dando

220
00:09:35,120 --> 00:09:37,500
S1 doble igual a S2

221
00:09:37,500 --> 00:09:40,019
Pues yo comparo S1 con S2

222
00:09:40,019 --> 00:09:42,759
Y S1 y S2 son

223
00:09:42,759 --> 00:09:44,740
La dirección de memoria

224
00:09:44,740 --> 00:09:45,240
Es esto

225
00:09:45,240 --> 00:09:52,509
Esta dirección es la dirección de aquí

226
00:09:52,509 --> 00:09:54,230
Y esta es la dirección de aquí

227
00:09:54,230 --> 00:09:55,669
Son dos variables distintas

228
00:09:55,669 --> 00:09:58,029
Hombre, lo que pasa es que ahora casualmente

229
00:09:58,029 --> 00:09:59,529
Tienen el mismo texto puesto

230
00:09:59,529 --> 00:10:01,970
Pero si yo a una la cambio

231
00:10:01,970 --> 00:10:03,750
Y ahora hago S2 igual a Dios

232
00:10:03,750 --> 00:10:04,809
Pues S2 cambia

233
00:10:04,809 --> 00:10:08,029
Entonces cuando yo haga esta condición

234
00:10:08,029 --> 00:10:10,049
S1, ¿quién es?

235
00:10:10,049 --> 00:10:12,250
S1 es lo que hay aquí, esta dirección

236
00:10:12,250 --> 00:10:14,269
Y S2, ¿quién es? Lo que hay aquí

237
00:10:14,269 --> 00:10:15,570
Es igual

238
00:10:15,570 --> 00:10:18,730
Es igual, son dos direcciones de memoria distintas

239
00:10:18,730 --> 00:10:20,269
Esta es la dirección de este trozo

240
00:10:20,269 --> 00:10:23,350
Y esta es la dirección de este otro trozo

241
00:10:23,350 --> 00:10:26,370
Con lo cual, esta condición

242
00:10:26,370 --> 00:10:29,009
Es

243
00:10:29,009 --> 00:10:30,309
False

244
00:10:30,309 --> 00:10:32,970
Tal cual, es falso

245
00:10:32,970 --> 00:10:35,950
¿Vale? Ahora veremos por qué nos ha dado cruz en esta prueba

246
00:10:35,950 --> 00:10:37,409
Es falso

247
00:10:37,409 --> 00:10:40,610
Entonces, esta es la conclusión que tenemos que sacar

248
00:10:40,610 --> 00:11:03,230
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.

249
00:11:03,230 --> 00:11:05,129
entonces si yo quiero ver

250
00:11:05,129 --> 00:11:07,029
si una cadena es igual a otra

251
00:11:07,029 --> 00:11:09,889
lo que realmente quiero ver es si el contenido

252
00:11:09,889 --> 00:11:11,049
del espacio grandote

253
00:11:11,049 --> 00:11:14,009
es el contenido de este otro espacio grandote

254
00:11:14,009 --> 00:11:15,509
y eso nunca

255
00:11:15,509 --> 00:11:17,289
lo voy a hacer con este operador

256
00:11:17,289 --> 00:11:19,690
con este operador comparo

257
00:11:19,690 --> 00:11:21,570
directamente si esta cadena

258
00:11:21,570 --> 00:11:23,509
perdón, si esto es igual a esto

259
00:11:23,509 --> 00:11:25,070
y esto es esta dirección

260
00:11:25,070 --> 00:11:27,509
y eso es esta dirección, con lo cual esto

261
00:11:27,509 --> 00:11:29,529
es falso

262
00:11:29,529 --> 00:11:30,950
¿vale?

263
00:11:30,950 --> 00:11:34,210
¿cómo podemos hacer entonces

264
00:11:34,210 --> 00:11:35,909
ver si una cadena es igual a otra?

265
00:11:36,710 --> 00:11:37,769
ahora lo hacemos

266
00:11:37,769 --> 00:11:40,309
por si tenemos que hacerlo en algún primer ejercicio

267
00:11:40,309 --> 00:11:42,190
ahora ya sé que

268
00:11:42,190 --> 00:11:43,850
me haréis la pregunta

269
00:11:43,850 --> 00:11:45,490
si tú dices que eso es falso

270
00:11:45,490 --> 00:11:48,250
pero lo hemos ejecutado ya

271
00:11:48,250 --> 00:11:51,210
¿por qué?

272
00:11:52,110 --> 00:11:53,889
claro, porque por la gestión

273
00:11:53,889 --> 00:11:55,190
que hace, pero eso

274
00:11:55,190 --> 00:11:56,970
de esa gestión debemos olvidarla

275
00:11:56,970 --> 00:11:58,309
porque escapa de nuestro control

276
00:11:58,309 --> 00:12:00,370
la gestión que hace

277
00:12:00,370 --> 00:12:02,809
para una primera cantidad de string

278
00:12:02,809 --> 00:12:04,830
java, entonces tú

279
00:12:04,830 --> 00:12:06,389
te haces dos string

280
00:12:06,389 --> 00:12:08,830
que los dos son

281
00:12:08,830 --> 00:12:10,889
y los inicializas con el mismo valor

282
00:12:10,889 --> 00:12:12,710
entonces él por ahorrar

283
00:12:12,710 --> 00:12:14,730
memoria, al segundo le da

284
00:12:14,730 --> 00:12:16,710
la misma dirección y lo hace que

285
00:12:16,710 --> 00:12:18,850
apunte a este también, porque ha dicho

286
00:12:18,850 --> 00:12:20,370
como les has dado el mismo valor

287
00:12:20,370 --> 00:12:22,710
¿para qué te voy a dar otro grandote?

288
00:12:23,750 --> 00:12:24,610
y hago

289
00:12:24,610 --> 00:12:26,370
apuntar a este hola, ¿para qué?

290
00:12:27,289 --> 00:12:28,769
entonces, por eso

291
00:12:28,769 --> 00:12:31,450
de puñetera casualidad por esta gestión

292
00:12:31,450 --> 00:12:33,429
en esta situación me ha salido true

293
00:12:33,429 --> 00:12:37,090
pero si yo ahora cambiara ese 2 y la pusiera

294
00:12:37,090 --> 00:12:40,210
adiós, ahora ya sí que no podría

295
00:12:40,210 --> 00:12:43,649
economizar, a esta dirección le daría

296
00:12:43,649 --> 00:12:44,009
otra

297
00:12:44,009 --> 00:12:48,629
y luego lo volviera a cambiar a hola

298
00:12:48,629 --> 00:12:51,490
pues ya a lo mejor ya no lo vuelve a cambiar aquí

299
00:12:51,490 --> 00:12:54,570
y ya se queda apuntando a otra, entonces ya me saldría falso

300
00:12:54,570 --> 00:12:57,450
¿vale? entonces en función

301
00:12:57,450 --> 00:12:59,350
de la casuística concreta

302
00:12:59,350 --> 00:13:01,429
de mi programa, puede dar

303
00:13:01,429 --> 00:13:03,210
la puñetera casualidad de que él

304
00:13:03,210 --> 00:13:05,289
para economizar, haya

305
00:13:05,289 --> 00:13:07,350
gestionado, oye, si estás poniendo

306
00:13:07,350 --> 00:13:09,429
hola también al grandote, pues tiro

307
00:13:09,429 --> 00:13:11,490
este a la basura y hago que este apunte aquí

308
00:13:11,490 --> 00:13:13,350
si luego me lo cambias

309
00:13:13,350 --> 00:13:14,350
pues ya lo deshago

310
00:13:14,350 --> 00:13:17,250
entonces de puñetera casualidad puede haber ocurrido

311
00:13:17,250 --> 00:13:18,970
que las direcciones sean iguales

312
00:13:18,970 --> 00:13:20,809
pero yo no debería contar nunca con ello

313
00:13:20,809 --> 00:13:23,110
porque exige que tenga cierto control

314
00:13:23,110 --> 00:13:24,669
de cómo funciona el buffer, que eso es hasta

315
00:13:24,669 --> 00:13:25,950
el 24 horas string

316
00:13:25,950 --> 00:13:26,929
entonces

317
00:13:26,929 --> 00:13:29,169
desde ya

318
00:13:29,169 --> 00:13:32,070
olvidémonos, aunque de puñetera

319
00:13:32,070 --> 00:13:34,330
casualidad pueda funcionar a veces por esta gestión

320
00:13:34,330 --> 00:13:36,029
olvidémonos de

321
00:13:36,029 --> 00:13:38,029
comparar si una cadena

322
00:13:38,029 --> 00:13:40,149
es igual a otra y un objeto

323
00:13:40,149 --> 00:13:41,809
en general con el doble igual, nunca

324
00:13:41,809 --> 00:13:43,529
nunca jamás

325
00:13:43,529 --> 00:13:46,389
porque nos creemos que estamos haciendo la condición

326
00:13:46,389 --> 00:13:47,870
de que esta sea igual a esta

327
00:13:47,870 --> 00:13:49,450
y no

328
00:13:49,450 --> 00:13:52,190
estamos haciendo que esta dirección

329
00:13:52,190 --> 00:13:54,149
sea igual a esta y no es lo que queremos

330
00:13:54,149 --> 00:13:55,490
ver si esta dirección es igual a esta

331
00:13:55,490 --> 00:13:58,129
Lo que queremos es ver si este contenido es igual a este

332
00:13:58,129 --> 00:14:01,440
Entonces, si necesitamos

333
00:14:01,440 --> 00:14:03,019
Ver si un contenido es igual a otro

334
00:14:03,019 --> 00:14:05,120
¿Cómo lo podemos hacer?

335
00:14:05,179 --> 00:14:06,919
¿Lo podemos hacer? Venga, sí, lo podemos hacer

336
00:14:06,919 --> 00:14:08,419
Eso

337
00:14:08,419 --> 00:14:15,100
Vale

338
00:14:15,100 --> 00:14:17,740
Ahora

339
00:14:17,740 --> 00:14:22,500
Aunque lo anterior

340
00:14:22,500 --> 00:14:24,580
Funcione

341
00:14:24,580 --> 00:14:31,019
Aunque lo anterior

342
00:14:31,019 --> 00:14:35,240
Funcione de casualidad

343
00:14:35,240 --> 00:14:36,539
Y ese casualidad

344
00:14:36,539 --> 00:14:38,659
No lo he usado bien

345
00:14:38,659 --> 00:14:39,679
No es que sea de casualidad

346
00:14:39,679 --> 00:14:40,860
Es por las razones que os he dicho

347
00:14:40,860 --> 00:14:42,879
No es que la máquina virtual lo haga funcionarse de la gana y no

348
00:14:42,879 --> 00:14:46,299
Aunque lo diga de casualidad

349
00:14:46,299 --> 00:14:47,899
¿Eh?

350
00:14:48,759 --> 00:14:49,000
Sí

351
00:14:49,000 --> 00:14:52,940
Nunca debemos

352
00:14:52,940 --> 00:14:59,399
Debemos

353
00:14:59,399 --> 00:15:02,100
Nunca debemos

354
00:15:02,100 --> 00:15:05,740
Comparar así cadenas

355
00:15:05,740 --> 00:15:09,179
Así la igualdad

356
00:15:09,179 --> 00:15:11,639
de string

357
00:15:11,639 --> 00:15:14,899
porque nos arriesgamos

358
00:15:14,899 --> 00:15:16,500
a que en la gran mayoría de los casos

359
00:15:16,500 --> 00:15:17,960
el resultado sea erróneo

360
00:15:17,960 --> 00:15:20,259
esto nunca jamás

361
00:15:20,259 --> 00:15:23,500
¿cómo lo podemos hacer?

362
00:15:24,259 --> 00:15:24,620
podemos

363
00:15:24,620 --> 00:15:26,379
hacerlo

364
00:15:26,379 --> 00:15:28,200
¿cómo lo hacemos?

365
00:15:28,399 --> 00:15:30,700
bueno, pues podemos, si es que necesitamos

366
00:15:30,700 --> 00:15:36,850
vale, como lo hemos dejado apuntado

367
00:15:36,850 --> 00:15:38,490
lo decimos, aunque

368
00:15:38,490 --> 00:15:40,669
por ejemplo, yo quiero la condición

369
00:15:40,669 --> 00:15:42,610
de que nombre1 sea igual a

370
00:15:42,610 --> 00:15:43,250
nombre2

371
00:15:43,250 --> 00:15:48,029
y la quiero ya bien hecha, no así, quiero la condición

372
00:15:48,029 --> 00:15:51,789
del espacio al que apunta nombre 1, quiero que sea

373
00:15:51,789 --> 00:15:55,669
quiero que me diga si es igual que el espacio al que apunta nombre 2

374
00:15:55,669 --> 00:16:01,879
pues lo tengo que hacer así, nombre 1

375
00:16:01,879 --> 00:16:05,220
y como nombre 1 es un objeto

376
00:16:05,220 --> 00:16:09,700
recordad que los objetos pueden llamar a funciones que hacen cosas

377
00:16:09,700 --> 00:16:14,200
de hecho aquí ha llamado a len, pues también puede llamar

378
00:16:14,200 --> 00:16:16,580
a una función que hace cosas

379
00:16:16,580 --> 00:16:18,600
que es la función equals

380
00:16:18,600 --> 00:16:23,139
que si tú le pasas

381
00:16:23,139 --> 00:16:24,580
otro string

382
00:16:24,580 --> 00:16:26,559
todo este código de aquí

383
00:16:26,559 --> 00:16:29,259
es capaz de acceder al espacio gordote

384
00:16:29,259 --> 00:16:30,519
acceder al espacio gordote

385
00:16:30,519 --> 00:16:31,720
ver si son iguales

386
00:16:31,720 --> 00:16:34,700
y si son iguales te devuelve true y si no false

387
00:16:34,700 --> 00:16:37,159
esto ya sí que sí

388
00:16:37,159 --> 00:16:40,019
esto ya sí que sí

389
00:16:40,019 --> 00:16:42,120
si yo tengo nombre 1

390
00:16:42,120 --> 00:16:45,279
que en realidad es una dirección de memoria

391
00:16:45,279 --> 00:16:46,960
que me apunta al espacio gordote

392
00:16:46,960 --> 00:16:48,059
que tiene el dato

393
00:16:48,059 --> 00:16:50,720
tengo nombre 2

394
00:16:50,720 --> 00:16:54,299
que en realidad es una dirección de memoria

395
00:16:54,299 --> 00:16:55,220
que me apunta

396
00:16:55,220 --> 00:16:57,919
a este que tiene el dato

397
00:16:57,919 --> 00:17:01,539
pues nombre 1

398
00:17:01,539 --> 00:17:03,299
punto equals nombre 2

399
00:17:03,299 --> 00:17:05,279
ya es un código más largo que te hace

400
00:17:05,279 --> 00:17:06,599
nombre 1

401
00:17:06,599 --> 00:17:08,440
vete a su espacio gordote

402
00:17:08,440 --> 00:17:09,140
este

403
00:17:09,140 --> 00:17:10,119
nombre 2

404
00:17:10,119 --> 00:17:11,119
vete al gordote

405
00:17:11,119 --> 00:17:11,660
este

406
00:17:11,660 --> 00:17:13,779
son iguales lo que hay aquí

407
00:17:13,779 --> 00:17:15,160
es la misma cadena

408
00:17:15,160 --> 00:17:17,759
Sí, es la misma, las dos son hola

409
00:17:17,759 --> 00:17:18,519
Te devuelvo true

410
00:17:18,519 --> 00:17:21,619
No es la misma, una es Pepito y otra es Juanito

411
00:17:21,619 --> 00:17:22,500
Te devuelvo false

412
00:17:22,500 --> 00:17:23,779
¿Vale?

413
00:17:24,380 --> 00:17:26,839
Esto ya sí que sí podemos contar

414
00:17:26,839 --> 00:17:28,579
Con que nos va a dar

415
00:17:28,579 --> 00:17:30,359
Si una cadena de texto es igual a 1

416
00:17:30,359 --> 00:17:33,059
Pero sin embargo esto otro

417
00:17:33,059 --> 00:17:35,299
Nombre 1

418
00:17:35,299 --> 00:17:37,400
Igual a nombre 2

419
00:17:37,400 --> 00:17:38,519
Eso nunca

420
00:17:38,519 --> 00:17:42,240
El doble igual solamente para

421
00:17:42,240 --> 00:17:44,079
Comparar

422
00:17:44,079 --> 00:17:47,960
Números y caraceres

423
00:17:47,960 --> 00:17:48,579
¿Vale?

424
00:17:50,200 --> 00:17:50,980
No objetos

425
00:17:50,980 --> 00:18:00,609
¿Por qué te da true entonces?

426
00:18:02,549 --> 00:18:03,029
Porque

427
00:18:03,029 --> 00:18:08,250
Porque nombre 1 y nombre 2

428
00:18:08,250 --> 00:18:09,869
A ver, en esta misma situación

429
00:18:09,869 --> 00:18:11,309
Yo creo que os debería dar

430
00:18:11,309 --> 00:18:12,470
Si es la misma

431
00:18:12,470 --> 00:18:14,569
Os debería dar true a todos

432
00:18:14,569 --> 00:18:15,170
Si es la misma

433
00:18:15,170 --> 00:18:15,930
Porque en esta

434
00:18:15,930 --> 00:18:17,390
¿Dónde estoy?

435
00:18:17,490 --> 00:18:17,670
Aquí

436
00:18:17,670 --> 00:18:19,930
Yo acabo de crear las variables

437
00:18:19,930 --> 00:18:21,529
Esas variables todavía no vienen

438
00:18:21,529 --> 00:18:23,369
de no, entonces

439
00:18:23,369 --> 00:18:25,250
es su creación inicial

440
00:18:25,250 --> 00:18:27,130
entonces cuando creo la segunda

441
00:18:27,130 --> 00:18:29,309
me dice, uy ya tengo una que se llama Luis

442
00:18:29,309 --> 00:18:31,809
pues que aproveche esa dirección

443
00:18:31,809 --> 00:18:33,849
pero si esa variable viene de antes

444
00:18:33,849 --> 00:18:35,690
ya tiene una dirección creada

445
00:18:35,690 --> 00:18:37,730
para otro dato, entonces ya no aprovecha

446
00:18:37,730 --> 00:18:39,650
el mismo, entonces en función de lo que haya pasado

447
00:18:39,650 --> 00:18:40,190
antes

448
00:18:40,190 --> 00:18:46,539
claro, porque ahí

449
00:18:46,539 --> 00:18:49,339
claro, ahí viene el stream

450
00:18:49,339 --> 00:18:50,460
de otro sitio, entonces

451
00:18:50,460 --> 00:18:52,259
para la primero ha hecho una dirección

452
00:18:52,259 --> 00:18:54,460
para la segunda he hecho otra

453
00:18:54,460 --> 00:18:56,259
entonces por eso es a lo que voy

454
00:18:56,259 --> 00:18:58,380
que en función de la situación

455
00:18:58,380 --> 00:19:01,019
puede reutilizar la dirección

456
00:19:01,019 --> 00:19:02,259
o puede no reutilizarla

457
00:19:02,259 --> 00:19:04,720
entonces como se nos escapa del control

458
00:19:04,720 --> 00:19:06,279
cada situación

459
00:19:06,279 --> 00:19:08,619
jamás comparamos con doble igual y ya está

460
00:19:08,619 --> 00:19:10,819
nunca, no lo vais a ver en ningún sitio

461
00:19:10,819 --> 00:19:12,000
jamás, de hecho

462
00:19:12,000 --> 00:19:13,920
prácticamente

463
00:19:13,920 --> 00:19:16,000
nadie sabe

464
00:19:16,000 --> 00:19:18,819
que la gestión de stream

465
00:19:18,819 --> 00:19:20,440
para una primera cantidad de stream

466
00:19:20,440 --> 00:19:22,400
la economiza de esta manera

467
00:19:22,400 --> 00:19:26,480
prácticamente nadie lo sabe

468
00:19:26,480 --> 00:19:28,380
porque es algo que no se pone de manifiesto nunca

469
00:19:28,380 --> 00:19:30,519
nadie usa esto con doble igual y se encuentra

470
00:19:30,519 --> 00:19:31,440
que le sale true

471
00:19:31,440 --> 00:19:34,299
no es una curiosidad que casi

472
00:19:34,299 --> 00:19:35,700
podríais olvidar desde ya

473
00:19:35,700 --> 00:19:38,460
y quedaros con la pauta de que si verse una

474
00:19:38,460 --> 00:19:39,960
cadena es igual

475
00:19:39,960 --> 00:19:42,079
para ver si una cadena es igual que otra

476
00:19:42,079 --> 00:19:44,279
siempre con igual

477
00:19:44,279 --> 00:19:44,819
siempre

478
00:19:44,819 --> 00:19:49,900
para ver si es distinto

479
00:19:49,900 --> 00:19:52,400
tendrías que poner el no delante

480
00:19:52,400 --> 00:19:53,880
Pero es que eso es el operador lógico

481
00:19:53,880 --> 00:19:54,819
Que todavía no lo hemos visto

482
00:19:54,819 --> 00:19:58,380
Es un operador lógico

483
00:19:58,380 --> 00:20:00,279
Vale, entonces vamos a ver

484
00:20:00,279 --> 00:20:01,880
Para callarme yo un rato

485
00:20:01,880 --> 00:20:03,019
Y para ver si