1
00:00:00,880 --> 00:00:06,740
Vale, pues hemos dicho que íbamos a empezar ya por fin

2
00:00:06,740 --> 00:00:12,980
esto que se llama colecciones.

3
00:00:14,179 --> 00:00:14,740
¿Vale?

4
00:00:16,839 --> 00:00:17,399
Vale.

5
00:00:18,920 --> 00:00:21,699
Bueno, pues en una aplicación

6
00:00:21,699 --> 00:00:27,280
en una aplicación informática

7
00:00:27,280 --> 00:00:31,539
siempre es imprescindible trabajar con datos.

8
00:00:31,539 --> 00:00:52,399
Eso lo tenemos clarísimo. Y los datos tienen que estar en variables de la aplicación. Y eso también lo tenemos clarísimo. Que los datos tienen que estar en variables de la aplicación. A ver si el micrófono está bien porque el otro día no se oía nada. Vale. En datos de la aplicación.

9
00:00:52,399 --> 00:00:55,280
entonces si son 3, 4 datos

10
00:00:55,280 --> 00:00:57,140
3 números, 4 cadenas

11
00:00:57,140 --> 00:00:58,700
en programas muy sencillitos

12
00:00:58,700 --> 00:01:01,280
tenemos nuestras variables para guardarlos

13
00:01:01,280 --> 00:01:03,439
pero normalmente una aplicación

14
00:01:03,439 --> 00:01:04,200
trabaja con

15
00:01:04,200 --> 00:01:06,560
volúmenes de datos grandotes

16
00:01:06,560 --> 00:01:08,519
pues un montón de usuarios

17
00:01:08,519 --> 00:01:10,040
un montón de DNIs

18
00:01:10,040 --> 00:01:12,980
un montón de objetos

19
00:01:12,980 --> 00:01:14,640
factura

20
00:01:14,640 --> 00:01:16,120
trabaja con un montón de datos

21
00:01:16,120 --> 00:01:19,219
normalmente volcados en una base de datos

22
00:01:19,219 --> 00:01:20,379
pero eso ya es otro tema

23
00:01:20,379 --> 00:01:30,319
Bueno, pues entonces para trabajar con un volumen de datos grande, las variables primitivas ya sabemos que no se adaptan, entonces usábamos Arrays y ya está.

24
00:01:30,420 --> 00:01:32,319
Y es lo único que hemos usado porque no teníamos otra cosa.

25
00:01:32,879 --> 00:01:40,469
Y sabemos que un Array es una estructura que es esto, tal cual.

26
00:01:41,170 --> 00:01:50,689
Un montón de datos que están ahí en filita y la ventaja que tienen, la ventaja maravillosa que tienen, es que se les puede acceder a través de la posición.

27
00:01:51,689 --> 00:01:52,750
¿Vale? A través de la posición.

28
00:01:53,469 --> 00:01:56,109
Y ese acceso es rapidísimo, es inmediato.

29
00:01:56,609 --> 00:01:59,790
Una vez que el array ya está creado en memoria, su espacio,

30
00:02:00,450 --> 00:02:03,230
el acceso a través de la posición es muy rápido.

31
00:02:04,349 --> 00:02:06,670
¿Vale? En términos de rendimiento, me refiero.

32
00:02:07,409 --> 00:02:12,669
Y esto es lo único que hay y lo único que existe para guardar muchos datos en memoria.

33
00:02:13,430 --> 00:02:16,330
Un array que los tiene todos así a mogollón, uno tras otro,

34
00:02:16,949 --> 00:02:19,789
y la posibilidad de acceso a través de un índice.

35
00:02:19,789 --> 00:02:22,270
¿Vale? Y no hay nada más

36
00:02:22,270 --> 00:02:25,750
Entonces, está claro

37
00:02:25,750 --> 00:02:27,629
Que aunque tiene esa

38
00:02:27,629 --> 00:02:29,469
Rapidez de acceso a través del índice

39
00:02:29,469 --> 00:02:31,250
Tiene la pega que nos hemos encontrado

40
00:02:31,250 --> 00:02:32,969
Todo el rato y que hemos sufrido

41
00:02:32,969 --> 00:02:35,330
Que una vez que uno ha decidido

42
00:02:35,330 --> 00:02:37,810
Usar un array de 30 posiciones

43
00:02:37,810 --> 00:02:39,050
O 40 o 50

44
00:02:39,050 --> 00:02:41,409
El array es de 30 posiciones

45
00:02:41,409 --> 00:02:43,110
O 40 o 50

46
00:02:43,110 --> 00:02:44,830
Es imposible decidir

47
00:02:44,830 --> 00:02:46,770
Ay no, espera, que quiero ahora tener más

48
00:02:46,770 --> 00:02:47,710
Ah, lo hago más grande

49
00:02:47,710 --> 00:02:49,650
Uy, me están sobrando un montón

50
00:02:49,650 --> 00:02:52,349
pues corto esto, no, eso no se puede hacer

51
00:02:52,349 --> 00:02:54,389
entonces es poco eficiente

52
00:02:54,389 --> 00:02:56,569
en términos de aprovechamiento de la memoria

53
00:02:56,569 --> 00:02:57,430
claro

54
00:02:57,430 --> 00:03:00,229
vale, pero es lo único que hay

55
00:03:00,229 --> 00:03:00,909
es que no hay otra cosa

56
00:03:00,909 --> 00:03:04,210
bueno, pues entonces, ¿qué es lo que

57
00:03:04,210 --> 00:03:06,590
se ha incorporado a través de Java 2

58
00:03:06,590 --> 00:03:08,129
las primeras versiones y luego después?

59
00:03:08,629 --> 00:03:10,629
pues hacer por código, programar

60
00:03:10,629 --> 00:03:12,110
estructuras

61
00:03:12,110 --> 00:03:14,389
apoyadas sobre

62
00:03:14,389 --> 00:03:16,229
lo único que hay, que son

63
00:03:16,229 --> 00:03:18,169
en términos de almacenamiento, me refiero

64
00:03:18,169 --> 00:03:21,069
las variables primitivas

65
00:03:21,069 --> 00:03:23,789
y los arrays

66
00:03:23,789 --> 00:03:25,490
que apoyándose sobre eso

67
00:03:25,490 --> 00:03:27,050
programen, simulen

68
00:03:27,050 --> 00:03:30,490
una forma de funcionamiento que sea más cómodo

69
00:03:30,490 --> 00:03:32,189
pero está todo programado

70
00:03:32,189 --> 00:03:33,849
por encima

71
00:03:33,849 --> 00:03:36,030
como vamos a programar nosotros ahora

72
00:03:36,030 --> 00:03:37,050
entonces

73
00:03:37,050 --> 00:03:39,430
eso como se hace todo el rato

74
00:03:39,430 --> 00:03:41,150
usar esas otras

75
00:03:41,150 --> 00:03:43,349
programar esas otras estructuras

76
00:03:43,349 --> 00:03:45,250
que son más cómodas a la hora de usar

77
00:03:45,250 --> 00:03:47,370
pues ya directamente

78
00:03:47,370 --> 00:03:48,650
se hacen unas clases

79
00:03:48,650 --> 00:03:51,270
que te ofrecen métodos que tú los usas

80
00:03:51,270 --> 00:03:52,810
y ya está simulado

81
00:03:52,810 --> 00:03:55,449
ese comportamiento. El comportamiento

82
00:03:55,449 --> 00:03:57,370
en realidad de estructura

83
00:03:57,370 --> 00:03:58,629
dinámica. Vale, a ver.

84
00:03:59,409 --> 00:04:00,449
Que me explico un poco mal.

85
00:04:01,150 --> 00:04:02,789
Lo que está claro es que

86
00:04:02,789 --> 00:04:05,270
nosotros solamente

87
00:04:05,270 --> 00:04:07,050
en Java solamente provee de

88
00:04:07,050 --> 00:04:09,229
la posibilidad de declarar variables

89
00:04:09,229 --> 00:04:10,430
primitivas y arrays.

90
00:04:11,569 --> 00:04:13,090
Y bueno, y variables objeto.

91
00:04:13,590 --> 00:04:15,409
Claro, variables objeto. O sea, variables

92
00:04:15,409 --> 00:04:17,209
en general sueltas, variables sueltas

93
00:04:17,209 --> 00:04:19,629
sean primitivas o objetos, variables sueltas

94
00:04:19,629 --> 00:04:21,790
y arrays, y ya está, y no provee de nada más

95
00:04:21,790 --> 00:04:23,709
vale, el problema

96
00:04:23,709 --> 00:04:25,410
del array es que es estático

97
00:04:25,410 --> 00:04:27,389
lo que hemos dicho, de que una vez declarado

98
00:04:27,389 --> 00:04:29,389
30 con 40 de ahí no se mueve

99
00:04:29,389 --> 00:04:31,170
y eso es incómodo

100
00:04:31,170 --> 00:04:32,470
a la hora de usarlo

101
00:04:32,470 --> 00:04:34,949
es incómodo porque si me aparecen

102
00:04:34,949 --> 00:04:37,149
20 usuarios nuevos

103
00:04:37,149 --> 00:04:38,430
no tengo espacio para ellos

104
00:04:38,430 --> 00:04:41,009
o si de repente empieza ya

105
00:04:41,009 --> 00:04:42,990
una forma de trabajo en la cual

106
00:04:42,990 --> 00:04:45,389
solamente trabajo

107
00:04:45,389 --> 00:04:47,370
con 10, pues todo lo que tenía

108
00:04:47,370 --> 00:04:49,069
reservado no vale, entonces es incómodo

109
00:04:49,069 --> 00:04:51,389
bueno, pues entonces

110
00:04:51,389 --> 00:04:53,610
se programa

111
00:04:53,610 --> 00:04:55,470
y esto ya es por programa, por encima

112
00:04:55,470 --> 00:04:57,529
otras estructuras, que son las que

113
00:04:57,529 --> 00:05:00,029
se llaman estructuras dinámicas

114
00:05:00,029 --> 00:05:09,170
y dinámicas

115
00:05:09,170 --> 00:05:11,110
¿por qué? porque simulan

116
00:05:11,110 --> 00:05:12,730
que todo está simulado

117
00:05:12,730 --> 00:05:15,269
el efecto de un array

118
00:05:15,269 --> 00:05:17,329
que crece

119
00:05:17,329 --> 00:05:19,089
según media milagana, se encoge

120
00:05:19,089 --> 00:05:21,170
según media milagana, etcétera, simulan

121
00:05:21,170 --> 00:05:22,709
eso, pero lo simulan por programa

122
00:05:22,709 --> 00:05:25,949
entonces

123
00:05:25,949 --> 00:05:28,230
una vez que esa clase ya está hecha

124
00:05:28,230 --> 00:05:29,790
y simula ese comportamiento

125
00:05:29,790 --> 00:05:31,569
yo me limito a usarla

126
00:05:31,569 --> 00:05:33,829
y entonces a nivel de código

127
00:05:33,829 --> 00:05:36,589
a nivel de uso

128
00:05:36,589 --> 00:05:38,089
es mucho más fácil

129
00:05:38,089 --> 00:05:40,470
el desarrollo me va a quedar mucho más cómodo

130
00:05:40,470 --> 00:05:41,910
lo que hay por debajo

131
00:05:41,910 --> 00:05:43,449
sigue siendo pesado

132
00:05:43,449 --> 00:05:45,569
lo que hay por debajo sigue siendo un array

133
00:05:45,569 --> 00:05:47,629
que está haciéndose, deshaciéndose

134
00:05:47,629 --> 00:05:49,569
todo eso, pero eso ya lo ha programado

135
00:05:49,569 --> 00:05:51,810
alguien y me da a mí los métodos

136
00:05:51,810 --> 00:05:54,490
para que yo simule que estoy metiendo algo nuevo

137
00:05:54,490 --> 00:05:56,110
y que la raya del suelo se ha agrandado

138
00:05:56,110 --> 00:05:58,790
o que estoy sacando y que la raya del suelo se ha encogido.

139
00:05:59,589 --> 00:06:01,750
Por eso se les llaman estructuras dinámicas,

