1
00:00:00,240 --> 00:00:19,460
Tenemos dos tipos, listas y colecciones. De las listas conocemos prácticamente todos los pormenores, ¿vale? De las listas ya no nos pillan en ningún lado, conocemos todos los pormenores, salvo su uso como streams, pero eso ya se queda ya aparcado para cuando tengamos más capacidad para hacerlo.

2
00:00:19,460 --> 00:00:21,920
bueno, pues además de las listas

3
00:00:21,920 --> 00:00:23,359
tenemos los conjuntos

4
00:00:23,359 --> 00:00:25,879
los conjuntos están implementados

5
00:00:25,879 --> 00:00:26,879
de otra manera por dentro

6
00:00:26,879 --> 00:00:29,120
ya irán surgiendo los detalles

7
00:00:29,120 --> 00:00:31,739
y ya lo podemos ir viendo, ahora no os voy a contar todo ese rollo

8
00:00:31,739 --> 00:00:33,000
de cómo están implementados por dentro

9
00:00:33,000 --> 00:00:36,039
entonces los conjuntos son los set

10
00:00:36,039 --> 00:00:37,479
y valen también para guardar cosas

11
00:00:37,479 --> 00:00:39,359
por ejemplo, yo quiero

12
00:00:39,359 --> 00:00:41,299
un conjunto de nombres

13
00:00:41,299 --> 00:00:43,560
pues puedo declarar

14
00:00:43,560 --> 00:00:45,840
mi conjunto de nombres tranquilamente

15
00:00:45,840 --> 00:00:46,579
así

16
00:00:46,579 --> 00:00:49,320
set stream

17
00:00:49,320 --> 00:00:55,570
vale, y set

18
00:00:55,570 --> 00:00:56,890
es de java útil

19
00:00:56,890 --> 00:01:00,369
igual que

20
00:01:00,369 --> 00:01:03,289
igual que collecten

21
00:01:03,289 --> 00:01:04,849
igual que list que todos, vale

22
00:01:04,849 --> 00:01:07,310
entonces set es la interfaz

23
00:01:07,310 --> 00:01:09,269
la clase abstracta como lo era list

24
00:01:09,269 --> 00:01:11,209
yo cuando ya

25
00:01:11,209 --> 00:01:12,930
instancie el conjunto

26
00:01:12,930 --> 00:01:15,329
tengo que elegir alguna

27
00:01:15,329 --> 00:01:16,269
implementación

28
00:01:16,269 --> 00:01:19,090
entonces hay tres implementaciones

29
00:01:19,090 --> 00:01:19,989
de set

30
00:01:19,989 --> 00:01:22,810
vale, entonces

31
00:01:22,810 --> 00:01:25,370
las implementaciones serían

32
00:01:25,370 --> 00:01:31,890
has set

33
00:01:31,890 --> 00:01:36,560
conjuntos

34
00:01:36,560 --> 00:01:40,120
linked has set

35
00:01:40,120 --> 00:01:42,120
y

36
00:01:42,120 --> 00:01:42,799
triset

37
00:01:42,799 --> 00:01:59,659
solo un pelinín por encima

38
00:01:59,659 --> 00:02:01,500
ver en que

39
00:02:01,500 --> 00:02:02,819
están basadas por dentro

40
00:02:02,819 --> 00:02:04,000
en que están basadas

41
00:02:04,000 --> 00:02:08,259
listas y conjuntos

42
00:02:08,259 --> 00:02:08,500
si

43
00:02:08,500 --> 00:02:11,599
el set entra en el examen

44
00:02:11,599 --> 00:02:15,099
pero no sufráis

45
00:02:15,099 --> 00:02:19,129
Vale

46
00:02:19,129 --> 00:02:21,389
¿En el examen no vas a poder hacer

47
00:02:21,389 --> 00:02:23,090
Como crear nuestro propio

48
00:02:23,090 --> 00:02:24,129
My LinkedIn List?

49
00:02:25,030 --> 00:02:25,370
No

50
00:02:25,370 --> 00:02:28,650
Solo usarlos, ¿vale?

51
00:02:30,229 --> 00:02:31,469
Ha sido mejor la respuesta

52
00:02:31,469 --> 00:02:37,759
Vale, pues entonces

53
00:02:37,759 --> 00:02:38,400
Bueno

54
00:02:38,400 --> 00:02:40,500
No raya

55
00:02:40,500 --> 00:02:47,319
Vale, pues

56
00:02:47,319 --> 00:02:50,939
Hashef

57
00:02:50,939 --> 00:02:54,080
¿Sobre qué idea está basado?

58
00:02:54,159 --> 00:03:00,819
No lo vamos a implementar nosotros porque es un poco lío, pero sí podemos entender sobre qué idea está basado.

59
00:03:01,719 --> 00:03:11,419
Vale, pues está basado sobre el concepto de tabla hash, que repito, es una idea que vamos a darme por encima.

60
00:03:11,419 --> 00:03:13,860
entonces la tabla

61
00:03:13,860 --> 00:03:15,759
el concepto de las tablas hash

62
00:03:15,759 --> 00:03:17,120
son tablas de códigos

63
00:03:17,120 --> 00:03:21,620
códigos sencillos

64
00:03:21,620 --> 00:03:26,090
que están pensados

65
00:03:26,090 --> 00:03:27,110
para asociarse

66
00:03:27,110 --> 00:03:29,669
a cosas

67
00:03:29,669 --> 00:03:32,590
a cosas un poquito ya más complejas

68
00:03:32,590 --> 00:03:33,789
¿vale?

69
00:03:35,490 --> 00:03:36,250
entonces

70
00:03:36,250 --> 00:03:38,129
la función de hash

71
00:03:38,129 --> 00:03:39,430
lo que hace es

72
00:03:39,430 --> 00:03:41,110
transformar

73
00:03:41,110 --> 00:03:46,229
esa cosa compleja que tiene un montón de datos

74
00:03:46,229 --> 00:04:11,650
esa cosa compleja, la transforma en un código hash, ¿vale? Esto sería una función hash, ¿vale? La transforma en un código hash, ¿vale? Entonces, de alguna manera, esto habilita la posibilidad de hacer ciertas cosas con estos objetos de forma más sencilla gracias a que los tengo transformados en códigos, ¿no?

75
00:04:11,650 --> 00:04:13,729
cosas como por ejemplo

76
00:04:13,729 --> 00:04:15,629
voy a localizar

77
00:04:15,629 --> 00:04:17,449
uno de estos elementos más rápido

78
00:04:17,449 --> 00:04:19,550
pues si tú consigues

79
00:04:19,550 --> 00:04:21,870
el código hash de ese elemento

80
00:04:21,870 --> 00:04:22,870
a través del código

81
00:04:22,870 --> 00:04:25,370
ah, está aquí, pues el elemento está aquí

82
00:04:25,370 --> 00:04:26,209
son ideas

83
00:04:26,209 --> 00:04:31,329
entonces un montón de información

84
00:04:31,329 --> 00:04:33,290
la puedes agrupar

85
00:04:33,290 --> 00:04:34,910
en una serie de códigos

