1
00:00:00,500 --> 00:00:11,919
Bueno, pues entonces esto que hemos visto

2
00:00:11,919 --> 00:00:16,500
es como ya sabemos

3
00:00:16,500 --> 00:00:18,420
una clase que ya está hecha

4
00:00:18,420 --> 00:00:20,559
luego no tenemos que usar

5
00:00:20,559 --> 00:00:22,460
nuestro miArrayList chulo

6
00:00:22,460 --> 00:00:23,679
ni miArrayList nada

7
00:00:23,679 --> 00:00:26,579
nada de eso, porque ya hay una clase

8
00:00:26,579 --> 00:00:28,399
que está hecha

9
00:00:28,399 --> 00:00:33,539
que es ArrayList

10
00:00:33,539 --> 00:00:35,479
que está ya

11
00:00:35,479 --> 00:00:38,399
en todas las clases

12
00:00:38,399 --> 00:00:39,780
que distribuye

13
00:00:39,780 --> 00:00:41,359
el JDK

14
00:00:41,359 --> 00:00:43,439
para que nosotros las podamos usar

15
00:00:43,439 --> 00:00:44,500
y que están en la JR

16
00:00:44,500 --> 00:00:47,960
pues esa clase ya existe

17
00:00:47,960 --> 00:00:48,780
¿vale?

18
00:00:48,820 --> 00:00:49,859
que está en particular

19
00:00:49,859 --> 00:00:51,399
dentro

20
00:00:51,399 --> 00:00:56,810
del paquete Java útil

21
00:00:56,810 --> 00:00:57,530
¿vale?

22
00:00:57,570 --> 00:00:58,689
dentro del paquete Java útil

23
00:00:58,689 --> 00:00:59,509
está esta clase

24
00:00:59,509 --> 00:01:01,750
¿cómo pasa?

25
00:01:02,810 --> 00:01:28,109
Vale, pues esto es un ejemplo de colección, ¿vale? Forma parte de lo que en Java entendemos por colecciones, ¿vale? Esto es un ejemplo de lo que llamamos colecciones.

26
00:01:28,109 --> 00:01:29,370
Es un ejemplo

27
00:01:29,370 --> 00:01:31,049
Que está hecho por dentro

28
00:01:31,049 --> 00:01:32,469
Pues como hemos hecho nosotros

29
00:01:32,469 --> 00:01:33,810
Tal cual

30
00:01:33,810 --> 00:01:35,849
Lo que pasa es que, bueno, incorpora

31
00:01:35,849 --> 00:01:37,950
Pues más métodos, más validaciones

32
00:01:37,950 --> 00:01:40,069
Temas de excepciones

33
00:01:40,069 --> 00:01:41,290
Que nosotros no hemos visto todavía

34
00:01:41,290 --> 00:01:42,650
Está más pulida

35
00:01:42,650 --> 00:01:45,150
Nuestra versión está muy cutre, obviamente

36
00:01:45,150 --> 00:01:47,969
Pero es lo mismo, conceptualmente es lo mismo

37
00:01:47,969 --> 00:01:49,010
Es un array, es lo mismo

38
00:01:49,010 --> 00:01:50,290
Pero está más pulido

39
00:01:50,290 --> 00:01:51,750
Pues es el ArrayList

40
00:01:51,750 --> 00:01:54,769
Y forma parte

41
00:01:54,769 --> 00:02:00,920
Y forma parte

42
00:02:00,920 --> 00:02:02,019
de lo que en Java

43
00:02:02,019 --> 00:02:03,120
llamamos colecciones

44
00:02:03,120 --> 00:02:06,299
vale, pues que son las colecciones

45
00:02:06,299 --> 00:02:08,280
las colecciones son

46
00:02:08,280 --> 00:02:11,810
clases que están

47
00:02:11,810 --> 00:02:13,889
pensadas, diseñadas

48
00:02:13,889 --> 00:02:17,599
para

49
00:02:17,599 --> 00:02:18,639
guardar

50
00:02:18,639 --> 00:02:20,759
datos

51
00:02:20,759 --> 00:02:28,500
vale, esas

52
00:02:28,500 --> 00:02:30,319
son las colecciones, clases que están

53
00:02:30,319 --> 00:02:32,120
diseñadas para guardar datos, como

54
00:02:32,120 --> 00:02:32,800
ArrayList

55
00:02:32,800 --> 00:02:36,319
vale, pero ArrayList no es

56
00:02:36,319 --> 00:02:36,780
la única

57
00:02:36,780 --> 00:02:38,960
hay muchas

58
00:02:38,960 --> 00:02:42,379
no hay tampoco tantas

59
00:02:42,379 --> 00:02:43,199
hay unas cuantas

60
00:02:43,199 --> 00:02:46,219
y esencialmente las podemos dividir

61
00:02:46,219 --> 00:02:47,319
en dos tipos

62
00:02:47,319 --> 00:02:48,599
¿vale?

63
00:02:51,599 --> 00:02:53,800
entonces las colecciones en Java

64
00:02:53,800 --> 00:02:59,969
se dividen en dos tipos

65
00:02:59,969 --> 00:03:01,129
tenemos

66
00:03:01,129 --> 00:03:08,280
listas y conjuntos

67
00:03:11,639 --> 00:03:12,039
¿vale?

68
00:03:13,139 --> 00:03:14,400
lo que viene a ser

69
00:03:14,400 --> 00:03:18,560
las list y los set

70
00:03:18,560 --> 00:03:37,259
Eso serían las colecciones, ¿vale? Listas y conjuntos. Vale, hay dos tipos en función de cómo funcionan por debajo, cómo estén implementadas por debajo, ¿vale? Pero ¿en qué se traduce eso de vistas hacia afuera? ¿En qué se traduce?

71
00:03:37,259 --> 00:03:42,159
¿Cuál es la distinción que nosotros vemos desde fuera cuando las usamos?

72
00:03:42,979 --> 00:03:46,860
Pues que las listas tienen orden

73
00:03:46,860 --> 00:03:58,419
Y los conjuntos no tienen orden

74
00:03:58,419 --> 00:04:03,400
Esa es la diferencia entre las listas y los conjuntos

75
00:04:03,400 --> 00:04:07,180
Es decir, una lista tenemos que verla

76
00:04:07,180 --> 00:04:10,580
como una filita

77
00:04:10,580 --> 00:04:11,139
de cosas

78
00:04:11,139 --> 00:04:14,479
en esa filita van los elementos

79
00:04:14,479 --> 00:04:16,759
¿vale? ahí van los elementos

80
00:04:16,759 --> 00:04:18,300
y cada elemento

81
00:04:18,300 --> 00:04:19,819
está en una posición

82
00:04:19,819 --> 00:04:22,500
eso significa que tiene orden, que está en una posición

83
00:04:22,500 --> 00:04:24,160
este elemento está en la cero

84
00:04:24,160 --> 00:04:26,139
y este está en la uno y este está en la dos

85
00:04:26,139 --> 00:04:28,620
los elementos tienen una posición asociada

86
00:04:28,620 --> 00:04:30,100
con tener orden

87
00:04:30,100 --> 00:04:31,439
quizá es más

88
00:04:31,439 --> 00:04:34,259
se entiende mejor el decir

89
00:04:34,259 --> 00:04:36,000
que tienen

90
00:04:36,000 --> 00:04:40,519
posición asociada, ¿vale?

91
00:04:40,540 --> 00:04:41,480
Se entiende mejor así.

92
00:04:49,790 --> 00:04:52,589
Cada elemento está en una posición de la caja.

93
00:04:52,750 --> 00:04:53,949
La 0, la 1, la 2.

94
00:04:54,550 --> 00:04:56,149
Y los elementos ya cada uno es el que sea.

95
00:04:56,370 --> 00:04:57,490
Eso ya nos da igual, ¿vale?

96
00:04:58,209 --> 00:05:00,029
Sin embargo, en un conjunto los elementos

97
00:05:00,029 --> 00:05:01,709
están todos ahí, pum, a mogollón.

98
00:05:02,670 --> 00:05:04,490
Ninguno tiene una posición asociada.

99
00:05:05,089 --> 00:05:05,949
Es un conjunto

100
00:05:05,949 --> 00:05:07,310
de toda la vida.

101
00:05:10,000 --> 00:05:11,839
Cuando metemos un elemento al set

102
00:05:11,839 --> 00:05:13,899
o conjunto, ahí va.

103
00:05:14,339 --> 00:05:15,019
Sin una posición.

104
00:05:16,220 --> 00:05:19,779
¿Vale? Luego,

105
00:05:19,819 --> 00:05:22,639
esto ya se traduce en muchos

106
00:05:22,639 --> 00:05:25,180
pequeños aspectos prácticos, por ejemplo

107
00:05:25,180 --> 00:05:27,759
en las listas

108
00:05:27,759 --> 00:05:29,199
podemos meter dos elementos

109
00:05:29,199 --> 00:05:31,259
iguales, imaginaos que es

110
00:05:31,259 --> 00:05:33,060
de números, yo puedo meter

111
00:05:33,060 --> 00:05:35,180
el 3 y aquí puedo meter

112
00:05:35,180 --> 00:05:37,439
el 3, no pasa nada

113
00:05:37,439 --> 00:05:39,319
porque se distinguen

114
00:05:39,319 --> 00:05:41,279
por la posición, este es

115
00:05:41,279 --> 00:05:42,819
el 3 que está en la posición 0

116
00:05:42,819 --> 00:05:45,220
y este es el 3 que está en la

117
00:05:45,220 --> 00:05:46,980
posición 4

118
00:05:46,980 --> 00:05:49,100
es decir

119
00:05:49,100 --> 00:05:51,360
el que los elementos

120
00:05:51,360 --> 00:05:53,240
de la lista tengan una

121
00:05:53,240 --> 00:05:54,860
posición asociada

122
00:05:54,860 --> 00:05:57,620
implica automáticamente que puede

123
00:05:57,620 --> 00:05:59,019
haber

124
00:05:59,019 --> 00:06:01,399
elementos duplicados

125
00:06:01,399 --> 00:06:03,220
esa es la implicación

126
00:06:03,220 --> 00:06:04,439
puede haber

127
00:06:04,439 --> 00:06:06,379
elementos

128
00:06:06,379 --> 00:06:10,339
duplicados, ¿vale?

129
00:06:16,160 --> 00:06:18,040
vale, en un conjunto

130
00:06:18,040 --> 00:06:19,899
no puede haber elementos duplicados

131
00:06:19,899 --> 00:06:21,500
si yo al conjunto le hago un add

132
00:06:21,500 --> 00:06:23,939
y le meto el 3, por aquí

133
00:06:23,939 --> 00:06:26,639
y ahora

134
00:06:26,639 --> 00:06:29,100
le vuelvo a intentar meter el 3

135
00:06:29,100 --> 00:06:31,459
vuelvo a hacer add de 3

136
00:06:31,459 --> 00:06:33,519
no lo va a meter

137
00:06:33,519 --> 00:06:35,019
porque ya ve que hay uno

138
00:06:35,019 --> 00:06:37,079
entonces no puede meterlo

139
00:06:37,079 --> 00:06:39,480
porque el otro 3 se confundiría

140
00:06:39,480 --> 00:06:41,480
con este, porque no tiene posición asociada

141
00:06:41,480 --> 00:06:43,740
¿y si te avisaría de alguna manera o directamente no lo hace?

142
00:06:43,819 --> 00:06:44,360
no lo hace

143
00:06:44,360 --> 00:06:46,959
luego ya los usos concretos de cada una

144
00:06:46,959 --> 00:06:47,800
ya lo vamos viendo

145
00:06:47,800 --> 00:06:51,120
no puede

146
00:06:51,120 --> 00:06:53,120
haber en un conjunto, no puede haber

147
00:06:53,120 --> 00:06:55,199
dos elementos iguales, porque directamente

148
00:06:55,199 --> 00:06:56,420
el segundo elemento

149
00:06:56,420 --> 00:06:58,279
no lo inserta

150
00:06:58,279 --> 00:07:00,420
ve que hay uno igual, no lo inserta

151
00:07:00,420 --> 00:07:01,720
¿por qué? porque habría una

152
00:07:01,720 --> 00:07:04,139
habría aquí una ambigüedad

153
00:07:04,139 --> 00:07:06,319
yo ya tengo un 3, ese otro 3

154
00:07:06,319 --> 00:07:08,379
¿qué hago con él? es que no lo puedo distinguir del otro

