1
00:00:00,050 --> 00:00:03,910
Vamos

2
00:00:03,910 --> 00:00:07,410
¿Te refieres a mí?

3
00:00:08,150 --> 00:00:09,689
Que yo tengo preparadas el que

4
00:00:09,689 --> 00:00:16,570
Justo, en casa me dedico a eso

5
00:00:16,570 --> 00:00:18,129
A preparar las frases

6
00:00:18,129 --> 00:00:19,190
Que digo aquí

7
00:00:19,190 --> 00:00:20,809
Hombre, estarían más curradas

8
00:00:20,809 --> 00:00:23,109
Si me las preparara en casa estarían más curradas, te lo juro

9
00:00:23,109 --> 00:00:26,809
Esa ha salido del alma

10
00:00:26,809 --> 00:00:28,690
No ha salido de casa la de cortarte la cabeza

11
00:00:28,690 --> 00:00:30,530
ha salido de las ganas

12
00:00:30,530 --> 00:00:33,250
bueno, venga

13
00:00:33,250 --> 00:00:35,229
a ver, esta clase

14
00:00:35,229 --> 00:00:37,049
repito, pues habéis visto

15
00:00:37,049 --> 00:00:38,929
de qué manera tan sencilla se puede programar

16
00:00:38,929 --> 00:00:41,250
una estructura dinámica y tan fácil

17
00:00:41,250 --> 00:00:42,869
para ahora en un main, pues

18
00:00:42,869 --> 00:00:44,990
yo meto, saco, hago lo que me da la gana

19
00:00:44,990 --> 00:00:47,009
vale, pero

20
00:00:47,009 --> 00:00:49,310
¿cuál es el problema de esta estructura

21
00:00:49,310 --> 00:00:49,890
dinámica?

22
00:00:50,649 --> 00:00:52,750
que solo me vale para guardar cadenas

23
00:00:52,750 --> 00:00:54,929
string, y si yo quiero

24
00:00:54,929 --> 00:00:57,090
guardar objetos clientes, tengo que hacer

25
00:00:57,090 --> 00:00:59,310
una poniendo aquí en nodo

26
00:00:59,310 --> 00:01:00,090
cliente

27
00:01:00,090 --> 00:01:03,109
pues sí, vaya rollo

28
00:01:03,109 --> 00:01:05,049
y si quiero guardar enteros, tengo que poner ahí

29
00:01:05,049 --> 00:01:07,129
una poniendo ahí int, pues sí

30
00:01:07,129 --> 00:01:09,290
o sea, tengo que tener una versión de esta

31
00:01:09,290 --> 00:01:10,790
estructura clase y nodo

32
00:01:10,790 --> 00:01:12,750
para cada

33
00:01:12,750 --> 00:01:14,790
tipo de dato que quiera guardar

34
00:01:14,790 --> 00:01:16,849
pues con lo que sabemos hasta ahora, sí

35
00:01:16,849 --> 00:01:19,090
menudo rollo, no podríamos

36
00:01:19,090 --> 00:01:20,090
hacer una genérica

37
00:01:20,090 --> 00:01:22,890
eso es lo que nos pide el cuerpo

38
00:01:22,890 --> 00:01:24,390
hacer una genérica

39
00:01:24,390 --> 00:01:27,250
hacer una que me valga para cualquier tipo de dato

40
00:01:27,250 --> 00:01:29,450
pues claro que podemos

41
00:01:29,450 --> 00:01:31,370
hacer clases genéricas

42
00:01:31,370 --> 00:01:33,750
clases genéricas

43
00:01:33,750 --> 00:01:35,510
son clases que dependen de un tipo

44
00:01:35,510 --> 00:01:37,530
de dato que yo no quiero

45
00:01:37,530 --> 00:01:39,250
concretar toda vida, todavía

46
00:01:39,250 --> 00:01:40,909
lo dejo como incógnita

47
00:01:40,909 --> 00:01:43,349
se queda como incógnita, ya lo concretaré

48
00:01:43,349 --> 00:01:43,870
en el futuro

49
00:01:43,870 --> 00:01:47,370
una clase genérica es como

50
00:01:47,370 --> 00:01:49,150
la función matemática de toda la vida

51
00:01:49,150 --> 00:01:50,310
es como esto

52
00:01:50,310 --> 00:01:59,450
esto os dice algo, ¿no?

53
00:01:59,450 --> 00:02:05,069
esto es una función

54
00:02:05,069 --> 00:02:07,750
que depende de una incógnita

55
00:02:07,750 --> 00:02:08,889
esta es la incógnita

56
00:02:08,889 --> 00:02:11,289
pues una clase genérica es lo mismo

57
00:02:11,289 --> 00:02:13,229
es una clase que depende

58
00:02:13,229 --> 00:02:15,669
de un tipo de dato que es incógnita

59
00:02:15,669 --> 00:02:17,889
ya lo concretaré yo

60
00:02:17,889 --> 00:02:19,810
cuando quiera usar esa clase

61
00:02:19,810 --> 00:02:21,169
cuando quiera usarla

62
00:02:21,169 --> 00:02:23,270
pero por ahora la voy a declarar

63
00:02:23,270 --> 00:02:24,969
en función de una incógnita

64
00:02:24,969 --> 00:02:26,729
y es justo

65
00:02:26,729 --> 00:02:29,009
lo que nos gustaría hacer con esta clase

66
00:02:29,009 --> 00:02:31,090
nodo, declararla en función

67
00:02:31,090 --> 00:02:33,169
de una incógnita, que string

68
00:02:33,169 --> 00:02:35,069
sea una incógnita, sea

69
00:02:35,069 --> 00:02:36,930
algo genérico, de ahí viene el nombre

70
00:02:36,930 --> 00:02:37,990
de clases genéricas

71
00:02:37,990 --> 00:02:40,349
entonces una clase genérica

72
00:02:40,349 --> 00:02:42,629
si hacemos una clase genérica cualquiera

73
00:02:42,629 --> 00:02:45,250
en otro paquete por aquí

74
00:02:45,250 --> 00:02:46,370
para no ensuciar este

75
00:02:46,370 --> 00:02:59,379
vale, vamos a hacernos una clase

76
00:02:59,379 --> 00:03:06,770
clase genérica, vamos a llamarla

77
00:03:06,770 --> 00:03:09,250
una clase genérica

78
00:03:09,250 --> 00:03:10,629
que tiene, por ejemplo

79
00:03:10,629 --> 00:03:12,430
una propiedad entero, por ejemplo

80
00:03:12,430 --> 00:03:15,169
tiene un código, vamos a suponer que tiene una propiedad código

81
00:03:15,169 --> 00:03:18,509
y luego tiene un dato aquí, tiene otra propiedad

82
00:03:18,509 --> 00:03:20,569
dato, pero que yo

83
00:03:20,569 --> 00:03:23,849
no sé de qué tipo me interesa todavía que sea

84
00:03:23,849 --> 00:03:27,490
no sé si yo quiero que ese dato sea un entero

85
00:03:27,490 --> 00:03:30,330
un stream, un cliente, un alumno

86
00:03:30,330 --> 00:03:33,389
no lo sé todavía, qué tipo de dato quiero que sea, no lo sé

87
00:03:33,389 --> 00:03:35,750
vale, pues lo dejo como incógnita

88
00:03:35,750 --> 00:03:39,250
¿y cómo se escribe la incógnita? aquí, pues

89
00:03:39,250 --> 00:03:41,969
como cualquier letra mayúscula

90
00:03:41,969 --> 00:03:44,469
pongo ahí cualquier letra mayúscula

91
00:03:44,469 --> 00:03:46,650
habitualmente se usa una T

92
00:03:46,650 --> 00:03:48,229
o una V

93
00:03:48,229 --> 00:03:49,150
a veces

94
00:03:49,150 --> 00:03:52,289
o una, ¿vale?

95
00:03:53,169 --> 00:03:54,229
vamos a llamarla T

96
00:03:54,229 --> 00:03:55,050
por eso de tipo

97
00:03:55,050 --> 00:03:57,370
porque esto es un tipo incógnita

98
00:03:57,370 --> 00:03:58,550
esto es un tipo incógnita

99
00:03:58,550 --> 00:04:01,669
y yo digo, pues venga, este es mi dato

100
00:04:01,669 --> 00:04:04,370
mi dato pertenece

101
00:04:04,370 --> 00:04:06,229
a un tipo incógnita

102
00:04:06,229 --> 00:04:07,689
yo no lo conozco todavía

103
00:04:07,689 --> 00:04:09,590
ese tipo es una incógnita

104
00:04:09,590 --> 00:04:10,930
T mayúscula, no es nada

105
00:04:10,930 --> 00:04:13,830
entonces, al haber dejado esta clase

106
00:04:13,830 --> 00:04:15,590
en función de un tipo incógnita

107
00:04:15,590 --> 00:04:17,709
esta clase se convierte

108
00:04:17,709 --> 00:04:19,069
en una clase genérica, que se llama

109
00:04:19,069 --> 00:04:21,509
y tengo que especificarlo

110
00:04:21,509 --> 00:04:22,990
poniendo aquí esto

111
00:04:22,990 --> 00:04:26,839
¿vale?

112
00:04:28,279 --> 00:04:29,240
poniendo aquí eso

113
00:04:29,240 --> 00:04:32,759
y ahora, poniendo eso significa