86
00:04:34,910 --> 00:04:37,810
y eso te permite pues trabajar con ellos

87
00:04:37,810 --> 00:04:39,990
para algunas cosas de forma más sencilla

88
00:04:39,990 --> 00:04:41,850
¿Vale?

89
00:04:42,490 --> 00:04:43,589
Bueno, pues entonces

90
00:04:43,589 --> 00:04:45,610
El haset está basado en esto

91
00:04:45,610 --> 00:04:46,750
¿Para qué sirve el haset?

92
00:04:47,550 --> 00:04:49,250
Para guardar un montón de objetos

93
00:04:49,250 --> 00:04:51,170
Eso como siempre, hasta ahí no hemos cambiado

94
00:04:51,170 --> 00:04:51,730
¿Vale?

95
00:04:52,490 --> 00:04:54,209
Para guardar un montón de objetos

96
00:04:54,209 --> 00:04:59,399
Pues yo aquí tengo

97
00:04:59,399 --> 00:05:02,560
Mis objetos

98
00:05:02,560 --> 00:05:05,680
Entonces

99
00:05:05,680 --> 00:05:10,079
Por otro lado, ¿cuál es la estructura más eficiente que hay?

100
00:05:10,079 --> 00:05:10,740
El array

101
00:05:10,740 --> 00:05:12,279
Bueno, pues entonces

102
00:05:12,279 --> 00:05:15,399
El haset se basa en que tenemos aquí

103
00:05:15,399 --> 00:05:20,029
un array y el array

104
00:05:20,029 --> 00:05:22,009
es cada uno de los

105
00:05:22,009 --> 00:05:24,050
códigos hash de estos

106
00:05:24,050 --> 00:05:25,930
elementos, el array es

107
00:05:25,930 --> 00:05:27,649
cada uno de los códigos hash de estos elementos

108
00:05:27,649 --> 00:05:29,189
que estos sí que ya son los objetos

109
00:05:29,189 --> 00:05:31,209
los objetos que van a ir

110
00:05:31,209 --> 00:05:32,949
en el hash set

111
00:05:32,949 --> 00:05:35,569
entonces para usar el hash set

112
00:05:35,569 --> 00:05:37,149
lo primero que tenemos que saber

113
00:05:37,149 --> 00:05:39,709
es que estas clases

114
00:05:39,709 --> 00:05:41,769
tienen que tener implementada

115
00:05:41,769 --> 00:05:43,769
la famosa función hash code

116
00:05:43,769 --> 00:05:45,649
que nos ha parecido a veces

117
00:05:45,649 --> 00:05:48,089
cuando hemos implementado el equals

118
00:05:48,089 --> 00:05:49,629
nos aparecía el hashCode

119
00:05:49,629 --> 00:05:51,449
¿vale? pues entonces

120
00:05:51,449 --> 00:05:53,910
esa función hashCode que el clip se me da

121
00:05:53,910 --> 00:05:55,709
una implementación por defecto

122
00:05:55,709 --> 00:05:58,110
que está bien y es la que normalmente cogemos

123
00:05:58,110 --> 00:05:59,870
esa implementación

124
00:05:59,870 --> 00:06:01,250
hashCode me permite llevar

125
00:06:01,250 --> 00:06:05,490
de un objeto al código

126
00:06:05,490 --> 00:06:06,790
correspondiente suyo

127
00:06:06,790 --> 00:06:08,870
¿vale? que se coloca en un array

128
00:06:08,870 --> 00:06:10,610
que se coloca en un array

129
00:06:10,610 --> 00:06:12,810
¿vale? entonces

130
00:06:12,810 --> 00:06:15,350
¿qué ocurre?

131
00:06:15,829 --> 00:06:16,269
que

132
00:06:16,269 --> 00:06:19,009
el array tampoco puede tener un tamaño

133
00:06:19,009 --> 00:06:21,069
enorme, entonces si van aumentando

134
00:06:21,069 --> 00:06:23,329
los objetos, van aumentando los objetos, van aumentando los objetos

135
00:06:23,329 --> 00:06:24,930
digo, jolín, es que

136
00:06:24,930 --> 00:06:27,129
¿por qué es tan eficiente esto si no estamos ganando

137
00:06:27,129 --> 00:06:29,149
tampoco nada? porque el hash set por debajo

138
00:06:29,149 --> 00:06:30,970
tendrá que gestionar el

139
00:06:30,970 --> 00:06:32,329
array de códigos, ¿verdad?

140
00:06:32,829 --> 00:06:34,689
para ver si un objeto es igual a otro

141
00:06:34,689 --> 00:06:37,430
pues el hash set por debajo internamente

142
00:06:37,430 --> 00:06:38,990
mira a ver si los códigos

143
00:06:38,990 --> 00:06:41,230
de hash son iguales, que le va a ser mucho más fácil

144
00:06:41,230 --> 00:06:43,230
ver si los dos códigos de hash son iguales

145
00:06:43,230 --> 00:06:45,230
que ver si los dos objetos son iguales

146
00:06:45,949 --> 00:06:48,730
La tabla de hash optimiza sobre todo esto.

147
00:06:49,189 --> 00:06:51,529
Tengo que ver, pues eso, ¿son diferentes?

148
00:06:51,850 --> 00:06:53,990
Pues voy a ver si los códigos de hash son distintos.

149
00:06:54,209 --> 00:07:00,189
Me es mucho más rápido hacer la igualdad entre dos códigos que entre dos objetos.

150
00:07:00,949 --> 00:07:01,949
En eso se basa el hasher.

151
00:07:02,649 --> 00:07:05,509
Él gracias a esta función lo transforma internamente en un código

152
00:07:05,509 --> 00:07:09,110
y ese código le facilita la manipulación de muchas de las acciones.

153
00:07:09,689 --> 00:07:14,769
Vale, pero efectivamente, si aquí empezara a haber un montón de objetos,

154
00:07:14,769 --> 00:07:16,110
un montón de objetos

155
00:07:16,110 --> 00:07:18,769
pues la tabla de hash tendría que ir creciendo

156
00:07:18,769 --> 00:07:20,689
hombre, esto no tiene mucho sentido

157
00:07:20,689 --> 00:07:22,949
precisamente los arrays son pesados

158
00:07:22,949 --> 00:07:24,389
de manejar, son poco manejables

159
00:07:24,389 --> 00:07:26,730
bueno, pues esta estructura hash set

160
00:07:26,730 --> 00:07:27,870
por debajo

161
00:07:27,870 --> 00:07:30,550
lo que se basa es

162
00:07:30,550 --> 00:07:32,709
yo voy a limitar el tamaño de mi tabla

163
00:07:32,709 --> 00:07:35,129
de códigos hash, la voy a limitar

164
00:07:35,129 --> 00:07:37,329
a por ejemplo

165
00:07:37,329 --> 00:07:38,110
este tamaño

166
00:07:38,110 --> 00:07:39,370
este tamaño

167
00:07:39,370 --> 00:07:43,370
y ahora ya, que el hash set siga aumentando

168
00:07:43,370 --> 00:07:48,029
No pasa nada, pues una vez que he desbordado la tabla

