1
00:00:00,000 --> 00:00:05,580
Bueno, pues vamos a avanzar un poquito

2
00:00:05,580 --> 00:00:17,100
y vamos a introducir las colecciones, ¿vale?

3
00:00:17,160 --> 00:00:19,559
Porque ya nos las está pidiendo el cuerpo.

4
00:00:19,699 --> 00:00:23,120
Ya estamos hartos de los Arrays.

5
00:00:23,859 --> 00:00:27,079
Porque son un rollo, los Arrays, realmente.

6
00:00:27,879 --> 00:00:28,120
¿Vale?

7
00:00:30,219 --> 00:00:32,020
¿Para qué hemos usado los Arrays?

8
00:00:32,020 --> 00:00:33,960
Han sido imprescindibles

9
00:00:33,960 --> 00:00:37,140
cuando necesitábamos guardar muchos datos

10
00:00:37,140 --> 00:00:38,920
del mismo tipo

11
00:00:38,920 --> 00:00:40,740
del mismo tipo

12
00:00:40,740 --> 00:00:43,000
o de la misma superclase

13
00:00:43,000 --> 00:00:44,600
todos ellos, ¿vale?

14
00:00:44,600 --> 00:00:46,899
en ambos casos los podíamos guardar en el mismo array

15
00:00:46,899 --> 00:00:47,979
ese array se queda

16
00:00:47,979 --> 00:00:51,359
declarado como la superclase

17
00:00:51,359 --> 00:00:54,399
y ya está, ¿vale?

18
00:00:55,179 --> 00:00:56,920
entonces, ha sido imprescindible

19
00:00:56,920 --> 00:00:58,460
si yo quiero guardar

20
00:00:58,460 --> 00:01:00,979
un montón de empleados

21
00:01:00,979 --> 00:01:03,380
un montón de ellos

22
00:01:03,380 --> 00:01:04,280
10, 100

23
00:01:04,280 --> 00:01:07,280
no puedo guardarlos en variables independientes

24
00:01:07,280 --> 00:01:08,359
podría, por supuesto

25
00:01:08,359 --> 00:01:10,579
pero ¿cuántas variables hago? 100

26
00:01:10,579 --> 00:01:12,920
y si luego aparece uno, me meto en el código

27
00:01:12,920 --> 00:01:13,939
y hago una variable más

28
00:01:13,939 --> 00:01:16,739
cuando tenga luego que recoger los empleados

29
00:01:16,739 --> 00:01:19,099
para procesarlos

30
00:01:19,099 --> 00:01:20,959
como hago, son variables sueltas

31
00:01:20,959 --> 00:01:22,980
obviamente, así no podíamos

32
00:01:22,980 --> 00:01:23,920
trabajar

33
00:01:23,920 --> 00:01:27,200
entonces cuando teníamos que usar un montón

34
00:01:27,200 --> 00:01:28,739
de datos del mismo tipo

35
00:01:28,739 --> 00:01:30,799
o de la misma super clase

36
00:01:30,799 --> 00:01:32,219
o de la misma super clase

37
00:01:32,219 --> 00:01:33,879
pues usábamos el array

38
00:01:33,879 --> 00:01:37,540
y esa estructura es una estructura imprescindible

39
00:01:37,540 --> 00:01:41,019
para poder hacer cualquier programa de programación estructurada

40
00:01:41,019 --> 00:01:43,700
y está en todos los lenguajes de programación estructurados

41
00:01:43,700 --> 00:01:46,719
ya sabemos cómo se maneja y todo eso

42
00:01:46,719 --> 00:01:50,459
y también sabemos que es un poco rollo

43
00:01:50,459 --> 00:01:52,719
porque cuando uno la declara

44
00:01:52,719 --> 00:02:00,900
tiene que comprometerse a definir un tamaño

45
00:02:00,900 --> 00:02:04,390
uno, no hay otra

46
00:02:04,390 --> 00:02:06,129
porque así funcionan los arrays

47
00:02:06,129 --> 00:02:19,789
Entonces, si yo pongo 10 en el momento de instanciar ese objeto Array, si yo pongo 10, esto se ha convertido en un Array de 10 posiciones y así va a ser para siempre.

48
00:02:23,090 --> 00:02:35,460
Entonces, una vez construido, es una estructura muy rápida de acceder. Yo accedo por su índice 0, 1, 2 y el acceso es muy rápido. Doy el índice y accedo.

49
00:02:37,439 --> 00:02:51,780
Pero, que quiero incorporar un dato nuevo que me ha aparecido posteriormente, pues este array ya no me vale, es imposible. Tenemos que hacer otro y no hay otra. Es así sí o sí.

50
00:02:51,780 --> 00:02:54,099
a ese otro moveré

51
00:02:54,099 --> 00:03:07,969
a ese otro moveré

52
00:03:07,969 --> 00:03:13,669
moveré lo viejo

53
00:03:13,669 --> 00:03:17,810
añadiré lo nuevo

54
00:03:17,810 --> 00:03:20,729
y este se va a la basura porque no hay otra

55
00:03:20,729 --> 00:03:22,229
y la referencia antigua

56
00:03:22,229 --> 00:03:24,150
ahora empieza a apuntar a esto

57
00:03:24,150 --> 00:03:26,930
y no hay otra manera de trabajar con Arrays

58
00:03:26,930 --> 00:03:28,750
¿vale? entonces en realidad

59
00:03:28,750 --> 00:03:30,050
no es un problema

60
00:03:30,050 --> 00:03:33,870
no es un problema, lo que pasa es que a nivel de código

61
00:03:33,870 --> 00:03:36,830
a nivel de escritura de código es un rollo

62
00:03:36,830 --> 00:03:39,889
porque a nivel de escritura de código tenemos que hacer todo esto

63
00:03:39,889 --> 00:03:42,650
que hemos hecho mil veces, crear el array nuevo

64
00:03:42,650 --> 00:03:46,030
con las nuevas posiciones, más posiciones

65
00:03:46,030 --> 00:03:48,430
o menos posiciones, depende de si queremos

66
00:03:48,430 --> 00:03:52,409
insertar o eliminar, hacer las copias

67
00:03:52,409 --> 00:03:55,030
que procedan y luego ya sustituir

68
00:03:55,710 --> 00:03:58,409
la referencia que apuntaba aquí, sustituirla por esta

69
00:03:58,409 --> 00:04:00,629
Entonces este, el viejo

70
00:04:00,629 --> 00:04:03,509
Ya sabemos que entonces se queda

71
00:04:03,509 --> 00:04:05,050
Desapuntado

72
00:04:05,050 --> 00:04:07,669
Ahí ya nadie le quiere

73
00:04:07,669 --> 00:04:09,090
No hay manera de acceder a él

74
00:04:09,090 --> 00:04:12,169
No pasa nada, durante unos milisegundos

75
00:04:12,169 --> 00:04:12,689
No más

76
00:04:12,689 --> 00:04:15,530
Se va a quedar ahí en memoria, ocupando memoria

77
00:04:15,530 --> 00:04:16,649
Durante unos milisegundos

78
00:04:16,649 --> 00:04:18,350
Pero al cabo de ciertos milisegundos

79
00:04:18,350 --> 00:04:20,089
El recolector de basura, pipipi

80
00:04:20,089 --> 00:04:22,550
Ese proceso demonio, pues despierta

81
00:04:22,550 --> 00:04:25,110
Y dice, uy, aquí hay algo en memoria

82
00:04:25,110 --> 00:04:27,670
Que no tiene ni una sola referencia

83
00:04:27,670 --> 00:04:30,250
en el código, en el proceso, ni una

84
00:04:30,250 --> 00:04:32,110
pues hala, fuera

85
00:04:32,110 --> 00:04:33,709
y lo quita

86
00:04:33,709 --> 00:04:34,509
¿vale?

87
00:04:36,509 --> 00:04:37,389
sí, puedes

88
00:04:37,389 --> 00:04:39,089
¿vale?

89
00:04:44,100 --> 00:04:45,060
bueno, pues entonces

90
00:04:45,060 --> 00:04:47,740
nos es pesado trabajar con Arrays

91
00:04:47,740 --> 00:04:50,060
a nivel de escritura de código

92
00:04:50,060 --> 00:04:51,860
esa es la conclusión, nos es pesado

93
00:04:51,860 --> 00:04:53,259
porque tenemos que hacer todo el rato

94
00:04:53,259 --> 00:04:54,959
esa creación nueva

95
00:04:54,959 --> 00:04:56,920
copiado y eliminado

96
00:04:56,920 --> 00:04:59,839
entonces, ¿qué

97
00:04:59,839 --> 00:05:02,279
soluciones podemos adoptar

98
00:05:02,279 --> 00:05:05,120
vale, pues vamos a

99
00:05:05,120 --> 00:05:07,319
encerrar esta complejidad

100
00:05:07,319 --> 00:05:08,500
en un objeto

101
00:05:08,500 --> 00:05:10,879
que me ofrezca métodos

102
00:05:10,879 --> 00:05:12,100
que ya me lo haga

103
00:05:12,100 --> 00:05:15,060
pero que me haga eso, porque es que no hay otra que me lo haga

104
00:05:15,060 --> 00:05:17,699
voy a encerrar esto en una clase

105
00:05:17,699 --> 00:05:19,459
en una clase

106
00:05:19,459 --> 00:05:21,439
que me ofrezca

107
00:05:21,439 --> 00:05:23,100
métodos para hacer estas cosas

108
00:05:23,100 --> 00:05:24,680
y que ya lo haga

109
00:05:24,680 --> 00:05:26,100
esa clase por dentro

110
00:05:26,100 --> 00:05:27,800
entonces yo llamo a esa clase

111
00:05:27,800 --> 00:05:29,560
llamo a esos métodos

112
00:05:29,560 --> 00:05:31,660
y ya está. Lo que está ocurriendo