114
00:04:32,759 --> 00:04:34,100
oye, que esta clase

115
00:04:34,100 --> 00:04:36,920
depende de un tipo de dato que es incógnita

116
00:04:36,920 --> 00:04:39,139
un tipo de dato que es incógnita

117
00:04:39,139 --> 00:04:39,540
depende

118
00:04:39,540 --> 00:04:42,399
y yo puedo trabajar, hacer métodos

119
00:04:42,399 --> 00:04:43,579
y hacer aquí lo que me dé la gana

120
00:04:43,579 --> 00:04:45,660
arrastrando ese tipo incógnita.

121
00:04:47,540 --> 00:04:48,019
¿Vale?

122
00:04:49,579 --> 00:04:51,519
Y podría incluso depender de dos.

123
00:04:52,240 --> 00:04:53,800
No tiene por qué depender de uno.

124
00:04:53,879 --> 00:04:55,519
Imaginaos que son dos los que yo quiero,

125
00:04:57,699 --> 00:04:58,779
que sean incógnitas.

126
00:05:05,399 --> 00:05:07,120
Pues estupendo, esta clase genérica

127
00:05:07,120 --> 00:05:08,480
depende de dos incógnitas.

128
00:05:09,019 --> 00:05:10,500
Y podría depender de más, pero bueno,

129
00:05:10,620 --> 00:05:12,899
las cosas se hacen para facilitar,

130
00:05:12,980 --> 00:05:13,720
no para complicar.

131
00:05:13,720 --> 00:05:15,279
Entonces ya que depende de más de dos.

132
00:05:16,079 --> 00:05:17,899
¿Vale? Y esta clase podría tener

133
00:05:17,899 --> 00:05:20,000
métodos, por ejemplo, pues imaginaos

134
00:05:20,000 --> 00:05:21,920
Que yo le quiero hacer un método

135
00:05:21,920 --> 00:05:23,740
Eh

136
00:05:23,740 --> 00:05:25,240
Mostrar

137
00:05:25,240 --> 00:05:28,000
Pues yo que sé, un método cualquiera

138
00:05:28,000 --> 00:05:29,000
Vamos a hacerlo para

139
00:05:29,000 --> 00:05:31,139
Mostrar

140
00:05:31,139 --> 00:05:35,910
El contenido, yo que sé

141
00:05:35,910 --> 00:05:37,910
Como si fuera un toString, pero bueno

142
00:05:37,910 --> 00:05:39,689
Más que un toString, pues

143
00:05:39,689 --> 00:05:44,550
Contenido

144
00:05:44,550 --> 00:05:47,269
Y ahora concateno aquí con dato1

145
00:05:47,269 --> 00:05:51,550
Y concateno también aquí con

146
00:05:51,550 --> 00:05:53,649
Dato2, por ejemplo

147
00:05:53,649 --> 00:05:59,959
y podría yo hacer aquí más métodos

148
00:05:59,959 --> 00:06:02,079
más cosas, lo que pasa es que

149
00:06:02,079 --> 00:06:03,920
claro, como esas variables son genéricas

150
00:06:03,920 --> 00:06:06,160
yo no puedo invocar a nada

151
00:06:06,160 --> 00:06:07,439
que no esté en object

152
00:06:07,439 --> 00:06:09,879
porque lo que yo sí que sé de cualquier clase

153
00:06:09,879 --> 00:06:12,240
es que le da de object, eso lo sé seguro

154
00:06:12,240 --> 00:06:13,420
eso lo sé seguro

155
00:06:13,420 --> 00:06:15,779
entonces cualquier método de object

156
00:06:15,779 --> 00:06:18,060
lo puedo utilizar para estos datos

157
00:06:18,060 --> 00:06:19,819
¿vale?

158
00:06:20,360 --> 00:06:21,660
es decir, si yo hago aquí

159
00:06:21,660 --> 00:06:27,480
dato1.

160
00:06:29,160 --> 00:06:30,259
pues me salen

161
00:06:30,259 --> 00:06:31,480
los de object

162
00:06:31,480 --> 00:06:32,639
porque

163
00:06:32,639 --> 00:06:33,879
no sé qué datos

164
00:06:33,879 --> 00:06:34,379
será

165
00:06:34,379 --> 00:06:34,740
no tengo

166
00:06:34,740 --> 00:06:35,040
perdón

167
00:06:35,040 --> 00:06:35,939
no sé qué clase será

168
00:06:35,939 --> 00:06:36,600
no tengo ni idea

169
00:06:36,600 --> 00:06:37,759
pero va a heredar

170
00:06:37,759 --> 00:06:38,579
de object sí o sí

171
00:06:38,579 --> 00:06:39,480
entonces lo más

172
00:06:39,480 --> 00:06:40,300
que puedo hacer yo

173
00:06:40,300 --> 00:06:41,579
aquí a nivel de código

174
00:06:41,579 --> 00:06:42,939
es llamar a métodos

175
00:06:42,939 --> 00:06:43,339
de object

176
00:06:43,339 --> 00:06:44,240
por ejemplo está

177
00:06:44,240 --> 00:06:45,439
el toString

178
00:06:45,439 --> 00:06:46,639
que el toString

179
00:06:46,639 --> 00:06:47,639
es el que habrá usado

180
00:06:47,639 --> 00:06:48,300
el system out

181
00:06:48,300 --> 00:06:49,339
cuando yo se lo he pasado aquí

182
00:06:49,339 --> 00:06:50,980
pero no puedo hacer

183
00:06:50,980 --> 00:06:51,920
más que llamar a esto

184
00:06:51,920 --> 00:06:53,180
a menos que yo haga

185
00:06:53,180 --> 00:06:53,600
un casting

186
00:06:53,600 --> 00:06:54,560
si hago un casting sí

187
00:06:54,560 --> 00:06:56,220
pero hacer un casting

188
00:06:56,220 --> 00:06:56,939
es peligroso

189
00:06:56,939 --> 00:06:57,600
porque vete a saber

190
00:06:57,600 --> 00:06:58,779
qué tipo de dato es

191
00:06:58,779 --> 00:06:59,899
¿vale?

192
00:06:59,899 --> 00:07:01,779
entonces hacer un casting por las buenas

193
00:07:01,779 --> 00:07:04,259
pero yo puedo hacer una clase que dependa de un tipo

194
00:07:04,259 --> 00:07:05,680
genérico y hacer cosas con ella

195
00:07:05,680 --> 00:07:07,360
como por ejemplo esta

196
00:07:07,360 --> 00:07:09,480
como por ejemplo esta

197
00:07:09,480 --> 00:07:12,079
ahora ya la duda sería, oye y esta clase

198
00:07:12,079 --> 00:07:12,980
¿cómo la usamos ahora?

199
00:07:14,000 --> 00:07:16,100
vamos a hacer un main, aquí dentro de este mismo

200
00:07:16,100 --> 00:07:17,399
paquete vamos a hacer un main

201
00:07:17,399 --> 00:07:19,779
una clase main para usarla

202
00:07:19,779 --> 00:07:29,259
vale, ahora

203
00:07:29,259 --> 00:07:31,540
vamos a instanciar un objeto de esta clase

204
00:07:31,540 --> 00:07:35,889
clase genérica

205
00:07:35,889 --> 00:07:37,769
venga

206
00:07:37,769 --> 00:07:38,850
pues este objeto de aquí

207
00:07:38,850 --> 00:07:41,709
vale, yo puedo declarar un objeto

208
00:07:41,709 --> 00:07:42,410
de esta clase

209
00:07:42,410 --> 00:07:45,269
vale, entonces

210
00:07:45,269 --> 00:07:47,310
aquí ya vemos que se le pone en amarillo

211
00:07:47,310 --> 00:07:49,430
me dice, no pasa nada

212
00:07:49,430 --> 00:07:51,850
puedes crear, declarar

213
00:07:51,850 --> 00:07:53,470
e incluso instanciar

214
00:07:53,470 --> 00:07:54,430
si te da la gana

215
00:07:54,430 --> 00:08:05,750
¿veis? él me deja sin ningún

216
00:08:05,750 --> 00:08:07,810
problema, porque el constructor

217
00:08:07,810 --> 00:08:09,610
sin parámetros obviamente existe, pero yo no he hecho

218
00:08:09,610 --> 00:08:11,189
ningún constructor, luego está sin parámetros

219
00:08:11,189 --> 00:08:13,689
yo puedo y ya tengo

220
00:08:13,689 --> 00:08:15,589
ahí obj, mi objeto

221
00:08:15,589 --> 00:08:17,389
bj que tiene

222
00:08:17,389 --> 00:08:19,810
espacio para un objeto

223
00:08:19,810 --> 00:08:20,490
de tipo int

224
00:08:20,490 --> 00:08:23,610
para uno de tipo t y para uno de tipo v

225
00:08:23,610 --> 00:08:26,110
pero diríamos, uy, ¿y qué ha reservado

226
00:08:26,110 --> 00:08:27,750
ahí? si yo no le he dicho t y v

227
00:08:27,750 --> 00:08:29,689
¿qué son? pues ha reservado

228
00:08:29,689 --> 00:08:31,730
dos espacios para dos, algo

229
00:08:31,730 --> 00:08:33,549
que sea object, un object, o sea

230
00:08:33,549 --> 00:08:34,950
el objeto object que no tiene nada