169
00:07:48,029 --> 00:07:50,829
Y ya no me caben más objetos colgando de la tabla

170
00:07:50,829 --> 00:07:56,370
Pues se van a ir a través de una lista enlazada

171
00:07:56,370 --> 00:07:59,269
Entonces mi tabla de códigos has, a lo mejor tiene cuatro códigos

172
00:07:59,269 --> 00:08:01,889
Vale, y los objetos están así

173
00:08:01,889 --> 00:08:06,860
Aquí a lo mejor hay tres

174
00:08:06,860 --> 00:08:11,379
Aquí hay otros tres

175
00:08:11,379 --> 00:08:13,420
Y aquí hay dos

176
00:08:13,420 --> 00:08:15,560
¿vale? entonces tengo en mi hash set

177
00:08:15,560 --> 00:08:16,939
tengo seis objetos

178
00:08:16,939 --> 00:08:19,779
estos tres, estos tres

179
00:08:19,779 --> 00:08:21,000
y estos dos

180
00:08:21,000 --> 00:08:23,240
que salen de ahí, entonces el hash set trata de

181
00:08:23,240 --> 00:08:25,319
combinar la potencia

182
00:08:25,319 --> 00:08:25,939
de un array

183
00:08:25,939 --> 00:08:29,079
con la eficiencia de una lista enlazada

184
00:08:29,079 --> 00:08:30,939
por dentro son las dos cosas

185
00:08:30,939 --> 00:08:33,539
una pequeña tablita manejable

186
00:08:33,539 --> 00:08:35,500
una pequeña tablita de códigos hash

187
00:08:35,500 --> 00:08:36,940
y a partir de ahí

188
00:08:36,940 --> 00:08:39,100
cada uno de ellos me puede llevar a un objeto

189
00:08:39,100 --> 00:08:41,179
o me puede llevar a una lista enlazada

190
00:08:41,179 --> 00:08:43,100
depende de si me han llegado

191
00:08:43,100 --> 00:08:44,960
a desbordar ya los objetos y tengo muchos

192
00:08:44,960 --> 00:08:46,360
pues todos los tengo que ir acoplando

193
00:08:46,360 --> 00:08:49,240
¿vale? pero todo eso se hace por debajo

194
00:08:49,240 --> 00:08:50,740
a nosotros todo eso

195
00:08:50,740 --> 00:08:52,639
no nos importa como lo hace

196
00:08:52,639 --> 00:08:54,879
solo nos importa

197
00:08:54,879 --> 00:08:56,919
que necesita el hashed para

198
00:08:56,919 --> 00:08:59,000
funcionar, para poder hacer

199
00:08:59,000 --> 00:09:01,019
esta historia, pues para

200
00:09:01,019 --> 00:09:03,299
poder hacer esta historia el hashed lo que significa

201
00:09:03,299 --> 00:09:04,940
repito, que los

202
00:09:04,940 --> 00:09:06,879
objetos que van a formar parte de él

203
00:09:06,879 --> 00:09:09,559
tengan el hashcode implementado

204
00:09:09,559 --> 00:09:13,669
y no solo el hashcode

205
00:09:13,669 --> 00:09:15,250
sino que tengan el equals

206
00:09:15,250 --> 00:09:19,350
¿por qué? porque a través del

207
00:09:19,350 --> 00:09:20,669
hashCode tú puedes llegar aquí

208
00:09:20,669 --> 00:09:23,389
pero si hay varios colgando

209
00:09:23,389 --> 00:09:25,490
de aquí, ¿cuál es

210
00:09:25,490 --> 00:09:27,429
cada uno? ¿cómo encuentra el hashSet a cuál te

211
00:09:27,429 --> 00:09:29,490
refieres? pues una vez que ha hecho el hashCode

212
00:09:29,490 --> 00:09:31,509
y ha llegado aquí, él ya va haciendo

213
00:09:31,509 --> 00:09:32,889
el equals a continuación

214
00:09:32,889 --> 00:09:35,289
hasta que encuentre el objeto con el que tú quieres

215
00:09:35,289 --> 00:09:35,769
trabajar

216
00:09:35,769 --> 00:09:39,250
luego para trabajar con un hashSet

217
00:09:39,250 --> 00:09:41,710
y que su funcionamiento sea el esperable

218
00:09:41,710 --> 00:09:43,549
en la clase a la que

219
00:09:43,549 --> 00:09:45,610
pertenecen los objetos del hashSet

220
00:09:45,610 --> 00:09:47,110
tienen que estar implementados

221
00:09:47,110 --> 00:09:49,169
estos dos métodos

222
00:09:49,169 --> 00:09:52,149
por ahora, con quedarnos con eso es suficiente

223
00:09:52,149 --> 00:09:54,049
si no están implementados

224
00:09:54,049 --> 00:09:55,990
no puedo trabajar con un haset

225
00:09:55,990 --> 00:09:57,909
sí, pero es que entonces esa clase

226
00:09:57,909 --> 00:09:59,789
se va a quedar con la implementación de object

227
00:09:59,789 --> 00:10:00,590
como ya sabemos

228
00:10:00,590 --> 00:10:03,549
y la implementación de object

229
00:10:03,549 --> 00:10:05,330
de hashCode e equals

230
00:10:05,330 --> 00:10:07,330
lo que me haría

231
00:10:07,330 --> 00:10:08,350
sería

232
00:10:08,350 --> 00:10:11,850
que todos los objetos fueran

233
00:10:11,850 --> 00:10:14,090
distintos, porque me haría la igualdad

234
00:10:14,090 --> 00:10:15,889
por dirección de memoria, como ya sabemos

235
00:10:15,889 --> 00:10:18,409
entonces sería un uso del hash set

236
00:10:18,409 --> 00:10:19,889
absolutamente poco

237
00:10:19,889 --> 00:10:22,590
eficiente, porque consideraría

238
00:10:22,590 --> 00:10:23,789
cada objeto

239
00:10:23,789 --> 00:10:26,090
distinto, tendría una

240
00:10:26,090 --> 00:10:27,870
tabla inmensa de códigos hash

241
00:10:27,870 --> 00:10:30,110
cada un objeto distinto por dirección de memoria

242
00:10:30,110 --> 00:10:30,990
pues no

243
00:10:30,990 --> 00:10:33,009
nosotros no queremos eso

244
00:10:33,009 --> 00:10:35,509
queremos precisamente los set

245
00:10:35,509 --> 00:10:37,830
para evitar duplicados, es decir

246
00:10:37,830 --> 00:10:39,710
para no poder meter dos objetos iguales

247
00:10:39,710 --> 00:10:41,710
si yo no implemento hash code

248
00:10:41,710 --> 00:10:43,769
e equals, para java

249
00:10:43,769 --> 00:10:46,730
Nunca jamás dos objetos van a ser iguales

250
00:10:46,730 --> 00:10:48,370
A menos que esté uno encima del otro

251
00:10:48,370 --> 00:10:49,509
Porque se va a ir a ir encima de memoria

252
00:10:49,509 --> 00:10:53,429
Entonces esto deja de tener su sentido semántico