113
00:05:31,660 --> 00:05:33,079
en Java por dentro es lo mismo.

114
00:05:34,120 --> 00:05:36,019
Pero al meter yo esto en una clase

115
00:05:36,019 --> 00:05:37,860
encerradita, con unos

116
00:05:37,860 --> 00:05:39,779
métodos, puedo usar esa clase

117
00:05:39,779 --> 00:05:41,720
llámala los métodos y a nivel de escritura

118
00:05:41,720 --> 00:05:43,060
de código es más sencillo.

119
00:05:44,399 --> 00:05:45,959
Vale, pues esa clase, ¿cuál es?

120
00:05:47,019 --> 00:05:47,720
Es la famosa

121
00:05:47,720 --> 00:05:49,379
clase ArrayList que tanto os gusta.

122
00:05:55,629 --> 00:05:57,129
¿Vale? Entonces,

123
00:05:57,269 --> 00:05:59,069
¿qué es una ArrayList? Primer

124
00:05:59,069 --> 00:06:01,089
ejemplo de colecciones. Primer ejemplo.

125
00:06:01,550 --> 00:06:02,730
Para que entendamos la idea,

126
00:06:02,730 --> 00:06:04,750
los colecciones no es que sea algo

127
00:06:04,750 --> 00:06:06,350
nuevo, no, no hay nada nuevo

128
00:06:06,350 --> 00:06:08,389
todo lo que hay en Java

129
00:06:08,389 --> 00:06:10,430
todo, ya lo conocemos

130
00:06:10,430 --> 00:06:12,410
porque solamente hay variables

131
00:06:12,410 --> 00:06:14,550
primitivas y arrays

132
00:06:14,550 --> 00:06:15,589
no hay más

133
00:06:15,589 --> 00:06:18,470
y sentencias de control como

134
00:06:18,470 --> 00:06:20,329
if, for, while, switch

135
00:06:20,329 --> 00:06:22,569
ya está, no hay más, todo lo que hay

136
00:06:22,569 --> 00:06:24,569
a partir de ahí es meter esas cosas

137
00:06:24,569 --> 00:06:25,389
en clases

138
00:06:25,389 --> 00:06:27,689
para usarlas nosotros

139
00:06:27,689 --> 00:06:30,290
muchas de esas clases

140
00:06:30,290 --> 00:06:32,069
lógicamente se distribuyen

141
00:06:32,069 --> 00:06:34,629
en la librería que acompaña a la máquina

142
00:06:34,629 --> 00:06:36,430
virtual, la que nosotros llamamos la JRE

143
00:06:36,430 --> 00:06:38,889
ahí sabemos que hay como 2.000 millones de clases

144
00:06:38,889 --> 00:06:40,069
¿vale?

145
00:06:40,589 --> 00:06:41,790
pues como Scanner

146
00:06:41,790 --> 00:06:44,649
como System.out, como un montón

147
00:06:44,649 --> 00:06:46,870
de clases, pues todas esas clases

148
00:06:46,870 --> 00:06:48,790
tienen dentro lo único que se puede

149
00:06:48,790 --> 00:06:50,410
hacer, que es

150
00:06:50,410 --> 00:06:52,410
combinación de variables primitivas

151
00:06:52,410 --> 00:06:54,509
Arrays y sentencias de control como

152
00:06:54,509 --> 00:06:55,629
EFIFOR, no hay más

153
00:06:55,629 --> 00:06:58,329
entonces aparte de las clases que ya

154
00:06:58,329 --> 00:07:00,490
vienen incorporadas en la máquina

155
00:07:00,490 --> 00:07:02,410
virtual a las que yo llamo

156
00:07:02,410 --> 00:07:03,329
desde mi programa

157
00:07:03,329 --> 00:07:06,110
uno se hace ya sus propias clases

158
00:07:06,110 --> 00:07:08,529
para crearse datos más complejos

159
00:07:08,529 --> 00:07:09,310
datos objetos

160
00:07:09,310 --> 00:07:10,750
¿vale? datos objetos

161
00:07:10,750 --> 00:07:12,529
y no hay más que eso

162
00:07:12,529 --> 00:07:15,290
bueno, pues las colecciones son eso

163
00:07:15,290 --> 00:07:18,250
clases que ya están hechas

164
00:07:18,250 --> 00:07:20,170
que podríamos hacer nosotros

165
00:07:20,170 --> 00:07:22,889
y alguna la vamos a hacer ahora

166
00:07:22,889 --> 00:07:23,949
podríamos hacer nosotros

167
00:07:23,949 --> 00:07:25,569
clases que ya están hechas

168
00:07:25,569 --> 00:07:28,610
que ocultan

169
00:07:28,610 --> 00:07:31,310
encapsulan dentro de ellas

170
00:07:31,310 --> 00:07:33,389
una forma de guardar objetos

171
00:07:33,389 --> 00:07:36,990
que yo puedo usar desde fuera

172
00:07:36,990 --> 00:07:39,410
y por tanto me olvido de la complejidad

173
00:07:39,410 --> 00:07:40,949
de cómo están almacenados

174
00:07:40,949 --> 00:07:43,209
yo me limito a una caja

175
00:07:43,209 --> 00:07:45,490
mete en la caja, saca, recorre

176
00:07:45,490 --> 00:07:46,930
¿vale? esas son las colecciones

177
00:07:46,930 --> 00:07:49,610
las colecciones son como si fueran

178
00:07:49,610 --> 00:07:50,829
cajas

179
00:07:50,829 --> 00:07:54,579
para meter datos

180
00:07:54,579 --> 00:08:01,000
es decir, en realidad

181
00:08:01,000 --> 00:08:04,319
como si fuera un array, un array es eso, una caja para meter datos

182
00:08:04,319 --> 00:08:06,379
pero las colecciones

183
00:08:06,379 --> 00:08:08,600
me envuelven toda esa complejidad

184
00:08:08,600 --> 00:08:10,439
me la encierran dentro y me ofrecen unos

185
00:08:10,439 --> 00:08:12,540
métodos para que yo llamando

186
00:08:12,540 --> 00:08:14,560
a los métodos se hagan esas

187
00:08:14,560 --> 00:08:16,519
cosas sin que yo las tenga

188
00:08:16,519 --> 00:08:18,319
que hacer directamente por código

189
00:08:18,319 --> 00:08:20,480
ya está, simplemente eso, sin que yo

190
00:08:20,480 --> 00:08:21,980
las tenga que hacer por código, nada más

191
00:08:21,980 --> 00:08:24,579
bueno, pues cajitas de estas

192
00:08:24,579 --> 00:08:26,579
es decir, colecciones, clases de estas

193
00:08:26,579 --> 00:08:28,500
que envuelven esa complejidad de meter

194
00:08:28,500 --> 00:08:30,399
cosas en las cajas y sacarlas

195
00:08:30,399 --> 00:08:32,519
hay muchas

196
00:08:32,519 --> 00:08:34,120
muchas posibilidades

197
00:08:34,120 --> 00:08:38,080
en función de qué tipo de almacenamiento me interese a mí

198
00:08:38,080 --> 00:08:40,919
o qué tipo de uso voy a hacer yo de ese almacenamiento.

199
00:08:41,399 --> 00:08:43,220
Hay muchas posibilidades, ¿vale?

200
00:08:44,000 --> 00:08:45,419
Ahora las vamos a ver en detalle.

201
00:08:45,820 --> 00:08:46,539
Ahora las vamos a ver en detalle.

202
00:08:47,220 --> 00:08:49,679
Pero antes de nada, para motivar un poquito

203
00:08:49,679 --> 00:08:50,860
de dónde sale todo esto,

204
00:08:52,279 --> 00:08:56,279
vamos a ver, hemos puesto el ejemplo del ArrayList, ¿vale?

205
00:08:56,860 --> 00:08:58,279
Entonces, ¿qué es un ArrayList?

206
00:08:58,820 --> 00:09:01,279
Un ArrayList es una clase que ya está hecha en Java,

207
00:09:01,639 --> 00:09:03,559
pero que podríamos hacer nosotros perfectamente.

208
00:09:04,120 --> 00:09:06,840
que me envuelve la complejidad

209
00:09:06,840 --> 00:09:08,879
de meter cosas en el array y sacarlas

210
00:09:08,879 --> 00:09:10,559
eso es un ArrayList, no es más que eso

211
00:09:10,559 --> 00:09:14,710
entonces si nosotros hiciéramos un

212
00:09:14,710 --> 00:09:15,950
ArrayList nuestro

213
00:09:15,950 --> 00:09:26,269
pues porque se nos podría haber ocurrido a nosotros

214
00:09:26,269 --> 00:09:28,870
en lugar de usar el ArrayList que ya viene en Java

215
00:09:28,870 --> 00:09:30,490
se nos podría haber ocurrido

216
00:09:30,490 --> 00:09:32,389
jolines, cada vez que meto en un Array

217
00:09:32,389 --> 00:09:34,789
estoy todo el rato repitiendo

218
00:09:34,789 --> 00:09:36,549
el mismo código, que es

219
00:09:36,549 --> 00:09:38,509
crea array auxiliar con una posición más

220
00:09:38,509 --> 00:09:41,029
copia, añade el nuevo

221
00:09:41,029 --> 00:09:43,210
elimina el anterior y sustituye

222
00:09:43,210 --> 00:10:01,600
Cada vez que estoy eliminando de una vez es lo mismo, crear uno con una posición menos, copia saltándote el de eliminar, estoy haciendo eso todo el rato. Otro principio de desarrollo es no repetirse, no te repitas, no te repitas, no te repitas, si lo puedes evitar no te repitas, ¿vale?

223
00:10:01,600 --> 00:10:04,919
bueno, pues se nos podría

224
00:10:04,919 --> 00:10:06,580
haber ocurrido, se nos podría haber ocurrido

