1
00:00:00,000 --> 00:00:04,740
y así te quedas en casa en la cama

2
00:00:04,740 --> 00:00:06,339
y me ves ahí desde la cama, mira que bien

3
00:00:06,339 --> 00:00:08,220
pues el año pasado lo hacían algunos

4
00:00:08,220 --> 00:00:09,419
a ver

5
00:00:09,419 --> 00:00:12,580
bueno

6
00:00:12,580 --> 00:00:15,080
a ver, este es nuestro main

7
00:00:15,080 --> 00:00:16,879
entonces

8
00:00:16,879 --> 00:00:19,019
el objetivo de este pequeño programa

9
00:00:19,019 --> 00:00:20,760
es simplemente trabajar

10
00:00:20,760 --> 00:00:21,539
con productos

11
00:00:21,539 --> 00:00:24,039
entonces como siempre hemos dicho

12
00:00:24,039 --> 00:00:26,640
una misma aplicación se puede hacer con un montón de

13
00:00:26,640 --> 00:00:28,039
se me distraigo

14
00:00:28,039 --> 00:00:30,519
con un montón de diseños posibles

15
00:00:30,519 --> 00:00:32,780
entonces lo que importa es

16
00:00:32,780 --> 00:00:35,399
que identifiquemos

17
00:00:35,399 --> 00:00:36,799
con qué entidades vamos a trabajar

18
00:00:36,799 --> 00:00:39,159
eso lo primero

19
00:00:39,159 --> 00:00:41,259
y luego ya que identifiquemos

20
00:00:41,259 --> 00:00:42,659
qué necesitamos hacer

21
00:00:42,659 --> 00:00:44,039
entonces recordad que

22
00:00:44,039 --> 00:00:46,799
el problema siempre se divide en dos partes

23
00:00:46,799 --> 00:00:47,219
una

24
00:00:47,219 --> 00:00:50,780
con qué trabajamos el diseño, la descripción

25
00:00:50,780 --> 00:00:51,759
la foto de lo que tenemos

26
00:00:51,759 --> 00:00:55,219
y otra, qué requisitos tenemos que satisfacer

27
00:00:55,219 --> 00:00:56,219
qué requisitos

28
00:00:56,219 --> 00:00:59,200
que eso ya es las funcionalidades

29
00:00:59,200 --> 00:01:00,899
lo que ya programamos mediante

30
00:01:00,899 --> 00:01:02,259
métodos, funciones, etc.

31
00:01:02,820 --> 00:01:04,819
Bueno, pues aquí esta aplicación, la foto

32
00:01:04,819 --> 00:01:07,000
de lo que va a trabajar es

33
00:01:07,000 --> 00:01:08,760
productos, pues a partir de ahí

34
00:01:08,760 --> 00:01:10,319
tenemos que entrar en el diseño para

35
00:01:10,319 --> 00:01:13,200
muy bien, como reflejamos

36
00:01:13,200 --> 00:01:14,640
los datos de los productos

37
00:01:14,640 --> 00:01:17,159
pues podríamos haber hecho una clase producto

38
00:01:17,159 --> 00:01:19,180
que reflejara las propiedades

39
00:01:19,180 --> 00:01:20,799
que interesan de los productos

40
00:01:20,799 --> 00:01:23,019
en las cuales habría que

41
00:01:23,019 --> 00:01:24,719
entrevistarse, ¿qué te interesa a ti el producto?

42
00:01:24,719 --> 00:01:26,359
todo esto, lo ideal sería

43
00:01:26,359 --> 00:01:28,599
que al menos una de las propiedades

44
00:01:28,599 --> 00:01:30,480
lo identificara de forma única

45
00:01:30,480 --> 00:01:32,920
porque si no hay algo que lo identifique

46
00:01:32,920 --> 00:01:34,840
de forma única, la aplicación seguro

47
00:01:34,840 --> 00:01:36,180
que luego va a funcionar

48
00:01:36,180 --> 00:01:38,219
teniendo comportamientos

49
00:01:38,219 --> 00:01:40,239
extraños

50
00:01:40,239 --> 00:01:43,000
bueno, pues en este caso, solo nos interesan

51
00:01:43,000 --> 00:01:44,599
el código y el precio

52
00:01:44,599 --> 00:01:46,939
pues podríamos hacer una clase producto con código y precio

53
00:01:46,939 --> 00:01:48,739
o si la aplicación es

54
00:01:48,739 --> 00:01:51,120
sencilla y pequeña y es para 4 chorradas

55
00:01:51,120 --> 00:01:52,439
pues hombre, tenemos

56
00:01:52,439 --> 00:01:53,920
la colección map

57
00:01:53,920 --> 00:02:00,480
que nos facilita muchísimo el trabajo con los datos que contiene,

58
00:02:00,659 --> 00:02:04,400
nos lo facilita muchísimo porque gracias a que contiene los datos

59
00:02:04,400 --> 00:02:09,659
en modo clave-valor, a través de esa clave podemos recuperar por clave

60
00:02:09,659 --> 00:02:13,719
y modificar por clave, eliminar por clave.

61
00:02:14,300 --> 00:02:16,800
Gracias a esa estructura de par clave-valor,

62
00:02:16,800 --> 00:02:21,419
solo por esa chorrada de que los datos se guarden en dos partes,

63
00:02:21,419 --> 00:02:23,599
clave y valor, solo por esa chorrada

64
00:02:23,599 --> 00:02:25,699
se nos facilita la gestión

65
00:02:25,699 --> 00:02:27,099
de esos datos muchísimo

66
00:02:27,099 --> 00:02:29,479
bueno, pues en este caso uno puede pensar

67
00:02:29,479 --> 00:02:31,120
como mis productos solo se caracterizan

68
00:02:31,120 --> 00:02:32,400
por dos cosas

69
00:02:32,400 --> 00:02:34,939
pues en lugar de una clase producto

70
00:02:34,939 --> 00:02:37,639
y hacer un list de productos, un set de productos

71
00:02:37,639 --> 00:02:38,819
pues es igual de eso

72
00:02:38,819 --> 00:02:41,639
me hago un map con los dos valores

73
00:02:41,639 --> 00:02:43,580
y ya está, y me olvido de la clase

74
00:02:43,580 --> 00:02:44,979
producto, pues en este caso

75
00:02:44,979 --> 00:02:47,560
es un diseño que va a hacer que sea todo más

76
00:02:47,560 --> 00:02:49,500
cómodo, si programáis esta

77
00:02:49,500 --> 00:02:51,259
misma aplicación

78
00:02:51,259 --> 00:02:52,539
con una clase producto

79
00:02:52,539 --> 00:02:55,259
y trabajando con una lista de productos

80
00:02:55,259 --> 00:02:56,539
o con un set de productos

81
00:02:56,539 --> 00:02:58,819
estos métodos vais a ver

82
00:02:58,819 --> 00:03:01,360
ya de partida que son más líneas

83
00:03:01,360 --> 00:03:03,199
no es que eso sea un problema

84
00:03:03,199 --> 00:03:04,979
en sí, pero bueno, ya para empezar

85
00:03:04,979 --> 00:03:06,860
son más líneas de código, sin embargo

86
00:03:06,860 --> 00:03:08,240
con un map va a ser más fácil

87
00:03:08,240 --> 00:03:09,740
bueno, pues entonces

88
00:03:09,740 --> 00:03:12,539
una vez que uno ha decidido eso

89
00:03:12,539 --> 00:03:15,020
pues ya decide que mete sus datos aquí

90
00:03:15,020 --> 00:03:17,020
en un map

91
00:03:17,020 --> 00:03:19,120
y ahora tiene que decidir que funciona como clave