253
00:10:53,429 --> 00:10:53,970
¿Vale?

254
00:10:54,049 --> 00:10:55,710
Me convierto yo ahí en una tabla

255
00:10:55,710 --> 00:10:58,750
Has enorme con un montón de objetos distintos

256
00:10:58,750 --> 00:11:00,389
Pues que sentido tiene esto

257
00:11:00,389 --> 00:11:02,110
Bueno esta es la idea por debajo

258
00:11:02,110 --> 00:11:04,230
Que ahora mismo no quería meterme en rollo en historias

259
00:11:04,230 --> 00:11:05,129
Vamos a ver el uso

260
00:11:05,129 --> 00:11:08,570
Y las implicaciones de que por debajo sea así el haset

261
00:11:08,570 --> 00:11:09,669
Pues

262
00:11:09,669 --> 00:11:13,350
Esperamos a cambiar esto primero

263
00:11:13,350 --> 00:11:30,799
vale, pues venga

264
00:11:30,799 --> 00:11:32,299
vamos a meter nombres

265
00:11:32,299 --> 00:11:36,200
en resumen

266
00:11:36,200 --> 00:11:38,419
los conjuntos, lo que más nos importa

267
00:11:38,419 --> 00:11:39,960
más que la implementación interna

268
00:11:39,960 --> 00:11:42,120
lo que nos importa es, como vamos a ver ahora en el ejemplo

269
00:11:42,120 --> 00:11:43,919
que en los conjuntos

270
00:11:43,919 --> 00:11:46,799
no puedes meter elementos duplicados

271
00:11:46,799 --> 00:11:47,860
¿vale?

272
00:11:48,480 --> 00:11:49,399
vamos a verlo ahora

273
00:11:49,399 --> 00:11:51,740
Vamos a hacer un conjunto de nombres

274
00:11:51,740 --> 00:11:54,960
Vamos a elegir la implementación

275
00:11:54,960 --> 00:11:57,019
Hashed, esa es la primera que vamos a

276
00:11:57,019 --> 00:11:57,919
Ver como ejemplo

277
00:11:57,919 --> 00:12:01,220
¿Vale? Como funciona el Hashed

278
00:12:01,220 --> 00:12:03,279
La primera de todas

279
00:12:03,279 --> 00:12:05,139
Bueno, voy a meter una función aparte

280
00:12:05,139 --> 00:12:07,340
Para que luego cuando probemos esto no sea tan

281
00:12:07,340 --> 00:12:16,580
Ejemplo Hashed

282
00:12:16,580 --> 00:12:17,539
Vale

283
00:12:17,539 --> 00:12:23,600
Pues venga

284
00:12:23,600 --> 00:12:29,269
Ejemplo Hashed, voy

285
00:12:29,269 --> 00:12:31,950
Vale, pues venga, nos vamos a hacer

286
00:12:31,950 --> 00:12:33,330
Nuestro Hashed de nombres

287
00:12:33,330 --> 00:12:39,570
Uy, de nombres de stream, perdón

288
00:12:39,570 --> 00:12:42,610
Bueno, es que no tengo ningún modelo

289
00:12:42,610 --> 00:12:44,429
Ahora mismo, no tengo ningún modelo

290
00:12:44,429 --> 00:12:52,200
Claro, claro, no lo estoy implementando yo

291
00:12:52,200 --> 00:12:54,600
Igual que hemos visto ArrayList, LinkedList

292
00:12:54,600 --> 00:12:56,320
Pues vamos a ver ahora estas

293
00:12:56,320 --> 00:12:58,679
Que son otras que ya están hechas, no las vamos a implementar nosotros

294
00:12:58,679 --> 00:13:00,440
Vale, entonces

295
00:13:00,440 --> 00:13:03,909
Vamos a hacer un conjunto

296
00:13:03,909 --> 00:13:04,549
De nombres

297
00:13:04,549 --> 00:13:10,500
Bueno, pues lo mismo

298
00:13:10,500 --> 00:13:14,049
los set

299
00:13:14,049 --> 00:13:16,090
son interfaces

300
00:13:16,090 --> 00:13:17,529
clases genéricas

301
00:13:17,529 --> 00:13:20,490
yo puedo decidir el tipo

302
00:13:20,490 --> 00:13:22,730
que voy a meter o puedo dejarlo abierto

303
00:13:22,730 --> 00:13:24,389
ya sabéis que si

304
00:13:24,389 --> 00:13:26,350
lo dejo abierto, él asume que es

305
00:13:26,350 --> 00:13:28,490
de object, con lo cual puedes meter cualquier

306
00:13:28,490 --> 00:13:28,950
cosa

307
00:13:28,950 --> 00:13:31,830
eso es un peligro

308
00:13:31,830 --> 00:13:34,409
porque cuando saques de ahí, recorras, te puedes

309
00:13:34,409 --> 00:13:36,250
salir cualquier cosa, entonces ¿qué haces?

310
00:13:36,350 --> 00:13:38,549
¿haces casting? ¿qué haces? mala idea

311
00:13:38,549 --> 00:13:40,269
¿no? buena idea

312
00:13:40,269 --> 00:13:41,909
cuando uno usa una colección

313
00:13:41,909 --> 00:13:43,830
Decidir qué va a ir ahí dentro

314
00:13:43,830 --> 00:13:45,509
Para que todos sean del mismo tipo

315
00:13:45,509 --> 00:13:47,370
O de las subclases correspondientes

316
00:13:47,370 --> 00:13:49,629
Bueno, pues un set de nombres, hashel

317
00:13:49,629 --> 00:13:51,710
¿Qué se hace con una colección?

318
00:13:51,990 --> 00:13:53,590
Pues lo mismo, siempre lo mismo

319
00:13:53,590 --> 00:13:56,509
Insertar, ver si algo hay

320
00:13:56,509 --> 00:13:58,049
Eliminar y ya está

321
00:13:58,049 --> 00:13:59,929
O cambiar algo que hay adentro

322
00:13:59,929 --> 00:14:01,389
El único que se hace, pues ya está

323
00:14:01,389 --> 00:14:02,409
Lo que pasa es que cada una

324
00:14:02,409 --> 00:14:04,970
Con sus matices para que funcione bien

325
00:14:04,970 --> 00:14:07,009
Los matices de las listas ya lo sabemos

326
00:14:07,009 --> 00:14:08,549
Pues en los sets

327
00:14:08,549 --> 00:14:10,929
Pues venga, vamos a meter nombres aquí

328
00:14:10,929 --> 00:14:30,659
vamos a ver cuantos hemos metido

329
00:14:30,659 --> 00:14:34,120
pues nombre tendrá su size

330
00:14:34,120 --> 00:14:36,659
lógicamente, como cualquier colección

331
00:14:36,659 --> 00:14:41,799
estamos implementando collection, pues implementamos collection

332
00:14:41,799 --> 00:14:43,399
el método size hay que implementarlo

333
00:14:43,399 --> 00:14:48,580
vamos a ejecutar esto

334
00:14:48,580 --> 00:14:49,940
antes que nada

335
00:14:49,940 --> 00:14:58,090
y me saldrá dos, lógicamente