225
00:10:06,580 --> 00:10:09,039
y decir, jolines, me voy a hacer yo una clase

226
00:10:09,039 --> 00:10:10,840
que pueda usar

227
00:10:10,840 --> 00:10:12,700
siempre que quiera usar un array

228
00:10:12,700 --> 00:10:15,039
y que esa clase tenga métodos

229
00:10:15,039 --> 00:10:17,120
dentro para encerrar esa complejidad

230
00:10:17,120 --> 00:10:18,720
de insertar en el array

231
00:10:18,720 --> 00:10:20,879
y sacar del array, y así no tengo que repetirme

232
00:10:20,879 --> 00:10:22,460
todo el rato con el mismo código

233
00:10:22,460 --> 00:10:24,700
¿vale? se nos podría haber ocurrido

234
00:10:24,700 --> 00:10:26,000
hacer esa clase a nosotros

235
00:10:26,000 --> 00:10:28,720
lo que pasa es que, bueno, que ya está hecha, es el array list

236
00:10:28,720 --> 00:10:30,659
si se nos hubiera ocurrido

237
00:10:30,659 --> 00:10:31,840
hacer esa clase a nosotros

238
00:10:31,840 --> 00:10:34,960
pues podríamos haber hecho por ejemplo esta clase

239
00:10:34,960 --> 00:10:36,720
¿vale? esta clase que está pensada

240
00:10:36,720 --> 00:10:37,820
para ser una cajita

241
00:10:37,820 --> 00:10:40,919
una cajita con datos

242
00:10:40,919 --> 00:10:42,720
y además con la

243
00:10:42,720 --> 00:10:44,480
posibilidad de tener un comportamiento

244
00:10:44,480 --> 00:10:46,179
del tipo pues meter

245
00:10:46,179 --> 00:10:49,759
sacar

246
00:10:49,759 --> 00:10:52,460
o sea consultar

247
00:10:52,460 --> 00:10:53,360
eliminar

248
00:10:53,360 --> 00:10:58,159
a ver

249
00:10:58,159 --> 00:10:59,299
se me ha roto el roto

250
00:10:59,299 --> 00:11:14,860
bueno pues si se nos hubiera ocurrido hacer a nosotros

251
00:11:14,860 --> 00:11:15,539
esa caja

252
00:11:15,539 --> 00:11:17,980
que habríamos dicho, vale

253
00:11:17,980 --> 00:11:20,059
los objetos

254
00:11:20,059 --> 00:11:22,159
miArrayList, los objetos

255
00:11:22,159 --> 00:11:23,879
cada vez que yo instancie

256
00:11:23,879 --> 00:11:25,720
un objeto miArrayList

257
00:11:25,720 --> 00:11:28,000
es decir, cada vez que hagamos

258
00:11:28,000 --> 00:11:28,899
esto en mi código

259
00:11:28,899 --> 00:11:31,840
cada vez que yo instancie

260
00:11:31,840 --> 00:11:33,480
un objeto miArrayList

261
00:11:33,480 --> 00:11:36,889
cada vez que yo lo instancie

262
00:11:36,889 --> 00:11:39,090
lo que querré que se cree

263
00:11:39,090 --> 00:11:41,250
lo que querré

264
00:11:41,250 --> 00:11:42,389
que se cree, lo he dicho bien

265
00:11:42,389 --> 00:11:44,909
lo que querré crear

266
00:11:44,909 --> 00:11:47,509
es una caja para meter datos

267
00:11:47,509 --> 00:11:49,070
eso es lo que querré crear

268
00:11:49,070 --> 00:11:51,149
cuando instancio mi ArrayList

269
00:11:51,149 --> 00:11:51,990
vale

270
00:11:51,990 --> 00:11:54,570
pues para que este objeto

271
00:11:54,570 --> 00:11:57,049
me sirva para meter muchos datos

272
00:11:57,049 --> 00:11:59,450
tendrá que tener

273
00:11:59,450 --> 00:12:01,110
dentro una propiedad

274
00:12:01,110 --> 00:12:02,610
que lo permita

275
00:12:02,610 --> 00:12:05,450
pues mi ArrayList no le queda más remedio

276
00:12:05,450 --> 00:12:07,330
que tener dentro una propiedad

277
00:12:07,330 --> 00:12:07,789
Array

278
00:12:07,789 --> 00:12:10,429
porque ese es el objeto mi ArrayList

279
00:12:10,429 --> 00:12:12,149
el objeto mi ArrayList es un objeto

280
00:12:12,149 --> 00:12:13,629
que me tiene que servir

281
00:12:13,629 --> 00:12:16,110
para guardar dentro un montón de cosas.

282
00:12:16,450 --> 00:12:17,990
Para guardar dentro un montón de cosas.

283
00:12:18,889 --> 00:12:28,019
Vale, pues tendrá que tener aquí un array de cositas.

284
00:12:28,500 --> 00:12:28,600
¿Vale?

285
00:12:28,659 --> 00:12:30,820
Entonces, ah, nos vendía la primera pregunta,

286
00:12:30,960 --> 00:12:34,240
que es, pero espérate, yo cuando declaro un array

287
00:12:34,240 --> 00:12:36,100
tengo que poner aquí siempre el tipo de dato,

288
00:12:36,340 --> 00:12:37,700
siempre, lógicamente.

289
00:12:38,919 --> 00:12:43,259
Entonces, este mi array list no me va a valer

290
00:12:43,259 --> 00:12:45,080
para cualquier tipo de dato,

291
00:12:45,080 --> 00:12:47,000
porque yo aquí si pongo string

292
00:12:47,000 --> 00:12:49,480
solo me va a valer para una caja

293
00:12:49,480 --> 00:12:51,559
de muchos string, si pongo int

294
00:12:51,559 --> 00:12:52,940
solo me va a valer para una caja

295
00:12:52,940 --> 00:12:54,320
de muchos int

296
00:12:54,320 --> 00:12:57,419
pues sí, efectivamente, no hay otra

297
00:12:57,419 --> 00:12:59,500
tendríamos que dar el salto

298
00:12:59,500 --> 00:13:00,200
a genérico

299
00:13:00,200 --> 00:13:03,080
que lo daremos más tarde

300
00:13:03,080 --> 00:13:04,759
para que esto me valga para todo

301
00:13:04,759 --> 00:13:07,000
pero ese salto a genérico no es trivial tampoco

302
00:13:07,000 --> 00:13:09,100
bueno, vamos a suponer que

303
00:13:09,100 --> 00:13:11,120
nosotros queremos hacernos

304
00:13:11,120 --> 00:13:12,639
nuestra propia colección

305
00:13:12,639 --> 00:13:15,100
para guardar solamente

306
00:13:15,100 --> 00:13:16,720
cadenas, por ejemplo, cadenas

307
00:13:16,720 --> 00:13:18,919
porque todavía no sabemos dar el salto genérico

308
00:13:18,919 --> 00:13:21,000
cadenas, pues entonces nos haríamos

309
00:13:21,000 --> 00:13:22,539
nuestra clase miArrayList

310
00:13:22,539 --> 00:13:24,840
y esto, y aquí

311
00:13:24,840 --> 00:13:25,960
pondríamos el string

312
00:13:25,960 --> 00:13:31,710
¿vale?

313
00:13:32,970 --> 00:13:34,110
bueno, pues cada vez

314
00:13:34,110 --> 00:13:36,330
que yo instancie un objeto miArrayList

315
00:13:36,330 --> 00:13:38,190
estoy instanciando una cajita

316
00:13:38,190 --> 00:13:39,129
para guardar string

317
00:13:39,129 --> 00:13:41,509
o sea, este objeto miArrayList

318
00:13:41,509 --> 00:13:43,529
está encapsulando dentro del array

319
00:13:43,529 --> 00:13:44,950
Lo está ocultando dentro, ¿vale?

320
00:13:44,950 --> 00:13:47,070
Lo que hay dentro de esta cajita en realidad es un array

321
00:13:47,070 --> 00:13:49,190
¿Vale? Eso es lo que habría ahí

322
00:13:49,190 --> 00:13:50,330
Un array de cosas, ¿vale?

323
00:13:51,110 --> 00:13:53,149
Pero para que este objeto me sirva para algo

324
00:13:53,149 --> 00:13:54,409
Este objeto que yo he creado

325
00:13:54,409 --> 00:13:55,850
El objeto new myArrayList

326
00:13:55,850 --> 00:13:57,190
Cuando yo le instancie mi programa

327
00:13:57,190 --> 00:13:59,429
Que lo llamaré como sea

328
00:13:59,429 --> 00:14:00,889
Pues yo que sea, como sea

329
00:14:00,889 --> 00:14:02,769
Pues tiene que ofrecerme

330
00:14:02,769 --> 00:14:05,549
Un comportamiento, es decir, me tiene que ofrecer

331
00:14:05,549 --> 00:14:07,830
La posibilidad de meter dentro

332
00:14:07,830 --> 00:14:09,470
Sacar, etcétera

333
00:14:09,470 --> 00:14:12,389
Bueno, pues, declaremos esos métodos

334
00:14:12,389 --> 00:14:14,549
por ejemplo,

335
00:14:14,730 --> 00:14:16,669
¿qué método básico querremos hacer?

336
00:14:17,350 --> 00:14:18,649
Querremos hacer un método

337
00:14:18,649 --> 00:14:23,990
que si yo le paso un elemento nuevo,

338
00:14:24,470 --> 00:14:27,899
como string,

339
00:14:29,480 --> 00:14:31,240
pues lo metan en el array.

340
00:14:32,059 --> 00:14:34,100
Eso es lo que yo querré hacer en esa cajita

341
00:14:34,100 --> 00:14:35,019
de mi ArrayList.

342
00:14:35,500 --> 00:14:38,000
Un método que si yo le paso un elemento nuevo

343
00:14:38,000 --> 00:14:38,799
lo metan en el array.