92
00:03:19,120 --> 00:03:20,900
y que funciona como valor, en este caso estaría

93
00:03:20,900 --> 00:03:23,340
claro que la clave es el código

94
00:03:23,340 --> 00:03:25,180
y el valor es el precio

95
00:03:25,180 --> 00:03:27,300
pues uno decide el tipo de

96
00:03:27,300 --> 00:03:28,139
dato para eso

97
00:03:28,139 --> 00:03:31,080
que decidimos string para la, pues string

98
00:03:31,080 --> 00:03:33,280
que el precio está en float, pues float

99
00:03:33,280 --> 00:03:35,319
eso el tipo de datos que sea

100
00:03:35,319 --> 00:03:37,240
recordad que los

101
00:03:37,240 --> 00:03:38,379
tipos primitivos

102
00:03:38,379 --> 00:03:41,240
no pueden sustituir a datos

103
00:03:41,240 --> 00:03:42,319
genéricos, nunca

104
00:03:42,319 --> 00:03:45,300
no pueden sustituir, aquí no podemos poner la f

105
00:03:45,300 --> 00:03:47,080
con minúscula, por eso

106
00:03:47,080 --> 00:03:49,240
existen los bloopers envolventes

107
00:03:49,240 --> 00:03:52,039
el float, el integer, el label con mayúscula

108
00:03:52,039 --> 00:03:53,759
para cuando

109
00:03:53,759 --> 00:03:55,680
necesitamos trabajar

110
00:03:55,680 --> 00:03:57,800
con números como si fueran

111
00:03:57,800 --> 00:03:59,759
objetos, pues este es

112
00:03:59,759 --> 00:04:01,840
uno de esos casos, necesitamos

113
00:04:01,840 --> 00:04:03,719
trabajar con el número como si fuera un objeto

114
00:04:03,719 --> 00:04:05,680
pues el envolvente, bueno pues

115
00:04:05,680 --> 00:04:07,699
esta va a ser mi lista de productos, repito

116
00:04:07,699 --> 00:04:09,500
podría haber sido una lista

117
00:04:09,500 --> 00:04:11,039
de clase producto

118
00:04:11,039 --> 00:04:13,740
pues nos habría complicado un pelín

119
00:04:13,740 --> 00:04:15,740
el desarrollo del código, mejor que

120
00:04:15,740 --> 00:04:17,459
sea un map de clave

121
00:04:17,459 --> 00:04:19,699
precio, clave, precio, clave, precio

122
00:04:19,699 --> 00:04:22,100
bueno, pues una vez ya con el diseño hecho

123
00:04:22,100 --> 00:04:24,060
y ya la representación

124
00:04:24,060 --> 00:04:25,579
de nuestros datos

125
00:04:25,579 --> 00:04:27,560
ya hecha, ahora ya

126
00:04:27,560 --> 00:04:30,100
uno ya se plantea que requisitos tiene que hacer

127
00:04:30,100 --> 00:04:31,699
bueno y aquí nos han dicho

128
00:04:31,699 --> 00:04:33,480
los requisitos de tu aplicación son esos

129
00:04:33,480 --> 00:04:36,100
introducir producto, modificar, consultar

130
00:04:36,100 --> 00:04:36,639
y eliminar

131
00:04:36,639 --> 00:04:39,379
las tareas típicas con cualquier

132
00:04:39,379 --> 00:04:41,980
conjunto de datos, las tareas de acceso

133
00:04:41,980 --> 00:04:43,060
a datos siempre son esas

134
00:04:43,060 --> 00:04:45,560
consultar, eliminar

135
00:04:45,560 --> 00:04:49,339
insertar

136
00:04:49,339 --> 00:04:50,339
y modificar.

137
00:04:51,220 --> 00:04:52,860
Esta de aquí, esto.

138
00:04:56,379 --> 00:04:56,600
¿Vale?

139
00:04:59,240 --> 00:04:59,759
Consultar,

140
00:05:00,139 --> 00:05:00,680
leer, no.

141
00:05:02,160 --> 00:05:03,220
Crear, jolín.

142
00:05:03,680 --> 00:05:05,220
Crear, consultar,

143
00:05:05,439 --> 00:05:07,519
actualizar y borrar. Esas son

144
00:05:07,519 --> 00:05:09,180
las cuatro tareas que se hacen

145
00:05:09,180 --> 00:05:11,480
con los datos. Bueno, pues son las que

146
00:05:11,480 --> 00:05:13,279
hay que hacer aquí. Y ahora, para eso

147
00:05:13,279 --> 00:05:14,420
se hacen unos métodos

148
00:05:14,420 --> 00:05:17,199
para insertar, guardar

149
00:05:17,199 --> 00:05:24,720
producto. ¿Qué necesitamos para insertar un producto? Pues los dos datos que tiene y en este

150
00:05:24,720 --> 00:05:34,879
caso como la lista de productos es una variable local del main, desde fuera del main es inaccesible,

151
00:05:36,120 --> 00:05:44,540
entonces guardar producto la va a necesitar como parámetro. Si esta lista de productos estuviera

152
00:05:44,540 --> 00:05:47,319
fuera declarada como variable estática del main

153
00:05:47,319 --> 00:05:49,019
no habría que pasarla

154
00:05:49,019 --> 00:05:50,939
porque el método tendría acceso a ella

155
00:05:50,939 --> 00:05:53,040
si estuviera en otra clase

156
00:05:53,040 --> 00:05:54,180
como variable estática

157
00:05:54,180 --> 00:05:56,399
pues también podría acceder esa función

158
00:05:56,399 --> 00:05:57,240
a esa variable

159
00:05:57,240 --> 00:05:59,519
como está como variable local

160
00:05:59,519 --> 00:06:01,199
aquí sí que no hay tutía

161
00:06:01,199 --> 00:06:03,199
para poder acceder desde fuera del main

162
00:06:03,199 --> 00:06:05,839
que es lo que va a tener que hacer

163
00:06:05,839 --> 00:06:06,639
guardar producto

164
00:06:06,639 --> 00:06:07,920
pues hay que pasársela

165
00:06:07,920 --> 00:06:10,160
bueno pues ahora probamos guardar producto

166
00:06:10,160 --> 00:06:15,470
pues guardar producto

167
00:06:15,470 --> 00:06:17,850
es

168
00:06:17,850 --> 00:06:19,610
una línea.

169
00:06:20,569 --> 00:06:21,790
Esto es guardar producto, ¿no?

170
00:06:38,220 --> 00:06:39,980
¡Hala! Entonces, aquí se

171
00:06:39,980 --> 00:06:41,720
inserta un par con este código

172
00:06:41,720 --> 00:06:43,699
y este precio, ¿vale?

173
00:06:44,540 --> 00:06:45,899
Si ocurriera...

174
00:06:45,899 --> 00:06:47,540
Ahora ya, a partir de aquí, uno puede

175
00:06:47,540 --> 00:06:49,759
hacer esto contemplando

176
00:06:49,759 --> 00:06:51,319
todos los casos raros que quiera.

177
00:06:52,819 --> 00:06:53,560
¿Vale? Podríamos

178
00:06:53,560 --> 00:06:55,639
decir, oye, pues, si el código ya

179
00:06:55,639 --> 00:06:57,439
existe, me apetece

180
00:06:57,439 --> 00:06:59,439
o me han pedido que

181
00:06:59,439 --> 00:07:01,680
avise, no, cuidado que ya está

182
00:07:01,680 --> 00:07:03,560
no se ha insertado uno nuevo

183
00:07:03,560 --> 00:07:05,420
y así no se crea confusión

184
00:07:05,420 --> 00:07:07,560
por ejemplo, podríamos hacer esto