140
00:06:02,250 --> 00:06:04,370
porque son estructuras de almacenamiento

141
00:06:04,370 --> 00:06:11,329
que simulan o dan a entender

142
00:06:11,329 --> 00:06:15,089
que efectivamente se están adaptando en cada momento

143
00:06:15,089 --> 00:06:16,889
al volumen de datos que yo tengo.

144
00:06:16,889 --> 00:06:20,370
Cuando tengo este dato, este volumen, se adaptan y son así.

145
00:06:20,370 --> 00:06:22,389
cuando meto más volumen de datos

146
00:06:22,389 --> 00:06:24,689
se van agrandando, algo que la RAI no hace

147
00:06:24,689 --> 00:06:26,870
pues estas estructuras son clases

148
00:06:26,870 --> 00:06:28,970
que ya están hechas y que nosotros usamos

149
00:06:28,970 --> 00:06:31,410
que a través de métodos muy sencillos

150
00:06:31,410 --> 00:06:33,449
añadir, borrar

151
00:06:33,449 --> 00:06:34,910
etcétera

152
00:06:34,910 --> 00:06:37,410
pues simulan ese comportamiento

153
00:06:37,410 --> 00:06:38,930
entonces son muy cómodas de usar

154
00:06:38,930 --> 00:06:41,250
pero por debajo está la programación

155
00:06:41,250 --> 00:06:43,470
de toda la vida, por debajo está eso

156
00:06:43,470 --> 00:06:45,350
entonces

157
00:06:45,350 --> 00:06:46,790
en estructuras dinámicas

158
00:06:46,790 --> 00:06:47,389
hay

159
00:06:47,389 --> 00:06:50,670
vamos a tener que desglosarlas

160
00:06:50,670 --> 00:06:52,709
una por una, porque hay matices

161
00:06:52,709 --> 00:06:54,529
de funcionamiento muy distintos entre

162
00:06:54,529 --> 00:06:56,790
unas y otras, y eso implica

163
00:06:56,790 --> 00:06:58,790
que algunas se adaptan

164
00:06:58,790 --> 00:07:00,589
mejor a unas situaciones que otras. Entonces, tenemos

165
00:07:00,589 --> 00:07:02,290
que poder seleccionar en cada situación

166
00:07:02,290 --> 00:07:04,750
qué estructura dinámica se adapta

167
00:07:04,750 --> 00:07:06,529
mejor. Bueno, pues estructuras dinámicas

168
00:07:06,529 --> 00:07:08,649
hay muchos

169
00:07:08,649 --> 00:07:14,040
tipos, que se dividen en

170
00:07:14,040 --> 00:07:15,899
tres grandes grupos.

171
00:07:16,279 --> 00:07:17,139
Tres grandes grupos.

172
00:07:18,360 --> 00:07:19,639
Las listas,

173
00:07:19,639 --> 00:07:25,319
los conjuntos

174
00:07:25,319 --> 00:07:28,850
y los mapas

175
00:07:28,850 --> 00:07:30,829
lo que

176
00:07:30,829 --> 00:07:32,829
también se suele llamar

177
00:07:32,829 --> 00:07:34,449
en programación diccionarios

178
00:07:34,449 --> 00:07:39,589
son tres tipos

179
00:07:39,589 --> 00:07:41,610
de estructuras dinámicas que hay, listas

180
00:07:41,610 --> 00:07:43,449
conjuntos y diccionarios

181
00:07:43,449 --> 00:07:45,970
vale, entonces esto

182
00:07:45,970 --> 00:07:47,470
el que lo diseñó

183
00:07:47,470 --> 00:07:49,689
e hizo las clases para que

184
00:07:49,689 --> 00:07:51,069
luego nosotros las usáramos

185
00:07:51,069 --> 00:07:53,350
pues por supuesto hizo un diseño

186
00:07:53,350 --> 00:07:55,610
basándose en herencia y en interfaces

187
00:07:55,610 --> 00:07:56,250
por supuesto

188
00:07:56,250 --> 00:07:58,569
entonces pues

189
00:07:58,569 --> 00:08:01,170
existe una cosa

190
00:08:01,170 --> 00:08:03,410
que es la interfaz

191
00:08:03,410 --> 00:08:04,689
colección

192
00:08:04,689 --> 00:08:06,149
esta si tal cual

193
00:08:06,149 --> 00:08:08,149
que es una interfaz

194
00:08:08,149 --> 00:08:10,730
que tiene los métodos básicos de

195
00:08:10,730 --> 00:08:12,970
meter en la colección, borrar de la colección

196
00:08:12,970 --> 00:08:13,769
y poquito más

197
00:08:13,769 --> 00:08:15,970
y esta interfaz

198
00:08:15,970 --> 00:08:19,350
tiene una implementación

199
00:08:19,350 --> 00:08:20,029
concreta

200
00:08:20,029 --> 00:08:21,930
que es list

201
00:08:21,930 --> 00:08:25,009
que es la implementación

202
00:08:25,009 --> 00:08:27,250
que ya adapta

203
00:08:27,250 --> 00:08:29,769
el funcionamiento al de las listas

204
00:08:29,769 --> 00:08:30,730
que ya veremos cuál es

205
00:08:30,730 --> 00:08:33,309
y tiene una implementación que es

206
00:08:33,309 --> 00:08:34,330
set

207
00:08:34,330 --> 00:08:37,929
que esa implementación ya particulariza

208
00:08:37,929 --> 00:08:39,809
estos métodos de añadir

209
00:08:39,809 --> 00:08:40,870
meter, sacar y borrar

210
00:08:40,870 --> 00:08:43,929
los particulariza al funcionamiento

211
00:08:43,929 --> 00:08:45,409
concreto de los conjuntos

212
00:08:45,409 --> 00:08:47,509
porque las listas y los conjuntos

213
00:08:47,509 --> 00:08:49,889
funcionan internamente de forma distinta

214
00:08:49,889 --> 00:08:51,649
o sea, todo esto vale

215
00:08:51,649 --> 00:08:53,850
para meter y sacar y tener

216
00:08:53,850 --> 00:08:55,610
y guardado, no vale para nada más que para eso

217
00:08:55,610 --> 00:08:57,889
para meter cosas y tenerlas ahí guardaditas

218
00:08:57,889 --> 00:09:00,090
y sacarlas y consultarlas

219
00:09:00,090 --> 00:09:01,909
todo eso solo vale para eso

220
00:09:01,909 --> 00:09:04,269
para almacenar datos, son estructuras de almacenamiento

221
00:09:04,269 --> 00:09:05,450
solo vale para almacenar

222
00:09:05,450 --> 00:09:08,250
pero claro, como el almacenamiento

223
00:09:08,250 --> 00:09:10,230
el diseño del almacenamiento es una parte

224
00:09:10,230 --> 00:09:11,350
tan importante

225
00:09:11,350 --> 00:09:14,149
en un código, porque de ahí depende

226
00:09:14,149 --> 00:09:15,990
que el código tenga más o menos rendimientos

227
00:09:15,990 --> 00:09:18,210
sea más fácil de programar, sea más fácil de ampliar

228
00:09:18,210 --> 00:09:20,169
como es, el almacenamiento

229
00:09:20,169 --> 00:09:22,450
es tan crítico, por eso hay tantas posibilidades

230
00:09:22,450 --> 00:09:23,149
hay tantas

231
00:09:23,149 --> 00:09:25,509
una de ellas es el array, ya está

232
00:09:25,509 --> 00:09:27,889
pero aparte del array están todas estas

233
00:09:27,889 --> 00:09:29,690
que funcionan de forma distinta

234
00:09:29,690 --> 00:09:32,210
bueno, pues todas esas

235
00:09:32,210 --> 00:09:34,289
son las diferentes clases que están

236
00:09:34,289 --> 00:09:36,629
programadas en una arquitectura

237
00:09:36,629 --> 00:09:38,110
de herencia de este tipo

238
00:09:38,110 --> 00:09:39,370
repito, collection

239
00:09:39,370 --> 00:09:41,809
una interfaz con los métodos básicos

240
00:09:41,809 --> 00:09:44,309
de meter, sacar, pero ahora ya

241
00:09:44,309 --> 00:09:45,590
las listas

242
00:09:45,590 --> 00:09:48,169
implementan esos métodos de una manera

243
00:09:48,169 --> 00:09:50,129
concreta, pero siguen siendo

244
00:09:50,129 --> 00:09:52,190
los mismos métodos, meter y sacar y consultar

245
00:09:52,190 --> 00:09:54,850
los conjuntos implementan

246
00:09:54,850 --> 00:09:56,570
esos métodos de otra manera concreta

247
00:09:56,570 --> 00:09:59,029
pero siguen siendo mismos métodos, meter, consultar

248
00:09:59,029 --> 00:09:59,850
sacar y ya está

249
00:09:59,850 --> 00:10:02,929
los mapas no eran de colección, son otra

250
00:10:02,929 --> 00:10:05,009
interfaz aparte

251
00:10:05,009 --> 00:10:05,710
que se llama map

252
00:10:05,710 --> 00:10:08,950
entonces list, set

253
00:10:08,950 --> 00:10:10,950
y map, que no era de colección

254
00:10:10,950 --> 00:10:13,409
son tres implementaciones

255
00:10:13,409 --> 00:10:14,210
concretas

256
00:10:14,210 --> 00:10:17,110
para meter, sacar y guardar

257
00:10:17,110 --> 00:10:18,690
datos en algún lado

258
00:10:18,690 --> 00:10:20,090
eso es lo que es

259
00:10:20,090 --> 00:10:53,460
Y luego, a su vez, las listas tienen variantes en función de cómo se haga internamente. Las listas tienen el ArrayList, que es una implementación concreta de List, porque List sigue siendo una clase abstracta.

260
00:10:53,480 --> 00:10:55,759
de esta, que ya te implementa

261
00:10:55,759 --> 00:10:57,600
de una manera muy concreta cómo hacer

262
00:10:57,600 --> 00:10:59,299
el meter, sacar y consultar.

263
00:10:59,840 --> 00:11:01,419
De una forma muy concreta.

264
00:11:02,120 --> 00:11:02,899
Pero tiene otra.

265
00:11:04,960 --> 00:11:06,240
Tiene otra implementación

266
00:11:06,240 --> 00:11:10,899
que es la Linked List.

267
00:11:12,019 --> 00:11:13,399
Entonces, estas ya sí que son

268
00:11:13,399 --> 00:11:15,360
dos implementaciones concretas,

269
00:11:15,519 --> 00:11:17,480
dos cosas que podemos instanciar

270
00:11:17,480 --> 00:11:19,899
y usar para guardar cosas a mogollón.

271
00:11:21,220 --> 00:11:21,779
Esta es una

272
00:11:21,779 --> 00:11:23,799
y esta es otra. Y las dos se usan

273
00:11:23,799 --> 00:11:25,860
igual porque solamente valen

274
00:11:25,860 --> 00:11:27,919
para eso, para meter y sacar, las dos se usan

275
00:11:27,919 --> 00:11:29,779
igual, lo que pasa es que

276
00:11:29,779 --> 00:11:32,059
por dentro están construidas

277
00:11:32,059 --> 00:11:32,879
de forma distinta

278
00:11:32,879 --> 00:11:36,100
y eso tiene implicaciones en cuanto a rendimiento

279
00:11:36,100 --> 00:11:37,980
para cuál, en qué situaciones se adapta

280
00:11:37,980 --> 00:11:39,740
mejor esta, en cuál se adapta mejor esta

281
00:11:39,740 --> 00:11:41,120
que tendremos que saber distinguir

282
00:11:41,120 --> 00:11:42,080
¿vale?

283
00:11:43,980 --> 00:11:45,840
¿vale? y ¿por qué hay dos?

284
00:11:46,100 --> 00:11:46,940
list y set

285
00:11:46,940 --> 00:11:49,220
bueno, pues hay dos

286
00:11:49,220 --> 00:11:52,100
porque las listas están pensadas

287
00:11:52,100 --> 00:11:53,740
para que en la cajita