155
00:07:08,379 --> 00:07:10,079
es imposible, no puedo distinguirlo

156
00:07:10,079 --> 00:07:12,560
aquí los puedo distinguir por posición

157
00:07:12,560 --> 00:07:14,819
aquí al no haber posiciones

158
00:07:14,819 --> 00:07:16,660
no puedo distinguirlo, luego no admite

159
00:07:16,660 --> 00:07:17,379
duplicados

160
00:07:17,379 --> 00:07:20,420
esa es la diferencia entre los

161
00:07:20,420 --> 00:07:22,560
sets

162
00:07:22,560 --> 00:07:24,339
y los conjuntos, y las listas

163
00:07:24,339 --> 00:07:49,209
Entonces, en aplicaciones en las cuales la posición para mí no tenga ningún interés, porque yo no necesito duplicados, en las que no tenga ningún interés la posición, yo quiero meter los elementos ahí y ya está, para luego recorrer, a ver los que hay, eliminarlos si quiero, lógicamente.

164
00:07:49,209 --> 00:08:06,250
Si yo quiero simplemente tener un almacén de datos y ese almacén, pues luego ya para recorrerlo, para eliminar uno, eliminar el tres, para insertar otro nuevo, una colección sin más, donde el hecho de que estén en filita no me aporta nada, pues entonces siempre cogeré un set.

165
00:08:06,250 --> 00:08:09,110
¿por qué? porque su implementación

166
00:08:09,110 --> 00:08:11,290
interna es más eficiente

167
00:08:11,290 --> 00:08:13,209
porque aquí

168
00:08:13,209 --> 00:08:15,069
la implementación interna tiene que

169
00:08:15,069 --> 00:08:16,250
gestionar las posiciones

170
00:08:16,250 --> 00:08:19,589
porque cada elemento se caracteriza

171
00:08:19,589 --> 00:08:20,209
en una posición

172
00:08:20,209 --> 00:08:23,290
entonces siempre hay más

173
00:08:23,290 --> 00:08:24,170
complejidad

174
00:08:24,170 --> 00:08:27,170
en la gestión y el uso

175
00:08:27,170 --> 00:08:29,250
de una lista

176
00:08:29,250 --> 00:08:31,250
que de un conjunto, porque no tienes

177
00:08:31,250 --> 00:08:32,549
aquí

178
00:08:32,549 --> 00:08:34,570
no hay que gestionar las posiciones

179
00:08:34,570 --> 00:08:36,889
entonces si que haya duplicados

180
00:08:36,889 --> 00:08:39,009
que estén en filita

181
00:08:39,009 --> 00:08:40,669
no me aporta nada, no es algo

182
00:08:40,669 --> 00:08:42,830
que yo necesite para mi aplicación

183
00:08:42,830 --> 00:08:44,809
por las características de lo que mi aplicación

184
00:08:44,809 --> 00:08:46,389
tiene que hacer, nunca se habían peinado

185
00:08:46,389 --> 00:08:48,870
mientras daba clase, nunca jamás

186
00:08:48,870 --> 00:08:52,710
la primera vez que me ocurre eso

187
00:08:52,710 --> 00:08:54,669
¿cómo va a ser lo siguiente que me pase?

188
00:08:55,470 --> 00:08:56,110
que me peine yo

189
00:08:56,110 --> 00:08:56,710
¿qué otra cosa?

190
00:08:56,710 --> 00:09:05,049
no tienes ninguna necesidad

191
00:09:05,049 --> 00:09:08,049
ya me refiero

192
00:09:08,049 --> 00:09:08,870
bueno, da igual

193
00:09:08,870 --> 00:09:11,649
no de peinarte

194
00:09:11,649 --> 00:09:12,389
sino de tener pelo

195
00:09:12,389 --> 00:09:12,990
quiero decir

196
00:09:12,990 --> 00:09:14,149
bueno, depende

197
00:09:14,149 --> 00:09:16,889
y las gorras

198
00:09:16,889 --> 00:09:20,929
bueno, pues entonces

199
00:09:20,929 --> 00:09:22,190
siempre cogeríamos un 6

200
00:09:22,190 --> 00:09:22,590
¿vale?

201
00:09:23,190 --> 00:09:24,649
los detalles de implementación

202
00:09:24,649 --> 00:09:25,330
y de uso

203
00:09:25,330 --> 00:09:26,049
y de todo eso

204
00:09:26,049 --> 00:09:27,049
ya los veremos

205
00:09:27,049 --> 00:09:27,730
lógicamente

206
00:09:27,730 --> 00:09:28,830
ya los veremos

207
00:09:28,830 --> 00:09:29,850
ahora estamos solamente

208
00:09:29,850 --> 00:09:32,029
describiendo

209
00:09:32,029 --> 00:09:32,830
de qué va el rollo

210
00:09:32,830 --> 00:09:33,809
ya los detalles

211
00:09:33,809 --> 00:09:34,590
de implementación

212
00:09:34,590 --> 00:09:35,450
los ejemplos que hay

213
00:09:35,450 --> 00:09:36,149
ya los iremos viendo

214
00:09:36,149 --> 00:09:36,909
¿vale?

215
00:09:37,830 --> 00:09:38,570
bueno pues tenemos

216
00:09:38,570 --> 00:09:39,350
estos dos tipos

217
00:09:39,350 --> 00:09:40,750
listas y conjuntos

218
00:09:40,750 --> 00:09:42,110
el ArrayList

219
00:09:42,110 --> 00:09:43,230
que hemos hecho nosotros

220
00:09:43,230 --> 00:09:44,169
que es ya digo

221
00:09:44,169 --> 00:09:46,870
similar al ArrayList

222
00:09:46,870 --> 00:09:47,830
que está hecho

223
00:09:47,830 --> 00:09:49,090
porque son iguales

224
00:09:49,090 --> 00:09:49,830
en cuanto a que los dos

225
00:09:49,830 --> 00:09:50,830
tienen un Array por debajo

226
00:09:50,830 --> 00:09:52,129
con los métodos

227
00:09:52,129 --> 00:09:52,750
que incorpora

228
00:09:52,750 --> 00:09:54,370
es una lista

229
00:09:54,370 --> 00:09:56,289
es una lista

230
00:09:56,289 --> 00:09:58,409
porque los elementos tienen una posición

231
00:09:58,409 --> 00:10:00,129
asociada, yo los puedo recuperar por posición

232
00:10:00,129 --> 00:10:02,129
de hecho hemos hecho el get 0

233
00:10:02,129 --> 00:10:04,490
para recuperar el 0, el get 1 para recuperar el 1

234
00:10:04,490 --> 00:10:06,149
luego la clase que hemos hecho

235
00:10:06,149 --> 00:10:08,230
miArrayList tiene una posición

236
00:10:08,230 --> 00:10:10,090
asociada, luego es una lista

237
00:10:10,090 --> 00:10:11,629
¿vale?

238
00:10:13,090 --> 00:10:14,230
no es la única

239
00:10:14,230 --> 00:10:16,230
implementación posible de listas

240
00:10:16,230 --> 00:10:17,610
que tenemos

241
00:10:17,610 --> 00:10:23,710
hay otro tipo

242
00:10:23,710 --> 00:10:25,049
de lista que podemos hacer

243
00:10:25,049 --> 00:10:31,419
luego, vámonos

244
00:10:31,419 --> 00:10:33,080
ahora las listas, ¿vale?

245
00:10:33,700 --> 00:10:35,299
Listas, conjuntos, los dos tipos

246
00:10:35,299 --> 00:10:37,360
de colecciones que tenemos. Vámonos ahora

247
00:10:37,360 --> 00:10:39,139
más en detalle a las listas, ¿vale?

248
00:10:42,019 --> 00:10:42,799
La lista

249
00:10:42,799 --> 00:10:45,399
es un objeto que uno puede instanciar

250
00:10:45,399 --> 00:10:47,139
para meter elementos

251
00:10:47,139 --> 00:10:49,100
en ella y cada elemento con una posición,

252
00:10:49,679 --> 00:10:49,899
¿vale?

253
00:10:50,940 --> 00:10:52,960
Bueno, pues, ¿qué listas tenemos ya hechas en

254
00:10:52,960 --> 00:10:57,470
Java para usar? Tenemos

255
00:10:57,470 --> 00:11:01,279
el ArrayList, que ya

256
00:11:01,279 --> 00:11:03,279
sabemos cómo está hecha por dentro, tiene un

257
00:11:03,279 --> 00:11:05,320
Array genérico, luego tú cuando

258
00:11:05,320 --> 00:11:07,320
lo instancias le das el tipo, o sea, es una clase

259
00:11:07,320 --> 00:11:08,360
como la que hemos hecho nosotros

260
00:11:08,360 --> 00:11:10,440
añade más métodos

261
00:11:10,440 --> 00:11:11,100
lógicamente

262
00:11:11,100 --> 00:11:12,399
para poder hacer más cosas

263
00:11:12,399 --> 00:11:14,220
y gestiona excepciones

264
00:11:14,220 --> 00:11:15,460
que eso no lo hemos gestionado nosotros

265
00:11:15,460 --> 00:11:16,120
pues no sabemos

266
00:11:16,120 --> 00:11:17,679
pero salvo eso

267
00:11:17,679 --> 00:11:18,639
es la que hemos hecho

268
00:11:18,639 --> 00:11:20,480
luego tenemos el ArrayList

269
00:11:20,480 --> 00:11:21,559
que uno instancia

270
00:11:21,559 --> 00:11:22,279
y mete cosas

271
00:11:22,279 --> 00:11:23,200
y cada cosa cae

272
00:11:23,200 --> 00:11:24,840
en una posición sí o sí

273
00:11:24,840 --> 00:11:27,559
pero ¿qué le pasa al ArrayList?

274
00:11:28,100 --> 00:11:28,899
que precisamente

275
00:11:28,899 --> 00:11:30,679
como nosotros sabemos programar

276
00:11:30,679 --> 00:11:32,220
pues sabemos

277
00:11:32,220 --> 00:11:33,500
que cuando uno hace add

278
00:11:33,500 --> 00:11:35,659
se queda tan tranquilo

279
00:11:35,659 --> 00:11:36,740
hecho add

280
00:11:36,740 --> 00:11:38,860
que a gusto, una línea de código

281
00:11:38,860 --> 00:11:41,220
que programa más corto, de corto nada

282
00:11:41,220 --> 00:11:42,559
ese add

283
00:11:42,559 --> 00:11:45,100
ahora, menudo pifostio

284
00:11:45,100 --> 00:11:46,200
que ha hecho él

285
00:11:46,200 --> 00:11:49,159
ese add ha creado

286
00:11:49,159 --> 00:11:50,559
otro array, ha copiado

287
00:11:50,559 --> 00:11:53,139
ha sobrescrito el otro array

288
00:11:53,139 --> 00:11:54,940
en este, este se tira a la basura

289
00:11:54,940 --> 00:11:57,080
o sea, lo que para nosotros se llamara add

290
00:11:57,080 --> 00:11:59,120
del array list, es un montón

291
00:11:59,120 --> 00:12:00,620
de líneas de código y muy

292
00:12:00,620 --> 00:12:03,039
complejas, son muy complejos

293
00:12:03,039 --> 00:12:04,460
crear otro array, borrar otro

294
00:12:04,460 --> 00:12:10,940
O sea, están, en un momento dado, van a estar coexistiendo dos arrays que pueden ser enormes.

295
00:12:11,340 --> 00:12:16,379
Imaginaos que tengo una lista, una array list de 300 posiciones y que voy a añadir el 301.

296
00:12:16,960 --> 00:12:20,299
Pues en un momento dado están coexistiendo dos arrays de 300.

297
00:12:21,139 --> 00:12:24,220
O sea, lo que para mí es hacer add no es trivial.

298
00:12:25,659 --> 00:12:28,000
El método add tiene dentro un montón de cosas.

299
00:12:29,259 --> 00:12:31,580
Y si llamamos a delete, pues ya ni te cuento.

300
00:12:31,580 --> 00:12:34,740
lo que para mí es

301
00:12:34,740 --> 00:12:36,700
oye elimina de la lista el número

302
00:12:36,700 --> 00:12:37,240
3

303
00:12:37,240 --> 00:12:40,539
lo que para mí es escribir delete usando

304
00:12:40,539 --> 00:12:42,679
este objeto ArrayList que he creado

305
00:12:42,679 --> 00:12:44,460
esto pues es un rollo