185
00:07:07,560 --> 00:07:08,560
porque que hace el put

186
00:07:08,560 --> 00:07:11,920
que hace el put, si no existe

187
00:07:11,920 --> 00:07:13,680
el par, inserta un par

188
00:07:13,680 --> 00:07:15,060
con este código y este precio

189
00:07:15,060 --> 00:07:17,519
y si ya existe

190
00:07:17,519 --> 00:07:19,959
y si ya existe, lo que hace es

191
00:07:19,959 --> 00:07:21,819
cambiarle el precio al que existe

192
00:07:21,819 --> 00:07:23,540
entonces

193
00:07:23,540 --> 00:07:25,740
bueno, depende de lo que nos hayan pedido

194
00:07:25,740 --> 00:07:27,360
si nos han pedido, oye

195
00:07:27,360 --> 00:07:29,540
el que llame a este método, el que lo llame

196
00:07:29,540 --> 00:07:31,120
asume que no existe

197
00:07:31,120 --> 00:07:33,540
con lo cual si está equivocado

198
00:07:33,540 --> 00:07:34,060
avísale

199
00:07:34,060 --> 00:07:37,379
porque si se cree que has metido

200
00:07:37,379 --> 00:07:39,439
uno nuevo y lo que has hecho

201
00:07:39,439 --> 00:07:40,800
era borrar uno de antes

202
00:07:40,800 --> 00:07:43,579
cambiar uno de antes y con eso a lo mejor la lías

203
00:07:43,579 --> 00:07:44,860
el resto de la aplicación ya

204
00:07:44,860 --> 00:07:47,480
hace otras cosas

205
00:07:47,480 --> 00:07:49,259
que no son las que se esperan

206
00:07:49,259 --> 00:07:51,279
entonces bueno, todo eso de nuevo

207
00:07:51,279 --> 00:07:53,079
depende de que uno se haya sentado

208
00:07:53,079 --> 00:07:54,860
con el que le ha pedido la aplicación y le haya dicho

209
00:07:54,860 --> 00:07:57,259
a ver, vamos parte por parte, guardar producto

210
00:07:57,259 --> 00:08:00,500
Pues no, guardar producto tiene muchas ramificaciones

211
00:08:00,500 --> 00:08:01,500
¿Qué es? Vamos a ver

212
00:08:01,500 --> 00:08:05,139
¿Y qué pasa si tu gestor pone a guardar un producto

213
00:08:05,139 --> 00:08:06,660
Y ese producto ya está?

214
00:08:07,040 --> 00:08:08,100
¿Qué quieres tú que ocurra?

215
00:08:08,620 --> 00:08:09,720
Y el tío te lo tiene que decir

216
00:08:09,720 --> 00:08:11,800
Ah, pues en ese caso quiero que le avises

217
00:08:11,800 --> 00:08:14,980
O en ese caso quiero que guardes el producto igualmente

218
00:08:14,980 --> 00:08:16,879
Aunque el precio se quede modificado y se lo cuentes

219
00:08:16,879 --> 00:08:18,480
Bueno, pues lo que él te haya dicho

220
00:08:18,480 --> 00:08:20,079
Ya está, lo que él te haya dicho

221
00:08:20,079 --> 00:08:21,860
Lo que nos importa a nosotros ahora mismo

222
00:08:21,860 --> 00:08:25,339
Es que conozcamos los métodos de la estructura

223
00:08:25,339 --> 00:08:25,819
Y ya está

224
00:08:25,819 --> 00:08:28,379
bueno, pues guardar producto

225
00:08:28,379 --> 00:08:30,000
dejémoslo así, que es lo que habréis hecho

226
00:08:30,000 --> 00:08:31,379
y no os habréis encontrado ningún problema

227
00:08:31,379 --> 00:08:34,240
si pongo alguna burrada me lo decís

228
00:08:34,240 --> 00:08:36,220
vale, el famoso modificar

229
00:08:36,220 --> 00:08:45,000
precio, entonces a

230
00:08:45,000 --> 00:08:46,059
modificar precio

231
00:08:46,059 --> 00:08:48,960
pues aquí como

232
00:08:48,960 --> 00:08:51,220
en el enunciado no tengo puesto

233
00:08:51,220 --> 00:08:53,159
que se le pase

234
00:08:53,159 --> 00:08:54,100
el nuevo precio

235
00:08:54,100 --> 00:08:56,500
modificar precio

236
00:08:56,500 --> 00:08:59,059
se supone, se sobreentiende que habrá que pedirlo

237
00:08:59,059 --> 00:09:00,799
dentro, se sobreentiende que habrá que pedirlo dentro

238
00:09:00,799 --> 00:09:03,299
Vale, bueno, pues entonces

239
00:09:03,299 --> 00:09:08,490
Vamos a pedirlo aquí dentro

240
00:09:08,490 --> 00:09:17,509
Bueno, aunque aquí yo creo que tenía

241
00:09:17,509 --> 00:09:20,210
La clase esa teclado ya puesta

242
00:09:20,210 --> 00:09:23,029
Sí, pues la voy a usar y ya está

243
00:09:23,029 --> 00:09:30,000
Vale

244
00:09:30,000 --> 00:09:34,080
Por ejemplo, voy a hacer esto

245
00:09:34,080 --> 00:09:39,480
Cio igual a

246
00:09:39,480 --> 00:09:45,029
Vale

247
00:09:45,029 --> 00:09:47,929
Entonces, ahora

248
00:09:47,929 --> 00:09:49,289
Ahora se trata de ver

249
00:09:49,289 --> 00:09:51,409
el map que me ofrece

250
00:09:51,409 --> 00:09:52,250
para hacer esto

251
00:09:52,250 --> 00:09:55,110
entonces es una clase que ya está hecha

252
00:09:55,110 --> 00:09:56,970
y me ofrecerá muchas cosas

253
00:09:56,970 --> 00:09:58,809
pues entonces uno se va

254
00:09:58,809 --> 00:10:00,769
a la documentación

255
00:10:00,769 --> 00:10:03,350
del proveedor, de Oracle o lo que sea

256
00:10:03,350 --> 00:10:05,169
o lo mira en la ayuda aquí en línea

257
00:10:05,169 --> 00:10:07,330
y ve a ver si hay algún método

258
00:10:07,330 --> 00:10:08,809
que le permita hacer lo que quiere hacer

259
00:10:08,809 --> 00:10:10,549
entonces esa es

260
00:10:10,549 --> 00:10:12,830
nuestra situación habitual

261
00:10:12,830 --> 00:10:15,149
normalmente estamos usando siempre clases

262
00:10:15,149 --> 00:10:15,929
que ya están hechas

263
00:10:15,929 --> 00:10:19,149
pues esas clases sabemos que tendrán métodos que harán cosas

264
00:10:19,149 --> 00:10:20,169
Pues vamos a usarlos

265
00:10:20,169 --> 00:10:22,889
Entonces aquí, si uno se va

266
00:10:22,889 --> 00:10:25,429
Al map este

267
00:10:25,429 --> 00:10:30,269
Lista

268
00:10:30,269 --> 00:10:32,169
Lista productos

269
00:10:32,169 --> 00:10:39,220
Pues si uno se va al map este

270
00:10:39,220 --> 00:10:41,679
Pues ve que hay muchas cosas escritas

271
00:10:41,679 --> 00:10:43,580
Y de repente una por nombre

272
00:10:43,580 --> 00:10:45,019
Le suena

273
00:10:45,019 --> 00:10:46,759
Que es lo que quiere hacer

274
00:10:46,759 --> 00:10:47,860
Una por nombre le suena