231
00:08:34,950 --> 00:08:37,269
eso es lo que ha reservado, que no tiene nada

232
00:08:37,269 --> 00:08:38,309
¿vale?

233
00:08:39,289 --> 00:08:41,730
lo normal es no usarlo así

234
00:08:41,730 --> 00:08:43,549
no es lo normal, si yo he hecho

235
00:08:43,549 --> 00:08:45,509
una clase genérica, es para

236
00:08:45,509 --> 00:08:47,429
En el momento de crear un objeto, decirle, ojo,

237
00:08:48,669 --> 00:08:51,590
que yo quiero un objeto concreto de esa clase,

238
00:08:51,789 --> 00:08:54,490
pero ahora te voy a decir qué dos tipos son los que me

239
00:08:54,490 --> 00:08:54,990
interesan.

240
00:08:55,409 --> 00:08:56,370
Te lo voy a decir ahora.

241
00:08:57,490 --> 00:08:57,710
¿Vale?

242
00:08:57,730 --> 00:08:59,289
Aquí está declarada de forma genérica.

243
00:08:59,470 --> 00:09:01,370
Di, tú me puedes instanciar.

244
00:09:02,230 --> 00:09:03,830
Yo voy a tener estas 3 propiedades.

245
00:09:04,429 --> 00:09:06,309
Estas van a ser de tipos incógnitas.

246
00:09:06,309 --> 00:09:08,769
Cuando me instancies, dime ya qué tipos quieres.

247
00:09:08,929 --> 00:09:09,370
Dímelo ya.

248
00:09:09,750 --> 00:09:12,190
Porque si no, te voy a tener que crear 2 espacios para object

249
00:09:12,190 --> 00:09:12,850
que no vale para nada.

250
00:09:13,990 --> 00:09:14,269
¿Vale?

251
00:09:14,269 --> 00:09:24,210
Pues la forma de decirle, oye, sí, créame ya, para estos concretos es ponérselo aquí, entre corchetes, los dos tipos que a ti te interesan.

252
00:09:24,730 --> 00:09:37,129
Pues, oye, quiero que el primero sea string y quiero que el segundo sea integer, por ejemplo, que es el tipo de dato para los números enteros, pero envueltos en ala.

253
00:09:37,129 --> 00:09:42,629
Y ahora aquí ya le tenemos que poner también los corchetes porque si no, no lo coge como...

254
00:09:42,629 --> 00:09:43,830
¿Veis? Ya se me ha quitado el amarillo.

255
00:09:44,269 --> 00:09:46,370
porque el amarillo era un aviso

256
00:09:46,370 --> 00:09:48,370
cuando yo no tenía esto

257
00:09:48,370 --> 00:09:49,830
el amarillo me decía, cuidado

258
00:09:49,830 --> 00:09:51,970
que clase genérica es

259
00:09:51,970 --> 00:09:55,070
una clase genérica, deberías parametrizarla

260
00:09:55,070 --> 00:09:56,289
etcétera, es lo que me dice

261
00:09:56,289 --> 00:09:58,710
porque si no te voy a generar una cosa con object ahí que no valga nada

262
00:09:58,710 --> 00:10:01,070
de eso me estaba avisando

263
00:10:01,070 --> 00:10:01,570
el amarillo

264
00:10:01,570 --> 00:10:04,509
ahora ya la estoy usando y diciendo, eh tú

265
00:10:04,509 --> 00:10:06,049
que sí

266
00:10:06,049 --> 00:10:07,070
que

267
00:10:07,070 --> 00:10:09,950
créame un objeto clase genérica

268
00:10:09,950 --> 00:10:11,769
y donde pone t que sea string

269
00:10:11,769 --> 00:10:13,929
y donde pone v que sea entero

270
00:10:13,929 --> 00:10:15,990
Bueno, pues es un ejemplo concreto

271
00:10:15,990 --> 00:10:19,600
¿Vale? Y ahora ya, pues yo que sé

272
00:10:19,600 --> 00:10:21,200
Uno podría ahora ya perfectamente

273
00:10:21,200 --> 00:10:24,659
Pues hacer, venga, obj.dato1

274
00:10:24,659 --> 00:10:26,259
Ni get ni set por rapidez

275
00:10:26,259 --> 00:10:28,000
Como esto va a ser un string

276
00:10:28,000 --> 00:10:28,659
Pues a la

277
00:10:28,659 --> 00:10:35,409
obj.dato2

278
00:10:35,409 --> 00:10:40,139
Pues este es un numerito

279
00:10:40,139 --> 00:10:42,159
Un entero, pues 4

280
00:10:42,159 --> 00:10:43,879
A la y perfectamente

281
00:10:43,879 --> 00:10:45,419
Pero eso sí

282
00:10:45,419 --> 00:10:48,299
Dato1 ya solamente va a poder ser string

283
00:10:48,299 --> 00:10:50,559
Y dato 2 va a poder solo ser número

284
00:10:50,559 --> 00:10:53,000
Ahora yo puedo llamar tranquilamente

285
00:10:53,000 --> 00:10:54,919
A obj.mostrar

286
00:10:54,919 --> 00:11:00,500
¿Vale? Y me mostrará

287
00:11:00,500 --> 00:11:02,600
Bueno, pues las dos cosas

288
00:11:02,600 --> 00:11:04,899
Que ahora resulta

289
00:11:04,899 --> 00:11:06,720
Que yo quiero crear

290
00:11:06,720 --> 00:11:08,080
Otro objeto clase genérica

291
00:11:08,080 --> 00:11:11,080
Pero ya no me interesan que los tipos sean estos

292
00:11:11,080 --> 00:11:12,980
Ahora me interesan que sean otros

293
00:11:12,980 --> 00:11:14,659
Pues no tengo que cambiar la clase

294
00:11:14,659 --> 00:11:15,519
No tengo que tocarla

295
00:11:15,519 --> 00:11:17,240
No tengo que tocarla

296
00:11:17,240 --> 00:11:19,120
Ahora digo, venga, créame otro

297
00:11:19,120 --> 00:11:23,299
créame otro

298
00:11:23,299 --> 00:11:26,419
objeto 2

299
00:11:26,419 --> 00:11:29,679
pero ahora este primero quiero que sea

300
00:11:29,679 --> 00:11:31,720
double, como no tengo ni cliente

301
00:11:31,720 --> 00:11:32,379
ni alguno ni nada

302
00:11:32,379 --> 00:11:34,679
y este quiero que sea

303
00:11:34,679 --> 00:11:37,600
string, ala pues ya está

304
00:11:37,600 --> 00:11:39,460
ya tenemos otro objeto

305
00:11:39,460 --> 00:11:40,820
de esta misma clase genérica

306
00:11:40,820 --> 00:11:43,740
pero ahora hemos concretado

307
00:11:43,740 --> 00:11:45,360
los dos tipos genéricos

308
00:11:45,360 --> 00:11:47,259
los hemos concretado a que sean esos dos

309
00:11:47,259 --> 00:11:49,720
porque para este nos interesa que sean esos dos

310
00:11:49,720 --> 00:11:58,440
bueno pues

311
00:11:58,440 --> 00:12:00,139
esto es una clase genérica

312
00:12:00,139 --> 00:12:03,379
que es tremendamente útil

313
00:12:03,379 --> 00:12:08,399
para programar

314
00:12:08,399 --> 00:12:09,799
muchos modelos de cosas

315
00:12:09,799 --> 00:12:12,419
una clase que tiene

316
00:12:12,419 --> 00:12:14,460
propiedades que yo no quiero comprometer

317
00:12:14,460 --> 00:12:15,299
el tipo de dato

318
00:12:15,299 --> 00:12:18,460
quiero que lo puedan elegir en tiempo de

319
00:12:18,460 --> 00:12:19,419
instanciación

320
00:12:19,419 --> 00:12:22,419
quiero que cuando se cree el objeto

321
00:12:22,419 --> 00:12:24,440
se pueda elegir el tipo de alguna

322
00:12:24,440 --> 00:12:25,220
de las propiedades

323
00:12:25,220 --> 00:12:27,480
no quiero elegirlo desde ya

324
00:12:27,480 --> 00:12:29,960
bueno pues

325
00:12:29,960 --> 00:12:31,940
esa posibilidad de poder elegir el tipo

326
00:12:31,940 --> 00:12:33,220
en tiempo de instanciación

327
00:12:33,220 --> 00:12:36,080
el que yo quiero, pues me abre

328
00:12:36,080 --> 00:12:37,519
ya la opción de hacer cosas

329
00:12:37,519 --> 00:12:39,279
más genéricas

330
00:12:39,279 --> 00:12:41,899
y me soluciona el problema

331
00:12:41,899 --> 00:12:44,039
que teníamos, que es, oye mi lista enlazada

332
00:12:44,039 --> 00:12:45,840
no quiero que sea de stream

333
00:12:45,840 --> 00:12:47,860
siempre, a veces

334
00:12:47,860 --> 00:12:49,840
querré que sea de stream, a veces querré que sea

335
00:12:49,840 --> 00:12:52,220
de integer, a veces querré que sea de cliente

336
00:12:52,220 --> 00:12:54,179
a veces querré que sea de lo que sea

337
00:12:54,179 --> 00:12:56,600
bueno, pues entonces

338
00:12:56,600 --> 00:12:58,139
como nos va a quedar ya bonita