306
00:12:44,460 --> 00:12:46,700
porque es llamar aquí un método

307
00:12:46,700 --> 00:12:48,320
que ya sabemos lo que tendrá que hacer

308
00:12:48,320 --> 00:12:50,019
crear otro Array, copiar, ver si es

309
00:12:50,019 --> 00:12:51,500
un rollo

310
00:12:51,500 --> 00:12:55,789
bueno a cambio cuando hagamos get

311
00:12:55,789 --> 00:12:57,389
para recuperar por posición

312
00:12:57,389 --> 00:13:01,379
que bien como nos gusta

313
00:13:01,379 --> 00:13:03,320
el ArrayList porque ya sabemos que lo que

314
00:13:03,320 --> 00:13:05,480
haces, retúr la posición 7.

315
00:13:05,960 --> 00:13:06,480
Magnífico.

316
00:13:07,159 --> 00:13:08,480
Eso está muy bien.

317
00:13:09,820 --> 00:13:11,279
Vale. Pues, ¿qué quiero decir

318
00:13:11,279 --> 00:13:13,399
con todo esto? Que la ArrayList

319
00:13:13,399 --> 00:13:14,759
está estupendo

320
00:13:14,759 --> 00:13:17,120
para recuperar cuando yo quiero

321
00:13:17,120 --> 00:13:18,480
hacer consultas por posición,

322
00:13:19,360 --> 00:13:21,000
pero para insertar y borrar

323
00:13:21,000 --> 00:13:22,940
es un verdadero

324
00:13:22,940 --> 00:13:25,159
rollo, computacionalmente hablando.

325
00:13:26,379 --> 00:13:27,320
¿Vale? Si yo tengo

326
00:13:27,320 --> 00:13:29,220
pocos registros, perdón, pocos

327
00:13:29,220 --> 00:13:31,299
elementos, da un poco igual. Pero yo tengo

328
00:13:31,299 --> 00:13:33,700
muchos elementos, computacionalmente

329
00:13:33,700 --> 00:13:34,919
esto empieza a complicarse.

330
00:13:35,559 --> 00:13:37,179
Hay que crear arrays, romperlos.

331
00:13:38,580 --> 00:13:39,299
Luego, computacionalmente,

332
00:13:40,279 --> 00:13:41,399
cuando ya estamos ejecutando

333
00:13:41,399 --> 00:13:43,419
el programa, los ArrayList

334
00:13:43,419 --> 00:13:45,440
son muy poco eficientes

335
00:13:45,440 --> 00:13:47,340
para inserciones y borrados.

336
00:13:48,019 --> 00:13:48,200
¿Vale?

337
00:13:48,740 --> 00:13:51,580
Para inserciones y borrados son muy poco eficientes.

338
00:13:54,309 --> 00:13:54,909
Entonces, claro,

339
00:13:55,950 --> 00:13:57,250
¿va a ser esta la única

340
00:13:57,250 --> 00:13:59,409
lista que tengamos para guardar

341
00:13:59,409 --> 00:14:00,769
un montón de elementos con orden?

342
00:14:00,769 --> 00:14:00,830
¿Vale?

343
00:14:00,830 --> 00:14:03,570
que ya sé que computacionalmente

344
00:14:03,570 --> 00:14:05,210
es muy costosa para insertar

345
00:14:05,210 --> 00:14:06,309
y borrar, va a ser la única

346
00:14:06,309 --> 00:14:08,309
pues no, afortunadamente

347
00:14:08,309 --> 00:14:11,049
hay gente muy lista que se le ocurren

348
00:14:11,049 --> 00:14:13,110
otras cosas, de almacenar

349
00:14:13,110 --> 00:14:15,049
un montón de datos juntos, todos

350
00:14:15,049 --> 00:14:16,330
del mismo tipo

351
00:14:16,330 --> 00:14:19,230
de tal forma que las inserciones y los borrados

352
00:14:19,230 --> 00:14:21,049
sean mucho más

353
00:14:21,049 --> 00:14:22,129
cómodos que con un array

354
00:14:22,129 --> 00:14:25,639
y esa es la que se llama

355
00:14:25,639 --> 00:14:30,179
la linked list

356
00:14:30,179 --> 00:14:32,919
que son las dos listas que tenemos

357
00:14:32,919 --> 00:14:33,799
¿vale?

358
00:14:34,740 --> 00:14:36,860
Las dos valen para lo mismo

359
00:14:36,860 --> 00:14:38,120
Para tener un montón de datos

360
00:14:38,120 --> 00:14:40,620
Meter dentro datos

361
00:14:40,620 --> 00:14:43,240
Recorrerlos, sacarlos por posición

362
00:14:43,240 --> 00:14:45,340
Eliminarlos, las dos valen para lo mismo

363
00:14:45,340 --> 00:14:47,440
Pero la implementación interna

364
00:14:47,440 --> 00:14:48,120
Es distinta

365
00:14:48,120 --> 00:14:50,659
El ArrayList ya sabemos como está

366
00:14:50,659 --> 00:14:53,259
Hecho por dentro, ya lo sabemos, de hecho lo hemos hecho

367
00:14:53,259 --> 00:14:55,200
Y el ArrayList

368
00:14:55,200 --> 00:14:56,419
¿Cómo está hecho por dentro?

369
00:14:59,440 --> 00:14:59,919
Pues

370
00:14:59,919 --> 00:15:02,340
Uy

371
00:15:02,340 --> 00:15:03,659
Qué mal rollo

372
00:15:03,659 --> 00:15:08,500
Pues a ver, pregunto

373
00:15:08,500 --> 00:15:12,480
yo, si os ocurre

374
00:15:12,480 --> 00:15:14,200
no pongáis

375
00:15:14,200 --> 00:15:15,259
a teclar rápido el mensaje

376
00:15:15,259 --> 00:15:19,539
otra manera a nivel

377
00:15:19,539 --> 00:15:21,399
teórico, ahora es una pregunta muy

378
00:15:21,399 --> 00:15:23,399
muy compleja, si uno no lo ha visto antes

379
00:15:23,399 --> 00:15:25,500
el concepto, vale, no es que espera que me digan

380
00:15:25,500 --> 00:15:27,000
uy pues ya me ocurre esto, no, pero bueno

381
00:15:27,000 --> 00:15:29,539
igual os suena el concepto, lo habéis visto antes

382
00:15:29,539 --> 00:15:31,700
o lo que sea, otra forma

383
00:15:31,700 --> 00:15:33,700
de guardar un montón de datos

384
00:15:33,700 --> 00:15:35,700
porque este es nuestro problema, imaginaos que tenemos

385
00:15:35,700 --> 00:15:37,360
alumnos que guardar

386
00:15:37,360 --> 00:15:39,879
mi alumno con tres propiedades

387
00:15:39,879 --> 00:15:40,740
mi alumno

388
00:15:40,740 --> 00:15:42,200
mi alumno

389
00:15:42,200 --> 00:15:45,139
mi alumno

390
00:15:45,139 --> 00:15:47,500
los queremos guardar todos juntos

391
00:15:47,500 --> 00:15:49,159
bajo una única referencia

392
00:15:49,159 --> 00:15:49,919
que esa es la idea

393
00:15:49,919 --> 00:15:51,639
para luego poder tratarlos conjuntamente

394
00:15:51,639 --> 00:15:52,440
para recorrer

395
00:15:52,440 --> 00:15:55,500
una de las ideas ya está

396
00:15:55,500 --> 00:15:56,320
ya está vista

397
00:15:56,320 --> 00:15:57,120
ya la conocemos

398
00:15:57,120 --> 00:15:58,779
que es ala todos a un array

399
00:15:58,779 --> 00:16:00,620
vale una de las ideas ya está

400
00:16:00,620 --> 00:16:02,340
todos a un array

401
00:16:02,340 --> 00:16:04,580
ahí están todos juntitos

402
00:16:04,580 --> 00:16:07,360
bajo la referencia de mi objeto array

403
00:16:07,360 --> 00:16:08,320
ala todos ahí

404
00:16:08,320 --> 00:16:09,960
esa solución

405
00:16:09,960 --> 00:16:11,740
es la del array list

406
00:16:11,740 --> 00:16:14,500
¿Vale? Todos a la raíz

407
00:16:14,500 --> 00:16:15,860
Ahí están

408
00:16:15,860 --> 00:16:18,539
Ahí recorro, meto uno nuevo

409
00:16:18,539 --> 00:16:19,100
Lo que quiera

410
00:16:19,100 --> 00:16:22,220
Pero esta solución, pues ya hemos dicho

411
00:16:22,220 --> 00:16:23,000
Que es costosa

412
00:16:23,000 --> 00:16:25,419
Para inserciones y borrados

413
00:16:25,419 --> 00:16:30,240
Entonces, ahora

414
00:16:30,240 --> 00:16:31,980
Pregunto yo

415
00:16:31,980 --> 00:16:34,460
¿Se nos ocurriría otra manera de guardar

416
00:16:34,460 --> 00:16:36,360
Un montón de datos como estos

417
00:16:36,360 --> 00:16:38,700
Bajo una única referencia

418
00:16:38,700 --> 00:16:39,720
Que me permita a mí

419
00:16:39,720 --> 00:16:41,399
Bajo esa referencia

420
00:16:41,399 --> 00:16:43,879
objeto, como lo queréis llamar, referencia

421
00:16:43,879 --> 00:16:45,919
objeto, tenerlos todos ahí accesibles

422
00:16:45,919 --> 00:16:47,879
para recorrerlos, para meter

423
00:16:47,879 --> 00:16:52,549
uno nuevo, una pregunta

424
00:16:52,549 --> 00:16:57,830
complicada, ¿verdad? A ver, es una

425
00:16:57,830 --> 00:16:58,750
pregunta complicada

426
00:16:58,750 --> 00:17:01,190
la idea de fondo

427
00:17:01,190 --> 00:17:03,830
es el concepto

428
00:17:04,490 --> 00:17:05,910
de informática de toda la vida

429
00:17:05,910 --> 00:17:08,049
que es el de una lista enlazada

430
00:17:08,049 --> 00:17:09,710
es decir

431
00:17:09,710 --> 00:17:11,150
¿qué idea es la más natural?

432
00:17:12,210 --> 00:17:13,690
¿vale? pues que cada uno

433
00:17:13,690 --> 00:17:15,930
o sea, que tenga yo

434
00:17:15,930 --> 00:17:17,990
aquí mi objeto. Esta es mi referencia.

435
00:17:20,609 --> 00:17:21,890
Debajo de esta es de la que

436
00:17:21,890 --> 00:17:23,950
quiero que cuelguen todos. A través de

437
00:17:23,950 --> 00:17:25,710
ella quiero poder acceder a todos, como la de la

438
00:17:25,710 --> 00:17:27,869
array, que a través de la referencia de la array accedo a

439
00:17:27,869 --> 00:17:29,730
todos. Pues a través de esta

440
00:17:29,730 --> 00:17:31,789
quiero poder acceder a

441
00:17:31,789 --> 00:17:33,970
todos. Vale, pues ¿cómo podemos

442
00:17:33,970 --> 00:17:35,690
hacer? Yo

443
00:17:35,690 --> 00:17:39,589
accedo al primero,

444
00:17:39,769 --> 00:17:41,869
que mi referencia me lleve al primero

445
00:17:41,869 --> 00:17:43,890
y cada uno que lleve

446
00:17:43,890 --> 00:17:44,869
de la manita al siguiente.

447
00:17:46,089 --> 00:17:46,910
Podemos llevar,

448
00:17:46,910 --> 00:17:50,109
sacar de excursión a los niños de primero de infantil

449
00:17:50,109 --> 00:17:51,930
los podemos meter a todos

450
00:17:51,930 --> 00:17:54,089
en el autobús, pum, y van todos en el autobús

451
00:17:54,089 --> 00:17:55,890
o los podemos

452
00:17:55,890 --> 00:17:57,049
o podemos coger al primero

453
00:17:57,049 --> 00:18:00,130
y que el primero dé de la mano al segundo y vayan todos de la manita

454
00:18:00,130 --> 00:18:01,049
y nosotros llevamos al primero

455
00:18:01,049 --> 00:18:03,029
o los llevamos en un autobús

456
00:18:03,029 --> 00:18:05,890
o llevamos de la mano al primero y cada uno lleva de la mano

457
00:18:05,890 --> 00:18:06,369
al siguiente