275
00:10:47,860 --> 00:10:50,539
Dice, hay un replace, hay un reemplazar

276
00:10:50,539 --> 00:10:51,940
Vale

277
00:10:51,940 --> 00:10:54,879
Pues entonces

278
00:10:54,879 --> 00:10:56,279
Lo pinchamos

279
00:10:56,279 --> 00:10:58,139
y miramos aquí

280
00:10:58,139 --> 00:10:59,919
si esto hace lo que queremos

281
00:10:59,919 --> 00:11:02,279
y esto lo hace, dice

282
00:11:02,279 --> 00:11:04,360
oye, el par correspondiente

283
00:11:04,360 --> 00:11:06,440
a esta clave, la reemplaza

284
00:11:06,440 --> 00:11:08,340
con este valor, pero solo

285
00:11:08,340 --> 00:11:10,039
si existe un elemento con esa clave

286
00:11:10,039 --> 00:11:12,000
solo si existe, pues hombre

287
00:11:12,000 --> 00:11:14,059
parece que es justo

288
00:11:14,059 --> 00:11:15,919
lo que queremos hacer

289
00:11:15,919 --> 00:11:16,960
¿no?

290
00:11:18,860 --> 00:11:20,120
entonces además

291
00:11:20,120 --> 00:11:22,539
además, cuando un método

292
00:11:22,539 --> 00:11:23,580
está bien

293
00:11:23,580 --> 00:11:26,379
programado, está bien programado

294
00:11:26,379 --> 00:11:28,019
tiene que permitir

295
00:11:28,019 --> 00:11:30,100
además de hacer lo que tiene

296
00:11:30,100 --> 00:11:31,919
que hacer, normalmente

297
00:11:31,919 --> 00:11:33,860
tiene que permitir algún mecanismo

298
00:11:33,860 --> 00:11:36,000
para informar al que usa

299
00:11:36,000 --> 00:11:37,139
el método de lo que ha pasado

300
00:11:37,139 --> 00:11:39,820
porque este método, el que lo programó

301
00:11:39,820 --> 00:11:41,899
cuando hizo las colecciones, el que programó el map

302
00:11:41,899 --> 00:11:43,759
podría haber hecho que devolviera

303
00:11:43,759 --> 00:11:45,600
void y punto pelota

304
00:11:45,600 --> 00:11:47,899
es decir, este método si nos vamos

305
00:11:47,899 --> 00:11:48,500
a

306
00:11:48,500 --> 00:11:51,559
a la clase hasMap

307
00:11:51,559 --> 00:11:53,759
Hola

308
00:11:53,759 --> 00:11:57,019
Y nos vamos aquí

309
00:11:57,019 --> 00:11:58,320
Y buscamos el

310
00:11:58,320 --> 00:11:59,879
Replace

311
00:11:59,879 --> 00:12:02,539
Vamos a buscar

312
00:12:02,539 --> 00:12:03,820
Replace

313
00:12:03,820 --> 00:12:06,179
¿Qué habías entendido?

314
00:12:07,059 --> 00:12:07,919
¿Habías entendido putas?

315
00:12:09,500 --> 00:12:11,120
Pues no ha dicho eso

316
00:12:11,120 --> 00:12:12,379
De verdad, eh

317
00:12:12,379 --> 00:12:14,500
Qué mal está

318
00:12:14,500 --> 00:12:16,940
Replace

319
00:12:16,940 --> 00:12:17,379
Vale

320
00:12:17,379 --> 00:12:18,659
Esto como

321
00:12:18,659 --> 00:12:21,559
¿Esto cómo se hace para avanzar?

322
00:12:24,610 --> 00:12:26,289
Joder, ¿cómo avanzo al siguiente replace?

323
00:12:34,799 --> 00:12:36,000
Ah, sí, vale, vale

324
00:12:36,000 --> 00:12:41,330
Boolean replace

325
00:12:41,330 --> 00:12:43,450
No, este no quería

326
00:12:43,450 --> 00:12:47,570
Este, vale

327
00:12:47,570 --> 00:12:49,909
Este es el método que estamos usando

328
00:12:49,909 --> 00:12:52,309
Este es el que estamos usando de map

329
00:12:52,309 --> 00:12:54,850
Este es el que vamos a usar

330
00:12:54,850 --> 00:12:55,889
Que ya está hecho en map

331
00:12:55,889 --> 00:12:57,490
Que se le pasa una clave

332
00:12:57,490 --> 00:12:58,870
Y se le da un valor

333
00:12:58,870 --> 00:13:01,750
aquí por supuesto está con los tipos genéricos

334
00:13:01,750 --> 00:13:03,490
claro, aquí está con los tipos genéricos

335
00:13:03,490 --> 00:13:04,490
en nuestro caso

336
00:13:04,490 --> 00:13:07,250
cuando nosotros le llamemos en nuestro caso

337
00:13:07,250 --> 00:13:09,750
k va a ser

338
00:13:09,750 --> 00:13:11,750
string y v va a ser

339
00:13:11,750 --> 00:13:13,370
float, en nuestro caso, claro

340
00:13:13,370 --> 00:13:14,909
pero aquí está programado como genérico

341
00:13:14,909 --> 00:13:16,710
bueno, entonces este método

342
00:13:16,710 --> 00:13:18,690
el que lo programó

343
00:13:18,690 --> 00:13:21,409
podría haber puesto ahí un void, ¿vale?

344
00:13:24,179 --> 00:13:25,419
no me deja obviamente

345
00:13:25,419 --> 00:13:27,740
ni siquiera, aunque luego no me guarde

346
00:13:27,740 --> 00:13:29,500
ni siquiera me deja, podría haber puesto ahí un void

347
00:13:29,500 --> 00:13:32,220
y decir, ya está, el método lo que hace es sustituir

348
00:13:32,220 --> 00:13:33,700
sustituye y se acabó

349
00:13:33,700 --> 00:13:34,720
y no tiene que devolver nada

350
00:13:34,720 --> 00:13:36,960
porque el efecto ya se queda en el map

351
00:13:36,960 --> 00:13:38,559
no tiene que devolver nada

352
00:13:38,559 --> 00:13:41,000
bueno, podría haber decidido hacer eso

353
00:13:41,000 --> 00:13:43,899
pero hombre, está programando a lo cutre

354
00:13:43,899 --> 00:13:46,700
lo ideal, cuando uno desarrolla software

355
00:13:46,700 --> 00:13:47,620
hace métodos

356
00:13:47,620 --> 00:13:49,299
es que el método, a lo que tenga que hacer

357
00:13:49,299 --> 00:13:51,879
y si además le permite

358
00:13:51,879 --> 00:13:53,120
al que llama el método

359
00:13:53,120 --> 00:13:55,059
una manera de averiguar

360
00:13:55,059 --> 00:13:57,259
si ha funcionado correctamente

361
00:13:57,259 --> 00:13:58,919
si lo ha podido hacer, si no lo ha podido hacer

362
00:13:58,919 --> 00:14:00,960
pues mejor, porque así el que llama

363
00:14:00,960 --> 00:14:03,039
al método podrá hacer algún tipo de verificación

364
00:14:03,039 --> 00:14:04,600
entonces

365
00:14:04,600 --> 00:14:06,460
por eso el que programó esto

366
00:14:06,460 --> 00:14:08,080
puso un valor de retorno

367
00:14:08,080 --> 00:14:11,080
y ese valor de retorno, ¿para qué nos

368
00:14:11,080 --> 00:14:12,820
sirve? para extraer información

369
00:14:12,820 --> 00:14:15,019
si queremos, sobre qué es lo que ha pasado

370
00:14:15,019 --> 00:14:17,179
¿vale? nos sirve para eso