344
00:14:39,639 --> 00:14:39,899
¿Vale?

345
00:14:39,980 --> 00:14:42,799
Pues aquí es donde programaríamos

346
00:14:42,799 --> 00:14:45,539
Toda esa cosa que ya hemos hecho mil veces de memoria

347
00:14:45,539 --> 00:14:46,179
Sí

348
00:14:46,179 --> 00:14:58,879
Lo que tienen los lunes y la lluvia

349
00:14:58,879 --> 00:15:00,399
Pero claro

350
00:15:00,399 --> 00:15:01,740
¿A qué habéis quedado?

351
00:15:02,100 --> 00:15:02,679
¿A coger el coche?

352
00:15:03,679 --> 00:15:04,860
¿A qué habéis quedado a coger el coche?

353
00:15:04,860 --> 00:15:05,799
Todos nos habíamos separado

354
00:15:05,799 --> 00:15:07,460
Venimos separados

355
00:15:07,460 --> 00:15:10,100
Bueno

356
00:15:10,100 --> 00:15:12,679
Vale, pues aquí es donde habría que hacer

357
00:15:12,679 --> 00:15:15,559
toda esa complejidad y de envolverla

358
00:15:15,559 --> 00:15:16,940
ahí, que aquí, pues, ¿qué haríamos?

359
00:15:17,440 --> 00:15:19,299
Lo de siempre. Pues una

360
00:15:19,299 --> 00:15:20,500
array aux

361
00:15:20,500 --> 00:15:23,039
igual a new

362
00:15:23,039 --> 00:15:25,059
stream

363
00:15:25,059 --> 00:15:27,799
de len de datos

364
00:15:27,799 --> 00:15:30,879
más uno.

365
00:15:31,200 --> 00:15:33,159
Lo pongo así abreviado. Ahora,

366
00:15:33,779 --> 00:15:34,539
copiar

367
00:15:34,539 --> 00:15:37,460
datos en aux.

368
00:15:40,740 --> 00:15:41,580
Añadir

369
00:15:41,580 --> 00:15:44,840
el elemento e

370
00:15:44,840 --> 00:15:47,379
Añadirlo al aux

371
00:15:47,379 --> 00:15:48,700
En la posición libre

372
00:15:48,700 --> 00:15:51,340
Ahora sustituir

373
00:15:51,340 --> 00:15:53,240
Datos para que sea

374
00:15:53,240 --> 00:15:55,179
Aux, es decir

375
00:15:55,179 --> 00:15:56,860
Este código es el que meteríamos aquí

376
00:15:56,860 --> 00:15:58,899
¿Vale? Este código es el que meteríamos aquí

377
00:15:58,899 --> 00:16:01,460
¿Vale? Entonces una vez metido

378
00:16:01,460 --> 00:16:02,299
Ahí ya ese código

379
00:16:02,299 --> 00:16:04,820
Ahora yo ya en cualquier programa

380
00:16:04,820 --> 00:16:07,139
Que a mí me dé la gana, cada vez que yo quiera

381
00:16:07,139 --> 00:16:08,960
Trabajar con un montón de cadenas

382
00:16:08,960 --> 00:16:11,419
Me hago un objeto new mi array list

383
00:16:11,419 --> 00:16:13,340
Y ahora ya que quiero

384
00:16:13,340 --> 00:16:15,399
meter una cadena nueva? Pues a

385
00:16:15,399 --> 00:16:16,700
punto a

386
00:16:16,700 --> 00:16:18,779
la cadena nueva que sea.

387
00:16:20,379 --> 00:16:21,279
Y ya está.

388
00:16:22,720 --> 00:16:23,419
Entonces, en

389
00:16:23,419 --> 00:16:25,419
esa caja, mi ArrayList, estaré metiendo

390
00:16:25,419 --> 00:16:26,580
la cadena nueva hola.

391
00:16:27,200 --> 00:16:27,639
Entonces,

392
00:16:29,299 --> 00:16:30,779
a través de un método a,

393
00:16:32,019 --> 00:16:33,399
pues, me estoy

394
00:16:33,399 --> 00:16:35,519
ahorrando todo lo que hemos estado haciendo a mano

395
00:16:35,519 --> 00:16:36,740
todo el rato.

396
00:16:41,340 --> 00:16:42,600
Claro, esta cajita

397
00:16:42,600 --> 00:16:43,820
para ser más funcional

398
00:16:43,820 --> 00:16:45,620
me tiene que permitir

399
00:16:45,620 --> 00:16:48,440
recuperar el objeto en una posición

400
00:16:48,440 --> 00:16:50,759
concreta, dame el objeto

401
00:16:50,759 --> 00:16:52,279
que tienes en la posición 7

402
00:16:52,279 --> 00:16:54,580
vale, también tendría

403
00:16:54,580 --> 00:16:55,460
que tener ese método

404
00:16:55,460 --> 00:16:57,019
vale

405
00:16:57,019 --> 00:17:00,740
bueno, pues no pasa nada, podríamos hacerle

406
00:17:00,740 --> 00:17:01,799
a este miArrayList

407
00:17:01,799 --> 00:17:05,609
le podríamos hacer un método

408
00:17:05,609 --> 00:17:08,190
que fuera

409
00:17:08,190 --> 00:17:09,009
pues

410
00:17:09,009 --> 00:17:18,960
delete y le pasamos

411
00:17:18,960 --> 00:17:19,740
una posición

412
00:17:19,740 --> 00:17:24,640
y ahora haríamos aquí todo el código

413
00:17:24,640 --> 00:17:26,640
que ya sabemos hacer, todo el que ya sabemos

414
00:17:26,640 --> 00:17:28,579
hacer que es, me creo

415
00:17:28,579 --> 00:17:30,640
una array aux con una

416
00:17:30,640 --> 00:17:31,779
posición menos

417
00:17:31,779 --> 00:17:34,119
que la que tiene datos

418
00:17:34,119 --> 00:17:36,579
copio todo lo de

419
00:17:36,579 --> 00:17:38,640
datos en aux, saltándome

420
00:17:38,640 --> 00:17:40,440
la posición esta

421
00:17:40,440 --> 00:17:42,619
esta me la salto, una vez

422
00:17:42,619 --> 00:17:44,480
que ya lo he hecho, sustituyo datos

423
00:17:44,480 --> 00:17:46,440
por aux, lo que hemos hecho siempre

424
00:17:46,440 --> 00:17:48,839
me estoy saltando todas las validaciones

425
00:17:48,839 --> 00:17:50,460
claro, para que esto fuera más potente

426
00:17:50,460 --> 00:17:52,680
pues me estoy saltando

427
00:17:52,680 --> 00:17:53,960
las validaciones de

428
00:17:53,960 --> 00:17:56,160
verificar que la posición

429
00:17:56,160 --> 00:17:58,220
esté comprendida entre

430
00:17:58,220 --> 00:18:00,500
cero y datos.led

431
00:18:00,500 --> 00:18:02,000
menos uno, ¿vale?

432
00:18:02,019 --> 00:18:04,039
Porque si no, pues este no te puede devolver

433
00:18:04,039 --> 00:18:05,640
nada, ¿vale? Pero bueno, estoy

434
00:18:05,640 --> 00:18:08,200
hablando en general más que

435
00:18:08,200 --> 00:18:09,859
del código en particular

436
00:18:09,859 --> 00:18:12,079
de la filosofía de las colecciones,

437
00:18:12,180 --> 00:18:13,660
de qué son, eso es lo que me importa,

438
00:18:14,180 --> 00:18:15,119
¿vale? Luego este código

439
00:18:15,119 --> 00:18:17,839
pues habría que hacerlo más en detalle, claro,

440
00:18:18,460 --> 00:18:20,160
¿vale? Bueno, pues una vez que yo

441
00:18:20,160 --> 00:18:21,900
he metido ahí ese código,

442
00:18:21,900 --> 00:18:24,140
que sabemos hacerlo perfectamente, lo hemos hecho mil veces

443
00:18:24,140 --> 00:18:25,579
y se basa en lo de toda la vida

444
00:18:25,579 --> 00:18:27,000
los if, los for y los arrays

445
00:18:27,000 --> 00:18:29,579
pues que ahora yo en mi objeto

446
00:18:29,579 --> 00:18:32,240
mi array list que me he creado para guardar cadenas

447
00:18:32,240 --> 00:18:33,900
quiero eliminar la cadera

448
00:18:33,900 --> 00:18:34,900
de posición 7

449
00:18:34,900 --> 00:18:37,299
pues a punto delete

450
00:18:37,299 --> 00:18:38,819
7

451
00:18:38,819 --> 00:18:40,440
y ya está

452
00:18:40,440 --> 00:18:43,480
y así podría hacer

453
00:18:43,480 --> 00:18:45,660
incorporar aquí todos los métodos

454
00:18:45,660 --> 00:18:47,980
para hacer lo que a mi me parezca

455
00:18:47,980 --> 00:18:49,799
que es útil con una

456
00:18:49,799 --> 00:18:51,779
colección de datos, con una caja de datos

457
00:18:51,779 --> 00:19:38,329
que viene a ser añadir, eliminar, que te devuelva elemento en una posición, que sería el get, por ejemplo, aquí tendría sentido hacer otro método, que sea este método, sería muy fácil de hacer, porque te devuelve directamente, este método sería return datos de post, vale, me estoy saltando validaciones,

458
00:19:38,329 --> 00:19:39,970
el método, habría que hacerlo más

459
00:19:39,970 --> 00:19:42,369
correcto, diciendo, a ver, pos

460
00:19:42,369 --> 00:19:44,289
está comprendido entre 0

461
00:19:44,289 --> 00:19:46,269
y datos.let menos 1, porque

462
00:19:46,269 --> 00:19:48,150
si no lo está, pues no puedes

463
00:19:48,150 --> 00:19:50,490
hacer esto directamente, porque te daría