458
00:18:06,369 --> 00:18:09,509
y si están bien educados no se van a soltar

459
00:18:09,509 --> 00:18:11,890
entonces van a llegar todos a su destino

460
00:18:11,890 --> 00:18:14,109
¿que yo quiero

461
00:18:14,109 --> 00:18:15,430
ver cómo está el quinto?

462
00:18:15,430 --> 00:18:17,589
pues hombre es un rollo, tengo que pasar

463
00:18:17,589 --> 00:18:19,529
por uno, por otro, por otro hasta que llego al quinto

464
00:18:19,529 --> 00:18:21,329
¿vale? pero desde luego están

465
00:18:21,329 --> 00:18:23,910
todos ahí accesibles, todos accesibles

466
00:18:23,910 --> 00:18:24,930
todos los dados de la manita

467
00:18:24,930 --> 00:18:26,910
van a llegar todos a su destino

468
00:18:26,910 --> 00:18:29,329
correctamente, pues aquí lo mismo

469
00:18:29,329 --> 00:18:30,829
cada objeto

470
00:18:30,829 --> 00:18:35,279
que se envuelva en un objeto

471
00:18:35,279 --> 00:18:36,400
joder

472
00:18:36,400 --> 00:18:38,420
que asustos

473
00:18:38,420 --> 00:18:40,279
que se envuelva en un objeto

474
00:18:40,279 --> 00:18:42,819
que además de sus propiedades

475
00:18:42,819 --> 00:18:45,640
tenga la referencia del siguiente

476
00:18:45,640 --> 00:18:49,319
Ahora este

477
00:18:49,319 --> 00:18:50,700
A su vez

478
00:18:50,700 --> 00:18:53,660
Tiene la referencia del siguiente

479
00:18:53,660 --> 00:18:56,700
Este a su vez

480
00:18:56,700 --> 00:18:59,359
Tiene la referencia del siguiente

481
00:18:59,359 --> 00:19:01,859
Este a su vez

482
00:19:01,859 --> 00:19:03,019
Tiene la referencia del siguiente

483
00:19:03,019 --> 00:19:04,180
Como él es el último

484
00:19:04,180 --> 00:19:07,200
Él su referencia esta del siguiente

485
00:19:07,200 --> 00:19:09,799
Ya apunta a mí

486
00:19:09,799 --> 00:19:12,599
Pues así los tengo a todos

487
00:19:12,599 --> 00:19:14,279
Perfectamente accesibles

488
00:19:14,279 --> 00:19:15,900
Desde esta

489
00:19:15,900 --> 00:19:21,410
pero es que yo no sé por qué se me mueve con esto

490
00:19:21,410 --> 00:19:23,289
a veces y a veces no, bueno no lo sé

491
00:19:23,289 --> 00:19:27,720
podría ser, no lo sé

492
00:19:27,720 --> 00:19:30,119
igual se roza

493
00:19:30,119 --> 00:19:31,000
esto y no me doy cuenta

494
00:19:31,000 --> 00:19:34,299
vale, pues así podemos perfectamente

495
00:19:34,299 --> 00:19:36,180
ya están todos

496
00:19:36,180 --> 00:19:37,960
accesibles desde aquí

497
00:19:37,960 --> 00:19:41,759
¿qué ventaja tengo con esta estructura?

498
00:19:43,500 --> 00:19:45,700
que insertar uno nuevo

499
00:19:45,700 --> 00:19:47,319
es facilísimo

500
00:19:47,319 --> 00:19:50,680
insertar uno nuevo es llegar y darse de la mano

501
00:19:50,680 --> 00:19:52,740
ya está, no tiene que hacer nada más

502
00:19:52,740 --> 00:19:53,960
insertar uno nuevo es

503
00:19:53,960 --> 00:19:57,160
tengo este objeto, si yo lo quiero meter en un array

504
00:19:57,160 --> 00:19:58,759
tengo que hacerme un autobús

505
00:19:58,759 --> 00:20:00,799
es como cambiarlos, si llega uno

506
00:20:00,799 --> 00:20:02,640
la filita de niños, uno, hostia

507
00:20:02,640 --> 00:20:04,500
que este llega tarde, pues se da la mano

508
00:20:04,500 --> 00:20:06,640
y se acabó, vale

509
00:20:06,640 --> 00:20:08,839
pero si llega uno y mi autobús

510
00:20:08,839 --> 00:20:10,599
era para 20 y me ha llegado el niño

511
00:20:10,599 --> 00:20:13,000
21, tengo que contratar un autobús nuevo

512
00:20:13,000 --> 00:20:14,640
cambiarlos a todos

513
00:20:14,640 --> 00:20:17,000
montar al 21, pues un rollo

514
00:20:17,000 --> 00:20:19,579
sin embargo así me llega uno nuevo

515
00:20:19,579 --> 00:20:22,859
uy que fácil, pues tú dejas de apuntar a null

516
00:20:22,859 --> 00:20:25,619
y empiezas a apuntar al nuevo y ya está

517
00:20:25,619 --> 00:20:28,519
luego acoger elementos nuevos en esta estructura

518
00:20:28,519 --> 00:20:32,799
no cuesta nada, se trata de hacer una asignación

519
00:20:32,799 --> 00:20:34,859
de una referencia, se acabó

520
00:20:34,859 --> 00:20:36,619
no hay que crear nada, destruir nada

521
00:20:36,619 --> 00:20:40,859
luego esta estructura es muchísimo más eficiente

522
00:20:40,859 --> 00:20:44,519
para insertar elementos nuevos

523
00:20:44,519 --> 00:20:45,640
que el ArrayList

524
00:20:45,640 --> 00:20:47,740
el ArrayList, ya sabemos lo que implica

525
00:20:47,740 --> 00:20:50,980
¿que quiero yo eliminar un elemento?

526
00:20:52,900 --> 00:20:53,380
facilísimo

527
00:20:53,380 --> 00:20:55,579
no tengo que crearme un autobús

528
00:20:55,579 --> 00:20:57,740
nuevo con una posición menos

529
00:20:57,740 --> 00:20:59,579
moverlos a todos, dejar fuera

530
00:20:59,579 --> 00:21:00,599
el niño que me sobra

531
00:21:00,599 --> 00:21:03,119
no, aquí el niño que me sobra

532
00:21:03,119 --> 00:21:05,400
pues se va afuera

533
00:21:05,400 --> 00:21:07,599
o sea, este enlace

534
00:21:07,599 --> 00:21:09,000
y este cambia de mano

535
00:21:09,000 --> 00:21:11,539
este le da la mano

536
00:21:11,539 --> 00:21:12,779
a uno, le da la mano al de atrás

537
00:21:12,779 --> 00:21:15,539
ya está, se trata de darle la mano al otro

538
00:21:15,539 --> 00:21:18,359
y el que se ha quedado fuera sin nadie que le dé la mano

539
00:21:18,359 --> 00:21:20,259
pues ya se lo llevará al recolector de basura

540
00:21:20,259 --> 00:21:22,559
luego

541
00:21:22,559 --> 00:21:24,740
inserciones y borrados

542
00:21:24,740 --> 00:21:26,740
computacionalmente

543
00:21:26,740 --> 00:21:27,680
inmejorables

544
00:21:27,680 --> 00:21:29,240
con una lista enlazada

545
00:21:29,240 --> 00:21:31,059
¿pero es solo para objetos?

546
00:21:31,680 --> 00:21:33,220
¿o sirve para otros servicios?

547
00:21:33,940 --> 00:21:35,160
no, no, para objetos también

548
00:21:35,160 --> 00:21:36,220
igual que la raíz

549
00:21:36,220 --> 00:21:39,339
claro, porque tiene que tener

550
00:21:39,339 --> 00:21:41,579
no, no, te ha preguntado

551
00:21:41,579 --> 00:21:42,759
si sirve para otros servicios

552
00:21:42,759 --> 00:21:45,819
Bueno, si lo envuelves en el integer, sí

553
00:21:45,819 --> 00:21:48,799
Las colecciones solamente pueden tener datos objeto

554
00:21:48,799 --> 00:21:50,400
¿Vale? Datos objeto

555
00:21:50,400 --> 00:21:52,220
Pero si tú quieres números, pues integer

556
00:21:52,220 --> 00:21:53,680
¿Vale? De hecho

557
00:21:53,680 --> 00:21:55,400
Normalmente

558
00:21:55,400 --> 00:21:58,140
A partir de cierto momento, ya tú no vas a ver

559
00:21:58,140 --> 00:21:59,119
En las aplicaciones

560
00:21:59,119 --> 00:22:01,779
Tipos primitivos como indavel, sueltos

561
00:22:01,779 --> 00:22:03,099
Vas a ver siempre el envolvente

562
00:22:03,099 --> 00:22:06,279
Porque computacionalmente te da igual, lo usas igual

563
00:22:06,279 --> 00:22:08,299
Y es más flexible

564
00:22:08,299 --> 00:22:09,980
Por si en un momento dado tienes que meterlo

565
00:22:09,980 --> 00:22:11,299
En una colección, por ejemplo

566
00:22:11,299 --> 00:22:12,339
¿Vale?

567
00:22:13,519 --> 00:22:15,940
Te va a ser más habitual en aplicaciones grandes

568
00:22:15,940 --> 00:22:18,019
Ver siempre el envolvente que ver el primitivo

569
00:22:18,019 --> 00:22:19,559
¿Vale?

570
00:22:19,740 --> 00:22:21,160
Entonces en una lista enlazada

571
00:22:21,160 --> 00:22:23,160
Que sería el linked list

572
00:22:23,160 --> 00:22:27,559
Insertar y eliminar

573
00:22:27,559 --> 00:22:30,039
Facilísimo, que era justo lo que era complicado

574
00:22:30,039 --> 00:22:32,019
En el array list, justo lo que era complicado

575
00:22:32,019 --> 00:22:35,079
Pero ostras

576
00:22:35,079 --> 00:22:37,799
Recorrer, es decir

577
00:22:37,799 --> 00:22:39,779
Recuperar un elemento

578
00:22:39,779 --> 00:22:42,259
consultar

579
00:22:42,259 --> 00:22:43,000
un elemento

580
00:22:43,000 --> 00:22:45,619
pues en el ArrayList era inmediato

581
00:22:45,619 --> 00:22:47,799
era un retún get el que fuera

582
00:22:47,799 --> 00:22:50,039
porque el ArrayList es que ya

583
00:22:50,039 --> 00:22:51,920
al ser un Array tú vas a la posición

584
00:22:51,920 --> 00:22:53,920
y vas tal cual, es de acceso directo

585
00:22:53,920 --> 00:22:55,299
a la posición en el Array, tal cual

586
00:22:55,299 --> 00:22:57,859
tú tienes tus corchetes para acceder

587
00:22:57,859 --> 00:22:58,420
a la posición

588
00:22:58,420 --> 00:23:02,099
pero este, aquí no hay corchetes

589
00:23:02,099 --> 00:23:03,839
para acceder, si yo quiero ver

590
00:23:03,839 --> 00:23:06,000
elemento en la posición 3, yo que sé

591
00:23:06,000 --> 00:23:06,740
este por ejemplo

592
00:23:06,740 --> 00:23:10,259
mi referencia apunta al primero solo

593
00:23:10,259 --> 00:23:12,599
el que manda, que es la referencia

594
00:23:12,599 --> 00:23:14,680
que está en el main, apunta al primero

595
00:23:14,680 --> 00:23:16,619
luego del primero tengo que ir al segundo

596
00:23:16,619 --> 00:23:18,980
y del segundo al tercero, ah, que ya ha llegado

597
00:23:18,980 --> 00:23:20,519
luego

598
00:23:20,519 --> 00:23:22,680
la recuperación por posición, el get

599
00:23:22,680 --> 00:23:24,200
es la que es

600
00:23:24,200 --> 00:23:25,720
pesada, la que tarda

601
00:23:25,720 --> 00:23:28,099
partimos del primero siempre

602
00:23:28,099 --> 00:23:30,859
partimos del primero y del primero hay que ir navegando

603
00:23:30,859 --> 00:23:32,440
hasta que lleguemos al que queremos ver

604
00:23:32,440 --> 00:23:35,200
luego son complementarias

605
00:23:35,200 --> 00:23:36,640
no es que una sea mejor que otra

606
00:23:36,640 --> 00:23:38,259
ArrayList

607
00:23:38,259 --> 00:23:41,099
está basada en un array que es la mejor estructura