371
00:14:17,179 --> 00:14:19,019
podemos ignorarlo, podemos hacer

372
00:14:19,019 --> 00:14:20,620
el replace y se acabó, ignoramos ese valor

373
00:14:20,620 --> 00:14:23,200
pero si queremos hacer algún tipo de verificación

374
00:14:23,200 --> 00:14:24,559
a ver si realmente

375
00:14:24,559 --> 00:14:26,740
ha encontrado esta clave

376
00:14:26,740 --> 00:14:28,360
la ha sustituido, si no la ha encontrado

377
00:14:28,360 --> 00:14:30,139
pues podemos usar este valor

378
00:14:30,139 --> 00:14:31,700
vale

379
00:14:31,700 --> 00:14:35,059
entonces esa es una manera buena de programar

380
00:14:35,059 --> 00:14:36,559
cuando uno hace métodos para otros

381
00:14:36,559 --> 00:14:39,039
aparte de que el método funcione y haga lo que tenga que hacer

382
00:14:39,039 --> 00:14:40,980
pues que ofrezca información

383
00:14:40,980 --> 00:14:43,000
para afuera de oye si

384
00:14:43,000 --> 00:14:45,159
esto ha funcionado o no te lo he podido hacer

385
00:14:45,159 --> 00:14:45,840
por lo que fuera

386
00:14:45,840 --> 00:14:48,860
vale, bueno pues entonces

387
00:14:48,860 --> 00:14:51,019
esto todo venía a cuento de que si uno mira

388
00:14:51,019 --> 00:14:54,389
la ayuda

389
00:14:54,389 --> 00:14:56,590
del replace all este de aquí

390
00:14:56,590 --> 00:14:58,210
replace all no, perdón

391
00:14:58,210 --> 00:14:59,889
del replace

392
00:14:59,889 --> 00:15:02,149
si uno mira esta ayuda

393
00:15:02,149 --> 00:15:03,629
aquí te lo explica

394
00:15:03,629 --> 00:15:05,210
te dice, a ver

395
00:15:05,210 --> 00:15:06,929
te hace el

396
00:15:06,929 --> 00:15:09,350
te reemplaza el valor

397
00:15:09,350 --> 00:15:11,289
para el par con esta clave

398
00:15:11,289 --> 00:15:13,990
te reemplaza el valor

399
00:15:13,990 --> 00:15:15,769
para esta clave solo si existe

400
00:15:15,769 --> 00:15:17,730
es lo que queremos, solo si existe

401
00:15:17,730 --> 00:15:18,669
y luego además te dice

402
00:15:18,669 --> 00:15:21,070
oye, te devuelve

403
00:15:21,070 --> 00:15:23,730
te devuelve por si quisieras usarlo

404
00:15:23,730 --> 00:15:25,389
para algo, te devuelve

405
00:15:25,389 --> 00:15:26,929
el valor que tenía antes

406
00:15:26,929 --> 00:15:28,850
el precio antiguo te lo devuelve

407
00:15:28,850 --> 00:15:30,690
o te devuelve nul

408
00:15:30,690 --> 00:15:31,909
si no lo encontró

409
00:15:31,909 --> 00:15:33,629
entonces, hombre, eso es útil

410
00:15:33,629 --> 00:15:36,350
pues no solo puedo sustituir sin más

411
00:15:36,350 --> 00:15:38,470
sino además puedo decirle al usuario

412
00:15:38,470 --> 00:15:40,529
no te lo pude sustituir porque no había

413
00:15:40,529 --> 00:15:42,750
o te lo he sustituido y se queda eliminado

414
00:15:42,750 --> 00:15:44,190
el precio tal, por ejemplo

415
00:15:44,190 --> 00:15:46,309
entonces así nos queda más bonito

416
00:15:46,309 --> 00:15:48,409
entonces repito

417
00:15:48,409 --> 00:15:50,950
en conclusión, los métodos hacen cosas

418
00:15:50,950 --> 00:15:52,950
y muchas veces no hace falta

419
00:15:52,950 --> 00:15:54,690
que devuelvan nada, a veces sí porque

420
00:15:54,690 --> 00:15:56,509
el resultado es lo que nos devuelve

421
00:15:56,509 --> 00:15:58,789
pero las veces en las que no hace falta

422
00:15:58,789 --> 00:16:00,750
que devuelvan nada, lo normal es que siempre

423
00:16:00,750 --> 00:16:02,850
nos devuelvan cosas para que podamos

424
00:16:02,850 --> 00:16:04,669
hacer a lo mejor comprobaciones

425
00:16:04,669 --> 00:16:06,889
y esto en particular te evita

426
00:16:06,889 --> 00:16:08,830
todo el chorizo ese de iteración

427
00:16:08,830 --> 00:16:10,549
para ver si existía, si no existía

428
00:16:10,549 --> 00:16:12,909
no hace falta, ya tienes ese valor de retorno

429
00:16:12,909 --> 00:16:14,629
para ver si existía o no existía

430
00:16:14,629 --> 00:16:16,929
¿vale? entonces con todo este

431
00:16:16,929 --> 00:16:18,789
rollo que os he soltado

432
00:16:18,789 --> 00:16:20,309
pues por ejemplo uno podría

433
00:16:20,309 --> 00:16:23,230
en lugar de limitarse

434
00:16:23,230 --> 00:16:24,649
hacer el replace este

435
00:16:24,649 --> 00:16:28,070
Y poner para este código

436
00:16:28,070 --> 00:16:29,830
Le pongo el nuevo precio

437
00:16:29,830 --> 00:16:30,649
Que acabo de leer

438
00:16:30,649 --> 00:16:39,860
Que aquí lógicamente me dice

439
00:16:39,860 --> 00:16:41,799
Eh, cuidado, que es que es float, no puedo

440
00:16:41,799 --> 00:16:43,019
Es que lo guardan doble porque

441
00:16:43,019 --> 00:16:46,320
Ah, le hago un casting, voy a perder cifras decimales

442
00:16:46,320 --> 00:16:47,960
Pero bueno, ya ves tú

443
00:16:47,960 --> 00:16:49,519
Vale

444
00:16:49,519 --> 00:16:55,350
Pues podemos limitar, hacer el replace y ya está

445
00:16:55,350 --> 00:16:57,669
O podemos ser muy exquisitos y decir

446
00:16:57,669 --> 00:16:59,590
Oye, voy a verificar lo que me devuelve

447
00:16:59,590 --> 00:17:01,490
Voy a guardarlo, si es null le digo

448
00:17:01,490 --> 00:17:03,710
no existía, lo que sea

449
00:17:03,710 --> 00:17:04,509
pues por ejemplo

450
00:17:04,509 --> 00:17:06,609
entonces podríamos hacer aquí

451
00:17:06,609 --> 00:17:09,630
si lista

452
00:17:09,630 --> 00:17:11,410
de productos.replace

453
00:17:11,410 --> 00:17:13,410
esto, resulta que

454
00:17:13,410 --> 00:17:14,670
esto es igual a null

455
00:17:14,670 --> 00:17:17,250
pues entonces

456
00:17:17,250 --> 00:17:19,609
podemos

457
00:17:19,609 --> 00:17:20,470
decir

458
00:17:20,470 --> 00:17:22,369
podemos decir

459
00:17:22,369 --> 00:17:24,089
nos encontró

460
00:17:24,089 --> 00:17:26,049
por ejemplo

461
00:17:26,049 --> 00:17:35,180
vale, pues nos permite hacer ese

462
00:17:35,180 --> 00:17:37,819
pequeño control, ya está, si es que queremos hacerlo

463
00:17:37,819 --> 00:17:47,819
bueno pues entonces