464
00:19:50,490 --> 00:19:52,190
un ArrayIndexAuronException,

465
00:19:52,410 --> 00:19:54,329
pero bueno, son detalles de implementación

466
00:19:54,329 --> 00:19:56,049
que sabréis hacer perfectamente.

467
00:19:57,309 --> 00:19:58,289
¿Vale? Lo que me

468
00:19:58,289 --> 00:20:00,170
importa ahora es que veáis lo que es

469
00:20:00,170 --> 00:20:02,210
una colección. Una colección

470
00:20:02,210 --> 00:20:04,329
es una clase que se declara

471
00:20:04,329 --> 00:20:06,289
pensada para contener datos

472
00:20:06,289 --> 00:20:09,069
y ofrecerme

473
00:20:09,069 --> 00:20:11,329
formas de manipular con ellos

474
00:20:11,329 --> 00:20:13,710
entonces cuando yo quiera un montón de datos

475
00:20:13,710 --> 00:20:16,509
me instancio una de esas colecciones

476
00:20:16,509 --> 00:20:17,650
que hay muchos tipos

477
00:20:17,650 --> 00:20:19,049
que ahora veremos cuáles

478
00:20:19,049 --> 00:20:20,789
dependiendo de lo que yo quiera hacer con los datos

479
00:20:20,789 --> 00:20:21,529
hay muchos tipos

480
00:20:21,529 --> 00:20:22,710
me instancio una de esas

481
00:20:22,710 --> 00:20:24,849
y ya tengo mi cajita

482
00:20:24,849 --> 00:20:27,230
y una vez instanciada

483
00:20:27,230 --> 00:20:30,150
pues ya meto cosas en la caja

484
00:20:30,150 --> 00:20:31,970
elimino de la caja

485
00:20:31,970 --> 00:20:33,210
recupero

486
00:20:33,210 --> 00:20:35,849
lo que sea que yo quiera ofrecer

487
00:20:35,849 --> 00:20:38,569
hacer con esos datos

488
00:20:38,569 --> 00:20:39,829
que siempre, pues es eso

489
00:20:39,829 --> 00:20:42,269
insertar nuevo en la caja

490
00:20:42,269 --> 00:20:44,670
borrar, recuperar

491
00:20:44,670 --> 00:20:46,450
y poco más

492
00:20:46,450 --> 00:20:48,430
decirme el tamaño

493
00:20:48,430 --> 00:20:49,910
que tiene, cosas de esas

494
00:20:49,910 --> 00:20:52,710
¿vale? pues esto es una colección

495
00:20:52,710 --> 00:20:54,049
una clase que ya está hecha

496
00:20:54,049 --> 00:20:56,390
para ahorrarnos, hacer lo que ya

497
00:20:56,390 --> 00:20:57,170
sabemos hacer

498
00:20:57,170 --> 00:21:00,470
¿vale? y estas clases, su objetivo es

499
00:21:00,470 --> 00:21:02,490
ofrecerme a mí la posibilidad

500
00:21:02,490 --> 00:21:04,390
de trabajar con un montón de datos

501
00:21:04,390 --> 00:21:06,730
escondiendo la complejidad

502
00:21:06,730 --> 00:21:08,490
de la RAI, que en realidad el RAI

503
00:21:08,490 --> 00:21:10,650
es lo único que hay nativo

504
00:21:10,650 --> 00:21:12,690
entre comillas en Java para guardar muchos datos

505
00:21:12,690 --> 00:21:14,049
es lo único, ¿vale?

506
00:21:14,069 --> 00:21:16,509
todo lo demás está hecho por clases que esconden

507
00:21:16,509 --> 00:21:18,549
esa complejidad, yo las instancio, las llamo

508
00:21:18,549 --> 00:21:21,029
y ya está, esta es la idea de una colección

509
00:21:21,029 --> 00:21:22,529
esto es lo que es una colección

510
00:21:22,529 --> 00:21:24,390
¿vale? ¿qué ibas a preguntar?

511
00:21:24,670 --> 00:21:26,670
no, que estaba pensando en por qué no le hacemos

512
00:21:26,670 --> 00:21:28,410
static esto, pero

513
00:21:28,410 --> 00:21:30,569
yo no sé si esto, o sea, la idea

514
00:21:30,569 --> 00:21:31,309
¿static el qué?

515
00:21:31,309 --> 00:21:33,490
Sí, las clases y los métodos

516
00:21:33,490 --> 00:21:35,069
No, las clases no pueden ser estáticas

517
00:21:35,069 --> 00:21:36,970
O sea, perdón, el método, los métodos

518
00:21:36,970 --> 00:21:39,369
Hombre, para que los métodos sean estáticos

519
00:21:39,369 --> 00:21:40,549
Esto tendría que ser estático

520
00:21:40,549 --> 00:21:43,210
Pero si esto es estático, no, o sea

521
00:21:43,210 --> 00:21:45,329
Cada objeto miArrayList

522
00:21:45,329 --> 00:21:47,750
Que tú instancies, es una caja distinta

523
00:21:47,750 --> 00:21:48,630
O sea, tú quieres

524
00:21:48,630 --> 00:21:51,150
Por ejemplo, uno puede ser nombres, aquí tienes los nombres

525
00:21:51,150 --> 00:21:53,150
Otro puede ser apellidos

526
00:21:53,150 --> 00:21:54,329
Pues otra nueva de apellidos

527
00:21:54,329 --> 00:21:56,970
Cada cajita miArrayList tiene su propia array

528
00:21:56,970 --> 00:21:59,109
O sea, tú quieres esto, me voy a usar ahora

529
00:21:59,109 --> 00:22:01,130
Arrays normales, quiero usar solo Arrays

530
00:22:01,130 --> 00:22:03,170
list, o sea, para aplicar

531
00:22:03,170 --> 00:22:03,710
todas estas cosas.

532
00:22:04,910 --> 00:22:07,089
O sea, si yo hago yo una nueva array, entonces

533
00:22:07,089 --> 00:22:08,329
mejor lo instancio como

534
00:22:08,329 --> 00:22:10,970
array list y ya está. Hombre, más cómodo

535
00:22:10,970 --> 00:22:11,890
que hagas una colección.

536
00:22:13,150 --> 00:22:15,009
Más cómodo que instancies

537
00:22:15,009 --> 00:22:17,029
un objeto array list porque te vas

538
00:22:17,029 --> 00:22:18,190
a dar a escribir tu código.

539
00:22:19,250 --> 00:22:21,069
No porque sea mejor a nivel

540
00:22:21,069 --> 00:22:22,450
de código. Siempre va a ser mejor

541
00:22:22,450 --> 00:22:24,289
todo lo que tú programes

542
00:22:24,289 --> 00:22:26,289
porque tienes un absoluto control

543
00:22:26,289 --> 00:22:28,890
de lo que realmente se va a ejecutar. Desde el momento

544
00:22:28,890 --> 00:22:31,029
que te vienes a llamar a métodos y a delegar

545
00:22:31,029 --> 00:22:33,170
acciones en esos métodos ya pierdes

546
00:22:33,170 --> 00:22:34,289
el control de cómo lo hacen

547
00:22:34,289 --> 00:22:37,049
pero desde luego es mucho más cómodo

548
00:22:37,049 --> 00:22:39,109
a nivel de escritura de código es mucho más cómodo

549
00:22:39,109 --> 00:22:40,109
en lugar de hacerte tú

550
00:22:40,109 --> 00:22:43,130
tu array de nombres, tu array de

551
00:22:43,130 --> 00:22:45,430
apellidos, tu array de notas

552
00:22:45,430 --> 00:22:47,170
puestos de instancias

553
00:22:47,170 --> 00:22:48,769
un objeto array list para tus nombres

554
00:22:48,769 --> 00:22:50,529
que tendrá dentro su propio array

555
00:22:50,529 --> 00:22:52,849
un objeto array list para los apellidos

556
00:22:52,849 --> 00:22:54,450
que tendrá dentro su propio array

557
00:22:54,450 --> 00:22:56,730
un objeto array list para las notas

558
00:22:56,730 --> 00:22:58,289
que tendrá dentro su propio array

559
00:22:58,289 --> 00:22:59,930
y luego ya

560
00:22:59,930 --> 00:23:02,390
cada cosa que quieras hacer

561
00:23:02,390 --> 00:23:04,190
con cada cajita, pues llamas a los

562
00:23:04,190 --> 00:23:05,109
métodos de ese objeto

563
00:23:05,109 --> 00:23:07,970
¿vale? en la cajita A

564
00:23:07,970 --> 00:23:09,410
quiero añadir un nombre nuevo

565
00:23:09,410 --> 00:23:12,150
en la cajita B, que era la de apellidos

566
00:23:12,150 --> 00:23:13,369
quiero borrar un apellido

567
00:23:13,369 --> 00:23:16,109
entonces el código queda muchísimo más fácil

568
00:23:16,109 --> 00:23:18,250
de hacer, aunque luego se esté ejecutando

569
00:23:18,250 --> 00:23:19,609
lo mismo, porque

570
00:23:19,609 --> 00:23:22,230
cada vez que tú llamas a Adelete

571
00:23:22,230 --> 00:23:24,009
te estás metiendo en un método

572
00:23:24,009 --> 00:23:26,329
que hace lo que hemos hecho nosotros todo el rato

573
00:23:26,329 --> 00:23:28,349
¿vale?

574
00:23:28,349 --> 00:23:30,509
Pero Java esto te lo da

575
00:23:30,509 --> 00:23:32,789
Java de por sí ya tiene una arraylist

576
00:23:32,789 --> 00:23:33,849
Una clase de arraylist de por sí

577
00:23:33,849 --> 00:23:37,029
Claro, claro, es lo que decía

578
00:23:37,029 --> 00:23:39,710
Pero te la podrías haber hecho tú