288
00:11:53,740 --> 00:11:54,779
de listas

289
00:11:54,779 --> 00:12:01,350
pensad que las colecciones

290
00:12:01,350 --> 00:12:04,269
son cajas, no son más que esto

291
00:12:04,269 --> 00:12:05,750
las colecciones son una caja

292
00:12:05,750 --> 00:12:08,230
para meter cosas, igual que era una raíz

293
00:12:08,230 --> 00:12:09,250
una caja, ¿vale?

294
00:12:10,250 --> 00:12:12,289
pues las listas, tanto esta

295
00:12:12,289 --> 00:12:14,450
como esta, son una implementación

296
00:12:14,450 --> 00:12:15,629
concreta de la caja

297
00:12:15,629 --> 00:12:18,309
una implementación concreta

298
00:12:18,309 --> 00:12:20,190
de la caja, en la que

299
00:12:20,190 --> 00:12:22,049
las cosas que metemos en la caja

300
00:12:22,049 --> 00:12:23,789
tienen una posición

301
00:12:23,789 --> 00:12:27,759
¿vale? luego la lista

302
00:12:27,759 --> 00:12:29,580
es una implementación en la cual

303
00:12:29,580 --> 00:12:31,059
yo meto algo en la caja

304
00:12:31,059 --> 00:12:33,720
pero lo meto en una posición siempre

305
00:12:33,720 --> 00:12:35,539
luego la lista sería

306
00:12:35,539 --> 00:12:37,019
una cajita con posiciones

307
00:12:37,019 --> 00:12:38,919
y yo meto en la posición

308
00:12:38,919 --> 00:12:41,860
y puedo recuperar por posición

309
00:12:41,860 --> 00:12:43,759
puedo decir, oye, recupérame

310
00:12:43,759 --> 00:12:45,539
la que pusiste en la posición 4

311
00:12:45,539 --> 00:12:48,919
conceptualmente es igual que un array

312
00:12:48,919 --> 00:12:51,179
en un array todo lo que metemos tiene una posición

313
00:12:51,179 --> 00:12:53,019
pues en una lista

314
00:12:53,019 --> 00:12:54,600
todo lo que metemos tiene una posición

315
00:12:54,600 --> 00:12:56,720
¿vale?

316
00:12:56,720 --> 00:12:59,759
entonces

317
00:12:59,759 --> 00:13:03,620
lo que caracteriza la lista

318
00:13:03,620 --> 00:13:05,960
es que puedes meter dos cosas iguales

319
00:13:05,960 --> 00:13:07,840
en realidad, porque van a ser

320
00:13:07,840 --> 00:13:09,100
distinguibles por la posición

321
00:13:09,100 --> 00:13:11,500
¿verdad? imagínate que es una

322
00:13:11,500 --> 00:13:13,799
lista en la que yo voy a meter caracteres

323
00:13:13,799 --> 00:13:14,279
letras

324
00:13:14,279 --> 00:13:16,879
pues podría meter esto

325
00:13:16,879 --> 00:13:19,299
y pueden coexistir dos X

326
00:13:19,299 --> 00:13:21,259
perfectamente, pueden coexistir dos

327
00:13:21,259 --> 00:13:23,019
porque una iría en esta posición

328
00:13:23,019 --> 00:13:24,299
y otra iría en esta

329
00:13:24,299 --> 00:13:26,179
luego en una lista

330
00:13:26,179 --> 00:13:27,799
las cosas que meto

331
00:13:27,799 --> 00:13:29,919
se caracterizan por supuesto por su valor

332
00:13:29,919 --> 00:13:31,860
lo que tiene, la letra X

333
00:13:31,860 --> 00:13:33,919
pero también se caracterizan

334
00:13:33,919 --> 00:13:36,220
por la posición en la que están

335
00:13:36,220 --> 00:13:37,759
desde el momento en el que las meto en la lista

336
00:13:37,759 --> 00:13:40,080
vale

337
00:13:40,080 --> 00:13:41,740
sin embargo eso

338
00:13:41,740 --> 00:13:44,179
el llevar un registro

339
00:13:44,179 --> 00:13:46,139
del orden o de la posición

340
00:13:46,139 --> 00:13:47,779
en la que se han metido las cosas en la lista

341
00:13:47,779 --> 00:13:49,639
requiere pues programarlo

342
00:13:49,639 --> 00:13:52,179
y tiene sus complejidades

343
00:13:52,179 --> 00:13:52,980
de programación

344
00:13:52,980 --> 00:13:55,820
pues los sets están pensados

345
00:13:55,820 --> 00:13:58,059
para situaciones en las cuales

346
00:13:58,059 --> 00:13:58,919
eso me da igual

347
00:13:58,919 --> 00:14:01,840
¿qué es un set? pues un set es

348
00:14:01,840 --> 00:14:03,539
una implementación de esta cajita

349
00:14:03,539 --> 00:14:05,580
un set es un conjunto

350
00:14:05,580 --> 00:14:07,820
una implementación de esta cajita

351
00:14:07,820 --> 00:14:09,759
en la que no hay ningún tipo de orden

352
00:14:09,759 --> 00:14:12,120
las cosas se meten

353
00:14:12,120 --> 00:14:14,019
en cualquier sitio

354
00:14:14,019 --> 00:14:14,840
donde caen

355
00:14:14,840 --> 00:14:17,700
luego esto por dentro

356
00:14:17,700 --> 00:14:20,059
es más fácil de programar

357
00:14:20,059 --> 00:14:22,379
que esto porque no hay que llevar un registro

358
00:14:22,379 --> 00:14:24,200
de la posición en la que ha caído la cosa

359
00:14:24,200 --> 00:14:26,419
aquí en un conjunto

360
00:14:26,419 --> 00:14:27,740
si yo meto caracteres

361
00:14:27,740 --> 00:14:30,039
el problema que tengo es que

362
00:14:30,039 --> 00:14:32,120
la X no la puedo meter dos veces

363
00:14:32,120 --> 00:14:34,080
¿vale? si yo

364
00:14:34,080 --> 00:14:35,740
metiera otra X aquí

365
00:14:35,740 --> 00:14:38,220
estas clases

366
00:14:38,220 --> 00:14:39,539
están pensadas para

367
00:14:39,539 --> 00:14:42,399
no aceptar esa X, porque ya hay una

368
00:14:42,399 --> 00:14:44,019
entonces como ya hay una

369
00:14:44,019 --> 00:14:45,980
esa otra X en la caja

370
00:14:45,980 --> 00:14:48,000
no se distinguiría de esta

371
00:14:48,000 --> 00:14:50,299
no se distinguiría, no puede haber aquí otra X

372
00:14:50,299 --> 00:14:52,299
entonces ¿cómo distingues esta de esta?

373
00:14:52,379 --> 00:14:55,080
Si no tienen posición, están ahí las dos a mogollón.

374
00:14:55,279 --> 00:14:58,379
No podrías distinguir cuál es la primera X que metiste y la segunda.

375
00:14:58,580 --> 00:14:59,399
Serían indistinguibles.

376
00:14:59,940 --> 00:15:06,179
Entonces, las clases set están programadas y pensadas para que tú no puedas meter duplicados.

377
00:15:06,539 --> 00:15:13,720
Y cuando intentas meter en una caja un elemento igual a otro que ya está igual,

378
00:15:15,259 --> 00:15:17,679
pues entonces el conjunto simplemente no lo mete.

379
00:15:17,980 --> 00:15:18,779
No lo mete y ya está.

380
00:15:18,779 --> 00:15:20,879
¿vale? no se pueden meter en un set

381
00:15:20,879 --> 00:15:22,700
elementos duplicados

382
00:15:22,700 --> 00:15:24,960
pues esa es la

383
00:15:24,960 --> 00:15:27,200
principal diferencia entre list y set

384
00:15:27,200 --> 00:15:29,139
y por eso hay dos tipos de colecciones

385
00:15:29,139 --> 00:15:31,039
tan distintas, porque en esta

386
00:15:31,039 --> 00:15:32,460
la cajita tiene posiciones

387
00:15:32,460 --> 00:15:35,100
con lo cual puedo meter duplicados

388
00:15:35,100 --> 00:15:36,179
es decir, dos cosas

389
00:15:36,179 --> 00:15:38,220
puedo meter dos cosas iguales

390
00:15:38,220 --> 00:15:41,059
y en esta nunca puede haber

391
00:15:41,059 --> 00:15:43,320
dos cosas iguales, porque el conjunto

392
00:15:43,320 --> 00:15:45,179
nunca te habría dejado meter una cosa

393
00:15:45,179 --> 00:15:46,559
igual a otra que ya está

394
00:15:46,559 --> 00:15:49,580
entonces, en función de lo que tú estés programando

395
00:15:49,580 --> 00:15:51,659
lo que estés desarrollando, cuál sea tu modelo de datos

396
00:15:51,659 --> 00:15:52,559
qué es lo que estés haciendo

397
00:15:52,559 --> 00:15:55,419
pues te puede valer un set o no

398
00:15:55,419 --> 00:15:57,659
si tú necesitas que sí están duplicados

399
00:15:57,659 --> 00:15:59,340
un segundo Inés, dime

400
00:15:59,340 --> 00:16:01,679
¿qué diferencia es con un array?

401
00:16:03,519 --> 00:16:05,179
a ver, un array es lo que es

402
00:16:05,179 --> 00:16:07,559
es una estructura nativa, por decirlo así de Java

403
00:16:07,559 --> 00:16:09,720
¿vale? que tiene las características

404
00:16:09,720 --> 00:16:11,879
que conocemos, que es tú la declaras

405
00:16:11,879 --> 00:16:13,679
tiene un tamaño fijo que ya

406
00:16:13,679 --> 00:16:14,899
no se puede cambiar

407
00:16:14,899 --> 00:16:17,139
y se accede a sus posiciones por Ingrid.

408
00:16:17,940 --> 00:16:19,620
Vale, entonces una lista

409
00:16:19,620 --> 00:16:21,440
que puede haber varias

410
00:16:21,440 --> 00:16:23,480
variantes, es una estructura

411
00:16:23,480 --> 00:16:25,580
de programación que se programa

412
00:16:25,580 --> 00:16:27,240
de hecho vamos a hacerlas las dos,

413
00:16:27,340 --> 00:16:28,200
vamos a programar nosotros,

414
00:16:29,399 --> 00:16:31,340
se programa de tal manera que te

415
00:16:31,340 --> 00:16:33,299
ofrece unos métodos que

416
00:16:33,299 --> 00:16:35,379
te facilitan la inserción y el recuperar

417
00:16:35,379 --> 00:16:37,500
de los datos. Entonces tú te olvidas

418
00:16:37,500 --> 00:16:38,100
de

419
00:16:38,100 --> 00:16:41,019
el problema del array

420
00:16:41,019 --> 00:16:43,139
de que si quieres meter un dato nuevo

421
00:16:43,139 --> 00:16:45,100
que no te cabe, todo eso que hemos hecho

422
00:16:45,100 --> 00:16:46,879
de hacer un array con una posición más

423
00:16:46,879 --> 00:16:48,779
meterlo extra

424
00:16:48,779 --> 00:16:51,279
sustituir el

425
00:16:51,279 --> 00:16:53,240
viejo con el nuevo, todo eso

426
00:16:53,240 --> 00:16:54,399
que hemos estado haciendo todo el rato

427
00:16:54,399 --> 00:16:56,259
la lista te lo enmascara

428
00:16:56,259 --> 00:16:59,200
y te ofrece un método, añade

429
00:16:59,200 --> 00:17:00,879
tú llamas al método, añade

430
00:17:00,879 --> 00:17:03,179
y ya por dentro hace todo lo que haga falta

431
00:17:03,179 --> 00:17:05,160
¿vale? o sea, una lista es como

432
00:17:05,160 --> 00:17:05,960
una especie de

433
00:17:05,960 --> 00:17:08,400
enmascarar un array

434
00:17:08,400 --> 00:17:11,319
para usarlo, para que te aparente

435
00:17:11,319 --> 00:17:12,380
a ti que es dinámico