608
00:23:41,099 --> 00:23:43,079
que hay, pero a partir

609
00:23:43,079 --> 00:23:44,339
de cierto tamaño

610
00:23:44,339 --> 00:23:47,180
las inserciones y borrados cuestan

611
00:23:47,180 --> 00:23:47,579
mucho

612
00:23:47,579 --> 00:23:50,799
sin embargo en un LinkedList

613
00:23:50,799 --> 00:23:53,220
si vamos a hacer muchas inserciones y borrados

614
00:23:53,220 --> 00:23:54,680
y mi aplicación sobre todo

615
00:23:54,680 --> 00:23:57,119
sus casos de uso, sus servicios

616
00:23:57,119 --> 00:23:59,180
son de insertar y borrar

617
00:23:59,180 --> 00:24:01,059
son sobre todo eso

618
00:24:01,059 --> 00:24:03,259
y tengo ya una cantidad de datos respetable

619
00:24:03,259 --> 00:24:04,759
pues un LinkedList

620
00:24:04,759 --> 00:24:07,480
si mi aplicación

621
00:24:07,480 --> 00:24:09,119
tiene los datos de partida ya

622
00:24:09,119 --> 00:24:11,339
construidos y lo único

623
00:24:11,339 --> 00:24:13,200
que va a hacer, va a ser consultarlos

624
00:24:13,200 --> 00:24:15,119
pues hombre, estar

625
00:24:15,119 --> 00:24:17,119
consultando todo el rato en esta es un rollo

626
00:24:17,119 --> 00:24:18,680
un ArrayList mejor

627
00:24:18,680 --> 00:24:21,000
en cualquier caso

628
00:24:21,000 --> 00:24:22,619
para una cantidad de datos manejable

629
00:24:22,619 --> 00:24:24,460
pequeñita

630
00:24:24,460 --> 00:24:27,180
pues por defecto siempre usaríamos un ArrayList

631
00:24:27,180 --> 00:24:28,960
porque es un Array que ya sabemos que es muy

632
00:24:28,960 --> 00:24:30,779
robusto

633
00:24:30,779 --> 00:24:32,599
es la estructura nativa

634
00:24:32,599 --> 00:24:33,700
de Java, de hecho el Array

635
00:24:33,700 --> 00:24:36,740
para una estructura de datos

636
00:24:36,740 --> 00:24:38,599
para una colección un poquito más anchota

637
00:24:38,599 --> 00:24:40,680
más grandota, que yo preveo

638
00:24:40,680 --> 00:24:41,720
que voy a tener muchos datos

639
00:24:41,720 --> 00:24:43,440
pues esta ya

640
00:24:43,440 --> 00:24:45,859
empieza a ser más

641
00:24:45,859 --> 00:24:46,960
eficiente

642
00:24:46,960 --> 00:24:53,400
pero las dos valen para lo mismo

643
00:24:53,400 --> 00:24:54,839
para guardar datos con posición

644
00:24:54,839 --> 00:24:58,200
y las dos ofrecen los mismos métodos

645
00:24:58,200 --> 00:24:59,220
con matices

646
00:24:59,220 --> 00:25:01,960
este ofrece algunos más porque este te permite

647
00:25:01,960 --> 00:25:03,460
simular una pila y una cola

648
00:25:03,460 --> 00:25:05,140
pero eso ya lo dejamos para después

649
00:25:05,140 --> 00:25:07,000
pero te ofrecen lo mismo

650
00:25:07,000 --> 00:25:09,180
las mismas posibilidades, que es insertar

651
00:25:09,180 --> 00:25:11,319
uno nuevo con el add, recuperar

652
00:25:11,319 --> 00:25:13,099
con el get, borrar con el

653
00:25:13,099 --> 00:25:14,619
remove, te permiten lo mismo

654
00:25:14,619 --> 00:25:17,099
¿vale? pero están construidas por dentro de forma

655
00:25:17,099 --> 00:25:19,039
distinta y eso hace que

656
00:25:19,039 --> 00:25:21,039
su funcionamiento sea distinto

657
00:25:21,039 --> 00:25:25,160
¿entendido?

658
00:25:28,819 --> 00:25:29,220
pues

659
00:25:29,220 --> 00:25:31,740
dicho esto

660
00:25:31,740 --> 00:25:42,789
si tuvierais que hacer mi linked list

661
00:25:42,789 --> 00:25:45,029
no la chula, mi linked list

662
00:25:45,029 --> 00:25:56,329
sin chula, genérica

663
00:25:56,329 --> 00:25:58,509
desde ya, ahorrémonos tiempo

664
00:25:58,509 --> 00:26:01,309
genérica para que sea cualquier tipo de dato

665
00:26:01,309 --> 00:26:06,390
vale, pues como la programaríamos

666
00:26:06,390 --> 00:26:08,170
como programaríamos la lista enlazada

667
00:26:08,170 --> 00:26:10,710
es la única colección

668
00:26:10,710 --> 00:26:12,150
que vamos a programar

669
00:26:12,150 --> 00:26:14,369
no va en los conjuntos y esos

670
00:26:14,369 --> 00:26:15,769
ya no, son demasiado complejos

671
00:26:15,769 --> 00:26:18,390
pero esto es una lista enlazada que junto con un árbol

672
00:26:18,390 --> 00:26:20,289
binario son las estructuras básicas para

673
00:26:20,289 --> 00:26:22,089
cualquier informático

674
00:26:22,089 --> 00:26:23,369
o cualquiera que quiera ser programador

675
00:26:23,369 --> 00:26:26,309
vale, pues si yo quiero programar este concepto que he hecho aquí

676
00:26:26,309 --> 00:26:27,950
esta sería

677
00:26:27,950 --> 00:26:29,589
mi referencia que tiene

678
00:26:29,589 --> 00:26:30,930
pues el inicio, ¿vale?

679
00:26:33,180 --> 00:26:35,440
Sí, yo creo que es que roza con esto

680
00:26:35,440 --> 00:26:36,119
cuando se mueve.

681
00:26:37,240 --> 00:26:41,109
Vale, pues entonces

682
00:26:41,109 --> 00:26:44,009
¿esto me apunta

683
00:26:44,009 --> 00:26:45,410
directamente a un objeto

684
00:26:45,410 --> 00:26:47,190
de tipo T?

685
00:26:48,670 --> 00:26:49,230
No.

686
00:26:49,970 --> 00:26:51,430
Esto me apunta a un objeto

687
00:26:51,430 --> 00:26:53,549
que lo envuelve un poquito

688
00:26:53,549 --> 00:26:55,410
más complejo, porque

689
00:26:55,410 --> 00:26:57,089
además de las propiedades de T

690
00:26:57,089 --> 00:26:59,650
tiene que tener

691
00:26:59,650 --> 00:27:01,150
la dirección del

692
00:27:01,150 --> 00:27:03,289
siguiente.

693
00:27:03,369 --> 00:27:13,069
y este ya

694
00:27:13,069 --> 00:27:15,349
me apuntará

695
00:27:15,349 --> 00:27:17,410
a otro objeto que no es

696
00:27:17,410 --> 00:27:19,269
directamente un objeto de tipo T

697
00:27:19,269 --> 00:27:23,960
porque además tendrá

698
00:27:23,960 --> 00:27:25,680
una propiedad

699
00:27:25,680 --> 00:27:26,680
siguiente

700
00:27:26,680 --> 00:27:29,740
luego para programar esto

701
00:27:29,740 --> 00:27:31,519
me aparece aquí

702
00:27:31,519 --> 00:27:34,900
adiós

703
00:27:34,900 --> 00:27:40,089
cuando los funcionarios se nos calbolen

704
00:27:40,089 --> 00:27:40,890
es que los tenemos aquí

705
00:27:40,890 --> 00:27:44,430
me aparece

706
00:27:44,430 --> 00:27:44,990
esa clase

707
00:27:44,990 --> 00:27:47,589
que esta clase

708
00:27:47,589 --> 00:27:49,289
es una clase, podemos llamarla

709
00:27:49,289 --> 00:27:50,809
nodo, ¿vale?

710
00:27:53,329 --> 00:27:55,109
que tendrá dentro dos cosas

711
00:27:55,109 --> 00:27:57,009
el objeto de tipo T

712
00:27:57,009 --> 00:27:59,509
y un objeto

713
00:27:59,509 --> 00:28:01,690
siguiente que a donde te apunta

714
00:28:01,690 --> 00:28:03,210
a su vez a un nodo

715
00:28:03,210 --> 00:28:04,829
luego vamos a tener que hacer esta clase

716
00:28:04,829 --> 00:28:07,250
la hacemos ahora, y ahora

717
00:28:07,250 --> 00:28:09,509
mi lista, mi objeto

718
00:28:09,509 --> 00:28:11,970
lista, el objeto que yo voy a instanciar

719
00:28:11,970 --> 00:28:13,589
para meter los elementos

720
00:28:13,589 --> 00:28:15,589
en la lista enlazada, ¿por qué se va a

721
00:28:15,589 --> 00:28:17,710
caracterizar. Se va a caracterizar

722
00:28:17,710 --> 00:28:19,990
exclusivamente por la dirección

723
00:28:19,990 --> 00:28:21,569
de un

724
00:28:21,569 --> 00:28:23,329
objeto de tipo T, de un nodo.

725
00:28:24,849 --> 00:28:25,710
Este nodo

726
00:28:25,710 --> 00:28:27,549
como también va a depender de T, porque esto

727
00:28:27,549 --> 00:28:29,490
es T, también va a ser un nodo genérico.

728
00:28:29,769 --> 00:28:31,670
Entonces, mi lista enlazada

729
00:28:31,670 --> 00:28:34,730
se va a caracterizar

730
00:28:34,730 --> 00:28:36,529
exclusivamente por esto.

731
00:28:40,940 --> 00:28:42,700
Por la dirección del primer nodo.

732
00:28:43,559 --> 00:28:43,880
Ya está.

733
00:28:45,500 --> 00:28:46,920
Por eso se va a caracterizar

734
00:28:46,920 --> 00:28:49,000
mi lista enlazada. Por la dirección

735
00:28:49,000 --> 00:28:50,900
del primero, recordad que esto es un objeto

736
00:28:50,900 --> 00:28:52,920
de nodo T, no necesita nada más

737
00:28:52,920 --> 00:28:54,660
para caracterizarse mi lista

738
00:28:54,660 --> 00:28:57,039
mi lista va a ser la dirección del primero

739
00:28:57,039 --> 00:28:58,359
ya está

740
00:28:58,359 --> 00:29:01,119
bueno, dirección de objeto es que es lo mismo

741
00:29:01,119 --> 00:29:02,480
o sea, es el primero

742
00:29:02,480 --> 00:29:05,000
el objeto, cuando a lo que llamamos

743
00:29:05,000 --> 00:29:06,720
objeto, es a su dirección en memoria

744
00:29:06,720 --> 00:29:09,099
vale, lo que pasa es que

745
00:29:09,099 --> 00:29:09,940
aquí nos falta

746
00:29:09,940 --> 00:29:13,119
nos falta declarar

747
00:29:13,119 --> 00:29:13,740
esta clase

748
00:29:13,740 --> 00:29:15,339
nos falta

749
00:29:15,339 --> 00:29:17,960
bueno, pues no pasa nada

750
00:29:17,960 --> 00:29:23,440
¿cómo será la clase

751
00:29:23,440 --> 00:29:24,000
nodo T?

752
00:29:27,880 --> 00:29:29,039
clase nodo

753
00:29:29,039 --> 00:29:29,940
será genérica

754
00:29:29,940 --> 00:29:35,160
su primera propiedad

755
00:29:35,160 --> 00:29:36,519
será de tipo T

756
00:29:36,519 --> 00:29:37,559
es el dato en sí

757
00:29:37,559 --> 00:29:43,359
esta será su primera propiedad

758
00:29:43,359 --> 00:29:47,440
porque recordad que cada nodo de la lista

759
00:29:47,440 --> 00:29:49,559
tiene el dato de tipo T

760
00:29:49,559 --> 00:29:50,960
y la dirección del siguiente

761
00:29:50,960 --> 00:29:53,279
la dirección del siguiente

762
00:29:53,279 --> 00:29:55,220
es un objeto de tipo nodo

763
00:29:55,220 --> 00:29:57,019
T, porque el siguiente es otro nodo.

764
00:30:02,609 --> 00:30:03,750
Pues estas son las dos clases