579
00:23:39,710 --> 00:23:41,529
Las colecciones son

580
00:23:41,529 --> 00:23:43,730
Clases que nos dan ya hechas

581
00:23:43,730 --> 00:23:45,569
Como otras millones de miles de clases

582
00:23:45,569 --> 00:23:46,950
Como local que nos dan hechas

583
00:23:46,950 --> 00:23:47,890
Para apretarnos la vida

584
00:23:47,890 --> 00:23:51,349
Pero lo que tienen dentro son cosas que podríamos haber hecho nosotros

585
00:23:51,349 --> 00:23:52,069
Lógicamente

586
00:23:52,069 --> 00:23:54,650
Entonces yo por esto este le he llamado

587
00:23:54,650 --> 00:23:56,950
Mi arraylist, si lo hubiéramos tenido que hacer nosotros

588
00:23:56,950 --> 00:23:57,789
Lo habríamos hecho así

589
00:23:57,789 --> 00:24:11,289
Vale, vamos a hacer

590
00:24:11,289 --> 00:24:12,309
Una versión sencilla

591
00:24:12,309 --> 00:24:14,630
Para que lo veamos más claro

592
00:24:14,630 --> 00:24:17,109
De nuestro

593
00:24:17,109 --> 00:24:19,369
ArrayList particular y como lo usaríamos

594
00:24:19,369 --> 00:24:20,869
Y luego ya explicamos

595
00:24:20,869 --> 00:24:22,029
Porque luego ya

596
00:24:22,029 --> 00:24:24,690
Las colecciones que trae Java

597
00:24:24,690 --> 00:24:26,769
Pues no son solo ArrayList, son muchas otras

598
00:24:26,769 --> 00:24:29,170
están clasificadas en función del tipo, patatín, patatán

599
00:24:29,170 --> 00:24:31,569
y eso ya pues sí que tenemos que ver

600
00:24:31,569 --> 00:24:34,130
solamente para acabar de entender

601
00:24:34,130 --> 00:24:36,869
por qué existen las colecciones

602
00:24:36,869 --> 00:24:38,390
y cuál es su filosofía de uso

603
00:24:38,390 --> 00:24:39,910
vamos a

604
00:24:39,910 --> 00:24:42,150
si nos programáramos la nuestra propia

605
00:24:42,150 --> 00:24:43,470
¿cómo lo haríamos?

606
00:24:50,599 --> 00:24:51,119
vale

607
00:24:51,119 --> 00:24:52,960
pues venga

608
00:24:59,420 --> 00:25:03,259
En japonés.

609
00:25:22,599 --> 00:25:23,359
Vale.

610
00:25:23,359 --> 00:25:30,420
vale, pues vamos a utilizar

611
00:25:30,420 --> 00:25:31,579
este primer proyecto

612
00:25:31,579 --> 00:25:35,130
que he subido a la virtual para

613
00:25:35,130 --> 00:25:37,569
programar nuestras propias colecciones

614
00:25:37,569 --> 00:25:38,710
que el linked list también

615
00:25:38,710 --> 00:25:41,630
lo vais a programar, porque ese sí que es chulo y divertido

616
00:25:41,630 --> 00:25:43,190
el linked list

617
00:25:43,190 --> 00:25:45,309
la lista enlazada

618
00:25:45,309 --> 00:25:47,069
linked

619
00:25:47,069 --> 00:25:48,490
no es linkedin

620
00:25:48,490 --> 00:25:51,230
del linked list

621
00:25:51,230 --> 00:25:53,490
vale, me hago un paquetillo

622
00:25:53,490 --> 00:25:54,930
Por aquí un paquetillo

623
00:25:54,930 --> 00:25:56,490
Para ArrayList

624
00:25:56,490 --> 00:26:06,440
Venga, pues me voy a hacer

625
00:26:06,440 --> 00:26:08,420
Un main para motivar

626
00:26:08,420 --> 00:26:10,539
Lo interesante que puede ser esto

627
00:26:10,539 --> 00:26:22,900
Pues resulta que yo tengo aquí un programa

628
00:26:22,900 --> 00:26:24,579
Que me pide trabajar

629
00:26:24,579 --> 00:26:26,440
Con un montón de nombres

630
00:26:26,440 --> 00:26:29,259
Y un montón de notas, por ejemplo

631
00:26:29,259 --> 00:26:30,779
O lo que sea, vale

632
00:26:30,779 --> 00:26:33,160
Entonces, joder, tengo que trabajar con un montón de nombres

633
00:26:33,160 --> 00:26:34,019
Haciendo cosas

634
00:26:34,019 --> 00:26:35,799
Pues nada

635
00:26:35,799 --> 00:26:39,180
Tengo que trabajar con un montón de nombres

636
00:26:39,180 --> 00:26:42,460
Pues nos haríamos esto

637
00:26:42,460 --> 00:26:45,220
Y ya tendríamos el primer problemilla

638
00:26:45,220 --> 00:26:46,240
Que es

639
00:26:46,240 --> 00:26:48,240
Jolines

640
00:26:48,240 --> 00:26:49,319
Que rollo

641
00:26:49,319 --> 00:26:52,779
Tener que decidir desde ya el tamaño

642
00:26:52,779 --> 00:26:54,180
Que rollo

643
00:26:54,180 --> 00:26:56,940
Vale, pues esta es la primera

644
00:26:56,940 --> 00:26:59,299
Complejidad que vamos a envolver

645
00:26:59,299 --> 00:27:01,019
Con nuestra clase

646
00:27:01,019 --> 00:27:02,259
Mi ArrayList

647
00:27:02,259 --> 00:27:03,940
Esta es la primera cosa

648
00:27:03,940 --> 00:27:07,220
que vamos a ocultar ya

649
00:27:07,220 --> 00:27:08,119
para que no moleste

650
00:27:08,119 --> 00:27:10,740
porque ahora uno sueña despierto

651
00:27:10,740 --> 00:27:12,900
y dice, jolín, ojalá

652
00:27:12,900 --> 00:27:14,759
yo tuviera una clase

653
00:27:14,759 --> 00:27:24,720
ojalá yo tuviera una clase

654
00:27:24,720 --> 00:27:31,859
así de largo

655
00:27:31,859 --> 00:27:32,980
los hay, y más

656
00:27:32,980 --> 00:27:33,680
y más

657
00:27:33,680 --> 00:27:37,779
ya veréis como seis fringos

658
00:27:37,779 --> 00:27:40,259
Vale, pues ojalá yo tuviera una clase

659
00:27:40,259 --> 00:27:42,359
Que en lugar de lo de arriba

660
00:27:42,359 --> 00:27:45,160
Me permitiera hacer esto

661
00:27:45,160 --> 00:27:48,359
Yo la instancio

662
00:27:48,359 --> 00:27:48,920
Sin más

663
00:27:48,920 --> 00:27:52,079
Y el tamaño que se adapte

664
00:27:52,079 --> 00:27:54,039
Yo creo la caja

665
00:27:54,039 --> 00:27:56,039
Y según meto en la caja

666
00:27:56,039 --> 00:27:57,720
Que se vaya agrandando

667
00:27:57,720 --> 00:27:58,700
Eso es un problema suyo

668
00:27:58,700 --> 00:28:01,119
Y según saco de la caja que vaya encogiendo

669
00:28:01,119 --> 00:28:01,980
Es un problema suyo

670
00:28:01,980 --> 00:28:04,200
Yo aquí en mi main no quiero problemas

671
00:28:04,200 --> 00:28:07,799
No quiero nada de tener que tomar decisiones sobre el tamaño

672
00:28:07,799 --> 00:28:09,240
No quiero, no me interesa

673
00:28:09,240 --> 00:28:10,779
Yo creo la caja

674
00:28:10,779 --> 00:28:13,019
Y que esa caja ya tenga la posibilidad

675
00:28:13,019 --> 00:28:14,420
De hacerse grande, pequeña

676
00:28:14,420 --> 00:28:16,880
Según yo le dé cosas o se las quite

677
00:28:16,880 --> 00:28:18,400
Ese es el primer problema

678
00:28:18,400 --> 00:28:19,819
Que quiero eludir

679
00:28:19,819 --> 00:28:24,099
Vale, pues vamos a crearnos esa caja

680
00:28:24,099 --> 00:28:26,039
Que nos permite olvidarnos

681
00:28:26,039 --> 00:28:27,140
De esas problemáticas

682
00:28:27,140 --> 00:28:29,599
Vamos a crearnos esta clase

683
00:28:29,599 --> 00:28:31,039
Venga

684
00:28:31,039 --> 00:28:39,000
Ahí me la he creado en el mismo paquete

685
00:28:39,000 --> 00:28:40,559
Vale, esta

686
00:28:40,559 --> 00:28:48,630
Ahí me la creo

687
00:28:48,630 --> 00:28:50,910
Esa clase que yo quiero instanciar desde aquí

688
00:28:50,910 --> 00:28:53,250
Vale

689
00:28:53,250 --> 00:28:54,569
Esta clase

690
00:28:54,569 --> 00:28:56,230
¿Para qué quería que me sirviera?

691
00:28:56,329 --> 00:28:57,549
Para guardar muchos stream

692
00:28:57,549 --> 00:28:59,130
Pues venga

693
00:28:59,130 --> 00:29:05,910
Inicialmente

694
00:29:05,910 --> 00:29:08,930
Cuando la caja se cree por primera vez

695
00:29:08,930 --> 00:29:11,309
¿Qué tamaño queremos que tenga?

696
00:29:12,589 --> 00:29:13,990
Cero pelotero

697
00:29:13,990 --> 00:29:16,089
Vale

698
00:29:16,089 --> 00:29:18,910
Yo aquí después de hacer el new

699
00:29:18,910 --> 00:29:21,349
Mi cajita

700
00:29:21,349 --> 00:29:22,150
Cero