436
00:17:12,380 --> 00:17:14,480
para que tú veas que es dinámico.

437
00:17:15,180 --> 00:17:16,700
Eso que yo he dicho en particular es una

438
00:17:16,700 --> 00:17:18,720
ArrayList. Lo que pasa es que luego

439
00:17:18,720 --> 00:17:20,980
está la LinkedList, que también simula

440
00:17:20,980 --> 00:17:22,460
eso, pero no partiendo de un Array,

441
00:17:22,640 --> 00:17:24,319
partiendo de otra cosa mucho más chula.

442
00:17:24,920 --> 00:17:25,920
Pero simula eso también.

443
00:17:26,779 --> 00:17:26,880
¿Vale?

444
00:17:28,539 --> 00:17:31,240
Entonces, lo que estamos ahora un poco...

445
00:17:31,240 --> 00:17:32,539
Te digo que si en un set

446
00:17:32,539 --> 00:17:34,920
que no tiene posiciones, metes dos objetos

447
00:17:34,920 --> 00:17:36,700
que son de diferente tiempo, una de sus

448
00:17:36,700 --> 00:17:38,599
propiedades, sí puede, pero se tiene

449
00:17:38,599 --> 00:17:40,279
diferencia. Claro, a ver.

450
00:17:40,819 --> 00:17:42,319
El set decide

451
00:17:42,319 --> 00:17:44,440
si lo que tú le das es igual

452
00:17:44,440 --> 00:17:46,299
que algo que ya esté, llamando

453
00:17:46,299 --> 00:17:47,059
al método equals.

454
00:17:48,180 --> 00:17:49,900
Claro, de ahí la importancia de equals.

455
00:17:50,039 --> 00:17:52,099
O sea, si tú le tienes puesto un método equals para que te diga

456
00:17:52,099 --> 00:17:54,460
el nombre, tiene que ser el nombre distinto

457
00:17:54,460 --> 00:17:56,339
en concreto. Aunque las otras características

458
00:17:56,339 --> 00:17:57,759
le darían igual. Efectivamente.

459
00:17:58,099 --> 00:18:00,119
Ahora ya, cuando usamos colecciones para

460
00:18:00,119 --> 00:18:02,200
guardar datos, la implementación

461
00:18:02,200 --> 00:18:04,180
de equals ahora ya sí que es fundamental.

462
00:18:04,940 --> 00:18:05,980
Porque las colecciones,

463
00:18:06,500 --> 00:18:08,180
los conjuntos en particular, cuando tú le metas

464
00:18:08,180 --> 00:18:09,599
un dato, va a decir, a ver,

465
00:18:10,099 --> 00:18:12,039
hay uno igual, y para ver si hay uno

466
00:18:12,039 --> 00:18:14,119
igual es equals. Java no tiene otra forma

467
00:18:14,119 --> 00:18:15,259
de ver si un objeto es igual a otro.

468
00:18:15,599 --> 00:18:17,299
Y ese equals está definido como tú quieras.

469
00:18:17,319 --> 00:18:19,140
No había la importancia de los equals antes porque

470
00:18:19,140 --> 00:18:21,900
si tú lo quieres realista, aunque sean iguales...

471
00:18:21,900 --> 00:18:23,660
Claro, pues equals es fundamental

472
00:18:23,660 --> 00:18:25,680
para cualquier estructura de programación

473
00:18:25,680 --> 00:18:27,200
que necesite saber si algo es igual a otro.

474
00:18:27,960 --> 00:18:30,079
Y el conjunto necesita saber

475
00:18:30,079 --> 00:18:31,180
si algo es igual a otro

476
00:18:31,180 --> 00:18:33,980
para decidir si lo mete o no lo mete, por ejemplo.

477
00:18:34,000 --> 00:18:34,960
Es esto lo que tú decías.

478
00:18:35,380 --> 00:18:38,160
Y ese equals ya estará programado como tú hayas querido.

479
00:18:38,500 --> 00:18:39,859
Que no lo has programado.

480
00:18:40,420 --> 00:18:41,799
Será el equals de object.

481
00:18:42,039 --> 00:18:42,900
Porque es el heredado.

482
00:18:43,599 --> 00:18:45,619
Y el equals de object define

483
00:18:45,619 --> 00:18:47,160
que un objeto es igual a otro

484
00:18:47,160 --> 00:18:49,180
si la dirección de memoria es la misma.

485
00:18:50,000 --> 00:18:52,420
Luego, si tú no

486
00:18:52,420 --> 00:18:54,099
sobreescribieras un método

487
00:18:54,099 --> 00:18:55,440
igual, si no hubiera tus clases...

488
00:18:55,440 --> 00:18:55,940
Pues que todos los objetos idénticos

489
00:18:55,940 --> 00:18:57,299
están con la dirección de memoria distinta.

490
00:18:57,299 --> 00:18:58,660
Claro, el set los cogería.

491
00:18:58,819 --> 00:19:01,259
Los cogería todos, porque para él son distintos.

492
00:19:01,319 --> 00:19:02,859
Porque están en direcciones de memoria distintas.

493
00:19:03,339 --> 00:19:06,000
Pero normalmente, eso no es lo que tú quieres hacer.

494
00:19:06,180 --> 00:19:07,740
Porque la aplicación pierde su sentido.

495
00:19:08,799 --> 00:19:08,980
¿Vale?

496
00:19:09,039 --> 00:19:10,880
Tú quieres que la aplicación tenga sentido

497
00:19:10,880 --> 00:19:12,880
y que si dos objetos sean iguales

498
00:19:12,880 --> 00:19:15,180
en virtud de N, I y D, lo que tú seas,

499
00:19:15,339 --> 00:19:16,500
pues que la aplicación lo sepa.

500
00:19:17,400 --> 00:19:18,559
Claro, la clave primaria

501
00:19:18,559 --> 00:19:20,579
tiene un sentido real

502
00:19:20,579 --> 00:19:22,359
y es que dos cosas sean la misma.

503
00:19:22,519 --> 00:19:23,920
Entonces tienes que simularla con el equal.

504
00:19:24,079 --> 00:19:25,480
Si no, la aplicación no tiene sentido.

505
00:19:27,779 --> 00:19:28,599
Claro, y

506
00:19:28,599 --> 00:19:30,180
quien te dice las colecciones,

507
00:19:30,740 --> 00:19:32,960
hay muchas otras clases que necesitan saber

508
00:19:32,960 --> 00:19:34,740
si algo es igual que otra cosa.

509
00:19:35,359 --> 00:19:37,039
Entonces tú lo tienes que proveer con el equal.

510
00:19:37,259 --> 00:19:38,319
Porque si no lo provees con el equal,

511
00:19:38,420 --> 00:19:39,480
se ha perdido el sentido todo.

512
00:19:39,480 --> 00:19:40,859
vale

513
00:19:40,859 --> 00:19:42,400
entonces

514
00:19:42,400 --> 00:19:46,180
estos son los dos tipos esenciales

515
00:19:46,180 --> 00:19:48,019
de colecciones que heredan

516
00:19:48,019 --> 00:19:49,059
de esta, de colección

517
00:19:49,059 --> 00:19:52,180
y luego aparte yo he mencionado para que tengamos ya

518
00:19:52,180 --> 00:19:54,200
los tres conceptos que tenemos

519
00:19:54,200 --> 00:19:55,900
que ver, los mapas

520
00:19:55,900 --> 00:19:58,359
que son los diccionarios

521
00:19:58,359 --> 00:20:00,519
la particularidad que tienen los mapas

522
00:20:00,519 --> 00:20:01,900
es que también valen

523
00:20:01,900 --> 00:20:03,599
para guardar datos, como todo

524
00:20:03,599 --> 00:20:05,920
para guardar datos, pero los mapas

525
00:20:05,920 --> 00:20:08,099
guardan los datos siempre en forma

526
00:20:08,099 --> 00:20:10,039
de pares, una clave

527
00:20:10,039 --> 00:20:10,700
y un valor

528
00:20:10,700 --> 00:20:13,200
una clave y un valor

529
00:20:13,200 --> 00:20:16,240
en las listas y los conjuntos

530
00:20:16,240 --> 00:20:17,720
se guarda el dato tal cual

531
00:20:17,720 --> 00:20:20,259
un dato, otro dato, otro dato, otro dato

532
00:20:20,259 --> 00:20:21,880
en los mapas

533
00:20:21,880 --> 00:20:23,380
tú guardas el dato

534
00:20:23,380 --> 00:20:25,700
siempre asociado a una clave

535
00:20:25,700 --> 00:20:27,460
y tú metes el par

536
00:20:27,460 --> 00:20:29,259
por eso se llaman diccionarios

537
00:20:29,259 --> 00:20:32,339
porque un diccionario es un montonazo

538
00:20:32,339 --> 00:20:33,160
de pares

539
00:20:33,160 --> 00:20:35,440
nombre de palabra, significado

540
00:20:35,440 --> 00:20:37,160
nombre de palabra, significado

541
00:20:37,160 --> 00:20:43,160
Eso es un diccionario, ¿no? ¿Vuestra generación todavía ha visto un diccionario alguna vez? ¿Un papel? ¿Un preso?

542
00:20:46,380 --> 00:21:04,000
Bueno, pues eso es un diccionario, un conjunto de pares, término, significado, término, significado, término, significado, pues el mapa reproduce esa idea, un conjunto de pares, clave, contenido de la clave, clave, contenido de la clave.

543
00:21:04,000 --> 00:21:06,900
existe esa estructura programada

544
00:21:06,900 --> 00:21:08,460
porque está programada, no es que exista

545
00:21:08,460 --> 00:21:10,259
como el array que existe por ciencia infusa

546
00:21:10,259 --> 00:21:12,480
existe esta estructura

547
00:21:12,480 --> 00:21:14,319
porque en muchas situaciones

548
00:21:14,319 --> 00:21:16,519
es interesante

549
00:21:16,519 --> 00:21:18,500
que cada dato

550
00:21:18,500 --> 00:21:20,240
tenga asociado una clave única

551
00:21:20,240 --> 00:21:22,539
porque nos va a facilitar

552
00:21:22,539 --> 00:21:24,140
normalmente el recuperar los datos

553
00:21:24,140 --> 00:21:25,720
es más fácil recuperar por clave

554
00:21:25,720 --> 00:21:27,460
que recuperar por contenido

555
00:21:27,460 --> 00:21:30,180
el diccionario, si es útil

556
00:21:30,180 --> 00:21:32,759
es precisamente porque está organizado de esa manera

557
00:21:32,759 --> 00:21:34,980
término, significado

558
00:21:34,980 --> 00:21:37,259
y los términos ordenados alfabéticamente

559
00:21:37,259 --> 00:21:39,279
entonces tú rápidamente en un diccionario

560
00:21:39,279 --> 00:21:41,059
encuentras el significado que buscas

561
00:21:41,059 --> 00:21:43,279
porque vas buscando por término

562
00:21:43,279 --> 00:21:44,480
pues entonces

563
00:21:44,480 --> 00:21:46,799
a veces una estructura

564
00:21:46,799 --> 00:21:48,920
map con un montón de términos, clave, valor

565
00:21:48,920 --> 00:21:50,880
te facilita encontrar rápidamente

566
00:21:50,880 --> 00:21:52,539
un valor, porque tú vas

567
00:21:52,539 --> 00:21:53,359
a la clave

568
00:21:53,359 --> 00:21:57,079
y todo eso está programado por dentro

569
00:21:57,079 --> 00:21:58,880
y nosotros nos vamos a limitar a aprender a usar

570
00:21:58,880 --> 00:22:01,099
estas dos de aquí

571
00:22:01,099 --> 00:22:03,579
el ArrayList y el LinkedList y que las vamos a programar

572
00:22:03,579 --> 00:22:04,559
porque tenéis que

573
00:22:04,559 --> 00:22:07,000
pues tenéis que saber aprender a programar

574
00:22:07,000 --> 00:22:09,599
y los conjuntos y los mapas

575
00:22:09,599 --> 00:22:11,039
ya vamos a aprender a usarlos