339
00:12:58,139 --> 00:12:59,100
esta clase

340
00:12:59,100 --> 00:13:00,860
es si

341
00:13:00,860 --> 00:13:04,480
a nodo, la clase nodo

342
00:13:04,480 --> 00:13:06,639
la cambiamos

343
00:13:06,639 --> 00:13:10,259
y este tipo stream

344
00:13:10,259 --> 00:13:12,000
le decimos, no, de stream nada

345
00:13:12,000 --> 00:13:13,379
genérico

346
00:13:13,379 --> 00:13:16,200
el que sea, en el momento

347
00:13:16,200 --> 00:13:17,080
de hacer la lista

348
00:13:17,080 --> 00:13:19,519
el tipo que a ti te dé la gana

349
00:13:19,519 --> 00:13:21,919
para que puedas guardar en la lista lo que tú quieras

350
00:13:21,919 --> 00:13:24,240
entonces ese string

351
00:13:24,240 --> 00:13:25,820
se cambia por t

352
00:13:25,820 --> 00:13:31,039
al cambiarse por t, nodo pasa a ser

353
00:13:31,039 --> 00:13:33,059
una clase genérica

354
00:13:33,059 --> 00:13:35,019
y nodo ahora ya

355
00:13:35,019 --> 00:13:36,840
depende de t, se convierte en t

356
00:13:36,840 --> 00:13:40,879
y ahora ya al haber cambiado

357
00:13:40,879 --> 00:13:42,620
el nombre de la clase, ya todas

358
00:13:42,620 --> 00:13:43,820
las referencias cambian

359
00:13:43,820 --> 00:13:46,340
ahora esto será así también

360
00:13:46,340 --> 00:13:48,799
vale, esto será

361
00:13:48,799 --> 00:13:49,659
también así

362
00:13:49,659 --> 00:13:52,600
ahora el nombre de la clase ha cambiado

363
00:13:52,600 --> 00:13:54,899
ahora el nombre de la clase es este, porque es genérica

364
00:13:54,899 --> 00:13:57,639
porque depende de T, pues la sustituyo

365
00:13:57,639 --> 00:13:59,000
en todas partes.

366
00:14:00,940 --> 00:14:02,500
Este string ya no es string.

367
00:14:03,019 --> 00:14:04,259
Este string es T también.

368
00:14:06,610 --> 00:14:10,149
Este dato del constructor no es string.

369
00:14:10,289 --> 00:14:11,450
Es T, es ese tipo genérico.

370
00:14:14,350 --> 00:14:15,970
Entonces ya esta clase ya la tengo

371
00:14:15,970 --> 00:14:17,549
cambiada para que sea genérica.

372
00:14:18,169 --> 00:14:18,909
La tengo cambiada.

373
00:14:19,769 --> 00:14:21,149
El tipo T es genérico.

374
00:14:21,750 --> 00:14:23,950
No se convierte a depender de T.

375
00:14:23,950 --> 00:14:26,529
con lo cual lo cambio aquí, lo cambio aquí

376
00:14:26,529 --> 00:14:28,429
y ahora ya el dato que yo paso

377
00:14:28,429 --> 00:14:30,649
al constructor no es un string

378
00:14:30,649 --> 00:14:31,970
es del tipo que sea, t

379
00:14:31,970 --> 00:14:34,190
o sea, esta clase se convierte en una

380
00:14:34,190 --> 00:14:36,509
función de t, es una función de t

381
00:14:36,509 --> 00:14:37,470
donde t es la incógnita

382
00:14:37,470 --> 00:14:40,169
y depende de t aquí y aquí y ahí

383
00:14:40,169 --> 00:14:41,129
y depende de t

384
00:14:41,129 --> 00:14:44,230
eso ya no es string, es t

385
00:14:44,230 --> 00:14:44,870
lo que sea

386
00:14:44,870 --> 00:14:48,029
¿vale? entonces la clase nodo ya está

387
00:14:48,029 --> 00:14:50,549
modificada para que sea general

388
00:14:50,549 --> 00:14:52,470
genérica, lo que pasa es que

389
00:14:52,470 --> 00:14:56,129
Y ahora lista, como depende de nodo, pues lista también cambia, claro.

390
00:14:57,029 --> 00:14:59,490
Ahora lista, ¿qué le ocurre?

391
00:14:59,970 --> 00:15:07,179
Que lista, esto, de nuevo es así, ¿vale?

392
00:15:07,580 --> 00:15:14,539
El inicio es un puntero a nodo T, porque esta clase ha cambiado, ya no es nodo, es nodo de T, es un nodo genérica.

393
00:15:15,480 --> 00:15:18,000
Entonces, tengo que cambiar todas las referencias, esto me va a cambiar.

394
00:15:18,000 --> 00:15:20,919
con lo cual al haber aparecido aquí la T

395
00:15:20,919 --> 00:15:23,500
ahora es la clase lista enlazada

396
00:15:23,500 --> 00:15:25,539
la que se hace dependiente de T también

397
00:15:25,539 --> 00:15:27,240
se hace dependiente de T

398
00:15:27,240 --> 00:15:29,679
porque me ha aparecido aquí esa T

399
00:15:29,679 --> 00:15:31,399
se hace dependiente de ella

400
00:15:31,399 --> 00:15:32,200
depende de T

401
00:15:32,200 --> 00:15:35,980
entonces tengo que indicar que es dependiente de T

402
00:15:35,980 --> 00:15:37,940
poniéndolo a su vez así

403
00:15:37,940 --> 00:15:39,320
ala

404
00:15:39,320 --> 00:15:41,399
lista enlazada

405
00:15:41,399 --> 00:15:42,539
también depende de T

406
00:15:42,539 --> 00:15:45,940
y ahora me toca cambiar todas las referencias

407
00:15:45,940 --> 00:15:47,700
string

408
00:15:47,700 --> 00:15:49,799
Ya no es string, esto es T

409
00:15:49,799 --> 00:15:52,100
Nodo

410
00:15:52,100 --> 00:15:54,700
Esto será así

411
00:15:54,700 --> 00:15:56,799
Nodo T

412
00:15:56,799 --> 00:15:57,659
¿Vale?

413
00:15:59,080 --> 00:16:00,320
Entonces, esto

414
00:16:00,320 --> 00:16:06,870
New nodo T

415
00:16:06,870 --> 00:16:08,730
Aquí no tengo que cambiar nada

416
00:16:08,730 --> 00:16:09,710
Esto ya está todo bien

417
00:16:09,710 --> 00:16:12,889
Int posición, nodo, aquí lo mismo

418
00:16:12,889 --> 00:16:14,769
Esto no será string, sino que esto será T

419
00:16:14,769 --> 00:16:17,570
Esto será

420
00:16:17,570 --> 00:16:19,389
Nodo de T

421
00:16:19,389 --> 00:16:25,330
ya está aquí

422
00:16:25,330 --> 00:16:26,149
todo cambiado

423
00:16:26,149 --> 00:16:29,250
aquí lo mismo, esto es nodo de T

424
00:16:29,250 --> 00:16:34,720
aquí el remove cuando

425
00:16:34,720 --> 00:16:35,539
lo hiciéramos

426
00:16:35,539 --> 00:16:37,720
aquí habría que ponerle T, claro

427
00:16:37,720 --> 00:16:40,679
vale, pues ya he puesto

428
00:16:40,679 --> 00:16:42,139
todas las referencias ya están

429
00:16:42,139 --> 00:16:44,720
bueno, esto es lo mismo, añadir, habría que pasarle

430
00:16:44,720 --> 00:16:45,120
un T

431
00:16:45,120 --> 00:16:48,379
y aquí habría que pasarle un T también

432
00:16:48,379 --> 00:16:52,289
vale, pues lista enlazada

433
00:16:52,289 --> 00:16:54,210
ya es genérica, depende de un tipo

434
00:16:54,210 --> 00:17:00,039
genérico, depende de T

435
00:17:00,039 --> 00:17:05,690
Y ahora ya

436
00:17:05,690 --> 00:17:08,349
Esto se queda mucho más bonito

437
00:17:08,349 --> 00:17:09,809
Ahora ya

438
00:17:09,809 --> 00:17:15,849
Esto ahora ya se queda completamente general

439
00:17:15,849 --> 00:17:16,750
Yo digo, vamos a ver

440
00:17:16,750 --> 00:17:19,289
Yo tengo, vamos a hacerlo para que

441
00:17:19,289 --> 00:17:21,109
Dentro de mi paquete main

442
00:17:21,109 --> 00:17:22,990
Vamos a hacer rápidamente una clase cliente

443
00:17:22,990 --> 00:17:23,990
Para no estar tirando

444
00:17:23,990 --> 00:17:26,630
Y ver como podemos guardar clientes

445
00:17:26,630 --> 00:17:27,450
Lo que nos dé la gana

446
00:17:27,450 --> 00:17:29,650
Vamos a hacer un cliente

447
00:17:29,650 --> 00:17:37,609
Con un código

448
00:17:37,609 --> 00:17:40,210
y un nombre

449
00:17:40,210 --> 00:17:48,079
vale, y vamos a hacer un constructor

450
00:17:48,079 --> 00:17:52,559
bueno, los get y set

451
00:17:52,559 --> 00:17:56,539
de los cuatro

452
00:17:56,539 --> 00:17:58,700
y vamos a hacer