701
00:29:22,150 --> 00:29:24,849
Ya sea la grande cuando le metamos cosas

702
00:29:24,849 --> 00:29:25,950
Ahora mismo cero

703
00:29:25,950 --> 00:29:27,670
Vale

704
00:29:27,670 --> 00:29:29,690
Y esta propiedad

705
00:29:29,690 --> 00:29:32,349
Puede ser un private magnífico

706
00:29:32,349 --> 00:29:33,130
Ahí estupendo

707
00:29:33,130 --> 00:29:36,410
Porque nadie tiene que acceder a ese array

708
00:29:36,410 --> 00:29:38,329
En absoluto

709
00:29:38,329 --> 00:29:40,230
Solamente la propia cajita

710
00:29:40,230 --> 00:29:42,470
Para meter cosas si yo se la doy y sacarlas

711
00:29:42,470 --> 00:29:44,069
Nadie más tiene que acceder a ese array

712
00:29:44,069 --> 00:29:46,509
Entonces hay un private estupendo

713
00:29:46,509 --> 00:29:49,710
Vale

714
00:29:49,710 --> 00:29:50,490
Ahora

715
00:29:50,490 --> 00:29:54,250
Ahora yo quiero meter un nombre nuevo que me han dado

716
00:29:54,250 --> 00:29:55,690
Quiero meter el primer nombre

717
00:29:55,690 --> 00:29:58,589
Jolines, pues yo quiero, ya que he creado una caja

718
00:29:58,589 --> 00:30:00,089
Que quiero que me

719
00:30:00,089 --> 00:30:02,410
Exima de todos

720
00:30:02,410 --> 00:30:03,210
Los problemas

721
00:30:03,210 --> 00:30:06,369
Pues yo quiero esto, esto es lo que yo quiero

722
00:30:06,369 --> 00:30:08,349
Yo quiero poder

723
00:30:08,349 --> 00:30:10,509
Hacer esto, añade un nombre

724
00:30:10,509 --> 00:30:12,289
Y olvidarme de todo

725
00:30:12,289 --> 00:30:14,049
Eso es lo que yo quiero hacer, desde este main

726
00:30:14,049 --> 00:30:16,769
O desde este otro main, o desde donde me dé la gana

727
00:30:16,769 --> 00:30:17,890
Esto es lo que yo quiero

728
00:30:17,890 --> 00:30:20,410
Esto es mi sueño

729
00:30:21,089 --> 00:30:24,230
Añade Luis, y ya está

730
00:30:24,230 --> 00:30:26,549
Y saber que ese nombre Luis está en la caja

731
00:30:26,549 --> 00:30:27,769
Esto es lo que yo querría

732
00:30:27,769 --> 00:30:30,089
Olvidarme de todo lo demás

733
00:30:30,089 --> 00:30:33,579
Bueno, pues para eso

734
00:30:33,579 --> 00:30:36,660
La clase miArrayListChulo, etcétera, etcétera

735
00:30:36,660 --> 00:30:38,839
Necesita tener este método

736
00:30:38,839 --> 00:30:40,000
Claro, necesita tenerlo

737
00:30:40,000 --> 00:30:40,720
No hay otra

738
00:30:40,720 --> 00:30:44,329
Bueno, cómo ver qué importará

739
00:30:44,329 --> 00:30:44,789
Hay que hacerlo

740
00:30:44,789 --> 00:30:46,910
Es una clase nueva, ¿qué estamos haciendo?

741
00:30:48,349 --> 00:30:48,990
Pues nada

742
00:30:48,990 --> 00:30:51,049
Vamos a hacer

743
00:30:51,049 --> 00:30:52,869
Este método

744
00:30:52,869 --> 00:30:57,589
Vale, pues este método

745
00:30:57,589 --> 00:30:59,890
que queremos que haga

746
00:30:59,890 --> 00:31:02,369
queremos que coja este dato

747
00:31:02,369 --> 00:31:04,789
agrande

748
00:31:04,789 --> 00:31:05,970
en una posición

749
00:31:05,970 --> 00:31:08,750
este array, lo agrande

750
00:31:08,750 --> 00:31:10,170
en una, lo meta

751
00:31:10,170 --> 00:31:12,529
y lo sustituya, bueno pues lo que hemos

752
00:31:12,529 --> 00:31:13,250
hecho mil veces

753
00:31:13,250 --> 00:31:16,049
aux igual

754
00:31:16,049 --> 00:31:24,450
new string

755
00:31:24,450 --> 00:31:25,009
de

756
00:31:25,009 --> 00:31:28,250
dato.length

757
00:31:28,250 --> 00:31:29,789
más uno

758
00:31:29,789 --> 00:31:32,349
agrandamos, hacemos una cajita

759
00:31:32,349 --> 00:31:34,329
Auxiliar con una posición más

760
00:31:34,329 --> 00:31:37,450
Datos

761
00:31:37,450 --> 00:31:39,650
Sí, vale

762
00:31:39,650 --> 00:31:42,289
Y len sin paréntesis

763
00:31:42,289 --> 00:31:43,710
Vale

764
00:31:43,710 --> 00:31:46,150
Ahora copiamos una en el otra

765
00:31:46,150 --> 00:31:52,269
Menor que

766
00:31:52,269 --> 00:31:54,109
Datos.lens

767
00:31:55,289 --> 00:31:56,109
Incrementando

768
00:31:57,150 --> 00:31:57,470
Y

769
00:31:57,470 --> 00:31:59,009
Pues que hacemos

770
00:31:59,009 --> 00:32:02,009
En aux de y queremos que vaya

771
00:32:02,009 --> 00:32:03,650
Datos de y

772
00:32:03,650 --> 00:32:05,069
Vale

773
00:32:05,069 --> 00:32:08,130
Ya hemos copiado todas las posiciones

774
00:32:08,130 --> 00:32:10,289
Salvo la adicional de AUX

775
00:32:10,289 --> 00:32:11,410
Que está vacía

776
00:32:11,410 --> 00:32:13,569
Pero claro, en la adicional de AUX

777
00:32:13,569 --> 00:32:15,289
Queremos que vaya dato

778
00:32:15,289 --> 00:32:19,799
AUX, en la adicional de AUX

779
00:32:19,799 --> 00:32:22,420
Que es AUX.len

780
00:32:22,420 --> 00:32:22,900
Dígame

781
00:32:22,900 --> 00:32:27,509
Vale

782
00:32:27,509 --> 00:32:31,630
Pues en la adicional de AUX

783
00:32:31,630 --> 00:32:32,670
Queremos que vaya dato

784
00:32:32,670 --> 00:32:35,509
Y ahora AUX es nuestra nueva caja

785
00:32:35,509 --> 00:32:37,269
AUX ya es la caja buena

786
00:32:37,269 --> 00:32:38,289
Es nuestra nueva caja

787
00:32:38,289 --> 00:32:39,750
Con lo cual la caja vieja

788
00:32:39,750 --> 00:32:41,109
Fuera

789
00:32:41,109 --> 00:32:43,089
La caja vieja fuera

790
00:32:43,089 --> 00:32:44,990
Queremos la nueva caja

791
00:32:44,990 --> 00:32:50,670
Pues ya está

792
00:32:50,670 --> 00:32:54,289
Ya tenemos el método aux

793
00:32:54,289 --> 00:32:55,950
Perdón, el método add

794
00:32:55,950 --> 00:32:58,349
El método de siempre, ya está hecho

795
00:32:58,349 --> 00:33:02,700
Entonces yo ahora desde cualquier otro sitio

796
00:33:02,700 --> 00:33:04,779
Desde mi main que está aquí

797
00:33:04,779 --> 00:33:06,660
O desde otro main que esté en otro lado

798
00:33:06,660 --> 00:33:07,579
O desde donde sea

799
00:33:07,579 --> 00:33:10,259
Yo puedo meter nombres en esa caja

800
00:33:10,259 --> 00:33:11,440
Mira, voy a meter Luis

801
00:33:11,440 --> 00:33:12,779
En la caja está Luis

802
00:33:12,779 --> 00:33:15,240
Mira, ahora voy a meter otro nombre

803
00:33:15,240 --> 00:33:16,920
Pues Ala

804
00:33:16,920 --> 00:33:22,519
Y genial, súper práctico esta clase

805
00:33:22,519 --> 00:33:24,619
Me permite guardar cosas con el add

806
00:33:24,619 --> 00:33:28,160
Y yo olvidada de

807
00:33:28,160 --> 00:33:30,259
Todos los rollos de Array, es que aquí ni veo Array

808
00:33:30,259 --> 00:33:31,259
No lo veo por ningún sitio

809
00:33:31,259 --> 00:33:33,359
¿Dónde está el Array? No sabemos

810
00:33:33,359 --> 00:33:38,680
Vale, lo que pasa es que una caja

811
00:33:38,680 --> 00:33:40,000
Que me vale solo para meter

812
00:33:40,000 --> 00:33:42,500
Pues que oculta es, ¿no?

813
00:33:42,799 --> 00:33:44,279
Que oscurantista

814
00:33:44,279 --> 00:33:46,359
O sea, hombre, también querré

815
00:33:46,359 --> 00:33:47,799
Ver lo que hay dentro

816
00:33:47,799 --> 00:33:50,059
o eliminarlo

817
00:33:50,059 --> 00:33:51,940
con un array yo puedo recorrerlo

818
00:33:51,940 --> 00:33:54,079
para ver lo que hay, o sea, si en un almacén

819
00:33:54,079 --> 00:33:55,920
de datos no puedo

820
00:33:55,920 --> 00:33:57,960
acceder a lo que hay dentro del almacén de datos

821
00:33:57,960 --> 00:33:59,720
tal cual los meto perdidos

822
00:33:59,720 --> 00:34:01,720
para siempre, pues no tiene mucho sentido

823
00:34:01,720 --> 00:34:04,299
¿no? vale, pues a mí me encantaría