576
00:22:11,039 --> 00:22:13,660
vale, de listas

577
00:22:13,660 --> 00:22:14,359
ya hemos dicho

578
00:22:14,359 --> 00:22:17,019
que hay dos implementaciones concretas

579
00:22:17,019 --> 00:22:18,759
el ArrayList

580
00:22:18,759 --> 00:22:20,359
y el LinkedList

581
00:22:20,359 --> 00:22:25,849
y de conjuntos

582
00:22:25,849 --> 00:22:27,990
hay tres, el HashSet

583
00:22:27,990 --> 00:22:32,130
una pequeña variante

584
00:22:32,130 --> 00:22:33,569
del HashSet que es el Linked

585
00:22:33,569 --> 00:22:35,609
HashSet

586
00:22:35,609 --> 00:22:37,549
y el

587
00:22:37,549 --> 00:22:38,250
tree set

588
00:22:38,250 --> 00:22:42,349
¿en qué se diferencian entre ellas?

589
00:22:42,829 --> 00:22:44,849
en cómo están programadas por dentro

590
00:22:44,849 --> 00:22:48,250
¿vale?

591
00:22:48,289 --> 00:22:49,609
en cómo están programadas por dentro

592
00:22:49,609 --> 00:22:51,930
y en función de cómo están programadas por dentro

593
00:22:51,930 --> 00:22:54,190
pues os repito, son más útiles para unas cosas

594
00:22:54,190 --> 00:22:56,269
o para otras, o más que útiles pegan más

595
00:22:56,269 --> 00:22:57,309
para unas cosas que para otras

596
00:22:57,309 --> 00:23:00,269
entonces hay que entender bien un hash set por dentro

597
00:23:00,269 --> 00:23:01,410
cómo está programado

598
00:23:01,410 --> 00:23:03,690
un tree set por dentro cómo está programado

599
00:23:03,690 --> 00:23:04,650
porque a veces el tree set

600
00:23:04,650 --> 00:23:07,549
tiene muy buen rendimiento para algunas cosas

601
00:23:07,549 --> 00:23:09,789
pero para otras no, entonces si pagas que no

602
00:23:09,789 --> 00:23:11,809
pues a lo mejor no tienes que hacer, entonces depende de la

603
00:23:11,809 --> 00:23:13,809
aplicación, pues interesa más coger

604
00:23:13,809 --> 00:23:15,730
una que otra, sabiendo

605
00:23:15,730 --> 00:23:17,329
que cualesquiera de ellas

606
00:23:17,329 --> 00:23:18,809
son set

607
00:23:18,809 --> 00:23:21,529
luego tiene esta particularidad

608
00:23:21,529 --> 00:23:23,269
que no admiten duplicados

609
00:23:23,269 --> 00:23:25,930
¿vale? y cualquiera

610
00:23:25,930 --> 00:23:27,750
de estas son listas, luego tiene esa

611
00:23:27,750 --> 00:23:29,809
particularidad, que todo en la cajita va

612
00:23:29,809 --> 00:23:30,670
en una posición

613
00:23:30,670 --> 00:23:33,309
y los mapas lo que he dicho

614
00:23:33,309 --> 00:23:33,970
¿vale?

615
00:23:36,230 --> 00:23:36,670
vale

616
00:23:36,670 --> 00:23:39,490
Pues a ver, la que nos va a ser

617
00:23:39,490 --> 00:23:40,710
Facilísimo de hacer

618
00:23:40,710 --> 00:23:43,250
Es el ArrayList porque lo hemos estado usando

619
00:23:43,250 --> 00:23:45,390
Todo el rato, hemos estado todo el rato metiendo en el Array

620
00:23:45,390 --> 00:23:46,609
Cosas y sacando cosas del Array

621
00:23:46,609 --> 00:23:49,369
Pues ahora ya vamos a darle un cuerpo

622
00:23:49,369 --> 00:23:51,390
De clase, para usarla

623
00:23:51,390 --> 00:23:52,009
Rápidamente

624
00:23:52,009 --> 00:23:54,529
Y luego el LinkedList

625
00:23:54,529 --> 00:23:56,109
Venga, hala

626
00:24:30,930 --> 00:24:34,059
A ver

627
00:24:34,059 --> 00:24:35,680
Venga, pues siempre que empezamos

628
00:24:35,680 --> 00:24:37,700
algo, como nos estamos

629
00:24:37,700 --> 00:24:39,680
todo el rato apoyando en lo

630
00:24:39,680 --> 00:24:41,440
de siempre, porque hay que usarlo todo

631
00:24:41,440 --> 00:24:43,599
hasta ahora, todo, no podemos obviar nada

632
00:24:43,599 --> 00:24:45,380
de lo que hemos visto, pues de nuevo

633
00:24:45,380 --> 00:24:46,940
aprovechad

634
00:24:46,940 --> 00:24:49,339
los que estáis así tambaleandos

635
00:24:49,339 --> 00:24:51,339
para volver

636
00:24:51,339 --> 00:24:53,539
a

637
00:24:53,539 --> 00:24:55,799
trabajar lo mismo, no hay otra vez

638
00:24:55,799 --> 00:24:57,579
pues venga, vamos a

639
00:24:57,579 --> 00:25:00,059
hacernos un proyecto

640
00:25:00,059 --> 00:25:02,019
mis colecciones

641
00:25:02,019 --> 00:25:03,720
porque van a ser las colecciones

642
00:25:03,720 --> 00:25:05,359
nuestras que nos va a dar la gana

643
00:25:05,359 --> 00:25:06,380
hacer a nosotros

644
00:25:06,380 --> 00:25:09,559
que luego vamos a exportar a Ujar

645
00:25:09,559 --> 00:25:11,500
y las vamos a usar como si fueran colecciones

646
00:25:11,500 --> 00:25:17,299
para que ya tienes el ArrayList

647
00:25:17,299 --> 00:25:19,339
y el LinkedInList, que van a ser esto

648
00:25:19,339 --> 00:25:20,839
pero un poquito

649
00:25:20,839 --> 00:25:23,640
mejor hecho, bueno mejor no

650
00:25:23,640 --> 00:25:24,359
con más

651
00:25:24,359 --> 00:25:26,440
venga pues ya está

652
00:25:26,440 --> 00:25:29,180
a ver

653
00:25:35,359 --> 00:25:38,339
Venga

654
00:25:38,339 --> 00:25:41,359
A ver, Gels

655
00:25:41,359 --> 00:25:45,799
¿Qué?

656
00:25:53,920 --> 00:25:55,220
Sí, sí, sí

657
00:25:55,220 --> 00:25:58,220
Te vamos a llevar a un sitio muy bonito

658
00:25:58,220 --> 00:25:59,940
Con gente vestida de blanco

659
00:25:59,940 --> 00:26:02,339
Sí, no te asustes

660
00:26:02,339 --> 00:26:04,220
Vas a estar muy a gusto allí

661
00:26:04,220 --> 00:26:08,440
Las paredes son blanditas

662
00:26:08,440 --> 00:26:13,700
A ver, igual te ponen un chaleco un poquito incómodo

663
00:26:13,700 --> 00:26:14,599
Pero te acostumbras

664
00:26:14,599 --> 00:26:19,519
Según Brian, ¿no?

665
00:26:22,220 --> 00:26:24,460
Venga, pues vamos a hacernos un paquete

666
00:26:24,460 --> 00:26:26,920
Lista

667
00:26:26,920 --> 00:26:29,359
Venga, listas

668
00:26:29,359 --> 00:26:30,400
Porque aquí vamos a meter

669
00:26:30,400 --> 00:26:33,680
Pues venga

670
00:26:33,680 --> 00:26:37,220
vamos a hacernos nosotros

671
00:26:37,220 --> 00:26:39,140
nuestra propia

672
00:26:39,140 --> 00:26:41,400
nuestra propia clase

673
00:26:41,400 --> 00:26:42,259
ArrayList

674
00:26:42,259 --> 00:26:43,799
la que nos ven de Java

675
00:26:43,799 --> 00:26:47,000
pues no, la vamos a hacer nosotros que somos malistos

676
00:26:47,000 --> 00:26:47,299
venga

677
00:26:47,299 --> 00:26:53,970
la vamos a llamar miArrayList

678
00:26:53,970 --> 00:26:56,589
para no repetir el nombre

679
00:26:56,589 --> 00:27:03,700
bueno, pues que va a ser esta clase

680
00:27:03,700 --> 00:27:05,779
esta clase

681
00:27:05,779 --> 00:27:06,500
esta clase está pensada

682
00:27:06,500 --> 00:27:09,059
para que los objetos

683
00:27:09,059 --> 00:27:11,559
que pertenecen a

684
00:27:11,559 --> 00:27:13,759
a ella, guarden

685
00:27:13,759 --> 00:27:15,740
dentro un montón de datos

686
00:27:15,740 --> 00:27:16,640
de forma que

687
00:27:16,640 --> 00:27:18,859
podamos nosotros

688
00:27:18,859 --> 00:27:21,299
meter, sacar y consultar

689
00:27:21,299 --> 00:27:22,660
de forma sencilla

690
00:27:22,660 --> 00:27:25,500
y que nos sea completamente

691
00:27:25,500 --> 00:27:27,180
transparente como

692
00:27:27,180 --> 00:27:29,279
hace por dentro lo de meter, sacar,

693
00:27:29,440 --> 00:27:31,680
consultar. Entonces, esta clase la idea es que nos ofrezca

694
00:27:31,680 --> 00:27:33,599
datos, perdón, que nos ofrezca

695
00:27:33,599 --> 00:27:34,960
métodos, por ejemplo, como este.

696
00:27:35,720 --> 00:27:37,539
A ver, como tenemos que decidir

697
00:27:37,539 --> 00:27:39,119
con qué tipo de datos vamos a trabajar,

698
00:27:39,119 --> 00:27:41,619
porque todavía no hemos dado el salto

699
00:27:41,619 --> 00:27:43,819
a tipo genérico que le vamos a dar

700
00:27:43,819 --> 00:27:45,740
ya mismo, en cuanto tengamos

701
00:27:45,740 --> 00:27:47,079
esta clase ya la damos a genérico

702
00:27:47,079 --> 00:27:49,779
tenemos que decidir un tipo

703
00:27:49,779 --> 00:27:51,660
de dato para ella, vamos a hacer esta primera

704
00:27:51,660 --> 00:27:53,480
versión que guarde

705
00:27:53,480 --> 00:27:59,140
cadenas, stream

706
00:27:59,140 --> 00:28:01,779
venga, pues

707
00:28:01,779 --> 00:28:03,740
entonces, esta clase

708
00:28:03,740 --> 00:28:05,640
va a servir para guardar un montón de

709
00:28:05,640 --> 00:28:07,700
cadenas dentro y además nos va

710
00:28:07,700 --> 00:28:09,920
a dar datos para fácilmente

711
00:28:09,920 --> 00:28:11,599
meter cadenas y sacar, nos va a dar

712
00:28:11,599 --> 00:28:13,500
métodos, jolines, luego sería

713
00:28:13,500 --> 00:28:15,299
maravilloso que esta clase

714
00:28:15,299 --> 00:28:17,519
tuviera un

715
00:28:17,519 --> 00:28:19,220
método que fuera este

716
00:28:19,220 --> 00:28:21,180
donde yo le paso

717
00:28:21,180 --> 00:28:22,799
un string

718
00:28:22,799 --> 00:28:27,059
y lo mete en esa

719
00:28:27,059 --> 00:28:27,660
estructura

720
00:28:27,660 --> 00:28:31,059
porque si lo ofrecen, si ofrecen

721
00:28:31,059 --> 00:28:33,039
este método, ya metí una

722
00:28:33,039 --> 00:28:35,200
cadena nueva, y sería maravilloso

723
00:28:35,200 --> 00:28:37,200
si tuviera un método

724
00:28:37,200 --> 00:28:38,900
que yo le llamo get