453
00:17:58,700 --> 00:17:59,400
constructor

454
00:17:59,400 --> 00:18:02,779
con parámetros por lo menos

455
00:18:02,779 --> 00:18:04,900
para poder

456
00:18:04,900 --> 00:18:05,859
instanciarlo rápido

457
00:18:05,859 --> 00:18:09,319
vale, constructor con parámetros

458
00:18:09,319 --> 00:18:11,380
vale, pues ahora

459
00:18:11,380 --> 00:18:13,380
yo tengo ya mi vista enlazada

460
00:18:13,380 --> 00:18:15,279
en la que voy a guardar

461
00:18:15,279 --> 00:18:17,039
objetos cliente, pues estupendo

462
00:18:17,039 --> 00:18:19,380
Me voy a estanciar mi lista enlazada

463
00:18:19,380 --> 00:18:21,680
Pero ojo

464
00:18:21,680 --> 00:18:22,940
¿Para qué la queremos?

465
00:18:23,680 --> 00:18:24,880
Pues esta lista enlazada

466
00:18:24,880 --> 00:18:26,759
Ahora queremos que guarde

467
00:18:26,759 --> 00:18:29,420
Cliente

468
00:18:29,420 --> 00:18:31,619
Que el tipo T sea cliente

469
00:18:31,619 --> 00:18:33,240
Lo queremos ya particularizar

470
00:18:33,240 --> 00:18:34,359
Ya estamos instanciando

471
00:18:34,359 --> 00:18:35,880
Pues estupendo

472
00:18:35,880 --> 00:18:40,480
Mi lista enlazada de clientes

473
00:18:40,480 --> 00:18:41,160
Va a ser esta

474
00:18:41,160 --> 00:18:45,529
Adiós

475
00:18:45,529 --> 00:18:51,109
Ya tengo mi lista enlazada

476
00:18:51,109 --> 00:18:53,049
Pero de objetos cliente

477
00:18:53,049 --> 00:18:55,910
la instancia, claro, lista

478
00:18:55,910 --> 00:18:57,970
enlazada

479
00:18:57,970 --> 00:19:03,359
aquí podéis poner

480
00:19:03,359 --> 00:19:05,700
cliente dentro o no ponerlo

481
00:19:05,700 --> 00:19:06,859
da igual, es lo mismo

482
00:19:06,859 --> 00:19:09,660
pero sí que tenéis que poner los corchetillos estos

483
00:19:09,660 --> 00:19:11,799
porque si no asume que no

484
00:19:11,799 --> 00:19:13,619
le habéis puesto nada adelante y le tenéis que

485
00:19:13,619 --> 00:19:14,700
meter object

486
00:19:14,700 --> 00:19:16,299
lo convierte a object

487
00:19:16,299 --> 00:19:19,339
ya no saldrá más

488
00:19:19,339 --> 00:19:21,240
vale, ya tenemos una lista de clientes

489
00:19:21,240 --> 00:19:23,740
y ahora yo ya uso mi lista

490
00:19:23,740 --> 00:19:25,680
pues venga, vamos a

491
00:19:25,680 --> 00:19:26,900
meter un cliente nuevo

492
00:19:26,900 --> 00:19:28,279
pues venga

493
00:19:28,279 --> 00:19:31,660
lista clientes

494
00:19:31,660 --> 00:19:35,539
punto add first, el único que tenemos hecho

495
00:19:35,539 --> 00:19:36,500
porque atlas no lo tenemos

496
00:19:36,500 --> 00:19:38,740
venga, vamos a meter un cliente nuevo

497
00:19:38,740 --> 00:19:44,329
un cliente nuevo

498
00:19:44,329 --> 00:19:46,890
que es este de aquí

499
00:19:46,890 --> 00:19:48,589
ala, venga, vamos a meter

500
00:19:48,589 --> 00:19:50,630
unos cuantos más clientes

501
00:19:50,630 --> 00:19:51,190
en mi lista

502
00:19:51,190 --> 00:19:54,910
y esto mucho más fácil que un array, yo los voy añadiendo

503
00:19:54,910 --> 00:19:56,509
y me despreocupo del tamaño

504
00:19:56,509 --> 00:19:58,049
del array, me despreocupo de todo

505
00:19:58,049 --> 00:20:01,529
Venga, vamos a añadir otro cliente

506
00:20:01,529 --> 00:20:03,509
Ala, Juan

507
00:20:03,509 --> 00:20:06,230
Vamos a añadir otro cliente

508
00:20:06,230 --> 00:20:07,490
Ala

509
00:20:07,490 --> 00:20:09,450
Y así podría añadir todos los que me dieran la gana

510
00:20:09,450 --> 00:20:11,789
Venga, vamos a recorrer la lista

511
00:20:11,789 --> 00:20:12,490
Ahora

512
00:20:12,490 --> 00:20:15,910
Para cada

513
00:20:15,910 --> 00:20:18,049
Y

514
00:20:18,049 --> 00:20:19,509
Mientras

515
00:20:19,509 --> 00:20:22,650
Y sea menor que lista

516
00:20:22,650 --> 00:20:23,549
Clientes

517
00:20:23,549 --> 00:20:32,410
Ala

518
00:20:32,410 --> 00:20:35,450
Pues que vamos a hacer, vamos a mostrar los nombres solo

519
00:20:35,450 --> 00:20:37,950
pues lista

520
00:20:37,950 --> 00:20:41,630
clientes.get

521
00:20:41,630 --> 00:20:42,930
ay

522
00:20:42,930 --> 00:20:45,269
get

523
00:20:45,269 --> 00:20:47,269
he abusado demasiado

524
00:20:47,269 --> 00:20:49,430
get i que será el cliente

525
00:20:49,430 --> 00:20:51,470
punto get nombre

526
00:20:51,470 --> 00:20:53,930
porque el get i

527
00:20:53,930 --> 00:20:55,250
ahora que me va a devolver

528
00:20:55,250 --> 00:20:57,890
el get i me va a devolver

529
00:20:57,890 --> 00:20:58,650
el cliente entero

530
00:20:58,650 --> 00:21:00,950
el get i me devuelve el cliente enterito

531
00:21:00,950 --> 00:21:02,609
porque la lista es de clientes

532
00:21:02,609 --> 00:21:22,759
no, o sea, mi get

533
00:21:22,759 --> 00:21:23,680
que es este de aquí

534
00:21:23,680 --> 00:21:26,619
mi get me devuelve

535
00:21:26,619 --> 00:21:28,400
el objeto que está en la lista

536
00:21:28,400 --> 00:21:30,900
en mi caso el objeto es el cliente, me devuelve el objeto

537
00:21:30,900 --> 00:21:32,680
enterito, pues nada

538
00:21:32,680 --> 00:21:34,980
el get y me devolverá al cliente, voy a mostrar el nombre

539
00:21:34,980 --> 00:21:35,559
solamente

540
00:21:35,559 --> 00:21:39,099
bueno, pues vamos a probarlo ya a la versión genérica

541
00:21:39,099 --> 00:21:40,839
a esta lista

542
00:21:40,839 --> 00:21:42,700
le digo el tipo concreto de

543
00:21:42,700 --> 00:21:44,779
t y ya trabajo

544
00:21:44,779 --> 00:21:46,220
trabajo con

545
00:21:46,220 --> 00:21:48,319
con objetos te para todo

546
00:21:48,319 --> 00:21:49,279
a todos los efectos

547
00:21:49,279 --> 00:21:55,369
vale y aquí están todos mis clientes

548
00:21:55,369 --> 00:21:57,250
obviamente en orden inverso a como los metí

549
00:21:57,250 --> 00:21:58,730
porque estamos usando el add first

550
00:21:58,730 --> 00:22:06,450
bueno pues

551
00:22:06,450 --> 00:22:07,970
con esta clase

552
00:22:07,970 --> 00:22:10,730
y con los métodos que faltan

553
00:22:10,730 --> 00:22:12,650
que repito no son tan complicados

554
00:22:12,650 --> 00:22:13,970
y al menos uno hace

555
00:22:13,970 --> 00:22:16,970
ya está

556
00:22:16,970 --> 00:22:19,049
ya tenemos la lista enlazada de toda la vida

557
00:22:19,049 --> 00:22:22,460
que me vale para guardar

558
00:22:22,460 --> 00:22:24,079
cualquier tipo de dato

559
00:22:24,079 --> 00:22:27,000
esto uno lo mete ya en un

560
00:22:27,000 --> 00:22:28,819
jar y lo importa

561
00:22:28,819 --> 00:22:30,140
desde cualquier proyecto

562
00:22:30,140 --> 00:22:32,359
y puede usarla para

563
00:22:32,359 --> 00:22:34,960
guardar de forma dinámica

564
00:22:34,960 --> 00:22:36,960
datos, mucho más cómodo que

565
00:22:36,960 --> 00:22:39,099
un array, que tenemos una lista

566
00:22:39,099 --> 00:22:40,880
de alumnos, pues me hago

567
00:22:40,880 --> 00:22:42,880
una lista de alumnos que sea lista de alumnos, lista

568
00:22:42,880 --> 00:22:45,059
enlazada y ya está, y le voy metiendo alumnos

569
00:22:45,059 --> 00:22:45,880
le saco lo que sea

570
00:22:45,880 --> 00:22:52,880
vale, entonces que ocurre