336
00:14:58,090 --> 00:15:07,179
pues sí, me sale dos, claro

337
00:15:07,179 --> 00:15:09,039
porque he metido dos nombres, me sale dos

338
00:15:09,039 --> 00:15:10,120
¿Vale?

339
00:15:11,820 --> 00:15:12,940
¿Cómo la recorremos?

340
00:15:13,419 --> 00:15:14,440
Pues como cual...

341
00:15:14,440 --> 00:15:15,960
¿Eh?

342
00:15:16,940 --> 00:15:18,539
Bueno, he llamado al método sin más

343
00:15:18,539 --> 00:15:19,759
En mi main

344
00:15:19,759 --> 00:15:22,320
Claro, es que las diferentes pruebas que haga

345
00:15:22,320 --> 00:15:23,919
En métodos aparte, para que no se me quede un main

346
00:15:23,919 --> 00:15:25,559
Luego te va a ganar comentando y es un rollo

347
00:15:25,559 --> 00:15:27,039
Vale

348
00:15:27,039 --> 00:15:30,340
¿Cómo recorremos una colección para ver lo que hay?

349
00:15:30,340 --> 00:15:32,639
Pues siempre podemos usar el for each

350
00:15:32,639 --> 00:15:33,820
Claro

351
00:15:33,820 --> 00:15:35,679
Para cada

352
00:15:35,679 --> 00:15:38,200
Nombre en mi colección

353
00:15:38,200 --> 00:15:40,220
nombres exactamente igual que en una lista

354
00:15:40,220 --> 00:15:41,440
exactamente igual que en una raíz

355
00:15:41,440 --> 00:15:43,419
para recorrer, para mostrar

356
00:15:43,419 --> 00:15:48,220
siempre podemos recorrerla con el for each

357
00:15:48,220 --> 00:15:49,340
nombre

358
00:15:49,340 --> 00:15:50,960
vale

359
00:15:50,960 --> 00:15:59,190
exactamente igual que con cualquiera

360
00:15:59,190 --> 00:16:00,649
con cualquier otra

361
00:16:00,649 --> 00:16:05,210
vale, pues vamos a ver los nombres que tiene

362
00:16:05,210 --> 00:16:11,080
vale, pues tiene los dos que he metido

363
00:16:11,080 --> 00:16:14,519
pero como veis

364
00:16:14,519 --> 00:16:16,740
el orden

365
00:16:16,740 --> 00:16:18,379
en el que me ha hecho

366
00:16:18,379 --> 00:16:19,600
la iteración

367
00:16:19,600 --> 00:16:22,539
no tiene que ver con el orden de inserción

368
00:16:22,539 --> 00:16:24,279
¿por qué? porque aquí no hay

369
00:16:24,279 --> 00:16:25,259
ningún tipo de orden

370
00:16:25,259 --> 00:16:28,240
esto no es una lista donde cada elemento

371
00:16:28,240 --> 00:16:29,000
tenga una posición

372
00:16:29,000 --> 00:16:31,039
cuando yo metí en el conjunto

373
00:16:31,039 --> 00:16:33,919
pues ahí fue entrando

374
00:16:33,919 --> 00:16:35,899
entonces no puedo pretender

375
00:16:35,899 --> 00:16:38,419
que en un recorrido para ver lo que hay

376
00:16:38,419 --> 00:16:39,759
se conserve

377
00:16:39,759 --> 00:16:42,360
el orden en el que yo lo introduje

378
00:16:42,360 --> 00:16:44,259
porque aquí cada elemento no tiene una posición

379
00:16:44,259 --> 00:16:45,639
Eso es lo primero, ¿vale?

380
00:16:46,960 --> 00:17:00,509
Entonces, el orden de iteración no es el de inserción, ¿vale?

381
00:17:01,029 --> 00:17:02,610
Y posiciones no hay.

382
00:17:03,529 --> 00:17:08,569
Es decir, aquí el método get de listas no existe.

383
00:17:09,069 --> 00:17:15,150
Con lo cual, si yo quisiera recorrer con un for de índice así, no puedo porque no tengo el get.

384
00:17:15,150 --> 00:17:16,569
No puede ser el net tampoco.

385
00:17:16,569 --> 00:17:20,349
el size sí, el size cualquier colección

386
00:17:20,349 --> 00:17:21,309
claro

387
00:17:21,309 --> 00:17:23,930
una colección tiene una cantidad

388
00:17:23,930 --> 00:17:25,809
de elementos, entonces tiene su size

389
00:17:25,809 --> 00:17:28,069
pero lo que yo no puedo hacer

390
00:17:28,069 --> 00:17:29,750
es pretender hacer ahora

391
00:17:29,750 --> 00:17:33,759
nombre.get

392
00:17:33,759 --> 00:17:34,940
de i

393
00:17:34,940 --> 00:17:36,980
porque este método no existe

394
00:17:36,980 --> 00:17:39,140
el método get no existe para la

395
00:17:39,140 --> 00:17:39,940
interfaz set

396
00:17:39,940 --> 00:17:43,039
porque no hay posición, no puedo

397
00:17:43,039 --> 00:17:44,599
recuperar por posición, no puedo

398
00:17:44,599 --> 00:17:47,740
entonces esto

399
00:17:47,740 --> 00:17:49,779
este recorrido

400
00:17:49,779 --> 00:17:50,720
no se puede hacer

401
00:17:50,720 --> 00:18:08,529
y por tanto tampoco podría

402
00:18:08,529 --> 00:18:10,289
borrar por posición con el remove

403
00:18:10,289 --> 00:18:12,569
y ni tendría sentido el método

404
00:18:12,569 --> 00:18:14,569
index of al que le pasas

405
00:18:14,569 --> 00:18:16,130
un elemento y te da la posición

406
00:18:16,130 --> 00:18:17,690
del primero que encuentra igual

407
00:18:17,690 --> 00:18:20,190
todos los métodos relativos a posiciones

408
00:18:20,190 --> 00:18:25,359
aquí no existen

409
00:18:25,359 --> 00:18:27,059
vale, entonces significa que solamente

410
00:18:27,059 --> 00:18:29,420
podemos recorrer con un for

411
00:18:29,420 --> 00:18:31,299
con un for each como este

412
00:18:31,299 --> 00:18:34,640
no, también podemos recorrer

413
00:18:34,640 --> 00:18:36,400
aparte de con streams de programación

414
00:18:36,400 --> 00:18:38,740
funcional, que insisto, que las aparcamos

415
00:18:38,740 --> 00:18:40,519
cuando sepamos un poco más, aparte

416
00:18:40,519 --> 00:18:41,539
de eso

417
00:18:41,539 --> 00:18:44,400
también podemos recorrer con el famoso

418
00:18:44,400 --> 00:18:48,150
iterador, ¿vale?

419
00:18:48,869 --> 00:18:50,049
vamos a ponerlo aquí

420
00:18:50,049 --> 00:18:54,400
¿qué es un iterador?

421
00:18:55,079 --> 00:18:56,539
un iterador es un objeto

422
00:18:56,539 --> 00:18:58,740
que me sirve