725
00:28:38,900 --> 00:29:09,230
por ejemplo le doy una posición y me devuelve la cadena en esa posición, magnífico, y sería genial si esta clase tiene un método que fuera borrar, por ejemplo, yo le doy una posición y me borra el elemento en esa posición, me lo saca de la lista,

726
00:29:09,230 --> 00:29:23,750
Y sería también estupendo, por ejemplo, si tuviera un método que fuera tamaño y me devolviera el tamaño de la lista para ya saber cuántos elementos hay.

727
00:29:23,849 --> 00:29:26,150
Si hay siete cadenas, ocho cadenas, nueve cadenas.

728
00:29:29,789 --> 00:29:31,029
¿El punto led de quién?

729
00:29:32,450 --> 00:29:34,789
Bueno, llámale el led si quieres, pero el led es de una RAI.

730
00:29:35,509 --> 00:29:36,509
Vale, entonces.

731
00:29:37,769 --> 00:29:38,250
Vale.

732
00:29:38,250 --> 00:29:40,869
entonces yo lo que quiero es hacer una clase

733
00:29:40,869 --> 00:29:42,950
para meter un montón de datos dentro

734
00:29:42,950 --> 00:29:45,109
y que me ofrezca estos datos

735
00:29:45,109 --> 00:29:46,549
y que me ofrezca estos métodos

736
00:29:46,549 --> 00:29:49,309
porque yo lo único que quiero hacer con ese mogollón

737
00:29:49,309 --> 00:29:51,289
de datos es meter datos

738
00:29:51,289 --> 00:29:52,990
consultar datos por posición

739
00:29:52,990 --> 00:29:55,130
eliminar datos por posición

740
00:29:55,130 --> 00:29:56,650
y cuantos datos hay

741
00:29:56,650 --> 00:29:59,230
porque claro si yo voy a recorrer

742
00:29:59,230 --> 00:30:01,130
la colección pues la tendré que recorrer

743
00:30:01,130 --> 00:30:03,170
a lo largo de su tamaño, maravilloso

744
00:30:03,170 --> 00:30:05,430
claro pero nos falta algo esencial

745
00:30:05,430 --> 00:30:06,349
que es

746
00:30:06,349 --> 00:30:09,349
oye, pero ¿dónde los va a guardar?

747
00:30:10,309 --> 00:30:11,430
hemos dicho que esta clase

748
00:30:11,430 --> 00:30:12,930
me va a servir para guardar dentro

749
00:30:12,930 --> 00:30:14,809
un montón de datos, un montón de cadenas

750
00:30:14,809 --> 00:30:16,890
¿dónde los va a guardar? internamente

751
00:30:16,890 --> 00:30:17,809
los va a guardar en algún sitio

752
00:30:17,809 --> 00:30:20,710
muy bien, venga, pues internamente

753
00:30:20,710 --> 00:30:23,390
pero nosotros no nos enteramos y nos da igual

754
00:30:23,390 --> 00:30:25,430
internamente que los guarde

755
00:30:25,430 --> 00:30:25,910
en un array

756
00:30:25,910 --> 00:30:29,430
que inicialmente puede ser un array vacío

757
00:30:29,430 --> 00:30:36,720
voy, voy, voy

758
00:30:36,720 --> 00:30:37,819
voy, voy, ya

759
00:30:37,819 --> 00:30:42,940
vale, pues entonces

760
00:30:42,940 --> 00:30:44,700
mi clase, mi ArrayList

761
00:30:44,700 --> 00:30:46,859
al que le va a usar

762
00:30:46,859 --> 00:30:49,200
le da lo mismo, al que la va a usar

763
00:30:49,200 --> 00:30:50,799
le da igual, no le importa

764
00:30:50,799 --> 00:30:52,839
pero la clase, mi ArrayList

765
00:30:52,839 --> 00:30:54,900
ella por dentro va a guardar

766
00:30:54,900 --> 00:30:57,079
todos los datos en un Array y se va a limitar

767
00:30:57,079 --> 00:30:58,240
a ofrecer unos métodos

768
00:30:58,240 --> 00:31:00,779
para que la gente meta y saca

769
00:31:00,779 --> 00:31:03,480
bueno, pues entonces el de añadir

770
00:31:03,480 --> 00:31:05,400
ya lo sabemos programar

771
00:31:05,400 --> 00:31:07,180
si el usuario

772
00:31:07,180 --> 00:31:08,000
me pasa un dato.

773
00:31:08,920 --> 00:31:10,940
¿Cómo lo meto en el array? Pues la misma

774
00:31:10,940 --> 00:31:13,140
historia de siempre, que estamos hartos

775
00:31:13,140 --> 00:31:15,180
ya de lo mismo. Nos hacemos

776
00:31:15,180 --> 00:31:16,920
un auxiliar con una posición

777
00:31:16,920 --> 00:31:18,920
más que

778
00:31:18,920 --> 00:31:20,900
el datos en el que quiero meter.

779
00:31:32,000 --> 00:31:32,779
Hacemos un

780
00:31:32,779 --> 00:31:34,960
for en el que copio

781
00:31:34,960 --> 00:31:39,609
todo lo que hay

782
00:31:39,609 --> 00:31:41,309
en el array antiguo, que es datos,

783
00:31:42,049 --> 00:31:43,349
en el nuevo.

784
00:31:53,589 --> 00:31:55,589
Una vez que ese for ha terminado,

785
00:31:55,589 --> 00:31:57,930
en la posición extra de auxiliar,

786
00:31:57,930 --> 00:32:03,029
que es la de aux.lenc-1

787
00:32:03,029 --> 00:32:05,509
copio el dato nuevo

788
00:32:05,509 --> 00:32:09,710
y una vez que ya tengo mi aux completito

789
00:32:09,710 --> 00:32:12,549
con los datos antiguos y el extra

790
00:32:12,549 --> 00:32:15,450
sobre escribo datos

791
00:32:15,450 --> 00:32:17,430
con el nuevo

792
00:32:17,430 --> 00:32:28,509
pues genial

793
00:32:28,509 --> 00:32:33,470
el método recuperar por posición

794
00:32:33,470 --> 00:32:35,430
este es muchísimo más fácil

795
00:32:35,430 --> 00:32:37,710
el método recuperar por posición

796
00:32:37,710 --> 00:32:39,029
es tan fácil como este

797
00:32:39,029 --> 00:32:50,339
Se la pasas por parámetro

798
00:32:50,339 --> 00:32:52,140
O sea, cuando tú uses el método

799
00:32:52,140 --> 00:32:54,079
Dices, dame el de la posición tal

800
00:32:54,079 --> 00:32:59,750
Size

801
00:32:59,750 --> 00:33:01,690
Bueno, size facilísimo también

802
00:33:01,690 --> 00:33:05,269
Devuelvo esto

803
00:33:05,269 --> 00:33:05,750
Ya está

804
00:33:05,750 --> 00:33:12,380
Me dice error de compilación

805
00:33:12,380 --> 00:33:13,220
Porque length

806
00:33:13,220 --> 00:33:15,519
Me lo devuelve en tipo long

807
00:33:15,519 --> 00:33:17,019
Y yo aquí he puesto int

808
00:33:17,019 --> 00:33:20,259
Y entonces estoy yéndome

809
00:33:20,259 --> 00:33:22,720
De un dato long a un int

810
00:33:22,720 --> 00:33:24,180
Podría perder información

811
00:33:24,180 --> 00:33:26,799
Bueno, voy a cambiar el size para que me devuelva un long

812
00:33:26,799 --> 00:33:27,359
Y así

813
00:33:27,359 --> 00:33:30,700
Y así no hago el casting y hago nada

814
00:33:30,700 --> 00:33:34,160
Ahora, vale

815
00:33:34,160 --> 00:33:43,779
Nada, o sea que datos.led

816
00:33:43,779 --> 00:33:46,839
Me devuelve el tamaño de la array en long

817
00:33:46,839 --> 00:33:48,200
Y por eso he puesto que me devuelva un long

818
00:33:48,200 --> 00:33:49,680
Pero ya está, nada más

819
00:33:49,680 --> 00:33:56,500
da igual, que más te da

820
00:33:56,500 --> 00:33:57,859
vas a tener tú a raíz

821
00:33:57,859 --> 00:34:00,500
de más de 2 elevado a

822
00:34:00,500 --> 00:34:01,220
31

823
00:34:01,220 --> 00:34:04,319
pues si

824
00:34:04,319 --> 00:34:05,940
entonces es un chulo

825
00:34:05,940 --> 00:34:07,099
y un listo de mierda

826
00:34:07,099 --> 00:34:09,840
pues le pones long

827
00:34:09,840 --> 00:34:12,400
y si tienes 2 elevado a 63

828
00:34:12,400 --> 00:34:13,519
más de eso, que le pones

829
00:34:13,519 --> 00:34:14,659
otro más

830
00:34:14,659 --> 00:34:18,039
venga, remove

831
00:34:18,039 --> 00:34:21,239
que me preguntaste

832
00:34:21,239 --> 00:34:28,619
es que no, imagino que te diría

833
00:34:28,619 --> 00:34:30,579
que lo tienes que construir tú por programa

834
00:34:30,579 --> 00:34:32,079
claro, combinando varios

835
00:34:32,079 --> 00:34:33,940
y haciendo multiplicaciones por dos

836
00:34:33,940 --> 00:34:35,559
para llevar la parte a

837
00:34:35,559 --> 00:34:36,659
construir otro por programa

838
00:34:36,659 --> 00:34:38,659
como tipo de dato en sí

839
00:34:38,659 --> 00:34:40,460
claro

840
00:34:40,460 --> 00:34:43,659
eso

841
00:34:43,659 --> 00:34:45,500
igual que estamos construyendo aquí

842
00:34:45,500 --> 00:34:47,340
pues construir un tipo de dato que tuviera

843
00:34:47,340 --> 00:34:48,559
parte una, parte dos

844
00:34:48,559 --> 00:34:51,039
Y a ofrecer tú los métodos

845
00:34:51,039 --> 00:34:52,119
Que fuera a guardar

846
00:34:52,119 --> 00:34:53,820
Y a llevarte

847
00:34:53,820 --> 00:34:58,829
Vale, entonces remove por posición

848
00:34:58,829 --> 00:35:00,170
Si habríais a hacerlo, pues sí

849
00:35:00,170 --> 00:35:02,670
Habría que hacer un auxiliar con una posición menos

850
00:35:02,670 --> 00:35:03,670
¿Verdad?

851
00:35:14,679 --> 00:35:15,239
De

852
00:35:15,239 --> 00:35:18,340
Datos.length

853
00:35:18,340 --> 00:35:20,840
Menos uno, uno con una posición menos

854
00:35:20,840 --> 00:35:22,679
Hasta la posición

855
00:35:22,679 --> 00:35:24,639
A borrar, copiamos los que había

856
00:35:24,639 --> 00:35:26,480
Y luego copiamos con una de adelanto

857
00:35:26,480 --> 00:35:27,980
entonces ahora

858
00:35:27,980 --> 00:35:31,500
mientras i sea igual a 0

859
00:35:31,500 --> 00:35:33,519
mientras i sea menor

860
00:35:33,519 --> 00:35:35,380
que la posición que

861
00:35:35,380 --> 00:35:36,699
no voy a copiar

862
00:35:36,699 --> 00:35:38,420
que me voy a saltar

863
00:35:38,420 --> 00:35:40,199
incrementando i

864
00:35:40,199 --> 00:35:41,840
pues copiamos

865
00:35:41,840 --> 00:35:43,940
en aux de i

866
00:35:43,940 --> 00:35:47,900
copiamos datos de i

867
00:35:47,900 --> 00:35:51,889
y ahora ya nos falta copiar

868
00:35:51,889 --> 00:35:52,789
la segunda parte

869
00:35:52,789 --> 00:35:54,789
la que va desde

870
00:35:54,789 --> 00:35:56,309
pos más 1

871
00:35:56,309 --> 00:36:01,670
Ah, perdón

872
00:36:01,670 --> 00:36:06,599
Vale

873
00:36:06,599 --> 00:36:07,599
Y

874
00:36:07,599 --> 00:36:11,380
Ahora nos faltaría copiar