571
00:22:52,880 --> 00:22:54,359
que esto está muy bien

572
00:22:54,359 --> 00:22:55,960
está estupenda y está

573
00:22:55,960 --> 00:22:57,500
estupendamente hecha

574
00:22:57,500 --> 00:22:59,640
pero ya existe

575
00:22:59,640 --> 00:23:01,460
claro, existe esta

576
00:23:01,460 --> 00:23:03,920
que es la

577
00:23:03,920 --> 00:23:05,099
linked list

578
00:23:05,099 --> 00:23:12,369
es decir, la JRE

579
00:23:12,369 --> 00:23:14,650
hemos dicho que da un montón de cosas

580
00:23:14,650 --> 00:23:17,170
la JRE

581
00:23:17,170 --> 00:23:18,910
que da un montón de clases ya hechas

582
00:23:18,910 --> 00:23:20,369
pues en concreto

583
00:23:20,369 --> 00:23:22,990
en el paquete Java útil

584
00:23:22,990 --> 00:23:25,269
tiene un montón

585
00:23:25,269 --> 00:23:25,970
de clases

586
00:23:25,970 --> 00:23:29,049
que son las que se llaman las colecciones

587
00:23:29,049 --> 00:23:30,589
las colecciones

588
00:23:30,589 --> 00:23:33,190
las colecciones son un montón de clases

589
00:23:33,190 --> 00:23:35,210
que valen para guardar

590
00:23:35,210 --> 00:23:36,970
de esta forma sencilla

591
00:23:36,970 --> 00:23:38,109
de manera dinámica

592
00:23:38,109 --> 00:23:40,890
entrar, salir, datos

593
00:23:40,890 --> 00:23:43,329
¿de qué se diferencian unas de otras?

594
00:23:43,769 --> 00:23:45,190
pues de cómo funcionan por dentro

595
00:23:45,190 --> 00:23:46,750
y algunas se adaptan más que otras

596
00:23:46,750 --> 00:23:47,710
a determinadas situaciones

597
00:23:47,710 --> 00:23:50,990
bueno, pues una de ellas es la LinkedList

598
00:23:50,990 --> 00:23:52,630
que es exactamente la que hemos hecho

599
00:23:52,630 --> 00:23:54,269
que es esta

600
00:23:54,269 --> 00:23:57,380
me la he pasado, esta

601
00:23:57,380 --> 00:24:06,920
la LinkedList es esta

602
00:24:06,920 --> 00:24:13,960
¿vale? que es una clase genérica

603
00:24:13,960 --> 00:24:15,079
como la nuestra

604
00:24:15,079 --> 00:24:17,660
y que implementa

605
00:24:17,660 --> 00:24:19,480
una lista enlazada

606
00:24:19,480 --> 00:24:21,700
implementa una lista enlazada y tiene aquí

607
00:24:21,700 --> 00:24:23,140
los métodos para hacer las cosas

608
00:24:23,140 --> 00:24:25,259
¿vale?

609
00:24:26,740 --> 00:24:27,700
tiene aquí un montón

610
00:24:27,700 --> 00:24:29,599
de métodos y de morraya y de todo

611
00:24:29,599 --> 00:24:31,980
para hacer mil cosas, de los que al final uno acaba usando

612
00:24:31,980 --> 00:24:33,759
pues añadir al principio

613
00:24:33,759 --> 00:24:35,200
añadir al final

614
00:24:35,200 --> 00:24:37,599
si contiene, ahora con estos

615
00:24:37,599 --> 00:24:39,839
hay que meterse en profundidad

616
00:24:39,839 --> 00:24:42,220
Porque luego usarlos se pueden usar bien o se pueden usar mal

617
00:24:42,220 --> 00:24:43,819
¿Vale?

618
00:24:43,839 --> 00:24:46,259
El añadir, que el añadir funciona igual

619
00:24:46,259 --> 00:24:47,359
Que el añadir al final

620
00:24:47,359 --> 00:24:49,960
Add y at last son iguales

621
00:24:49,960 --> 00:24:51,579
¿Por qué existen dos?

622
00:24:51,680 --> 00:24:54,400
Pues ya os lo diré también, pero son iguales

623
00:24:54,400 --> 00:24:57,779
Añadir a doll

624
00:24:57,779 --> 00:24:59,940
Le das un montón en una colección

625
00:24:59,940 --> 00:25:01,220
Y te los añade todos a la vez

626
00:25:01,220 --> 00:25:03,920
Bueno, pues tiene aquí un montón de cosas implementadas

627
00:25:03,920 --> 00:25:05,779
¿Vale?

628
00:25:05,859 --> 00:25:08,099
Tendrá clear para borrarlos todos

629
00:25:08,099 --> 00:25:09,640
Este

630
00:25:09,640 --> 00:25:11,339
para recuperar por posición

631
00:25:11,339 --> 00:25:13,720
¿vale? que devuelve el tipo

632
00:25:13,720 --> 00:25:15,619
genérico e, es lo que hemos

633
00:25:15,619 --> 00:25:17,539
hecho nosotros, lo que pasa es que bueno, lo hace de otra

634
00:25:17,539 --> 00:25:19,079
manera, más bonita

635
00:25:19,079 --> 00:25:21,660
o no, o no más bonita

636
00:25:21,660 --> 00:25:26,039
bueno, pues esa clase

637
00:25:26,039 --> 00:25:28,059
es nuestra clase con más métodos

638
00:25:28,059 --> 00:25:29,099
nada más, pero es eso

639
00:25:29,099 --> 00:25:31,579
y luego está ArrayList

640
00:25:31,579 --> 00:25:34,279
ArrayList

641
00:25:34,279 --> 00:25:35,099
es esta

642
00:25:35,099 --> 00:25:37,940
que ArrayList

643
00:25:37,940 --> 00:25:38,480
es

644
00:25:38,480 --> 00:25:40,980
otra

645
00:25:40,980 --> 00:25:43,180
estructura como esta

646
00:25:43,180 --> 00:25:45,539
pero que la forma de guardarlo todo es en un array

647
00:25:45,539 --> 00:25:47,299
entonces antes de irnos

648
00:25:47,299 --> 00:25:49,160
vamos a suponer que hiciéramos el array list

649
00:25:49,160 --> 00:25:51,559
y ya dejamos ya introducido el tema de colecciones

650
00:25:51,559 --> 00:25:52,579
para verlo mañana

651
00:25:52,579 --> 00:25:59,329
estructuras dinámicas

652
00:25:59,329 --> 00:26:01,289
tenemos el paquetillo con

653
00:26:01,289 --> 00:26:03,390
lista enlazada

654
00:26:03,390 --> 00:26:04,930
vamos a hacer otro paquete

655
00:26:04,930 --> 00:26:07,049
que se llame lista array

656
00:26:07,049 --> 00:26:16,480
pues lista array

657
00:26:16,480 --> 00:26:17,940
que es el array list

658
00:26:17,940 --> 00:26:19,559
de java ss

659
00:26:19,559 --> 00:26:22,559
Es una clase mucho más fácil de programar

660
00:26:22,559 --> 00:26:23,579
Sería esta

661
00:26:23,579 --> 00:26:26,480
Vamos a llamarle miArrayList

662
00:26:26,480 --> 00:26:27,400
Le voy a llamar

663
00:26:27,400 --> 00:26:32,650
Y al otro lo podríamos haber llamado miLinkedList

664
00:26:32,650 --> 00:26:34,930
Esta, miArrayList

665
00:26:34,930 --> 00:26:36,910
Esta es una clase más fácil de programar

666
00:26:36,910 --> 00:26:38,809
Esta, ¿dónde guarda los datos dentro?

667
00:26:39,730 --> 00:26:40,730
Los guarda en un array

668
00:26:40,730 --> 00:26:42,289
Los guarda en un array

669
00:26:42,289 --> 00:26:44,049
¿Vale? Los guarda en un array

670
00:26:44,049 --> 00:26:45,410
¿De qué tipo?

671
00:26:46,990 --> 00:26:47,470
¿Vale?

672
00:27:00,140 --> 00:27:01,759
Vale, aquí guarda los datos

673
00:27:01,759 --> 00:27:04,619
y ahora habría que programar

674
00:27:04,619 --> 00:27:06,599
los métodos que es que son

675
00:27:06,599 --> 00:27:08,680
los que hemos programado mil veces en realidad

676
00:27:08,680 --> 00:27:11,880
el de añadir

677
00:27:11,880 --> 00:27:15,920
uno le mete un dato t

678
00:27:15,920 --> 00:27:18,220
pues que hay que hacer aquí

679
00:27:18,220 --> 00:27:20,099
crea la raya auxiliar

680
00:27:20,099 --> 00:27:21,900
copiar uno en otro

681
00:27:21,900 --> 00:27:23,700
añadir, pues el añadir sería

682
00:27:23,700 --> 00:27:24,279
ese

683
00:27:24,279 --> 00:27:27,299
creamos una raya auxiliar

684
00:27:27,299 --> 00:27:30,079
pues ala

685
00:27:30,079 --> 00:27:35,349
que sea

686
00:27:35,349 --> 00:27:37,890
a ver

687
00:27:37,890 --> 00:27:53,220
datos.length

688
00:27:53,220 --> 00:27:55,920
más

689
00:27:55,920 --> 00:27:56,839
uno

690
00:27:56,839 --> 00:27:59,980
más uno, vale, entonces