464
00:17:47,819 --> 00:17:50,000
como veis

465
00:17:50,000 --> 00:17:51,140
esto en realidad

466
00:17:51,140 --> 00:17:53,480
es más corto que si hubiéramos hecho

467
00:17:53,480 --> 00:17:55,339
el programa con una clase producto

468
00:17:55,339 --> 00:17:57,839
una lista, localizar el producto

469
00:17:57,839 --> 00:17:59,480
y una vez que tenemos el producto

470
00:17:59,480 --> 00:18:01,440
hacerle un set de su propiedad

471
00:18:01,440 --> 00:18:03,519
valor, eso habría sido más largo

472
00:18:03,519 --> 00:18:05,039
que trabajar con el pares

473
00:18:05,039 --> 00:18:07,579
trabajar con un diccionario facilita

474
00:18:07,579 --> 00:18:09,640
mucho las cosas por el hecho de que tenemos una clave

475
00:18:09,640 --> 00:18:11,180
una clave para tirar de todo

476
00:18:11,180 --> 00:18:13,519
entonces siempre que podamos hacer un math pues lo hacemos

477
00:18:13,519 --> 00:18:16,119
Bueno, pues modificar el precio y ya está

478
00:18:16,119 --> 00:18:17,539
¿Vale?

479
00:18:19,420 --> 00:18:20,519
Entonces habrá veces

480
00:18:20,519 --> 00:18:22,299
Que no podremos

481
00:18:22,299 --> 00:18:24,460
Que no podremos usar el valor de retorno

482
00:18:24,460 --> 00:18:25,940
De algo como

483
00:18:25,940 --> 00:18:28,480
Forma de control, porque ese valor de retorno

484
00:18:28,480 --> 00:18:30,539
Tiene el propio

485
00:18:30,539 --> 00:18:31,700
Resultado del método

486
00:18:31,700 --> 00:18:33,259
Si uno tiene un método

487
00:18:33,259 --> 00:18:36,240
Obtener factorial, pues el valor de retorno

488
00:18:36,240 --> 00:18:36,880
Tiene que ser factorial

489
00:18:36,880 --> 00:18:39,819
¿Vale? Entonces hay veces que

490
00:18:39,819 --> 00:18:41,960
No podemos usar el valor de retorno cuando programamos

491
00:18:41,960 --> 00:18:44,140
un método para que nos dé información

492
00:18:44,140 --> 00:18:46,279
porque es que ya tiene el resultado

493
00:18:46,279 --> 00:18:48,039
bueno, pero aún así

494
00:18:48,039 --> 00:18:50,200
podemos transmitir información de lo que ha pasado

495
00:18:50,200 --> 00:18:52,059
vía excepciones

496
00:18:52,059 --> 00:18:54,059
vía excepciones, lo adelanto ahora

497
00:18:54,059 --> 00:18:55,960
porque es lo siguiente que vamos a ver

498
00:18:55,960 --> 00:18:57,400
porque

499
00:18:57,400 --> 00:19:00,769
lo estáis deseando

500
00:19:00,769 --> 00:19:01,890
a ver

501
00:19:01,890 --> 00:19:05,529
vamos a ver, modificar precio, ya lo hemos hecho

502
00:19:05,529 --> 00:19:07,650
y lo demás es que

503
00:19:07,650 --> 00:19:08,910
pues bueno, esto no

504
00:19:08,910 --> 00:19:12,509
mostrar productos

505
00:19:12,509 --> 00:19:15,309
Pues aquí sí que tenemos que iterar

506
00:19:15,309 --> 00:19:17,910
Aquí tenemos que iterar por la lista de productos

507
00:19:17,910 --> 00:19:20,230
Bueno, pues iterar, ya iteramos el otro día

508
00:19:20,230 --> 00:19:22,029
De todas las variantes posibles

509
00:19:22,029 --> 00:19:24,589
Iterar por el conjunto de pares

510
00:19:24,589 --> 00:19:25,710
Directamente no podemos

511
00:19:25,710 --> 00:19:27,250
Tenemos que trasladarlo a un set

512
00:19:27,250 --> 00:19:28,789
Y ya iteramos por el set

513
00:19:28,789 --> 00:19:31,170
O bien iteramos a un set de claves

514
00:19:31,170 --> 00:19:32,490
Y luego recorremos las claves

515
00:19:32,490 --> 00:19:35,849
O bien iteramos a un set de objetos envolventes

516
00:19:35,849 --> 00:19:37,630
Entry, iteramos por los entries

517
00:19:37,630 --> 00:19:40,130
Vamos a iterar por los entries

518
00:19:40,130 --> 00:19:47,500
y esto era, pues si tenemos nuestra lista

519
00:19:47,500 --> 00:19:56,299
lista productos, vale, si tenemos nuestra lista

520
00:19:56,299 --> 00:20:00,279
productos teníamos el método entrySet, que este método

521
00:20:00,279 --> 00:20:04,119
entrySet nos devuelve un set de estos objetos raros

522
00:20:04,119 --> 00:20:07,940
de esta clase rara, entry de string

523
00:20:07,940 --> 00:20:22,059
float, vale, nos devuelve

524
00:20:22,059 --> 00:20:24,940
un set de esta clase rara, entonces

525
00:20:24,940 --> 00:20:27,259
importamos

526
00:20:27,259 --> 00:20:29,440
entry e importamos set

527
00:20:29,440 --> 00:20:32,670
vale, a ver

528
00:20:32,670 --> 00:20:34,210
que

529
00:20:34,210 --> 00:20:37,450
era esto, esto era un conjunto

530
00:20:37,450 --> 00:20:39,170
de objetos que ahora ya

531
00:20:39,170 --> 00:20:41,049
podemos iterar por él y cada objeto

532
00:20:41,049 --> 00:20:42,269
tiene dentro

533
00:20:42,269 --> 00:20:44,490
los dos elementos del par

534
00:20:44,490 --> 00:20:46,809
la clave y el valor, pues entonces

535
00:20:46,809 --> 00:20:49,089
iteremos por este set y en

536
00:20:49,089 --> 00:20:51,210
cada uno de esos conjuntos saquemos su clave

537
00:20:51,210 --> 00:20:52,670
y su valor y ya está

538
00:20:52,670 --> 00:20:54,990
pues eso es lo que hicimos el otro día

539
00:20:54,990 --> 00:20:56,289
Vamos a iterar por este set

540
00:20:56,289 --> 00:20:57,690
Como nos dé la gana iterar

541
00:20:57,690 --> 00:20:59,490
Y como podamos y proceda, claro

542
00:20:59,490 --> 00:21:01,609
Pues vamos a iterar por este set

543
00:21:01,609 --> 00:21:03,190
Que pertenece a este tipo extraño

544
00:21:03,190 --> 00:21:06,150
Pues iteramos con un for each

545
00:21:06,150 --> 00:21:13,670
Pues ahora aquí

546
00:21:13,670 --> 00:21:15,690
Cada p

547
00:21:15,690 --> 00:21:18,589
Cada p es un objeto de esta clase

548
00:21:18,589 --> 00:21:20,430
Que tiene dentro

549
00:21:20,430 --> 00:21:22,630
La clave y el valor del par que envuelve

550
00:21:22,630 --> 00:21:24,170
Pues si lo que queremos es mostrar

551
00:21:24,170 --> 00:21:25,630
La clave y el valor

552
00:21:25,630 --> 00:21:26,490
Pues venga

553
00:21:26,490 --> 00:21:29,049
Código

554
00:21:29,049 --> 00:21:36,039
Código es P punto

555
00:21:36,039 --> 00:21:37,819
Y para eso tenemos el get key