423
00:18:58,740 --> 00:19:00,880
para recorrer cualquier colección

424
00:19:00,880 --> 00:19:02,700
cualquiera, lo que vamos a hacer aquí

425
00:19:02,700 --> 00:19:03,859
para la lista sería igual

426
00:19:03,859 --> 00:19:06,779
¿vale?

427
00:19:07,339 --> 00:19:08,880
entonces no es un elemento que se use

428
00:19:08,880 --> 00:19:10,700
ya mucho porque ahora mismo en las colecciones

429
00:19:10,700 --> 00:19:12,500
siempre se usa programación funcional

430
00:19:12,500 --> 00:19:13,700
prácticamente siempre

431
00:19:13,700 --> 00:19:16,019
pero bueno, hay que conocerlo

432
00:19:16,019 --> 00:19:18,660
entonces el objeto iterador es un objeto

433
00:19:18,660 --> 00:19:19,380
de esta clase

434
00:19:19,380 --> 00:19:23,509
que se asocia lógicamente

435
00:19:23,509 --> 00:19:25,269
al tipo de dato

436
00:19:25,269 --> 00:19:27,750
que yo ponga

437
00:19:27,750 --> 00:19:28,569
mi iterador

438
00:19:28,569 --> 00:19:32,390
¿y cómo consigo este objeto iterador?

439
00:19:32,390 --> 00:19:34,230
este objeto iterador lo consigo

440
00:19:34,230 --> 00:19:38,759
a partir de mi colección

441
00:19:38,759 --> 00:19:40,559
sacándola con el

442
00:19:40,559 --> 00:19:41,220
método iterador

443
00:19:41,220 --> 00:19:55,930
iterador se convierte

444
00:19:55,930 --> 00:19:58,390
ahora hecho esto

445
00:19:58,390 --> 00:20:01,529
se convierte en una especie de objeto puntero

446
00:20:01,529 --> 00:20:04,349
que me va señalando cada objeto

447
00:20:04,349 --> 00:20:07,069
y a partir de ese objeto puntero yo puedo hacer cosas

448
00:20:07,069 --> 00:20:10,730
inicialmente este objeto puntero

449
00:20:10,730 --> 00:20:12,690
se queda apuntando

450
00:20:12,690 --> 00:20:15,410
al anterior al primero

451
00:20:15,410 --> 00:20:18,190
o sea, a ninguno todavía, al anterior al primero que ve

452
00:20:18,190 --> 00:20:21,289
Entonces, yo avanzo el objeto puntero

453
00:20:21,289 --> 00:20:22,990
Con un método que es next

454
00:20:22,990 --> 00:20:26,690
Y además tengo otro método de literador

455
00:20:26,690 --> 00:20:27,589
Que es hashNext

456
00:20:27,589 --> 00:20:29,170
Que me dice si tengo puntero

457
00:20:29,170 --> 00:20:30,430
O sea, si tengo siguiente

458
00:20:30,430 --> 00:20:34,009
Con lo cual, la forma de recorrer con un puntero

459
00:20:34,009 --> 00:20:34,930
Es esta siempre

460
00:20:34,930 --> 00:20:41,859
n igual a ir.next

461
00:20:41,859 --> 00:20:45,200
Y ahora aquí con n hago lo que sea

462
00:20:45,200 --> 00:20:46,299
Lo que quiera

463
00:20:46,299 --> 00:20:50,220
Es decir, el literador

464
00:20:50,220 --> 00:20:53,140
Es un objeto que según yo voy haciendo

465
00:20:53,140 --> 00:20:53,599
next

466
00:20:53,599 --> 00:20:56,099
se va cargando

467
00:20:56,099 --> 00:20:58,059
con cada uno de los elementos

468
00:20:58,059 --> 00:21:01,380
y hash next me devuelve un boolean

469
00:21:01,380 --> 00:21:02,779
para decirme si hay siguiente

470
00:21:02,779 --> 00:21:03,980
o si no hay siguiente

471
00:21:03,980 --> 00:21:07,299
con lo cual la mejor forma de combinar eso en un bucle

472
00:21:07,299 --> 00:21:07,740
es esta

473
00:21:07,740 --> 00:21:09,960
mientras tenga siguiente

474
00:21:09,960 --> 00:21:12,440
cárgate con el siguiente

475
00:21:12,440 --> 00:21:14,900
y yo ya con ese hago lo que quiera

476
00:21:14,900 --> 00:21:16,279
pero claro

477
00:21:16,279 --> 00:21:17,980
aquí no te devuelve ningún

478
00:21:17,980 --> 00:21:22,329
no, este iterador va

479
00:21:22,329 --> 00:21:23,910
random

480
00:21:23,910 --> 00:21:25,549
A ver, no es que vaya random

481
00:21:25,549 --> 00:21:27,529
Pero no sigue orden de inserción

482
00:21:27,529 --> 00:21:28,349
Pero no hay posiciones

483
00:21:28,349 --> 00:21:30,769
Va a seguir el mismo que el for each

484
00:21:30,769 --> 00:21:33,930
Si lo ejecutamos

485
00:21:33,930 --> 00:21:34,829
Aquí otra vez, ¿ves?

486
00:21:35,369 --> 00:21:37,450
Este es con el for each y este es con el iterador

487
00:21:37,450 --> 00:21:40,180
¿Vale?

488
00:21:45,720 --> 00:21:47,339
Porque está usando

489
00:21:47,339 --> 00:21:49,019
Internamente el orden alfabético

490
00:21:49,019 --> 00:21:51,119
Como veis

491
00:21:51,119 --> 00:21:52,119
¿Vale? O sea, si

492
00:21:52,119 --> 00:21:55,339
Juraría, imaginaos que yo meto ahora

493
00:21:55,339 --> 00:21:57,279
Nombre

494
00:21:57,279 --> 00:21:59,019
¿No?

495
00:21:59,380 --> 00:22:11,400
En cualquier caso es que es una pregunta que no deberíamos necesitar resolver, porque uno usa un conjunto precisamente en estructuras en las que el orden no le importa, no quiere orden, ¿vale?

496
00:22:12,000 --> 00:22:14,859
De hecho, por eso no existe ni el sort, ¿vale?

497
00:22:16,400 --> 00:22:18,799
¿Veis? El método sort no existe aquí.

498
00:22:20,299 --> 00:22:24,160
Entonces, voy a probar.

499
00:22:32,299 --> 00:22:34,599
a ver, voy a meter

500
00:22:34,599 --> 00:22:36,059
claro, es que

501
00:22:36,059 --> 00:22:39,000
descubrimos un patrón que los string

502
00:22:39,000 --> 00:22:40,619
él los itera por

503
00:22:40,619 --> 00:22:42,619
alfabético, que los int los itera

504
00:22:42,619 --> 00:22:44,500
por orden de menor a mayor, puede ser

505
00:22:44,500 --> 00:22:46,799
pero no es una información que debamos usar, pero si queremos un orden

506
00:22:46,799 --> 00:22:48,480
entonces usamos otras estructuras

507
00:22:48,480 --> 00:22:49,740
usamos comparables, etc