824
00:34:04,299 --> 00:34:05,759
poder recorrer, por ejemplo

825
00:34:05,759 --> 00:34:11,840
esta colección, ¿vale?

826
00:34:32,530 --> 00:34:34,070
vale, la posibilidad de recorrer

827
00:34:34,070 --> 00:34:35,409
la colección queremos tenerla

828
00:34:35,409 --> 00:34:37,809
o sea, nosotros podíamos recorrer un array

829
00:34:37,809 --> 00:34:39,570
con un for, ¿verdad? podíamos recorrer

830
00:34:39,570 --> 00:34:41,010
para ver lo que hay en cada posición

831
00:34:41,010 --> 00:34:43,670
y así veíamos lo que había, si nos interesaba

832
00:34:43,670 --> 00:34:47,349
es lo que hacíamos con un array, recorrerlo y acceder a posiciones sueltas

833
00:34:47,349 --> 00:34:50,510
bueno, pues también querríamos poder con mi caja

834
00:34:50,510 --> 00:34:53,070
es decir, yo querría

835
00:34:53,070 --> 00:34:57,460
voy a poner primero acceder

836
00:34:57,460 --> 00:35:00,420
acceder a elementos de la colección

837
00:35:00,420 --> 00:35:05,309
yo querría la posibilidad de acceder

838
00:35:05,309 --> 00:35:08,630
igual que podía un array, yo mi array, si fuera mi array nombres

839
00:35:08,630 --> 00:35:11,789
yo podría poner nombres de 3, nombres de 1

840
00:35:11,789 --> 00:35:14,489
pues aquí querría poder acceder también

841
00:35:14,489 --> 00:35:30,010
Entonces, ¿cómo me gustaría a mí tener un método que con esta cajita me permitiera recuperar el elemento en una posición cualquiera?

842
00:35:30,090 --> 00:35:31,230
En la cero, por ejemplo.

843
00:35:32,150 --> 00:35:40,210
Ojalá, ojalá tuviera un método que me permitiera recuperar, que me devolviera el elemento en esa posición,

844
00:35:40,449 --> 00:35:43,050
que me lo devolviera para que yo lo consultara y viera cuál es.

845
00:35:43,630 --> 00:35:47,610
Igual que tengo el array, si esto fuera un array, ya sabemos que tenemos esto.

846
00:35:50,440 --> 00:35:52,619
Pero es que esto no es un array

847
00:35:52,619 --> 00:35:54,860
Pero yo tengo que poder hacer a la posición

848
00:35:54,860 --> 00:35:55,980
De la caja igualmente

849
00:35:55,980 --> 00:35:58,539
Pues ojalá tuviera yo un método

850
00:35:58,539 --> 00:36:00,619
Que me hiciera esto

851
00:36:00,619 --> 00:36:01,559
Ojalá lo tuviera

852
00:36:01,559 --> 00:36:03,519
Pues hombre, ¿por qué no?

853
00:36:04,239 --> 00:36:06,500
Es muy fácil, ¿por qué no? Vamos a hacérselo

854
00:36:06,500 --> 00:36:10,340
Pues venga, en mi super clase

855
00:36:10,340 --> 00:36:11,239
En mi ArrayList

856
00:36:11,239 --> 00:36:13,260
Yo le puedo hacer

857
00:36:13,260 --> 00:36:15,199
Un método

858
00:36:15,199 --> 00:36:18,639
Que me devuelva un string

859
00:36:18,639 --> 00:36:22,239
Hacemos este método y paramos

860
00:36:22,239 --> 00:36:25,559
Que yo le paso una posición

861
00:36:25,559 --> 00:36:26,920
¿Vale?

862
00:36:27,280 --> 00:36:31,559
Y me devuelvo lo que hay en esa posición

863
00:36:31,559 --> 00:36:35,239
Vale, vamos a validar

864
00:36:35,239 --> 00:36:36,940
Que la posición sea correcta

865
00:36:36,940 --> 00:36:37,599
Porque si no

866
00:36:37,599 --> 00:36:40,019
Si posición

867
00:36:40,019 --> 00:36:42,780
Es mayor

868
00:36:42,780 --> 00:36:46,440
Que datos.length

869
00:36:46,440 --> 00:36:47,920
Menos uno

870
00:36:47,920 --> 00:36:51,400
O

871
00:36:51,400 --> 00:36:56,190
Posición

872
00:36:56,190 --> 00:36:58,030
Es menor que cero

873
00:36:58,030 --> 00:37:00,449
Problemas, la posición me la han pasado mal

874
00:37:00,449 --> 00:37:01,630
Problemas

875
00:37:01,630 --> 00:37:04,510
Pues entonces aquí pongo un null y ya está, por ejemplo

876
00:37:04,510 --> 00:37:06,530
¿Vale? Es la versión que estoy haciendo

877
00:37:06,530 --> 00:37:07,829
Return null

878
00:37:07,829 --> 00:37:10,610
Devuélveme un objeto null

879
00:37:10,610 --> 00:37:12,829
Si la posición es incorrecta

880
00:37:12,829 --> 00:37:14,670
Y si no

881
00:37:14,670 --> 00:37:18,550
Y si no

882
00:37:18,550 --> 00:37:19,989
Pues return el qué

883
00:37:19,989 --> 00:37:21,929
Pues return datos

884
00:37:21,929 --> 00:37:23,710
De posición

885
00:37:23,710 --> 00:37:26,110
Y tan ricamente

886
00:37:26,110 --> 00:37:28,210
Y tan ricamente

887
00:37:28,210 --> 00:37:29,889
¿Vale?

888
00:37:39,000 --> 00:37:40,880
Pues ala, un método estupendo

889
00:37:40,880 --> 00:37:42,820
Que me permite a mí

890
00:37:42,820 --> 00:37:44,980
Dada una posición, ver que hay

891
00:37:44,980 --> 00:37:47,639
Pues yo ya desde mi main

892
00:37:47,639 --> 00:37:49,219
Sin problemas

893
00:37:49,219 --> 00:37:52,139
Aquí puedo mostrar lo que hay en la posición 0

894
00:37:52,139 --> 00:37:54,599
Y lo que es más

895
00:37:54,599 --> 00:37:56,860
Podría recorrer

896
00:37:56,860 --> 00:37:58,360
El array

897
00:37:58,360 --> 00:37:59,619
La caja

898
00:37:59,619 --> 00:38:00,900
Ahora después lo hacemos

899
00:38:00,900 --> 00:38:02,400
Vamos a probar esto sin más

900
00:38:02,400 --> 00:38:04,239
Entonces yo ejecuto esto

901
00:38:04,239 --> 00:38:12,949
Y ala, estupendo

902
00:38:12,949 --> 00:38:15,530
Que quiero ver lo que hay en la posición 1

903
00:38:15,530 --> 00:38:17,989
Pues en la posición 1 me mostrará

904
00:38:17,989 --> 00:38:21,150
Que quiero ver lo que hay en la posición 7

905
00:38:21,150 --> 00:38:24,050
Me va a dar un null

906
00:38:24,050 --> 00:38:25,929
Pues null

907
00:38:25,929 --> 00:38:26,849
En la posición 7

908
00:38:26,849 --> 00:38:28,610
No hay posición 7

909
00:38:28,610 --> 00:38:31,389
¿Veis? Entonces desde mi main

910
00:38:31,389 --> 00:38:33,650
Yo ahí en mi main

911
00:38:33,650 --> 00:38:35,809
Ni tengo a raíz

912
00:38:35,809 --> 00:38:37,110
Ni tengo cosas extrañas

913
00:38:37,110 --> 00:38:39,269
Desde mi main tengo una caja que instancio

914
00:38:39,269 --> 00:38:41,070
Para guardar stream

915
00:38:41,070 --> 00:38:42,989
Solamente vale para stream, eso sí

916
00:38:42,989 --> 00:38:44,489
Añado

917
00:38:44,489 --> 00:38:46,289
recupero por posición

918
00:38:46,289 --> 00:38:49,150
y podríamos añadir más métodos

919
00:38:49,150 --> 00:38:50,090
¿vale?

920
00:38:51,110 --> 00:38:52,590
pues esto es una colección

921
00:38:52,590 --> 00:38:54,750
una clase que me permite

922
00:38:54,750 --> 00:38:56,130
almacenar un montón de datos

923
00:38:56,130 --> 00:38:59,050
y me ofrece unos métodos para manipularlos

924
00:38:59,050 --> 00:39:00,929
y esos métodos

925
00:39:00,929 --> 00:39:03,150
pues son métodos normales y corrientes

926
00:39:03,150 --> 00:39:04,449
que podemos hacer nosotros

927
00:39:04,449 --> 00:39:07,230
pero claro, luego me es a mi más cómodo

928
00:39:07,230 --> 00:39:08,909
usar directamente esa colección

929
00:39:08,909 --> 00:39:11,110
en cualquier otro sitio, la uso

930
00:39:11,110 --> 00:39:13,090
y ya está, es mucho más fácil

931
00:39:13,090 --> 00:39:15,570
Pues el ArrayList

932
00:39:15,570 --> 00:39:17,570
El ArrayList es esto

933
00:39:17,570 --> 00:39:20,269
Con más métodos

934
00:39:20,269 --> 00:39:22,369
Lógicamente y más depuraditos

935
00:39:22,369 --> 00:39:24,550
Y saltado a genérico

936
00:39:24,550 --> 00:39:26,590
Que es lo que sí que no sabemos hacer todavía

937
00:39:26,590 --> 00:39:27,750
Para que yo pueda guardarme

938
00:39:27,750 --> 00:39:29,690
Da igual que sea string, que sea int, que sea lo que sea

939
00:39:29,690 --> 00:39:31,889
Pues esto es un ArrayList

940
00:39:31,889 --> 00:39:35,849
Vale, vamos a parar aquí un momentico