875
00:36:11,380 --> 00:36:12,500
La que va

876
00:36:12,500 --> 00:36:15,139
Desde pos más uno

877
00:36:15,139 --> 00:36:17,079
Porque la pos nos la saltamos

878
00:36:17,079 --> 00:36:20,420
Desde pos más uno

879
00:36:20,420 --> 00:36:21,880
Mientras

880
00:36:21,880 --> 00:36:23,739
Eh, perdón

881
00:36:23,739 --> 00:36:25,480
Si, pos más uno

882
00:36:25,480 --> 00:36:26,800
Mientras i sea menor

883
00:36:26,800 --> 00:36:29,760
que datos.length

884
00:36:29,760 --> 00:36:31,800
incrementando

885
00:36:31,800 --> 00:36:35,500
y, vale

886
00:36:35,500 --> 00:36:38,300
pues aquí hay que copiarla

887
00:36:38,300 --> 00:36:40,000
en una inferior

888
00:36:40,000 --> 00:36:42,000
de la y, porque i va por dentro de la aux

889
00:36:42,000 --> 00:36:43,139
porque aux va por detrás

890
00:36:43,139 --> 00:36:54,340
vale, y una vez que tenemos el aux construido

891
00:36:54,340 --> 00:36:56,119
datos

892
00:36:56,119 --> 00:36:57,119
igual a aux

893
00:36:57,119 --> 00:37:11,170
vale, pues ahora ya hemos metido en una

894
00:37:11,170 --> 00:37:13,050
clase nuestra, que podemos llamar

895
00:37:13,050 --> 00:37:14,809
colección, y además porque lo es

896
00:37:14,809 --> 00:37:17,090
en una clase nuestra la posibilidad de

897
00:37:17,090 --> 00:37:22,650
instanciar objetos para guardar un montón de datos y simular un comportamiento dinámico.

898
00:37:23,389 --> 00:37:33,230
Por ejemplo, ahora nos hacemos un paquete con mi main que hace cosas.

899
00:37:43,099 --> 00:37:48,889
Venga, una clase main para hacer cositas.

900
00:37:52,610 --> 00:37:57,510
Bueno, pues resulta que esta aplicación mía va a trabajar con un montón de nombres.

901
00:37:57,769 --> 00:38:00,369
Un montón de nombres que pide por teclado o como sea.

902
00:38:01,949 --> 00:38:04,929
Entonces, voy a meterle lo de leer por teclado.

903
00:38:05,389 --> 00:38:18,550
Para que sea más cómodo, en el classpad le añado el jar.

904
00:38:26,130 --> 00:38:27,849
A ver, está aquí, ¿qué es lo que falta?

905
00:38:28,130 --> 00:38:30,010
Pedro, ¿qué es lo que falta?

906
00:38:47,139 --> 00:38:54,940
Bueno, pues entonces, esta clase a mí me la han dado, ya ni siquiera tengo acceso a su código.

907
00:38:55,059 --> 00:38:59,099
La puedo haber importado con un jar, me la han dado exportada en un jar, yo la he importado

908
00:38:59,099 --> 00:39:00,539
Y no tengo ni código ni tengo nada

909
00:39:00,539 --> 00:39:03,119
Pero sé que tengo una clase en mi ArrayList

910
00:39:03,119 --> 00:39:04,239
Que puedo instanciar

911
00:39:04,239 --> 00:39:06,539
Pues venga

912
00:39:06,539 --> 00:39:12,610
Por ejemplo

913
00:39:12,610 --> 00:39:14,050
Queremos un montón de nombres

914
00:39:14,050 --> 00:39:16,170
Pues todos estos nombres

915
00:39:16,170 --> 00:39:18,929
En lugar de crear un Array

916
00:39:18,929 --> 00:39:19,690
Para ellos

917
00:39:19,690 --> 00:39:22,269
Yo me creo

918
00:39:22,269 --> 00:39:24,630
Una estructura, un objeto

919
00:39:24,630 --> 00:39:25,489
Mi ArrayList

920
00:39:25,489 --> 00:39:41,780
Vale

921
00:39:41,780 --> 00:39:43,059
Importo

922
00:39:43,059 --> 00:39:47,360
vale, entonces me he creado

923
00:39:47,360 --> 00:39:49,059
un objeto de esa clase

924
00:39:49,059 --> 00:39:50,940
¿este objeto para qué vale?

925
00:39:51,480 --> 00:39:53,320
pues yo sé que vale, porque en la ayuda

926
00:39:53,320 --> 00:39:55,440
que me han dado de la clase, que me he importado con el

927
00:39:55,440 --> 00:39:57,659
jar, lo que sea, en la ayuda

928
00:39:57,659 --> 00:39:59,480
he visto que vale para meter un montón de

929
00:39:59,480 --> 00:40:01,679
nombres, con add, recuperar, lo que sea

930
00:40:01,679 --> 00:40:03,519
pues yo me creo esta estructura

931
00:40:03,519 --> 00:40:04,900
entonces esto es

932
00:40:04,900 --> 00:40:07,059
una instancia concreta

933
00:40:07,059 --> 00:40:09,639
de mi ArrayList, de la colección

934
00:40:09,639 --> 00:40:11,519
que yo me he programado, que vale para

935
00:40:11,519 --> 00:40:12,840
meter un montón de nombres

936
00:40:12,840 --> 00:40:15,019
vale, y yo repito

937
00:40:15,019 --> 00:40:17,079
como esté hecha por dentro me da igual, sé que vale

938
00:40:17,079 --> 00:40:18,639
para guardar nombres, bueno pues por ejemplo

939
00:40:18,639 --> 00:40:20,920
suponer que le vamos a pedir

940
00:40:20,920 --> 00:40:22,639
en un bucle a un usuario

941
00:40:22,639 --> 00:40:25,059
que meta nombres

942
00:40:25,059 --> 00:40:25,679
todo el rato

943
00:40:25,679 --> 00:40:28,980
por ejemplo yo que sé, pues 10 nombres

944
00:40:28,980 --> 00:40:30,900
vamos a suponer que

945
00:40:30,900 --> 00:40:33,219
un programa que mete 10 nombres

946
00:40:33,219 --> 00:40:35,460
y luego los muestra, ya está, vamos a hacer eso

947
00:40:35,460 --> 00:40:39,619
venga, pues vamos a meter 10 nombres

948
00:40:39,619 --> 00:40:41,199
luego un bucle que ejecutamos

949
00:40:41,199 --> 00:40:41,940
10 veces

950
00:40:41,940 --> 00:40:45,019
y ahora le decimos

951
00:40:45,019 --> 00:40:51,000
nombre

952
00:40:51,000 --> 00:40:57,670
ahora leemos el nombre

953
00:40:57,670 --> 00:41:05,809
y ahora este nombre

954
00:41:05,809 --> 00:41:07,230
se va a la caja

955
00:41:07,230 --> 00:41:09,530
no se va a un array

956
00:41:09,530 --> 00:41:11,590
que yo construí, nada, se va a la caja

957
00:41:11,590 --> 00:41:13,389
nombres, porque nombres es una caja

958
00:41:13,389 --> 00:41:15,789
una colección, y como se va a la caja

959
00:41:15,789 --> 00:41:18,949
pues a través de su método add

960
00:41:18,949 --> 00:41:21,389
que acabo de programar, ala, ya está en la caja

961
00:41:21,389 --> 00:41:25,059
como está hecha por dentro de esa caja

962
00:41:25,059 --> 00:41:26,940
me da igual, yo sé que llamo al método

963
00:41:26,940 --> 00:41:28,639
add y el nombre

964
00:41:28,639 --> 00:41:30,539
se va a esa cajita nombres

965
00:41:30,539 --> 00:41:32,099
que acabo de crear

966
00:41:32,099 --> 00:41:33,780
de esta clase

967
00:41:33,780 --> 00:41:36,780
ya está, me da igual

968
00:41:36,780 --> 00:41:37,900
los detalles

969
00:41:37,900 --> 00:41:41,019
entonces yo desde fuera

970
00:41:41,019 --> 00:41:43,019
veo como voy

971
00:41:43,019 --> 00:41:44,840
metiendo, voy metiendo, luego la caja se va

972
00:41:44,840 --> 00:41:46,780
agrandando, pero es una lista dinámica, yo voy metiendo

973
00:41:46,780 --> 00:41:48,800
nombres, voy metiendo nombres y ya está, en este caso 10

974
00:41:48,800 --> 00:41:50,679
como si fueran 100, como si fueran 50

975
00:41:50,679 --> 00:41:52,920
esto es simplemente una caja para meter

976
00:41:52,920 --> 00:41:53,300
nombres

977
00:41:53,300 --> 00:41:56,460
venga a suponer que ya hemos metido la caja

978
00:41:56,460 --> 00:41:57,420
ahora vamos a mostrarlos

979
00:41:57,420 --> 00:42:03,539
podría ser cualquier otra cosa la que queramos hacer

980
00:42:03,539 --> 00:42:04,500
pero vamos a mostrarlos

981
00:42:04,500 --> 00:42:07,420
vale pues yo sé que esta cajita

982
00:42:07,420 --> 00:42:09,199
mía nombres tiene un método get

983
00:42:09,199 --> 00:42:11,199
para devolverme

984
00:42:11,199 --> 00:42:13,639
el de cada posición si a mi me da la gana

985
00:42:13,639 --> 00:42:15,179
bueno de hecho

986
00:42:15,179 --> 00:42:16,920
en lugar de mostrarlos todos vamos a hacer una cosa

987
00:42:16,920 --> 00:42:18,800
mostramos el primero

988
00:42:18,800 --> 00:42:20,800
introducido pues como mostramos

989
00:42:20,800 --> 00:42:22,400
el primero introducido como va a salir

990
00:42:22,400 --> 00:42:24,340
pues nombres

991
00:42:24,340 --> 00:42:26,460
punto get

992
00:42:26,460 --> 00:42:28,719
de 0

993
00:42:28,719 --> 00:42:33,320
entonces yo aquí me olvido

994
00:42:33,320 --> 00:42:35,119
de la implementación interna que es un array

995
00:42:35,119 --> 00:42:36,960
tengo un get que me saca el que yo quiera

996
00:42:36,960 --> 00:42:39,539
vamos a mostrar el último

997
00:42:39,539 --> 00:42:51,599
pues el último

998
00:42:51,599 --> 00:42:53,820
sería

999
00:42:53,820 --> 00:42:56,019
el noveno en este caso

1000
00:42:56,019 --> 00:42:58,039
vale resulta que queremos

1001
00:42:58,039 --> 00:42:58,980
eliminar

1002
00:42:58,980 --> 00:43:02,059
el que está en la posición 3

1003
00:43:02,059 --> 00:43:02,980
por ejemplo

1004
00:43:02,980 --> 00:43:06,710
eliminamos

1005
00:43:06,710 --> 00:43:07,849
posición

1006
00:43:07,849 --> 00:43:09,630
3

1007
00:43:09,630 --> 00:43:12,829
bueno, pues yo sé que hay un método

1008
00:43:12,829 --> 00:43:14,889
de esa cajita que me acabo

1009
00:43:14,889 --> 00:43:15,869
de construir nombres

1010
00:43:15,869 --> 00:43:18,210
sé que hay un método que es remove

1011
00:43:18,210 --> 00:43:20,809
que le paso una posición y me elimina

1012
00:43:20,809 --> 00:43:22,670
ese, pues magnífico

1013
00:43:22,670 --> 00:43:26,280
voy a mostrar ahora los que tengo

1014
00:43:26,280 --> 00:43:28,800
todos, pues voy a recorrer

1015
00:43:28,800 --> 00:43:30,360
voy a recorrer

1016
00:43:30,360 --> 00:43:31,139
mi colección

1017
00:43:31,139 --> 00:43:33,599
desde igual a 0, metéis a menor que igual

1018
00:43:33,599 --> 00:43:35,679
que el tamaño que tenga la colección

1019
00:43:35,679 --> 00:43:37,679
el tamaño que tenga la colección, sé cuál es