691
00:27:59,980 --> 00:28:02,019
aquí el problema

692
00:28:02,019 --> 00:28:03,960
que te da el compilador es que te dice

693
00:28:03,960 --> 00:28:05,440
el compilador no te deja

694
00:28:05,440 --> 00:28:08,119
poner un tipo genérico detrás

695
00:28:08,119 --> 00:28:10,160
de un new, porque te dice

696
00:28:10,160 --> 00:28:12,319
oye, que te es genérico, no lo puedo instanciar

697
00:28:12,319 --> 00:28:13,839
no te dejo, patatín, patatán

698
00:28:13,839 --> 00:28:15,599
entonces, ¿cómo hace uno esto?

699
00:28:16,339 --> 00:28:18,160
hace un object

700
00:28:18,160 --> 00:28:21,460
y luego le hace un casting

701
00:28:21,460 --> 00:28:22,160
a este.

702
00:28:23,200 --> 00:28:24,220
Tiene que hacer esta cosa.

703
00:28:26,579 --> 00:28:27,359
Vale, pero esto es solo

704
00:28:27,359 --> 00:28:28,880
para que viéramos cómo sería.

705
00:28:29,000 --> 00:28:30,140
Luego no vamos a usar esto.

706
00:28:30,220 --> 00:28:31,240
Luego usamos el ArrayList

707
00:28:31,240 --> 00:28:31,960
que ya está hecho.

708
00:28:32,920 --> 00:28:33,740
No vamos a usar el nuestro.

709
00:28:33,839 --> 00:28:34,680
Tendríamos que estarlo arrastrando

710
00:28:34,680 --> 00:28:35,319
por todos lados.

711
00:28:37,059 --> 00:28:37,299
¿Vale?

712
00:28:37,720 --> 00:28:38,480
O igual que aquí.

713
00:28:38,480 --> 00:28:40,359
Aquí lo querríamos instanciar a cero

714
00:28:40,359 --> 00:28:43,420
para evitar un null pointer exception.

715
00:28:43,559 --> 00:28:44,460
Querríamos hacer esto

716
00:28:44,460 --> 00:28:45,599
y no nos deja.

717
00:28:46,339 --> 00:28:48,259
Pues lo hacemos así

718
00:28:48,259 --> 00:28:54,970
Y luego lo convertimos

719
00:28:54,970 --> 00:28:55,910
A esto

720
00:28:55,910 --> 00:28:59,009
Esto ya si me deja hacer el casting

721
00:28:59,009 --> 00:28:59,670
Vale

722
00:28:59,670 --> 00:29:02,769
Entonces el añadir, el añadir lo hemos hecho mil veces

723
00:29:02,769 --> 00:29:04,849
Sería copiar uno en el otro

724
00:29:04,849 --> 00:29:06,170
Copiar la adicional y

725
00:29:06,170 --> 00:29:08,849
Pues esto que hemos hecho

726
00:29:08,849 --> 00:29:09,589
Tantas veces

727
00:29:09,589 --> 00:29:13,009
Mientras si sea menor

728
00:29:13,009 --> 00:29:15,970
Que datos.led

729
00:29:15,970 --> 00:29:18,289
Incrementando y

730
00:29:18,289 --> 00:29:20,509
Pues aquí tendríamos que hacer

731
00:29:20,509 --> 00:29:21,470
Aux

732
00:29:21,470 --> 00:29:23,569
De i

733
00:29:23,569 --> 00:29:26,049
Igual a datos

734
00:29:26,049 --> 00:29:30,059
De i

735
00:29:30,059 --> 00:29:32,000
Vale, una vez que ya hemos copiado

736
00:29:32,000 --> 00:29:33,500
En la que falta

737
00:29:33,500 --> 00:29:35,359
Que sería

738
00:29:35,359 --> 00:29:37,779
Aux.length

739
00:29:37,779 --> 00:29:40,299
Menos uno, el dato nuevo

740
00:29:40,299 --> 00:29:42,460
Que es el dato que me pasan por parámetro

741
00:29:42,460 --> 00:29:44,559
Y ahora ya sobre escribir

742
00:29:44,559 --> 00:29:45,980
A datos

743
00:29:45,980 --> 00:29:47,720
Le paso aux

744
00:29:47,720 --> 00:29:50,099
Ah, ya tendríamos el añadir

745
00:29:50,099 --> 00:29:51,460
La añadida ya la tenemos

746
00:29:51,460 --> 00:29:52,740
Del miArrayList

747
00:29:52,740 --> 00:29:55,180
Es lo que hemos hecho siempre

748
00:29:55,180 --> 00:29:57,200
El borrar

749
00:29:57,200 --> 00:29:58,940
Pues lo que hemos hecho

750
00:29:58,940 --> 00:30:00,839
Devolver el tamaño, el get

751
00:30:00,839 --> 00:30:02,960
Pues el get este sería más fácil todavía

752
00:30:02,960 --> 00:30:05,299
Public

753
00:30:05,299 --> 00:30:06,940
Int, el size, perdón

754
00:30:06,940 --> 00:30:10,569
Tamaño de la colección

755
00:30:10,569 --> 00:30:12,829
¿Qué devolveríais aquí?

756
00:30:15,890 --> 00:30:16,930
¿Qué pondríais ahí?

757
00:30:17,150 --> 00:30:18,250
Para devolver el tamaño

758
00:30:18,250 --> 00:30:21,210
¿Cuántos datos tiene esta colección que yo estoy haciendo?

759
00:30:21,690 --> 00:30:24,160
¿Qué pondríais?

760
00:30:24,160 --> 00:30:26,740
Recordad que los datos están en este array

761
00:30:26,740 --> 00:30:29,160
Los datos están ahí

762
00:30:29,160 --> 00:30:30,539
Luego, ¿cuántos datos va a haber?

763
00:30:30,759 --> 00:30:31,259
¿Qué pongo ahí?

764
00:30:32,759 --> 00:30:33,799
Datos.length

765
00:30:33,799 --> 00:30:37,200
Datos.length

766
00:30:37,200 --> 00:30:40,619
Podríamos hacer el remove

767
00:30:40,619 --> 00:30:42,400
Todos, y este es el array list

768
00:30:42,400 --> 00:30:43,700
El array list genérico

769
00:30:43,700 --> 00:30:46,940
Que lo uso yo en mi main porque ahora me quiero hacer yo

770
00:30:46,940 --> 00:30:48,619
Unos clientes

771
00:30:48,619 --> 00:30:49,960
Pero guardados en un array list

772
00:30:49,960 --> 00:30:51,660
Que ya no quiero lista enlazada

773
00:30:51,660 --> 00:30:53,980
Pues me hago mi array list

774
00:30:53,980 --> 00:30:58,559
mi array list de cliente

775
00:30:58,559 --> 00:30:59,900
o de lo que a mí me dé la gana

776
00:30:59,900 --> 00:31:19,710
importo

777
00:31:19,710 --> 00:31:25,000
y ya está, y a mí ya me da igual

778
00:31:25,000 --> 00:31:26,380
cómo esté hecho esto por dentro

779
00:31:26,380 --> 00:31:28,819
me da lo mismo, yo la uso para añadir

780
00:31:28,819 --> 00:31:29,619
para lo que quiera

781
00:31:29,619 --> 00:31:32,599
vamos a añadirle clientes a esta lista también

782
00:31:32,599 --> 00:31:34,140
a esta estructura

783
00:31:34,140 --> 00:31:36,819
pues venga, clientes.add

784
00:31:37,599 --> 00:31:42,119
new cliente

785
00:31:44,119 --> 00:31:46,140
ala de código 1

786
00:31:46,140 --> 00:31:48,519
y nombre javi

787
00:31:48,519 --> 00:31:50,740
ala, vamos a añadirle otro más

788
00:31:50,740 --> 00:31:52,400
a esta estructura

789
00:31:52,400 --> 00:31:59,410
el 2

790
00:31:59,410 --> 00:32:03,720
ala, luis

791
00:32:03,720 --> 00:32:05,579
que ahora quiero recorrer

792
00:32:05,579 --> 00:32:07,759
mi estructura, pues para eso

793
00:32:07,759 --> 00:32:08,500
tengo mi

794
00:32:08,500 --> 00:32:16,660
for, pues recorro

795
00:32:16,660 --> 00:32:18,799
mi lista de clientes

796
00:32:18,799 --> 00:32:24,359
que está aquí

797
00:32:24,359 --> 00:32:26,700
con mi método size, muestro

798
00:32:26,700 --> 00:32:27,859
clientes

799
00:32:27,859 --> 00:32:30,880
con el método, ah es que no me he hecho el get

800
00:32:30,880 --> 00:32:33,299
Pero el get aquí, este sí que sería

801
00:32:33,299 --> 00:32:34,460
Lo más sencillo del mundo

802
00:32:34,460 --> 00:32:36,099
¿Cómo sería el get?

803
00:32:40,059 --> 00:32:43,140
Public t get al que le pasamos una posición

804
00:32:43,140 --> 00:32:48,880
El get tendría una línea

805
00:32:48,880 --> 00:32:50,519
Retún que

806
00:32:50,519 --> 00:32:53,259
Los datos están en el array

807
00:32:53,259 --> 00:32:54,660
En este de aquí

808
00:32:54,660 --> 00:33:00,819
¿Cómo devuelvo el dato de posición?