508
00:22:49,740 --> 00:22:51,480
entonces aquí

509
00:22:51,480 --> 00:22:55,390
pues me ha cambiado estos dos y este no

510
00:22:55,390 --> 00:22:56,710
entonces

511
00:22:56,710 --> 00:23:00,369
en realidad está usando

512
00:23:00,369 --> 00:23:02,190
el orden del hashcode

513
00:23:02,190 --> 00:23:03,490
en realidad

514
00:23:03,490 --> 00:23:05,150
vale

515
00:23:05,150 --> 00:23:08,430
a ver

516
00:23:08,430 --> 00:23:11,349
volvemos al iterador

517
00:23:11,349 --> 00:23:13,930
el iterador entonces

518
00:23:13,930 --> 00:23:16,769
en realidad es muy poco útil

519
00:23:16,769 --> 00:23:18,670
porque uno puede recorrer con un for each

520
00:23:18,670 --> 00:23:20,230
salvo para una cosa

521
00:23:20,230 --> 00:23:22,829
el iterador es utilísimo

522
00:23:22,829 --> 00:23:24,589
para eliminar

523
00:23:24,589 --> 00:23:26,569
porque tiene

524
00:23:26,569 --> 00:23:27,609
el método remove

525
00:23:27,609 --> 00:23:30,210
vale, por ejemplo

526
00:23:30,210 --> 00:23:32,450
vamos a suponer que queremos

527
00:23:32,450 --> 00:23:33,329
Hacer esto

528
00:23:33,329 --> 00:23:35,430
Eliminar

529
00:23:35,430 --> 00:23:37,670
Los nombres

530
00:23:37,670 --> 00:23:40,650
Que empiecen

531
00:23:40,650 --> 00:23:43,829
Por A

532
00:23:43,829 --> 00:23:45,029
Por ejemplo

533
00:23:45,029 --> 00:23:49,250
Vale

534
00:23:49,250 --> 00:23:50,650
Pues

535
00:23:50,650 --> 00:23:54,509
Si lo hacemos aquí con un for each

536
00:23:54,509 --> 00:23:55,910
Que empiecen por A

537
00:23:55,910 --> 00:23:57,869
Pues haríamos algo así

538
00:23:57,869 --> 00:23:59,789
For string

539
00:23:59,789 --> 00:24:02,890
Y nombre

540
00:24:02,890 --> 00:24:08,440
Si n.char

541
00:24:08,440 --> 00:24:09,980
At 0

542
00:24:09,980 --> 00:24:12,920
Resulta que es igual

543
00:24:12,920 --> 00:24:13,599
A

544
00:24:13,599 --> 00:24:17,000
Pues entonces

545
00:24:17,000 --> 00:24:17,720
Haríamos

546
00:24:17,720 --> 00:24:20,680
Nombre.remove

547
00:24:20,680 --> 00:24:22,640
Remove

548
00:24:22,640 --> 00:24:23,500
N

549
00:24:23,500 --> 00:24:26,960
Porque el remove funciona exactamente

550
00:24:26,960 --> 00:24:28,420
Igual que en cualquier otra colección

551
00:24:28,420 --> 00:24:30,599
Te borra un elemento

552
00:24:30,599 --> 00:24:31,319
Igual que n

553
00:24:31,319 --> 00:24:34,420
Te borra un elemento igual que n

554
00:24:34,420 --> 00:24:36,579
y empezar por no es criterio de igualdad

555
00:24:36,579 --> 00:24:38,000
lo cual no puedes poner directamente

556
00:24:38,000 --> 00:24:41,019
entonces, si quieres borrar

557
00:24:41,019 --> 00:24:43,079
por algo que no sea el criterio

558
00:24:43,079 --> 00:24:44,839
de igualdad, con el for each

559
00:24:44,839 --> 00:24:46,779
es que no nos queda más remedio que hacer esto

560
00:24:46,779 --> 00:24:48,920
no nos quedaría más remedio que hacer esto

561
00:24:48,920 --> 00:24:50,960
y aquí es cuando se nos saltan

562
00:24:50,960 --> 00:24:52,779
las alarmas, pero bueno

563
00:24:52,779 --> 00:24:55,039
¿qué es esto de meter un remove

564
00:24:55,039 --> 00:24:55,980
dentro de un for?

565
00:24:56,759 --> 00:24:58,880
ya sabemos que esto nos puede dar el concurrent

566
00:24:58,880 --> 00:25:00,200
modification exception

567
00:25:00,200 --> 00:25:03,019
que en este caso no sé si me lo va a dar, depende de en qué

568
00:25:03,019 --> 00:25:04,559
momento pilla, vamos a probarlo

569
00:25:04,559 --> 00:25:12,779
¿veis? me lo ha dado, no puedo hacerlo así

570
00:25:12,779 --> 00:25:15,000
vale, pues para esto

571
00:25:15,000 --> 00:25:16,700
a falta de la programación funcional

572
00:25:16,700 --> 00:25:17,680
que sería la buena

573
00:25:17,680 --> 00:25:19,900
yo lo puedo hacer con

574
00:25:19,900 --> 00:25:21,759
el iterador

575
00:25:21,759 --> 00:25:25,390
entonces ponemos aquí

576
00:25:25,390 --> 00:25:27,529
esto

577
00:25:27,529 --> 00:25:30,809
error

578
00:25:30,809 --> 00:25:32,769
concurrencia

579
00:25:32,769 --> 00:25:34,589
vale, ¿cómo lo podríamos

580
00:25:34,589 --> 00:25:35,890
hacer sin que eso

581
00:25:35,890 --> 00:25:38,690
pues con un iterador? entonces

582
00:25:38,690 --> 00:25:40,569
me cojo yo

583
00:25:40,569 --> 00:25:42,369
mi iterador, vale

584
00:25:42,369 --> 00:25:44,710
aquí con el iterador

585
00:25:44,710 --> 00:25:45,869
ya he terminado

586
00:25:45,869 --> 00:25:48,029
pues vamos a volver a generarlo

587
00:25:48,029 --> 00:25:50,470
porque después del bucle

588
00:25:50,470 --> 00:25:51,769
de arriba ya lo he

589
00:25:51,769 --> 00:25:54,529
ya lo he

590
00:25:54,529 --> 00:26:01,049
vale, me cojo mi iterador

591
00:26:01,049 --> 00:26:02,769
y voy recorriendo

592
00:26:02,769 --> 00:26:04,930
y ahora

593
00:26:04,930 --> 00:26:06,630
¿qué puedo hacer yo con el iterador?

594
00:26:06,789 --> 00:26:07,549
pues si n

595
00:26:07,549 --> 00:26:10,910
resulta que

596
00:26:10,910 --> 00:26:12,750
charat 0

597
00:26:12,750 --> 00:26:16,940
es igual a la

598
00:26:16,940 --> 00:26:18,980
cumple el criterio que quiero borrar

599
00:26:18,980 --> 00:26:21,400
a cero

600
00:26:21,400 --> 00:26:24,579
igual a a

601
00:26:24,579 --> 00:26:27,519
pues entonces a través del iterador

602
00:26:27,519 --> 00:26:30,420
puedo borrar sin problema