556
00:21:37,819 --> 00:21:40,759
Y ahora

557
00:21:40,759 --> 00:21:45,549
Precio

558
00:21:45,549 --> 00:21:49,200
Y aquí tenemos

559
00:21:49,200 --> 00:21:50,240
El

560
00:21:50,240 --> 00:21:58,079
Get value

561
00:21:58,079 --> 00:22:03,180
Ahí

562
00:22:03,180 --> 00:22:06,720
Vale, estoy haciendo yo algo raro

563
00:22:06,720 --> 00:22:07,920
Ah, claro, que no he puesto la llave

564
00:22:07,920 --> 00:22:09,380
Y entonces

565
00:22:09,380 --> 00:22:11,720
Vale

566
00:22:11,720 --> 00:22:20,980
Bueno, pues ya está

567
00:22:20,980 --> 00:22:23,619
Entonces

568
00:22:23,619 --> 00:22:25,500
¿qué ventaja tiene este objeto?

569
00:22:26,019 --> 00:22:27,299
si es que tiene alguna

570
00:22:27,299 --> 00:22:30,079
vale, no lo iba a decir, pero como ha salido

571
00:22:30,079 --> 00:22:32,079
con el eso tuyo, pues ahora lo digo

572
00:22:32,079 --> 00:22:32,680
por tu culpa

573
00:22:32,680 --> 00:22:35,539
bueno, tiene una ventaja extraña

574
00:22:35,539 --> 00:22:37,980
este objeto entry

575
00:22:37,980 --> 00:22:39,960
no es útil solamente

576
00:22:39,960 --> 00:22:41,619
para envolver los pares

577
00:22:41,619 --> 00:22:43,819
en un único objeto y así

578
00:22:43,819 --> 00:22:45,779
poder yuterar por él y mostrarlo, no es útil

579
00:22:45,779 --> 00:22:47,720
solo para eso, sino que es útil

580
00:22:47,720 --> 00:22:49,839
porque está declarado de tal manera

581
00:22:49,839 --> 00:22:51,059
que cuando lo instanciamos

582
00:22:51,059 --> 00:22:53,279
se queda conectado al map

583
00:22:53,279 --> 00:22:55,500
al que lo hemos asociado, se queda conectado

584
00:22:55,500 --> 00:22:56,980
entonces si yo ahora

585
00:22:56,980 --> 00:22:58,400
en cada uno de estos objetos

586
00:22:58,400 --> 00:23:01,299
cambio a través de los métodos correspondientes

587
00:23:01,299 --> 00:23:02,420
la clave o el valor

588
00:23:02,420 --> 00:23:03,980
se van a cambiar en el

589
00:23:03,980 --> 00:23:05,460
bueno, está pensado que se cambia en el valor

590
00:23:05,460 --> 00:23:06,839
se van a cambiar en el valor

591
00:23:06,839 --> 00:23:11,400
entonces, si yo aquí además de recorrer

592
00:23:11,400 --> 00:23:12,980
quisiera cambiar el precio

593
00:23:12,980 --> 00:23:13,880
de alguno de ellos

594
00:23:13,880 --> 00:23:16,619
podría a través de este objeto P

595
00:23:16,619 --> 00:23:19,000
hacer el cambio y el cambio que yo haga en P

596
00:23:19,000 --> 00:23:21,200
se va a quedar reflejado en la lista

597
00:23:21,200 --> 00:23:22,740
de productos a la que está enganchado

598
00:23:22,740 --> 00:23:24,619
es un funcionamiento extraño

599
00:23:24,619 --> 00:23:26,299
pero bueno, ocurre

600
00:23:26,299 --> 00:23:27,240
vale, nada más

601
00:23:27,240 --> 00:23:33,799
pero bueno, dejémoslo aquí y ya está

602
00:23:33,799 --> 00:23:34,819
no tiene mayor

603
00:23:34,819 --> 00:23:37,500
vale, y ya está

604
00:23:37,500 --> 00:23:40,119
entonces tenemos ya mostrar productos

605
00:23:40,119 --> 00:23:42,220
modificar precio, guardar producto

606
00:23:42,220 --> 00:23:43,980
y eliminar

607
00:23:43,980 --> 00:23:48,890
pues eliminar

608
00:23:48,890 --> 00:23:50,750
aquí es que claro

609
00:23:50,750 --> 00:23:52,230
siempre nos invade

610
00:23:52,230 --> 00:23:54,490
la tentación cuando tenemos que

611
00:23:54,490 --> 00:23:56,490
eliminar de una caja

612
00:23:56,490 --> 00:23:59,089
en general, que es lo que hacemos aquí

613
00:23:59,089 --> 00:24:00,690
cuando eliminamos de una lista, de un map

614
00:24:00,690 --> 00:24:03,390
parece como que intuitivamente nos invade

615
00:24:03,390 --> 00:24:05,509
la tentación de empezar a coger

616
00:24:05,509 --> 00:24:07,410
uno por uno hasta que encuentro

617
00:24:07,410 --> 00:24:08,750
el que sea y cuando lo he encontrado fuera

618
00:24:08,750 --> 00:24:10,589
pero es que no hace falta

619
00:24:10,589 --> 00:24:14,029
ir uno por uno

620
00:24:14,029 --> 00:24:15,250
y cuando lo he encontrado fuera

621
00:24:15,250 --> 00:24:16,910
no hace falta

622
00:24:16,910 --> 00:24:19,970
porque en el map

623
00:24:19,970 --> 00:24:21,650
si tenemos el código al que eliminar

624
00:24:21,650 --> 00:24:23,809
tenemos el método de eliminar por código

625
00:24:23,809 --> 00:24:25,450
eliminas por código y fuera

626
00:24:25,450 --> 00:24:27,710
cuando tengo un set

627
00:24:27,710 --> 00:24:29,329
o tengo un list

628
00:24:29,329 --> 00:24:31,029
también tenemos un remove

629
00:24:31,029 --> 00:24:33,549
que tú le das un objeto

630
00:24:33,549 --> 00:24:34,829
y te elimina el que es igual a ese

631
00:24:34,829 --> 00:24:37,430
no hay que recorrer y cuando encuentras

632
00:24:37,430 --> 00:24:39,690
el que es igual, borrarlo, no hay que recorrer

633
00:24:39,690 --> 00:24:41,470
tienes el remove, punto pelota

634
00:24:41,470 --> 00:24:43,490
remove y le pasas el objeto que es igual

635
00:24:43,490 --> 00:24:45,589
y el remove por dentro

636
00:24:45,589 --> 00:24:47,210
y ahí te dará, ¿vale?

637
00:24:47,210 --> 00:24:48,769
pero siempre tenemos como la tentación de

638
00:24:48,769 --> 00:24:51,109
uy, tengo que borrar de una colección

639
00:24:51,109 --> 00:24:53,049
pues voy a recorrerla hasta que

640
00:24:53,049 --> 00:24:54,869
encuentre y borro, no, es que ya tenemos

641
00:24:54,869 --> 00:24:57,089
los métodos que por dentro

642
00:24:57,089 --> 00:24:58,549
ya recorrerán hasta que encuentren

643
00:24:58,549 --> 00:25:01,009
entonces llamamos al método, le decimos

644
00:25:01,009 --> 00:25:03,009
lo que hay que borrar y él ya

645
00:25:03,009 --> 00:25:03,849
recorrerá por dentro

646
00:25:03,849 --> 00:25:06,730
pues en el map igual, el map tendrá

647
00:25:06,730 --> 00:25:10,900
algún método, si está bien

648
00:25:10,900 --> 00:25:12,200
hecho, tendrá algún método

649
00:25:12,200 --> 00:25:14,859
para borrar, como efectivamente