1020
00:43:37,679 --> 00:43:39,260
Porque he programado un método size

1021
00:43:39,260 --> 00:43:42,360
Entonces, como he programado este método

1022
00:43:42,360 --> 00:43:44,000
El tamaño de la colección sé cuál es

1023
00:43:44,000 --> 00:43:45,239
Que ahora mismo será uno menos

1024
00:43:45,239 --> 00:43:46,619
Porque he hecho un remove

1025
00:43:46,619 --> 00:43:56,389
Y ahora vamos a mostrar todos y cada uno

1026
00:43:56,389 --> 00:43:57,789
De los que están en esas posiciones

1027
00:43:57,789 --> 00:44:01,210
Uy, nombres get

1028
00:44:01,210 --> 00:44:11,179
Bueno, pues esto es mucho más cómodo de usar

1029
00:44:11,179 --> 00:44:12,800
Que cualquier array

1030
00:44:12,800 --> 00:44:16,460
Tengo mi add para añadir

1031
00:44:16,460 --> 00:44:18,960
Cuando a mí me dé la gana meter uno nuevo en la caja

1032
00:44:18,960 --> 00:44:21,420
mi remove para eliminar el que yo quiera

1033
00:44:21,420 --> 00:44:22,400
en la posición que quiera

1034
00:44:22,400 --> 00:44:24,780
un método de consulta por posición

1035
00:44:24,780 --> 00:44:27,659
y podría poner muchos más métodos

1036
00:44:27,659 --> 00:44:29,340
para hacer cosas con lo que hay ahí

1037
00:44:29,340 --> 00:44:30,940
pero bueno, esto es para ver la idea

1038
00:44:30,940 --> 00:44:32,579
de lo que es una colección

1039
00:44:32,579 --> 00:44:35,619
pues esto es una colección

1040
00:44:35,619 --> 00:44:37,539
de verdad

1041
00:44:37,539 --> 00:44:38,480
de todas las que hay

1042
00:44:38,480 --> 00:44:41,239
esto es una clase como esta que hemos hecho

1043
00:44:41,239 --> 00:44:43,579
que mediante sus variables

1044
00:44:43,579 --> 00:44:45,559
internas te provee

1045
00:44:45,559 --> 00:44:47,659
de una posibilidad de guardar muchas cosas

1046
00:44:47,659 --> 00:44:49,639
dentro y te provee de

1047
00:44:49,639 --> 00:44:51,639
métodos para meterlos, sacarlos y consultarlos.

1048
00:44:51,679 --> 00:44:52,320
Es una colección.

1049
00:44:53,559 --> 00:44:55,320
Con lo cual, tú la usas

1050
00:44:55,320 --> 00:44:57,880
instanciando la colección.

1051
00:44:59,260 --> 00:44:59,880
La usas

1052
00:44:59,880 --> 00:45:01,760
instanciando la colección y la usas

1053
00:45:01,760 --> 00:45:03,219
como se usan las colecciones,

1054
00:45:03,619 --> 00:45:06,059
que se usan para meter, sacar y consultar

1055
00:45:06,059 --> 00:45:06,800
y punto, pelota.

1056
00:45:07,719 --> 00:45:09,360
¿Y cómo está hecha por dentro? Te da igual.

1057
00:45:09,719 --> 00:45:11,639
¿Cómo añade? Me da lo mismo. Yo añado

1058
00:45:11,639 --> 00:45:13,920
y se acabó. ¿Cómo recupera?

1059
00:45:13,920 --> 00:45:15,880
Me da igual cómo recupere. Yo recupero

1060
00:45:15,880 --> 00:45:17,599
y se acabó. ¿Cómo borra? Me da igual.

1061
00:45:17,659 --> 00:45:19,159
yo borro y se acabó, dime

1062
00:45:19,159 --> 00:45:24,860
el tamaño porque así

1063
00:45:24,860 --> 00:45:26,579
la he programado yo, yo me he hecho un método

1064
00:45:26,579 --> 00:45:28,679
size aquí que te

1065
00:45:28,679 --> 00:45:30,860
devuelve el tamaño

1066
00:45:30,860 --> 00:45:32,159
de los datos

1067
00:45:32,159 --> 00:45:34,699
entonces size te da el tamaño de los datos

1068
00:45:34,699 --> 00:45:37,320
por eso el size es imprescindible

1069
00:45:37,320 --> 00:45:38,579
para recorrer esa colección

1070
00:45:38,579 --> 00:45:44,380
claro, pero por eso he hecho

1071
00:45:44,380 --> 00:45:45,139
el método size

1072
00:45:45,139 --> 00:45:47,460
aquí nombres nunca le haría lenz

1073
00:45:47,460 --> 00:45:49,539
claro, es el método

1074
00:45:49,539 --> 00:45:52,380
de hecho es que el array este

1075
00:45:52,380 --> 00:45:54,739
es privado. Que exista este

1076
00:45:54,739 --> 00:45:56,360
array, el usuario de la colección

1077
00:45:56,360 --> 00:45:58,780
no tiene ni idea de que este array existe. Es su forma

1078
00:45:58,780 --> 00:46:00,199
interna de guardar esos datos.

1079
00:46:01,039 --> 00:46:01,840
Tú desde fuera

1080
00:46:01,840 --> 00:46:04,699
añade, desde fuera

1081
00:46:04,699 --> 00:46:06,199
llamas a los métodos y ya está.

1082
00:46:07,639 --> 00:46:08,980
¿Vale? Entonces,

1083
00:46:09,280 --> 00:46:12,699
lo que pasa es que nosotros hemos hecho esto

1084
00:46:12,699 --> 00:46:14,579
muy alegremente. Aquí pueden salir un punto de interés

1085
00:46:14,579 --> 00:46:17,000
y de todo, porque no estamos viendo los casos particulares

1086
00:46:17,000 --> 00:46:17,659
de

1087
00:46:17,659 --> 00:46:20,780
borrar uno y le das una posición

1088
00:46:20,780 --> 00:46:22,559
que no exista, entonces

1089
00:46:22,559 --> 00:46:25,119
yo he hecho los métodos sin verificar

1090
00:46:25,119 --> 00:46:26,079
por ejemplo el get

1091
00:46:26,079 --> 00:46:28,360
habría que verificar que

1092
00:46:28,360 --> 00:46:30,800
pos está comprendido

1093
00:46:30,800 --> 00:46:32,699
entre 0 y el tamaño

1094
00:46:32,699 --> 00:46:34,679
del array menos 1 porque si no esto me va a dar

1095
00:46:34,679 --> 00:46:35,780
un array in this bound exception

1096
00:46:35,780 --> 00:46:38,800
pero a ver, mi idea ahora es que

1097
00:46:38,800 --> 00:46:40,900
entendáis la filosofía de las colecciones

1098
00:46:40,900 --> 00:46:42,579
que es una clase que

1099
00:46:42,579 --> 00:46:44,599
internamente te ofrece

1100
00:46:44,599 --> 00:46:46,980
espacio de almacenamiento

1101
00:46:46,980 --> 00:46:48,920
y te ofrece

1102
00:46:48,920 --> 00:46:50,619
una forma de acceder a ese espacio

1103
00:46:50,619 --> 00:46:52,820
de almacenamiento, ese espacio

1104
00:46:52,820 --> 00:46:54,420
de almacenamiento como está

1105
00:46:54,420 --> 00:46:56,480
hecho, si está con una array, si está con una lista

1106
00:46:56,480 --> 00:46:58,019
enlazada, como veremos luego

1107
00:46:58,019 --> 00:47:00,559
es lo de menos, entonces vamos a hacer

1108
00:47:00,559 --> 00:47:01,619
este main, a ver si

1109
00:47:01,619 --> 00:47:04,460
pero voy a ponerlos con

1110
00:47:04,460 --> 00:47:06,780
con mensajitos

1111
00:47:06,780 --> 00:47:08,460
para enterarnos bien de los

1112
00:47:08,460 --> 00:47:10,199
a ver

1113
00:47:10,199 --> 00:47:13,969
el primero, voy a poner

1114
00:47:13,969 --> 00:47:15,250
ahí para liarnos

1115
00:47:15,250 --> 00:47:16,369
el primero

1116
00:47:16,369 --> 00:47:19,110
aquí ponemos

1117
00:47:19,110 --> 00:47:24,179
el segundo

1118
00:47:24,179 --> 00:47:27,059
voy a poner aquí

1119
00:47:27,059 --> 00:47:28,679
el segundo no, perdón

1120
00:47:28,679 --> 00:47:30,079
el último

1121
00:47:30,079 --> 00:47:36,360
voy a poner aquí

1122
00:47:36,360 --> 00:47:42,769
eliminamos

1123
00:47:42,769 --> 00:47:46,969
el que está en posición 3

1124
00:47:46,969 --> 00:47:49,610
y ahora voy a poner aquí

1125
00:47:49,610 --> 00:47:56,329
los que quedan

1126
00:47:56,329 --> 00:47:58,349
vale, a ver si así

1127
00:47:58,349 --> 00:48:00,769
podemos, entendemos mejor

1128
00:48:00,769 --> 00:48:01,530
la salida y

1129
00:48:01,530 --> 00:48:03,889
A ver qué ocurre

1130
00:48:03,889 --> 00:48:09,219
Venga, ejecutamos esto

1131
00:48:09,219 --> 00:48:10,820
Vale, ha metido cadena de texto

1132
00:48:10,820 --> 00:48:12,039
Pues

1133
00:48:12,039 --> 00:48:16,219
Tenía que haber puesto 5

1134
00:48:16,219 --> 00:48:23,969
Vale

1135
00:48:23,969 --> 00:48:26,150
Entonces yo he metido mis 10 cadenas de texto

1136
00:48:26,150 --> 00:48:28,329
El primero, este, efectivamente

1137
00:48:28,329 --> 00:48:30,309
El último que metí

1138
00:48:30,309 --> 00:48:31,550
Este, efectivamente

1139
00:48:31,550 --> 00:48:33,590
Vamos a eliminar la posición 3

1140
00:48:33,590 --> 00:48:36,190
Que la posición 3

1141
00:48:36,190 --> 00:48:37,469
Era el DD

1142
00:48:37,469 --> 00:48:39,630
No, el DD no, ese es el 2

1143
00:48:39,630 --> 00:48:42,170
el FF, vamos a ver

1144
00:48:42,170 --> 00:48:43,730
si el FF lo he eliminado

1145
00:48:43,730 --> 00:48:45,710
pues sí, el FF lo he eliminado

1146
00:48:45,710 --> 00:48:46,949
¿vale?

1147
00:48:48,630 --> 00:48:49,590
luego yo

1148
00:48:49,590 --> 00:48:50,630
desde fuera

1149
00:48:50,630 --> 00:48:52,769
y como usuario

1150
00:48:52,769 --> 00:48:55,389
desde fuera me he limitado a

1151
00:48:55,389 --> 00:48:57,130
crear mi caja

1152
00:48:57,130 --> 00:48:59,210
instanciar el objeto

1153
00:48:59,210 --> 00:49:01,489
crear mi caja con el tipo de dato

1154
00:49:01,489 --> 00:49:02,750
del que yo dispongo

1155
00:49:02,750 --> 00:49:05,929
creo mi caja y la uso metiendo y sacando

1156
00:49:05,929 --> 00:49:06,949
y ya está

1157
00:49:06,949 --> 00:49:08,510
a mí el site me devuelve feo

1158
00:49:08,510 --> 00:49:17,539
Habiendo guardado previamente

1159
00:49:17,539 --> 00:49:25,940
Y los añade realmente

1160
00:49:25,940 --> 00:49:28,340
Claro, es que si pone 0

1161
00:49:28,340 --> 00:49:29,219
Es que no los está añadiendo

1162
00:49:29,219 --> 00:49:32,880
A ver si te va a faltar esto de sobreescribir datos por aus

1163
00:49:32,880 --> 00:49:42,539
Bueno, necesitéis parar un momentito

1164
00:49:42,539 --> 00:49:44,400
Vamos a aprovechar la parada