765
00:30:03,750 --> 00:30:04,549
involucradas

766
00:30:04,549 --> 00:30:07,849
en la lista enlazada, estas dos.

767
00:30:08,390 --> 00:30:10,230
La clase que te dice

768
00:30:10,230 --> 00:30:11,789
lo que hay en cada nodo,

769
00:30:12,190 --> 00:30:13,509
que es el propio dato,

770
00:30:13,950 --> 00:30:16,150
el propio dato y el objeto siguiente,

771
00:30:16,349 --> 00:30:17,329
el objeto siguiente,

772
00:30:18,329 --> 00:30:19,849
el propio dato y el objeto siguiente,

773
00:30:20,710 --> 00:30:21,230
que es este,

774
00:30:22,190 --> 00:30:23,609
y

775
00:30:23,609 --> 00:30:26,269
la lista en sí, que la lista en sí

776
00:30:26,269 --> 00:30:27,990
es el primer elemento,

777
00:30:28,109 --> 00:30:29,369
o la dirección del primero.

778
00:30:30,789 --> 00:30:33,470
Recordad que un objeto y su dirección es lo mismo.

779
00:30:36,009 --> 00:30:37,349
O sea, un objeto, en realidad,

780
00:30:37,509 --> 00:30:41,329
cuando escribimos el nombre de un objeto en Java,

781
00:30:41,950 --> 00:30:46,289
estamos escribiendo, en realidad,

782
00:30:46,450 --> 00:30:47,509
su dirección de memoria.

783
00:30:48,309 --> 00:30:50,970
Entonces, Java, cuando ve el nombre de un objeto escrito

784
00:30:50,970 --> 00:30:53,269
y entra dentro, sabe que lo que hay ahí es la dirección

785
00:30:53,269 --> 00:30:55,630
y a través de la dirección, pues llega ya el objeto.

786
00:30:55,630 --> 00:30:58,450
vale, bueno pues esta es

787
00:30:58,450 --> 00:31:00,849
la dirección del primer nodo

788
00:31:00,849 --> 00:31:02,829
y ahora ya

789
00:31:02,829 --> 00:31:04,589
cada nodo tiene el propio

790
00:31:04,589 --> 00:31:06,569
dato y la dirección del

791
00:31:06,569 --> 00:31:08,670
siguiente, vale, el propio objeto

792
00:31:08,670 --> 00:31:10,529
siguiente, son las únicas

793
00:31:10,529 --> 00:31:11,589
clases involucradas

794
00:31:11,589 --> 00:31:15,430
y ahora aquí

795
00:31:15,430 --> 00:31:18,589
habrá que hacer los métodos

796
00:31:18,589 --> 00:31:19,869
correspondientes

797
00:31:19,869 --> 00:31:24,400
public void

798
00:31:24,400 --> 00:31:28,140
add del dato

799
00:31:28,140 --> 00:31:31,930
t, claro aquí

800
00:31:31,930 --> 00:31:33,809
¿Y qué pasa? Que aquí el problema

801
00:31:33,809 --> 00:31:35,829
ya no es tan sencillo. Añadir

802
00:31:35,829 --> 00:31:37,990
a la lista, ahora

803
00:31:37,990 --> 00:31:39,849
ya implica mover

804
00:31:39,849 --> 00:31:41,529
los enlaces y hacer las cosas

805
00:31:41,529 --> 00:31:46,720
que hagan falta, ¿vale?

806
00:31:48,000 --> 00:31:48,839
Esto no es

807
00:31:48,839 --> 00:31:49,900
como lo del array.

808
00:31:50,779 --> 00:31:52,440
Entonces, vamos a hacer el de añadir, por ejemplo.

809
00:31:52,579 --> 00:31:53,519
¿Cómo lo podríamos hacer?

810
00:31:54,680 --> 00:31:56,859
El de, ¿vale? El método de añadir

811
00:31:56,859 --> 00:31:58,680
a la lista. Vamos a hacer

812
00:31:58,680 --> 00:32:00,880
ese, más o menos para intuir la idea,

813
00:32:00,880 --> 00:32:02,319
pero tampoco vamos a hacerlos todos

814
00:32:02,319 --> 00:32:03,599
para no

815
00:32:03,599 --> 00:32:05,640
nos volváis demasiado locos

816
00:32:05,640 --> 00:32:08,460
vale, pues como haríamos el método de añadir

817
00:32:08,460 --> 00:32:10,660
voy a borrar aquí para hacer un poco de hueco

818
00:32:10,660 --> 00:32:18,930
vale, método de añadir

819
00:32:18,930 --> 00:32:19,390
a ver

820
00:32:19,390 --> 00:32:22,869
pensad que nuestra lista

821
00:32:22,869 --> 00:32:24,710
es esta, tenemos inicio

822
00:32:24,710 --> 00:32:32,920
inicio

823
00:32:32,920 --> 00:32:36,789
que es este, que me lleva

824
00:32:36,789 --> 00:32:38,309
el primero que tiene T

825
00:32:38,309 --> 00:32:40,349
el dato de tipo T

826
00:32:40,349 --> 00:32:41,730
siguiente

827
00:32:41,730 --> 00:32:44,930
que me lleva este

828
00:32:44,930 --> 00:32:46,950
y este

829
00:32:46,950 --> 00:32:48,069
imaginaos que me lleva a luz

830
00:32:48,069 --> 00:32:49,490
es private y todo, ¿no?

831
00:32:50,809 --> 00:32:51,930
sí, lo que pasa es que bueno

832
00:32:51,930 --> 00:32:54,750
lo estoy, vamos, por no hacer

833
00:32:54,750 --> 00:32:56,529
la línea muy larga, estoy quitando el

834
00:32:56,529 --> 00:32:58,210
modificador y, ¿vale?

835
00:32:58,670 --> 00:33:00,470
entonces hay una forma muy fácil de añadir

836
00:33:00,470 --> 00:33:02,230
si cada vez que añadamos

837
00:33:02,230 --> 00:33:03,869
en lugar de añadir por la cola

838
00:33:03,869 --> 00:33:06,210
colamos aquí al principio

839
00:33:06,210 --> 00:33:08,769
ahí el método add se hace muy sencillo

840
00:33:08,769 --> 00:33:10,569
en lugar de dar la mano al último

841
00:33:10,569 --> 00:33:12,609
nos colamos en el primero

842
00:33:12,609 --> 00:33:14,890
hay una forma muy sencilla de hacer ese método

843
00:33:14,890 --> 00:33:17,029
que sería, este es el nuevo, que tengo que añadir

844
00:33:17,029 --> 00:33:20,349
el nuevo, con su siguiente

845
00:33:20,349 --> 00:33:22,289
que inicialmente no apuntará a nada

846
00:33:22,289 --> 00:33:23,730
inicialmente esto será un no

847
00:33:23,730 --> 00:33:26,670
vale, pues hay una forma muy sencilla

848
00:33:26,670 --> 00:33:27,750
de colarlo

849
00:33:27,750 --> 00:33:30,470
al principio, que es

850
00:33:30,470 --> 00:33:32,609
a este elemento

851
00:33:32,609 --> 00:33:34,890
punto siguiente, a su propiedad

852
00:33:34,890 --> 00:33:36,509
siguiente, a este nodo

853
00:33:36,509 --> 00:33:38,049
punto siguiente

854
00:33:38,049 --> 00:33:40,210
vamos a asignarle lo que tenga inicio

855
00:33:40,210 --> 00:33:56,049
Sería la primera sentencia, ¿vale? Que sería este. T dato. Primero, ¿qué nos haríamos? Nos haríamos un nodo T, ¿vale? Aquí le vamos a meter un nuevo dato. Primero construimos un nodo con él.

856
00:33:56,049 --> 00:34:00,220
nodo T, nodo

857
00:34:00,220 --> 00:34:02,119
ahora lo escribimos ahí que se va a ver mejor

858
00:34:02,119 --> 00:34:03,619
igual

859
00:34:03,619 --> 00:34:06,480
nos hacemos un nuevo

860
00:34:06,480 --> 00:34:07,480
nodo T

861
00:34:07,480 --> 00:34:09,639
¿vale?

862
00:34:10,820 --> 00:34:12,219
pasándole el dato que fuera

863
00:34:12,219 --> 00:34:16,079
¿vale? es decir

864
00:34:16,079 --> 00:34:17,980
aunque lo escriba faltándome cosas

865
00:34:17,980 --> 00:34:20,019
lo que importa es la idea, ahí me pasan

866
00:34:20,019 --> 00:34:21,139
un dato, me pasan esto

867
00:34:21,139 --> 00:34:23,420
me pasan esto

868
00:34:23,420 --> 00:34:25,460
primero que hace el método

869
00:34:25,460 --> 00:34:27,679
construye con él un nodo

870
00:34:27,679 --> 00:34:30,300
es decir, hace un nodo

871
00:34:30,300 --> 00:34:31,659
donde pone aquí el dato

872
00:34:31,659 --> 00:34:33,940
y aquí lo pone a nudo

873
00:34:33,940 --> 00:34:36,420
es lo primero que hace, se construye un nodo nuevo

874
00:34:36,420 --> 00:34:37,420
para colar en la lista

875
00:34:37,420 --> 00:34:40,340
se construye un nodo nuevo, vale, ya he metido

876
00:34:40,340 --> 00:34:42,159
el dato ahí, vale

877
00:34:42,159 --> 00:34:43,239
ahora que hacemos

878
00:34:43,239 --> 00:34:46,059
a inicio

879
00:34:46,059 --> 00:34:47,099
perdón

880
00:34:47,099 --> 00:34:50,480
que el siguiente

881
00:34:50,480 --> 00:34:52,440
nodo de este sea el que tenga

882
00:34:52,440 --> 00:34:56,070
inicio, luego

883
00:34:56,070 --> 00:34:58,090
si es

884
00:34:58,090 --> 00:34:59,389
podríamos hacer

885
00:34:59,389 --> 00:35:04,360
nodo punto siguiente

886
00:35:04,360 --> 00:35:05,599
igual a inicio

887
00:35:05,599 --> 00:35:08,179
¿qué estaríamos

888
00:35:08,179 --> 00:35:09,860
consiguiendo con nodo punto siguiente

889
00:35:09,860 --> 00:35:12,239
igual a inicio? pues estaríamos consiguiendo hacer este enlace

890
00:35:12,239 --> 00:35:15,599
ese enlace ya lo tendríamos

891
00:35:15,599 --> 00:35:17,139
este es nodo

892
00:35:17,139 --> 00:35:18,860
el que acabamos de hacer

893
00:35:18,860 --> 00:35:21,940
pues al hacer nodo punto siguiente

894
00:35:21,940 --> 00:35:23,800
igual a inicio

895
00:35:23,800 --> 00:35:26,099
este deja de apuntar a null y empieza a apuntar

896
00:35:26,099 --> 00:35:28,239
donde apunta inicio, ese enlace ya está

897
00:35:28,239 --> 00:35:29,780
¿y qué nos falta?

898
00:35:29,780 --> 00:35:32,159
Pues hacer inicio

899
00:35:32,159 --> 00:35:33,500
Igual a nodo

900
00:35:33,500 --> 00:35:37,619
Al hacer inicio igual a nodo

901
00:35:37,619 --> 00:35:39,699
Inicio deja de apuntar a este

902
00:35:39,699 --> 00:35:42,820
Y pasa a apuntar a este de aquí

903
00:35:42,820 --> 00:35:46,900
Luego con

904
00:35:46,900 --> 00:35:48,360
Dos sentencias

905
00:35:48,360 --> 00:35:51,460
Hemos metido este dato

906
00:35:51,460 --> 00:35:53,019
En la lista enlazada

907
00:35:53,019 --> 00:35:54,340
¿Vale?

908
00:35:55,159 --> 00:35:57,099
Hemos metido el dato en la lista enlazada

909
00:35:57,099 --> 00:35:59,159
Mucho más fácil que en un array

910
00:35:59,159 --> 00:36:03,500
Este es el código para meter en la lista enlazada

911
00:36:03,500 --> 00:36:04,659
mucho más sencillo que el array

912
00:36:04,659 --> 00:36:09,289
lo único que le hemos colado al principio

913
00:36:09,289 --> 00:36:11,150
porque para ponerlo al final no es tan fácil

914
00:36:11,150 --> 00:36:12,050
hay que ir avanzando

915
00:36:12,050 --> 00:36:14,030
pero colarlo al principio