603
00:26:30,420 --> 00:26:34,940
es decir, el iterador no vale solo para apuntar

604
00:26:34,940 --> 00:26:37,700
a través de elit.next me devuelve el objeto

605
00:26:37,700 --> 00:26:41,000
y se queda apuntando a él, sino que además lo puede borrar

606
00:26:41,000 --> 00:26:44,000
y esto lo hace ya protegiendo

607
00:26:44,000 --> 00:26:45,880
Toda esa concurrencia

608
00:26:45,880 --> 00:26:47,259
Y no nos vamos a encontrar aquí el problema

609
00:26:47,259 --> 00:26:50,319
Entonces vamos a volver a mostrar la colección aquí

610
00:26:50,319 --> 00:26:52,039
Para ver si lo ha borrado

611
00:26:52,039 --> 00:27:00,000
Bueno, a ver, es que estoy haciendo la prueba

612
00:27:00,000 --> 00:27:01,640
Que borre directamente el que empieza por A

613
00:27:01,640 --> 00:27:03,880
Podría pasarlo por parámetro, es solamente para hacer la prueba

614
00:27:03,880 --> 00:27:04,579
De cómo funciona

615
00:27:04,579 --> 00:27:08,819
El que le tengo que pasar como parámetro

616
00:27:08,819 --> 00:27:11,859
El it se queda apuntando

617
00:27:11,859 --> 00:27:14,079
El it es que ya está apuntando al objeto en el que está

618
00:27:14,079 --> 00:27:16,420
Cada it.next le deja colocado en uno

619
00:27:16,420 --> 00:27:17,619
Y ahí se queda colocado

620
00:27:17,619 --> 00:27:19,740
Y hasta que tú no hagas otro it.next

621
00:27:19,740 --> 00:27:20,819
No avanza el siguiente

622
00:27:20,819 --> 00:27:23,200
Y aquel en el que está colocado

623
00:27:23,200 --> 00:27:26,000
Pues te lo puede borrar con it.remove

624
00:27:26,000 --> 00:27:27,099
En el que está colocado

625
00:27:27,099 --> 00:27:29,819
Entonces si ahora mostramos otra vez la colección

626
00:27:29,819 --> 00:27:33,980
Pues esto que es lo que da error

627
00:27:33,980 --> 00:27:35,200
Lo voy a dejar comentado

628
00:27:35,200 --> 00:27:39,859
Que era lo que nos daba error

629
00:27:39,859 --> 00:27:42,799
Y ahora si lo ejecutamos otra vez

630
00:27:42,799 --> 00:27:46,200
Pues efectivamente me ha borrado

631
00:27:46,200 --> 00:27:48,519
Al primero, al que empezaba por a

632
00:27:53,700 --> 00:28:04,599
¿Vale? Luego

633
00:28:04,599 --> 00:28:07,789
Sí

634
00:28:07,789 --> 00:28:13,819
Pues eliminar

635
00:28:13,819 --> 00:28:16,619
A falta de programación funcional

636
00:28:16,619 --> 00:28:18,099
Eliminaremos con un iterador

637
00:28:18,099 --> 00:28:21,119
De una colección

638
00:28:21,119 --> 00:28:22,259
Y esto que hago

639
00:28:22,259 --> 00:28:24,799
Aplica igual, me da igual que sea una lista que un conjunto

640
00:28:24,799 --> 00:28:26,700
Esto de iterador es igual

641
00:28:26,700 --> 00:28:28,779
En ambos casos funciona igual

642
00:28:28,779 --> 00:28:30,259
Me da igual lista de conjunto

643
00:28:30,259 --> 00:28:32,240
¿Vale? Para cualquier colección, me da igual

644
00:28:32,240 --> 00:28:37,210
Vale

645
00:28:37,210 --> 00:28:40,069
Entonces, añadir está claro

646
00:28:40,069 --> 00:28:42,130
add, los métodos de add all

647
00:28:42,130 --> 00:28:43,750
remove all, todo eso funciona

648
00:28:43,750 --> 00:28:45,890
el remove funciona, por ejemplo

649
00:28:45,890 --> 00:28:47,849
que yo quiero borrar a Bea

650
00:28:47,849 --> 00:28:51,710
pues no hay ningún problema

651
00:28:51,710 --> 00:28:53,250
esto funciona

652
00:28:53,250 --> 00:28:54,029
¿vale?

653
00:28:55,269 --> 00:28:57,670
esto funciona igual que las listas

654
00:28:57,670 --> 00:28:58,210
por ejemplo

655
00:28:58,210 --> 00:29:01,069
que yo quiero borrar ahora un elemento

656
00:29:01,069 --> 00:29:03,309
pues el remove funciona igual que en las listas

657
00:29:03,309 --> 00:29:05,589
igual, yo le paso el elemento

658
00:29:05,589 --> 00:29:07,130
y me borra

659
00:29:07,130 --> 00:29:09,529
aquí no hace falta que diga yo el primero que

660
00:29:09,529 --> 00:29:11,430
encuentre igual a Bea, es que aquí

661
00:29:11,430 --> 00:29:12,730
solo puede haber uno igual a Bea

662
00:29:12,730 --> 00:29:14,130
entonces me borra a Bea

663
00:29:14,130 --> 00:29:16,750
sin embargo en una lista

664
00:29:16,750 --> 00:29:19,490
me borraba el primero que encontraba igual

665
00:29:19,490 --> 00:29:21,609
aquí me borra directamente

666
00:29:21,609 --> 00:29:23,230
la única instancia que puede haber

667
00:29:23,230 --> 00:29:26,559
de este, vale

668
00:29:26,559 --> 00:29:27,440
de hecho si

669
00:29:27,440 --> 00:29:30,839
si, te devuelve un boolean para ver si borró

670
00:29:30,839 --> 00:29:31,940
alguno o si no lo borró

671
00:29:31,940 --> 00:29:34,920
vale, pero es que aquí solo puede haber

672
00:29:34,920 --> 00:29:35,880
un Bea entonces

673
00:29:35,880 --> 00:29:40,059
de hecho para añadir

674
00:29:40,059 --> 00:29:42,000
vamos a suponer que añadimos

675
00:29:42,000 --> 00:29:46,299
aquí al principio de todo que yo tengo

676
00:29:46,299 --> 00:30:02,259
ya a estos tres, vamos a añadir uno que ya está. Vamos a añadir a Juan otra vez, ¿vale?

677
00:30:02,259 --> 00:30:13,519
Y vamos a mostrar otra vez cuántos tiene. Pues este ad no ha añadido nada, porque ya

678
00:30:13,519 --> 00:30:21,359
hay uno igual. Veremos que aquí hay tres y que aquí hay tres, ¿vale? ¿Veis? Tres

679
00:30:21,359 --> 00:30:33,930
y 3 no ha añadido nada vale eso es lo siguiente es que es muy lista y te adelantas sí pero este

680
00:30:33,930 --> 00:30:38,930
objeto lo hemos hecho nosotros entonces efectivamente bueno paramos en un minutos

681
00:30:43,930 --> 00:30:44,410
un momentito