809
00:33:06,680 --> 00:33:07,400
Fijaos aquí

810
00:33:07,400 --> 00:33:09,299
Qué fácil sería el get

811
00:33:09,299 --> 00:33:10,519
De esta estructura

812
00:33:10,519 --> 00:33:12,480
Devuelvo el dato de esa posición

813
00:33:12,480 --> 00:33:13,440
Facilísimo

814
00:33:13,440 --> 00:33:16,460
entonces ya tengo aquí mi main

815
00:33:16,460 --> 00:33:18,440
donde estoy usando

816
00:33:18,440 --> 00:33:20,519
esta otra, vale, voy a poner aquí

817
00:33:20,519 --> 00:33:21,019
un

818
00:33:21,019 --> 00:33:23,619
un separador

819
00:33:23,619 --> 00:33:33,299
un separador, entonces

820
00:33:33,299 --> 00:33:35,460
en este main, he usado primero

821
00:33:35,460 --> 00:33:37,259
la de arriba, para añadir

822
00:33:37,259 --> 00:33:39,000
recorrer, ahora uso la de abajo

823
00:33:39,000 --> 00:33:41,519
para añadir, recorrer

824
00:33:41,519 --> 00:33:42,579
y me da

825
00:33:42,579 --> 00:33:44,059
y el main

826
00:33:44,059 --> 00:33:46,940
no ha visto como están hechas por dentro

827
00:33:46,940 --> 00:33:48,539
ni le importa, ni nada

828
00:33:48,539 --> 00:33:50,980
Sabe que tiene esas estructuras para guardar datos

829
00:33:50,980 --> 00:33:53,759
Vamos a usarlas, no vaya a ser que hayamos hecho algo mal

830
00:33:53,759 --> 00:33:55,619
En el ArrayList

831
00:33:55,619 --> 00:33:58,220
Y aquí los tengo

832
00:33:58,220 --> 00:34:00,339
Este es mi ArrayList con sus datos

833
00:34:00,339 --> 00:34:02,619
¿Vale?

834
00:34:03,839 --> 00:34:05,460
Tan cómodo

835
00:34:05,460 --> 00:34:07,920
Entonces pues tengo dos posibilidades

836
00:34:07,920 --> 00:34:08,940
La lista enlazada

837
00:34:08,940 --> 00:34:11,059
La LinkedList que ya está hecha

838
00:34:11,059 --> 00:34:13,679
Y el mi ArrayList que se llama ArrayList

839
00:34:13,679 --> 00:34:15,579
¿Cómo se usan?

840
00:34:15,639 --> 00:34:17,619
Se usan igual, uno lo instancia

841
00:34:17,619 --> 00:34:20,139
mete, saca, borra y ya está

842
00:34:20,139 --> 00:34:21,019
se usan igual

843
00:34:21,019 --> 00:34:22,719
porque hay dos

844
00:34:22,719 --> 00:34:26,119
porque uno se adapta mejor, funciona mejor

845
00:34:26,119 --> 00:34:27,639
en una situación y otro funciona mejor en otra

846
00:34:27,639 --> 00:34:30,300
y como ya sabemos cómo están hechos por dentro

847
00:34:30,300 --> 00:34:32,039
porque los acabamos de hacer, los hemos hecho los dos

848
00:34:32,039 --> 00:34:33,760
no todos los métodos, pero los hemos hecho

849
00:34:33,760 --> 00:34:36,260
pues ya sabemos cuál va a funcionar

850
00:34:36,260 --> 00:34:38,079
mejor en una situación y cuál va a funcionar mejor en otra

851
00:34:38,079 --> 00:34:40,199
la linked list ya hemos dicho

852
00:34:40,199 --> 00:34:41,840
es magnífica

853
00:34:41,840 --> 00:34:43,780
para insertar y eliminar

854
00:34:43,780 --> 00:34:46,239
lo único que hay que hacer es mover enlaces

855
00:34:46,239 --> 00:34:47,460
no hay que hacer nada más

856
00:34:47,460 --> 00:34:49,460
¿Vale?

857
00:34:49,500 --> 00:34:50,900
Pero para consultar es un rollo

858
00:34:50,900 --> 00:34:52,099
Porque tenemos que ir navegando

859
00:34:52,099 --> 00:34:55,099
El ArrayList es maravilloso

860
00:34:55,099 --> 00:34:56,780
Para consultar, lo acabamos de ver

861
00:34:56,780 --> 00:34:58,960
Para consultar es estupendo

862
00:34:58,960 --> 00:34:59,840
Es esto

863
00:34:59,840 --> 00:35:01,639
Es hacer el Array

864
00:35:01,639 --> 00:35:03,880
Pero sin embargo la lista enlazada

865
00:35:03,880 --> 00:35:06,440
Para consultar, el get de la lista enlazada

866
00:35:06,440 --> 00:35:08,000
Tiene que hacer todo esto

867
00:35:08,000 --> 00:35:10,699
Entonces aplicaciones que sobre todo

868
00:35:10,699 --> 00:35:13,139
Con los datos hagan consultas

869
00:35:13,139 --> 00:35:14,280
Mejor el ArrayList

870
00:35:14,280 --> 00:35:16,940
Los que hagan muchas inserciones y borrados

871
00:35:16,940 --> 00:35:17,980
mejor el linked list

872
00:35:17,980 --> 00:35:20,860
¿vale? pero las dos se usan

873
00:35:20,860 --> 00:35:21,920
igual, una vez hechas

874
00:35:21,920 --> 00:35:25,139
ofrecen sus métodos, añadir, borrar

875
00:35:25,139 --> 00:35:26,059
eliminar y ya está

876
00:35:26,059 --> 00:35:27,260
¿vale?

877
00:35:28,460 --> 00:35:30,739
y son clases que ya están hechas y podemos usar

878
00:35:30,739 --> 00:35:33,260
incorporando los matices

879
00:35:33,260 --> 00:35:35,099
que ya iremos incorporando mañana

880
00:35:35,099 --> 00:35:35,780
¿vale?

881
00:35:37,639 --> 00:35:38,920
bueno, pues entonces

882
00:35:38,920 --> 00:35:41,159
hacer

883
00:35:41,159 --> 00:35:43,159
al menos un método

884
00:35:43,159 --> 00:35:43,800
de estos

885
00:35:43,800 --> 00:35:45,739
¿vale? un método de estos

886
00:35:45,739 --> 00:35:51,630
en realidad es

887
00:35:51,630 --> 00:35:54,530
similares todos, cualquiera de los tres primero

888
00:35:54,530 --> 00:35:56,550
bueno, yo haría o este

889
00:35:56,550 --> 00:36:00,139
o este, que son los que

890
00:36:00,139 --> 00:36:02,199
más os van a ayudar a ver si realmente

891
00:36:02,199 --> 00:36:04,280
habéis entendido un poco el fundamento de la lista enlazada

892
00:36:04,280 --> 00:36:06,260
o el de borrar

893
00:36:06,260 --> 00:36:08,099
por posición o el de añadir

894
00:36:08,099 --> 00:36:10,019
al final, pero bueno son un poco

895
00:36:10,019 --> 00:36:12,159
parecidos los cuatro, en realidad hacer uno de ellos para entender

896
00:36:12,159 --> 00:36:13,820
bien que consiste

897
00:36:13,820 --> 00:36:15,800
vale, entonces

898
00:36:15,800 --> 00:36:17,780
aquí lo que hemos visto es

899
00:36:17,780 --> 00:36:19,380
¿qué es una estructura dinámica?

900
00:36:19,400 --> 00:36:21,519
no es nada que no conozcamos, es una clase más

901
00:36:21,519 --> 00:36:22,980
que uno ha construido

902
00:36:22,980 --> 00:36:25,739
para hacer cosas de forma sencilla

903
00:36:25,739 --> 00:36:27,119
pero lo que está hecho por debajo

904
00:36:27,119 --> 00:36:29,159
es lo que hemos hecho siempre, es que no hay otra

905
00:36:29,159 --> 00:36:31,639
¿vale? y como esas clases

906
00:36:31,639 --> 00:36:33,280
ya están, pues las podemos usar

907
00:36:33,280 --> 00:36:35,659
tranquilamente y de forma cómoda

908
00:36:35,659 --> 00:36:36,940
¿vale?

909
00:36:37,860 --> 00:36:39,079
y por último

910
00:36:39,079 --> 00:36:41,139
revisad bien qué es esto de

911
00:36:41,139 --> 00:36:42,739
las clases genéricas

912
00:36:42,739 --> 00:36:44,960
entender lo que es

913
00:36:44,960 --> 00:36:50,280
porque, a ver, usarlo

914
00:36:50,280 --> 00:36:51,840
cuando uno instancia una lista puede decir

915
00:36:51,840 --> 00:36:54,179
yo instancio una lista, le pongo el tipo y ya está

916
00:36:54,179 --> 00:36:56,760
y se queda tan ancho y puede trabajar con eso

917
00:36:56,760 --> 00:36:57,699
sin saber nada más

918
00:36:57,699 --> 00:36:59,400
pero hombre, hay que entender que es

919
00:36:59,400 --> 00:37:01,019
hay que entender que es un tipo genérico

920
00:37:01,019 --> 00:37:05,730
bueno, pues venga, vamos a

921
00:37:05,730 --> 00:37:07,409
parar aquí entonces