916
00:36:14,030 --> 00:36:19,289
este es el método que el linked list original

917
00:36:19,289 --> 00:36:21,210
lo llama, no lo llama

918
00:36:21,210 --> 00:36:23,030
lo llama add first

919
00:36:23,030 --> 00:36:25,309
que es añade al principio

920
00:36:25,309 --> 00:36:27,650
porque el add normal

921
00:36:27,650 --> 00:36:29,030
lo usa para añadir al final

922
00:36:29,030 --> 00:36:31,389
que habría que hacerlo de otra manera, claro

923
00:36:31,389 --> 00:36:33,690
pero añadir al principio es tan sencillo

924
00:36:33,690 --> 00:36:35,750
como esto, entonces es un buen ejemplo

925
00:36:35,750 --> 00:36:37,909
para ver que insertar

926
00:36:37,909 --> 00:36:39,650
en una lista enlazada es mucho más fácil

927
00:36:39,650 --> 00:36:40,630
que insertar en un array

928
00:36:40,630 --> 00:37:00,869
no es sencillo

929
00:37:00,869 --> 00:37:03,210
la idea de lista enlazada

930
00:37:03,210 --> 00:37:05,110
no es sencilla tampoco, porque es meter un objeto

931
00:37:05,110 --> 00:37:07,349
en un nodo, ese nodo

932
00:37:07,349 --> 00:37:09,369
añade la dirección del siguiente objeto

933
00:37:09,369 --> 00:37:10,889
de la lista y todo eso

934
00:37:10,889 --> 00:37:12,630
está oculto

935
00:37:12,630 --> 00:37:14,289
el que usa mi linked list

936
00:37:14,289 --> 00:37:17,110
instancia un objeto, mi linked list para un tipo

937
00:37:17,110 --> 00:37:19,329
y luego llama add, llama lo que sea

938
00:37:19,329 --> 00:37:21,090
y el que lo usa ni ve nodo ni ve nada

939
00:37:21,090 --> 00:37:25,909
Más o menos procesado

940
00:37:25,909 --> 00:37:28,190
Es que yo lo que no entiendo

941
00:37:28,190 --> 00:37:29,530
O sea, tú en el nodo

942
00:37:29,530 --> 00:37:31,150
O sea, cuando haces el new node

943
00:37:31,150 --> 00:37:33,489
Sí, me creo un objeto

944
00:37:33,489 --> 00:37:35,070
Nodo nuevo donde meto el dato

945
00:37:35,070 --> 00:37:36,630
Vale, metes el dato

946
00:37:36,630 --> 00:37:39,769
Y a la dirección siguiente la pongo a null por ahora

947
00:37:39,769 --> 00:37:41,570
Luego ya se la cambio

948
00:37:41,570 --> 00:37:43,230
Para que apunte aquí

949
00:37:43,230 --> 00:37:46,170
Y luego ya inicio

950
00:37:46,170 --> 00:37:47,309
La hago llevar aquí arriba

951
00:37:47,309 --> 00:37:49,369
Pero es que el siguiente

952
00:37:49,369 --> 00:37:51,429
Está apuntando al inicio, no está apuntando a la nueva

953
00:37:51,429 --> 00:37:53,309
O sea, primero es nudo

954
00:37:53,309 --> 00:37:55,590
Pero luego le pones que apunte inicio

955
00:37:55,590 --> 00:37:57,550
No, no le pongo que apunte inicio

956
00:37:57,550 --> 00:37:59,710
Le pongo que apunte a donde apunta inicio

957
00:37:59,710 --> 00:38:01,690
Esta sentencia

958
00:38:01,690 --> 00:38:03,190
Significa

959
00:38:03,190 --> 00:38:05,269
Que nodo siguiente

960
00:38:05,269 --> 00:38:08,010
Apunte a donde apunta inicio

961
00:38:08,010 --> 00:38:10,550
E inicio donde apunta

962
00:38:10,550 --> 00:38:10,789
Aquí

963
00:38:10,789 --> 00:38:11,610
No, pero

964
00:38:11,610 --> 00:38:14,250
Tú en la clase nodo

965
00:38:14,250 --> 00:38:16,969
Tienes dos atributos

966
00:38:16,969 --> 00:38:18,369
Sí, el dato

967
00:38:18,369 --> 00:38:20,769
Y la dirección del siguiente

968
00:38:20,769 --> 00:38:22,829
o el objeto siguiente

969
00:38:22,829 --> 00:38:24,670
pero claro, ahí tú

970
00:38:24,670 --> 00:38:26,949
entonces el siguiente

971
00:38:26,949 --> 00:38:29,010
o sea, en el nodo nuevo que has creado

972
00:38:29,010 --> 00:38:30,409
le estás diciendo

973
00:38:30,409 --> 00:38:33,329
que su atributo siguiente sea inicio

974
00:38:33,329 --> 00:38:35,210
claro, e inicio es

975
00:38:35,210 --> 00:38:35,610
esto

976
00:38:35,610 --> 00:38:39,469
inicio es a quien apunto yo

977
00:38:39,469 --> 00:38:41,150
claro, inicio es

978
00:38:41,150 --> 00:38:42,349
e inicio apunta aquí

979
00:38:42,349 --> 00:38:44,829
entonces si yo digo que

980
00:38:44,829 --> 00:38:46,869
nodo siguiente igual a inicio, estoy diciendo que

981
00:38:46,869 --> 00:38:49,010
nodo siguiente igual a esta misma flecha

982
00:38:49,010 --> 00:38:51,150
le estoy diciendo, oye, tu flecha

983
00:38:51,150 --> 00:38:52,210
que sea esta flecha

984
00:38:52,210 --> 00:38:57,409
y ahora la flecha inicio

985
00:38:57,409 --> 00:38:59,409
que deje de ser esta, para ahora ser

986
00:38:59,409 --> 00:39:01,510
la flecha

987
00:39:01,510 --> 00:39:02,610
que te lleva

988
00:39:02,610 --> 00:39:04,269
el objeto nuevo

989
00:39:04,269 --> 00:39:07,429
vale, pero no es fácil

990
00:39:07,429 --> 00:39:09,150
entender un poco lo de la

991
00:39:09,150 --> 00:39:11,369
referencia, o sea, la dirección de objeto

992
00:39:11,369 --> 00:39:11,789
objeto

993
00:39:11,789 --> 00:39:15,329
pero bueno, sí que deberíais dedicar

994
00:39:15,329 --> 00:39:17,110
tiempo a pensarlo un poco para tener claves

995
00:39:17,110 --> 00:39:18,329
porque muchos de los errores

996
00:39:18,329 --> 00:39:20,210
de ejecución que salen

997
00:39:20,210 --> 00:39:22,869
es porque uno a veces no tiene

998
00:39:22,869 --> 00:39:24,289
simplemente la idea

999
00:39:24,289 --> 00:39:26,510
de que es realmente un objeto

1000
00:39:26,510 --> 00:39:27,829
¿vale?

1001
00:39:29,010 --> 00:39:30,710
entonces tenéis que entender muy bien

1002
00:39:30,710 --> 00:39:31,969
las bases de todo, porque

1003
00:39:31,969 --> 00:39:34,889
programar no es hago código y llamo a métodos

1004
00:39:34,889 --> 00:39:36,869
no, es tratar de hacer aplicaciones

1005
00:39:36,869 --> 00:39:37,769
que funcionen

1006
00:39:37,769 --> 00:39:40,869
y para que las aplicaciones hagan lo que tienen que hacer

1007
00:39:40,869 --> 00:39:42,789
hay que entender la esencia

1008
00:39:42,789 --> 00:39:43,489
de lo que

1009
00:39:43,489 --> 00:39:45,829
programa, ¿vale?

1010
00:39:45,929 --> 00:39:47,710
si escribir líneas de código es fácil

1011
00:39:47,710 --> 00:39:50,150
que hagan exactamente lo que realmente

1012
00:39:50,150 --> 00:39:51,730
se espera que hagan, ya no es tan fácil

1013
00:39:51,730 --> 00:39:54,469
¿Quieres aprender otra cosa?

1014
00:39:55,690 --> 00:39:56,369
Lo voy a poner

1015
00:39:56,369 --> 00:39:58,789
Bueno, más o menos

1016
00:39:58,789 --> 00:40:01,670
¿Qué significa?

1017
00:40:03,670 --> 00:40:05,289
Si queremos hacer otro node

1018
00:40:05,289 --> 00:40:09,530
Sí, otro objeto

1019
00:40:09,530 --> 00:40:12,130
O sea, otro add, llamar a add otra vez

1020
00:40:12,130 --> 00:40:13,550
Sí, llamar a add otra vez

1021
00:40:13,550 --> 00:40:15,070
Pues se colaría aquí

1022
00:40:15,070 --> 00:40:18,090
se llama otro add, pues ese otro add

1023
00:40:18,090 --> 00:40:20,190
empezaría a apuntar a donde apuntaba

1024
00:40:20,190 --> 00:40:21,389
inicio y lo apunta a este

1025
00:40:21,389 --> 00:40:22,769
e

1026
00:40:22,769 --> 00:40:25,949
inicio empezaría a apuntar a este nuevo

1027
00:40:25,949 --> 00:40:28,050
cada vez que yo haga

1028
00:40:28,050 --> 00:40:29,989
un add, se cuela delante

1029
00:40:29,989 --> 00:40:30,590
del que había

1030
00:40:30,590 --> 00:40:33,889
pensaba que

1031
00:40:33,889 --> 00:40:34,909
iba al último

1032
00:40:34,909 --> 00:40:37,630
no, no, no, claro

1033
00:40:37,630 --> 00:40:40,050
podríamos hacer el método add last

1034
00:40:40,050 --> 00:40:41,869
añadir al final, pero este no es tan fácil

1035
00:40:41,869 --> 00:40:43,849
pero hay que ir avanzando, entonces la operación de avance

1036
00:40:43,849 --> 00:40:44,929
la vamos a ver ahora con el get

1037
00:40:44,929 --> 00:40:46,670
porque nos faltaría un recuperar

1038
00:40:46,670 --> 00:40:48,530
entonces, a ver

1039
00:40:48,530 --> 00:40:50,550
si

1040
00:40:50,550 --> 00:41:03,099
si

1041
00:41:03,099 --> 00:41:05,780
vamos a, si lo programamos

1042
00:41:05,780 --> 00:41:07,340
aquí igual se ve un poco mejor

1043
00:41:07,340 --> 00:41:09,679
ahora ya, escrito bien en código

1044
00:41:09,679 --> 00:41:15,840
vale, me voy a hacer otro paquete

1045
00:41:15,840 --> 00:41:17,500
que se llame ahora

1046
00:41:17,500 --> 00:41:18,539
linked list para

1047
00:41:18,539 --> 00:41:21,460
las clases relacionadas con esto

1048
00:41:21,460 --> 00:41:27,440
linked list, vale

1049
00:41:27,440 --> 00:41:30,980
primero vamos a hacernos la clase nodo

1050
00:41:30,980 --> 00:41:35,110
la clase nodo es la que tiene el dato

1051
00:41:35,110 --> 00:41:38,969
junto con la dirección del siguiente

1052
00:41:38,969 --> 00:41:40,650
la clase nodo es la que envuelve al dato

1053
00:41:40,650 --> 00:41:42,789
entonces la clase nodo tiene

1054
00:41:42,789 --> 00:41:44,150
el dato

1055
00:41:44,150 --> 00:41:45,909
que será genérico

1056
00:41:45,909 --> 00:41:48,269
de un tipo el que sea

1057
00:41:48,269 --> 00:41:50,469
luego la clase nodo depende de t

1058
00:41:50,469 --> 00:41:53,090
y aquí está el dato

1059
00:41:53,090 --> 00:41:55,969
pero el objeto nodo

1060
00:41:55,969 --> 00:41:57,909
el objeto que pertenece a esa clase

1061
00:41:57,909 --> 00:42:00,010
el nodo, también tiene que tener

1062
00:42:00,010 --> 00:42:02,309
la dirección del siguiente

1063
00:42:02,309 --> 00:42:04,269
elemento. Y el siguiente

1064
00:42:04,269 --> 00:42:05,789
elemento es un nodo a su vez.

1065
00:42:12,440 --> 00:42:13,840
Llamémosle siguiente, por ejemplo.

1066
00:42:16,840 --> 00:42:18,440
Vale. Vamos a hacernos un constructor

1067
00:42:18,440 --> 00:42:20,420
que nos va a ir muy bien. Construir un nodo