650
00:25:14,859 --> 00:25:15,339
tiene

651
00:25:15,339 --> 00:25:17,759
tiene un remove

652
00:25:17,759 --> 00:25:19,039
que

653
00:25:19,039 --> 00:25:22,519
tiene varias variantes, está sobrecargado

654
00:25:22,519 --> 00:25:24,240
pero esta

655
00:25:24,240 --> 00:25:26,599
si le pasamos

656
00:25:26,599 --> 00:25:27,180
un código

657
00:25:27,180 --> 00:25:30,460
la ayuda ya nos dice lo que hace

658
00:25:30,460 --> 00:25:32,380
nos dice, te quita

659
00:25:32,380 --> 00:25:34,440
el par cuyo código

660
00:25:34,440 --> 00:25:35,880
es este, pues ya está

661
00:25:35,880 --> 00:25:38,380
esa es la ventaja de los map, que por código podemos hacerlo

662
00:25:38,380 --> 00:25:40,180
todo, entonces este método

663
00:25:40,180 --> 00:25:42,039
además imagino que devolverá un valor

664
00:25:42,039 --> 00:25:44,420
que te permita verificar

665
00:25:44,420 --> 00:25:46,400
si es que quieres, si el par existía

666
00:25:46,400 --> 00:25:47,960
si no existía, etc, etc

667
00:25:47,960 --> 00:25:49,980
vamos a mirarlo

668
00:25:49,980 --> 00:25:52,000
remove object

669
00:25:52,000 --> 00:25:54,299
pues removeObject la ayuda es esta

670
00:25:54,299 --> 00:25:55,180
y te dice

671
00:25:55,180 --> 00:25:59,230
a ver

672
00:25:59,230 --> 00:26:05,140
te dice, borra el par

673
00:26:05,140 --> 00:26:06,839
para esta clave especificada

674
00:26:06,839 --> 00:26:08,740
si es que existe, lógicamente, si no existe

675
00:26:08,740 --> 00:26:09,400
¿cómo lo va a borrar?

676
00:26:10,079 --> 00:26:12,579
y luego te dice, ¿qué devuelve?

677
00:26:13,420 --> 00:26:14,740
devuelve el valor

678
00:26:14,740 --> 00:26:16,039
que tenía

679
00:26:16,039 --> 00:26:18,660
ese par, devuelve el valor que tenía

680
00:26:18,660 --> 00:26:20,960
o null si no lo había, pues de nuevo

681
00:26:20,960 --> 00:26:22,980
el valor de retorno de ese método

682
00:26:22,980 --> 00:26:25,140
te permite verificar si existía o no

683
00:26:25,140 --> 00:26:27,400
no tienes que recorrerlo antes para verificarlo

684
00:26:27,400 --> 00:26:28,920
entonces

685
00:26:28,920 --> 00:26:31,480
podríamos, si así nos lo han pedido

686
00:26:31,480 --> 00:26:33,319
pues podríamos hacer

687
00:26:33,319 --> 00:26:34,799
otra vez aquí un if

688
00:26:34,799 --> 00:26:36,759
de esta manera

689
00:26:36,759 --> 00:26:39,519
si lista producto, removeCódigo

690
00:26:39,519 --> 00:26:40,299
es igual a null

691
00:26:40,299 --> 00:26:43,299
eso significa que no lo ha encontrado

692
00:26:43,299 --> 00:26:45,420
y podríamos poner

693
00:26:45,420 --> 00:26:46,000
pues lo mismo

694
00:26:46,000 --> 00:26:52,670
no existe producto

695
00:26:52,670 --> 00:26:56,539
y ya está

696
00:26:56,539 --> 00:27:03,170
vale, pues bueno, estos en realidad son todas las

697
00:27:03,170 --> 00:27:05,269
opciones

698
00:27:05,269 --> 00:27:06,289
que nos da el map

699
00:27:06,289 --> 00:27:09,329
para recuperar, borrar, eliminar

700
00:27:09,329 --> 00:27:11,849
y no hay más

701
00:27:11,849 --> 00:27:13,349
aquí el map

702
00:27:13,349 --> 00:27:15,490
era de dos clases

703
00:27:15,490 --> 00:27:17,569
que no hemos tenido que hacer nosotros

704
00:27:17,569 --> 00:27:19,210
porque ya están hechas, que son la clase C

705
00:27:19,210 --> 00:27:21,569
y la clase Float, pero podrían ser de clases

706
00:27:21,569 --> 00:27:23,670
nuestras, esta podría ser

707
00:27:23,670 --> 00:27:25,609
de una clase cliente, esta podría

708
00:27:25,609 --> 00:27:27,349
ser de una clase

709
00:27:27,349 --> 00:27:29,130
factura, por ejemplo

710
00:27:29,130 --> 00:27:31,589
una aplicación que trabaja con clientes

711
00:27:31,589 --> 00:27:33,769
y facturas, tenemos la clase

712
00:27:33,769 --> 00:27:34,990
cliente y la clase factura

713
00:27:34,990 --> 00:27:38,029
y tenemos una asociación

714
00:27:38,029 --> 00:27:39,230
de clientes a facturas

715
00:27:39,230 --> 00:27:41,910
cada cliente tiene su factura

716
00:27:41,910 --> 00:27:43,650
pues podríamos

717
00:27:43,650 --> 00:27:44,589
guardarlos en un map

718
00:27:44,589 --> 00:27:47,529
en ese map la clave sería

719
00:27:47,529 --> 00:27:49,170
el cliente, el objeto cliente

720
00:27:49,170 --> 00:27:51,670
y el valor sería su factura

721
00:27:51,670 --> 00:27:52,549
por ejemplo

722
00:27:52,549 --> 00:27:57,799
entonces estos tipos de datos

723
00:27:57,799 --> 00:27:59,599
serán del tipo que sean

724
00:27:59,599 --> 00:28:01,940
y aquí recordad que claro

725
00:28:01,940 --> 00:28:03,700
la implicación que tiene es

726
00:28:03,700 --> 00:28:06,299
que la clave, el tipo de dato

727
00:28:06,299 --> 00:28:07,519
al que pertenece la clave

728
00:28:07,519 --> 00:28:10,579
si es un hash map

729
00:28:10,579 --> 00:28:12,339
el tipo de dato

730
00:28:12,339 --> 00:28:14,259
al que pertenece la clave se guarda en un hash set

731
00:28:14,259 --> 00:28:16,480
con lo cual este tipo de dato

732
00:28:16,480 --> 00:28:18,039
tendrá que tener el hash code y el equals

733
00:28:18,039 --> 00:28:20,160
y si es un tree map

734
00:28:20,160 --> 00:28:21,599
si es un tree map

735
00:28:21,599 --> 00:28:24,099
las claves se guardan en un tree set

736
00:28:24,099 --> 00:28:25,940
con lo cual la clase

737
00:28:25,940 --> 00:28:27,660
a la que pertenecen las claves

738
00:28:27,660 --> 00:28:29,299
tiene que tener el comparable

739
00:28:29,299 --> 00:28:32,039
¿vale? esos son los matices

740
00:28:32,039 --> 00:28:34,119
que hay, porque si no tiene el comparable

741
00:28:34,119 --> 00:28:35,980
el trimar, cuando

742
00:28:35,980 --> 00:28:38,099
lo instanciemos hay que pasarle un comparador

743
00:28:38,099 --> 00:28:39,319
etcétera, bueno

744
00:28:39,319 --> 00:28:41,539
lo que vimos el otro día, vale

745
00:28:41,539 --> 00:28:43,460
venga, vamos a parar aquí un

746
00:28:43,460 --> 00:28:44,640
segundinito