1068
00:42:20,420 --> 00:42:22,260
con un dato en particular, poniendo

1069
00:42:22,260 --> 00:42:23,519
la dirección del siguiente a nulo.

1070
00:42:24,579 --> 00:42:26,099
Vamos a hacernos un constructor

1071
00:42:26,099 --> 00:42:27,539
para el nodo.

1072
00:42:32,719 --> 00:42:34,860
Como al constructor solo le va a llamar

1073
00:42:34,860 --> 00:42:36,719
mi linked list, esto ni lo ve el main

1074
00:42:36,719 --> 00:42:38,760
ni lo ve nada, no lo voy a hacer public

1075
00:42:38,760 --> 00:42:39,420
el constructor

1076
00:42:39,420 --> 00:42:42,039
nodo

1077
00:42:42,039 --> 00:42:46,900
a ver, t dato

1078
00:42:46,900 --> 00:42:52,230
this.dato

1079
00:42:52,230 --> 00:42:53,670
igual a

1080
00:42:53,670 --> 00:42:54,190
dato

1081
00:42:54,190 --> 00:42:57,349
y siguiente

1082
00:42:57,349 --> 00:42:58,369
igual a nulo

1083
00:42:58,369 --> 00:43:01,710
vale, este constructor pues me va a ser útil

1084
00:43:01,710 --> 00:43:03,289
me crea un nodo

1085
00:43:03,289 --> 00:43:05,309
por ahora que tiene el dato dentro pero

1086
00:43:05,309 --> 00:43:06,530
no está enlazado con nadie

1087
00:43:06,530 --> 00:43:09,230
enlazarlo ya será un problema

1088
00:43:09,230 --> 00:43:11,389
de la linked list

1089
00:43:11,389 --> 00:43:15,809
Sí, ya sería null, pero bueno, para que quede

1090
00:43:15,809 --> 00:43:17,909
más claro. Cualquier objeto

1091
00:43:17,909 --> 00:43:19,730
si no lo inicializamos específicamente

1092
00:43:19,730 --> 00:43:20,949
se queda inicializado como null.

1093
00:43:21,750 --> 00:43:23,969
¿Vale? Entonces

1094
00:43:23,969 --> 00:43:27,949
no le voy a poner ni get ni set

1095
00:43:27,949 --> 00:43:29,650
voy a quitarle los

1096
00:43:29,650 --> 00:43:31,869
private, porque esta clase

1097
00:43:31,869 --> 00:43:33,110
va a ir asociada a la otra

1098
00:43:33,110 --> 00:43:35,750
y quiero que se comuniquen fácilmente entre sí

1099
00:43:35,750 --> 00:43:37,030
esto no es para

1100
00:43:37,030 --> 00:43:39,449
ser accedida desde la main

1101
00:43:39,449 --> 00:43:41,030
ni nada de eso, esto no es una entidad

1102
00:43:41,030 --> 00:43:43,090
es una clase operativa de trabajo

1103
00:43:43,090 --> 00:43:44,730
entonces vamos a dejar el nodo así

1104
00:43:44,730 --> 00:43:47,530
vale, ahora nos vamos a hacer

1105
00:43:47,530 --> 00:43:49,510
ahora ya sí la lista enlazada

1106
00:43:49,510 --> 00:43:58,610
mi linked list

1107
00:43:58,610 --> 00:44:01,710
la lista enlazada

1108
00:44:01,710 --> 00:44:02,869
esta

1109
00:44:02,869 --> 00:44:06,449
solo necesita, solo se caracteriza

1110
00:44:06,449 --> 00:44:10,610
por la dirección del primer elemento

1111
00:44:10,610 --> 00:44:12,929
que será de nodo T

1112
00:44:12,929 --> 00:44:16,489
luego al depender

1113
00:44:16,489 --> 00:44:16,929
de T

1114
00:44:16,929 --> 00:44:20,150
la estoy haciendo dependiente de t por aquí

1115
00:44:20,150 --> 00:44:21,969
pues entonces va a ser genérica ya también

1116
00:44:21,969 --> 00:44:23,610
también va a ser genérica

1117
00:44:23,610 --> 00:44:25,670
vale

1118
00:44:25,670 --> 00:44:34,199
y ahora

1119
00:44:34,199 --> 00:44:36,420
vamos a hacerle el método

1120
00:44:36,420 --> 00:44:36,659
at

1121
00:44:36,659 --> 00:44:45,300
al que yo le paso un dato

1122
00:44:45,300 --> 00:44:50,369
de tipo t, vale

1123
00:44:50,369 --> 00:44:52,710
pues cada vez que queramos añadir algo

1124
00:44:52,710 --> 00:44:54,750
at first a la lista

1125
00:44:54,750 --> 00:44:55,670
que yo instancie

1126
00:44:55,670 --> 00:44:58,349
¿qué habrá que hacer? pues

1127
00:44:58,349 --> 00:44:59,849
se crea un nodo

1128
00:44:59,849 --> 00:45:09,869
con ese dato

1129
00:45:09,869 --> 00:45:13,090
¿vale?

1130
00:45:14,289 --> 00:45:15,909
creo un nodo con ese dato

1131
00:45:15,909 --> 00:45:18,090
por ahora está desenlazado

1132
00:45:18,090 --> 00:45:20,090
el nodo con ese dato

1133
00:45:20,090 --> 00:45:21,190
está desenlazado

1134
00:45:21,190 --> 00:45:23,599
¿vale?

1135
00:45:25,440 --> 00:45:25,960
así

1136
00:45:25,960 --> 00:45:32,380
de nodo T, puedo poner aquí la T o no

1137
00:45:32,380 --> 00:45:33,820
esto es como lo que hemos visto antes

1138
00:45:33,820 --> 00:45:35,960
creo un nodo

1139
00:45:35,960 --> 00:45:37,380
con ese dato

1140
00:45:37,380 --> 00:45:37,860
¿vale?

1141
00:45:38,679 --> 00:45:40,739
ahora, ¿qué es lo que hacemos?

1142
00:45:41,559 --> 00:45:42,619
el siguiente

1143
00:45:42,619 --> 00:45:44,760
de ese nodo que sea

1144
00:45:44,760 --> 00:45:46,360
el primero de la lista

1145
00:45:46,360 --> 00:45:49,300
es decir, a donde apunte inicio

1146
00:45:49,300 --> 00:45:50,219
el primero de la lista

1147
00:45:50,219 --> 00:45:55,150
y ahora una vez que el siguiente de ese nodo

1148
00:45:55,150 --> 00:45:56,409
es el primero de la lista

1149
00:45:56,409 --> 00:45:58,409
ahora que el primero de la lista

1150
00:45:58,409 --> 00:46:01,070
pase a ser este nodo

1151
00:46:01,070 --> 00:46:01,630
que yo he hecho

1152
00:46:01,630 --> 00:46:03,909
y ya está, se acabó el método

1153
00:46:03,909 --> 00:46:10,840
se acabó el método

1154
00:46:10,840 --> 00:46:13,679
vamos a hacer un main para ver al menos

1155
00:46:13,679 --> 00:46:15,780
que no salen errores, aunque no vamos a poder todavía

1156
00:46:15,780 --> 00:46:18,039
comprobar si lo ha metido porque no tenemos un get

1157
00:46:18,039 --> 00:46:22,219
pero vamos a ver por lo menos

1158
00:46:22,219 --> 00:46:23,519
si no nos saltan errores

1159
00:46:23,519 --> 00:46:27,400
¿Cómo lo usaríamos esto ahora en nuestro main?

1160
00:46:30,139 --> 00:46:32,000
Pues yo me quiero hacer una lista enlazada

1161
00:46:32,000 --> 00:46:33,619
Para meter, pues yo que sé

1162
00:46:33,619 --> 00:46:35,199
Cadenas, venga

1163
00:46:35,199 --> 00:46:39,489
Pues me hago mi lista enlazada

1164
00:46:39,489 --> 00:46:41,769
Quiero meter cadenas

1165
00:46:41,769 --> 00:46:42,889
Pues que sea de stream

1166
00:46:42,889 --> 00:46:55,750
Ahí la tengo

1167
00:46:55,750 --> 00:46:56,849
Mi lista enlazada

1168
00:46:56,849 --> 00:47:00,570
Tal y cual la he creado

1169
00:47:00,570 --> 00:47:02,469
Ahora mismo

1170
00:47:02,469 --> 00:47:04,889
Se ha creado una, mi linked list

1171
00:47:04,889 --> 00:47:06,750
Con inicio apuntando a null

1172
00:47:06,750 --> 00:47:08,349
La lista está vacía

1173
00:47:08,349 --> 00:47:09,489
Inicio, apunta, anul

1174
00:47:09,489 --> 00:47:10,889
Lista muy vacía

1175
00:47:10,889 --> 00:47:12,010
Vamos a hacer un par de add

1176
00:47:12,010 --> 00:47:12,989
Comprobar que no da errores

1177
00:47:12,989 --> 00:47:13,489
Y nos vamos

1178
00:47:13,489 --> 00:47:15,130
Vale, vamos a usarla

1179
00:47:15,130 --> 00:47:18,010
Cadenas.addFirst

1180
00:47:18,010 --> 00:47:19,590
Hola

1181
00:47:19,590 --> 00:47:24,699
Cadenas.addFirst

1182
00:47:24,699 --> 00:47:27,059
Adiós

1183
00:47:27,059 --> 00:47:30,860
Ahora mismo

1184
00:47:30,860 --> 00:47:32,239
No puedo hacer más con la lista

1185
00:47:32,239 --> 00:47:33,059
Solo puedo meter

1186
00:47:33,059 --> 00:47:35,159
No puedo comprobar con get

1187
00:47:35,159 --> 00:47:36,199
No puedo borrar

1188
00:47:36,199 --> 00:47:37,119
Porque no lo he hecho

1189
00:47:37,119 --> 00:47:38,199
Porque no lo he hecho

1190
00:47:38,199 --> 00:47:40,199
Solamente puedo hacer esto

1191
00:47:40,199 --> 00:47:43,239
es decir, no podemos comprobar si lo ha metido

1192
00:47:43,239 --> 00:47:45,199
realmente, pero no tenemos un get, pero al menos vamos a ver

1193
00:47:45,199 --> 00:47:47,079
si nos da errores, excepciones

1194
00:47:47,079 --> 00:47:49,079
de ejecución, porque algo ya hayamos programado mal

1195
00:47:49,079 --> 00:47:56,750
o no, vale

1196
00:47:56,750 --> 00:47:59,289
no da errores, con lo cual tiene toda la pinta

1197
00:47:59,289 --> 00:48:01,429
de que, a ver, programado, está bien

1198
00:48:01,429 --> 00:48:02,750
programado, pero

1199
00:48:02,750 --> 00:48:05,650
necesitaríamos tener un método get

1200
00:48:05,650 --> 00:48:07,449
para comprobar, a ver si

1201
00:48:07,449 --> 00:48:09,610
lo ha metido, necesitaríamos tener esto

1202
00:48:09,610 --> 00:48:11,449
desde igual a cero, mientras si

1203
00:48:11,449 --> 00:48:12,269
sea menor que

1204
00:48:12,269 --> 00:48:15,070
cadenas.size

1205
00:48:15,070 --> 00:48:16,929
Estos dos métodos los necesitaría

1206
00:48:16,929 --> 00:48:17,530
Como poco

1207
00:48:17,530 --> 00:48:20,170
Cadenas.size

1208
00:48:20,170 --> 00:48:23,250
Incrementando y más más

1209
00:48:23,250 --> 00:48:26,530
Pues iso

1210
00:48:26,530 --> 00:48:28,510
Cadenas.get

1211
00:48:29,070 --> 00:48:31,329
De i

1212
00:48:31,329 --> 00:48:33,690
Es decir, jolín

1213
00:48:33,690 --> 00:48:36,590
Quiero un size en mi linked list

1214
00:48:36,590 --> 00:48:37,369
Y quiero un get

1215
00:48:37,369 --> 00:48:38,929
¿Vale?

1216
00:48:40,070 --> 00:48:42,309
Bueno, pues el que se anime

1217
00:48:42,309 --> 00:48:44,650
Que haga el size

1218
00:48:44,650 --> 00:48:45,250
y el get

1219
00:48:45,250 --> 00:48:46,949
aquí en esta clase

1220
00:48:46,949 --> 00:48:49,429
si no lloraremos mañana