1
00:00:00,370 --> 00:00:06,280
Yo, siéntate

2
00:00:06,280 --> 00:00:07,120
Y tú también

3
00:00:07,120 --> 00:00:09,859
Venga, sí, como todo el mundo

4
00:00:09,859 --> 00:00:12,080
A ver

5
00:00:12,080 --> 00:00:13,460
Cristian

6
00:00:13,460 --> 00:00:14,699
Calla

7
00:00:14,699 --> 00:00:17,019
Porque eres el que estás hablando

8
00:00:17,019 --> 00:00:19,239
Y tú estás paseando

9
00:00:19,239 --> 00:00:21,079
A los de los izquierdos

10
00:00:21,079 --> 00:00:22,280
Ana

11
00:00:22,280 --> 00:00:26,600
Bueno, pues entonces

12
00:00:26,600 --> 00:00:27,879
Lo

13
00:00:27,879 --> 00:00:30,440
Lo que hemos hecho

14
00:00:30,440 --> 00:00:31,280
Está claro, ¿no?

15
00:00:31,280 --> 00:00:33,859
hemos hecho una clase

16
00:00:33,859 --> 00:00:35,780
claro

17
00:00:35,780 --> 00:00:37,399
pero ya, pero la idea

18
00:00:37,399 --> 00:00:40,280
es hacer una clase que lo enmascare

19
00:00:40,280 --> 00:00:44,140
ya no me refiero tanto al código de los métodos

20
00:00:44,140 --> 00:00:45,899
sino la filosofía es

21
00:00:45,899 --> 00:00:48,060
hacer una clase que enmascara

22
00:00:48,060 --> 00:00:49,679
eso en unos métodos

23
00:00:49,679 --> 00:00:51,640
y entonces, para nosotros ahora

24
00:00:51,640 --> 00:00:53,840
esas cajitas en las que meter datos

25
00:00:53,840 --> 00:00:55,299
ya no van a ser arrays

26
00:00:55,299 --> 00:00:57,539
esas cajitas van a ser objetos

27
00:00:57,539 --> 00:00:58,359
de esas clases

28
00:00:58,359 --> 00:01:07,019
Y cada objeto será una caja para meter datos y a través de los métodos que ese objeto me ofrece, yo ya meto, saco, lo que sea.

29
00:01:07,620 --> 00:01:14,480
E internamente, esa referencia, ese objeto internamente ya tendrá unas propiedades para tener ahí todos los objetos dentro que hagan falta.

30
00:01:15,159 --> 00:01:18,459
Pero están todos bajo una única referencia, la del objeto.

31
00:01:19,099 --> 00:01:23,000
Y a través de los métodos, pues yo ya decido si añado, borro, lo que sea.

32
00:01:23,239 --> 00:01:25,099
Esa es la idea de las colecciones.

33
00:01:25,099 --> 00:01:26,700
enmascarar

34
00:01:26,700 --> 00:01:29,700
todo un volumen de datos

35
00:01:29,700 --> 00:01:31,659
enmascararlo en una única referencia

36
00:01:31,659 --> 00:01:34,159
yo instancio ese objeto y a través de los métodos

37
00:01:34,159 --> 00:01:35,540
accedo a esos datos

38
00:01:35,540 --> 00:01:37,480
para insertar, borrar, etc.

39
00:01:37,840 --> 00:01:38,040
¿Vale?

40
00:01:39,239 --> 00:01:41,579
Pablo, para una vez que vienes, cállate

41
00:01:41,579 --> 00:01:42,840
No, digo yo

42
00:01:42,840 --> 00:01:45,140
Hablar, pues sí

43
00:01:45,140 --> 00:01:47,780
Bueno

44
00:01:47,780 --> 00:01:49,280
Vale

45
00:01:49,280 --> 00:01:50,299
Entonces

46
00:01:50,299 --> 00:01:52,959
Esta lista que hemos hecho

47
00:01:52,959 --> 00:01:54,599
cumple todo lo

48
00:01:54,599 --> 00:01:56,739
todos los requisitos de una lista

49
00:01:56,739 --> 00:01:58,980
que es, yo puedo meter

50
00:01:58,980 --> 00:02:01,060
aparentemente es dinámico

51
00:02:01,060 --> 00:02:03,040
yo hago add y remove

52
00:02:03,040 --> 00:02:04,920
y me da la sensación de que se estira

53
00:02:04,920 --> 00:02:07,000
y se encoge y es dinámico aparentemente

54
00:02:07,000 --> 00:02:08,900
¿vale? y además

55
00:02:08,900 --> 00:02:11,120
existe una posición, la del array

56
00:02:11,120 --> 00:02:13,099
está claro, y de hecho mi get puede ser

57
00:02:13,099 --> 00:02:14,800
por posición, porque cada elemento

58
00:02:14,800 --> 00:02:15,259
tiene una posición

59
00:02:15,259 --> 00:02:19,060
bueno, entonces vale, con esta nos valdría y uno podría tirar

60
00:02:19,060 --> 00:02:20,759
y ya está, y ya no habría por qué inventarse

61
00:02:20,759 --> 00:02:23,000
más colecciones en la vida, y esta colección

62
00:02:23,000 --> 00:02:24,979
existe y en lugar de llamarse miArrayList

63
00:02:24,979 --> 00:02:26,340
se llama ArrayList.

64
00:02:27,259 --> 00:02:28,979
Salvo el salto de que es genérica

65
00:02:28,979 --> 00:02:30,780
que eso lo incorporaremos. Es decir,

66
00:02:30,860 --> 00:02:32,919
que la que hemos hecho nosotros solo vale para stream.

67
00:02:33,639 --> 00:02:34,840
Entonces tendríamos que ser capaces

68
00:02:34,840 --> 00:02:36,719
de hacer una que va a ir a para cualquier cosa.

69
00:02:37,800 --> 00:02:39,039
Eso no es tan sencillo

70
00:02:39,039 --> 00:02:40,759
pero ya veremos cómo hacerlo. Pero bueno,

71
00:02:41,400 --> 00:02:42,719
con ese ArrayList que

72
00:02:42,719 --> 00:02:44,699
equivale a nuestro

73
00:02:44,699 --> 00:02:47,000
miArrayList uno ya podría, venga, tiramos para adelante.

74
00:02:47,919 --> 00:02:48,780
Pero es que

75
00:02:48,780 --> 00:02:50,919
fijaos en los métodos.

76
00:02:51,300 --> 00:02:52,620
Cada vez que hemos hecho un app

77
00:02:53,000 --> 00:02:55,400
madre de Dios, crear un array nuevo

78
00:02:55,400 --> 00:02:56,800
copiar uno en otro

79
00:02:56,800 --> 00:02:59,539
una jodienda, cada vez que hemos

80
00:02:59,539 --> 00:03:01,539
borrado un elemento, hacemos un

81
00:03:01,539 --> 00:03:03,819
array nuevo, copiamos uno en otro

82
00:03:03,819 --> 00:03:05,520
es decir, cada app

83
00:03:05,520 --> 00:03:07,960
es un montón de código muy costoso

84
00:03:07,960 --> 00:03:09,259
para la máquina virtual

85
00:03:09,259 --> 00:03:11,620
cada remove es un montón de código muy

86
00:03:11,620 --> 00:03:13,439
costoso, cada get no

87
00:03:13,439 --> 00:03:15,439
el get es sencillísimo, recuperas por posición

88
00:03:15,439 --> 00:03:17,360
que es lo bueno que tienen los arrays, el get

89
00:03:17,360 --> 00:03:19,659
facilísimo, pero cada app y cada

90
00:03:19,659 --> 00:03:21,439
remove es algo que

91
00:03:21,439 --> 00:03:23,159
computacionalmente cuesta mucho

92
00:03:23,159 --> 00:03:25,500
luego con esto, bien, podríamos ya

93
00:03:25,500 --> 00:03:27,139
tirar millas

94
00:03:27,139 --> 00:03:29,280
pero si se nos ocurriera

95
00:03:29,280 --> 00:03:30,900
otra manera

96
00:03:30,900 --> 00:03:34,060
de guardar un montón de objetos a mogollón

97
00:03:34,060 --> 00:03:36,159
de tal manera

98
00:03:36,159 --> 00:03:37,879
bajo una única referencia

99
00:03:37,879 --> 00:03:39,879
como esto, que estaba bajo la referencia

100
00:03:39,879 --> 00:03:40,960
del objeto, mi Arraylis

101
00:03:40,960 --> 00:03:44,039
a partir de él, bajo una única referencia

102
00:03:44,039 --> 00:03:45,560
de manera que

103
00:03:45,560 --> 00:03:47,460
insertar nuevos

104
00:03:47,460 --> 00:03:50,280
y sacar no fuera tan costoso

105
00:03:50,280 --> 00:03:51,520
Pues eso sería maravilloso

106
00:03:51,520 --> 00:03:52,939
¿Vale?

107
00:03:53,939 --> 00:03:56,000
Y ese sería el linked list

108
00:03:56,000 --> 00:04:01,520
Eso es lo que os voy a preguntar

109
00:04:01,520 --> 00:04:03,840
El linked list no usa RISE

110
00:04:03,840 --> 00:04:05,479
No usa RISE

111
00:04:05,479 --> 00:04:07,439
Sino que usa la

112
00:04:07,439 --> 00:04:09,319
Imaginación

113
00:04:09,319 --> 00:04:10,259
Pues que le he hecho

114
00:04:10,259 --> 00:04:13,740
La imaginación que le he hecho a un tío

115
00:04:13,740 --> 00:04:15,219
Hace 50 años

116
00:04:15,219 --> 00:04:16,579
Porque el linked list es una

117
00:04:16,579 --> 00:04:19,579
Es una implementación de un concepto informativo que ya existe

118
00:04:19,579 --> 00:04:21,560
que viene lista enlazada

119
00:04:21,560 --> 00:04:23,019
lo único que hay que hacer es traducirlo

120
00:04:23,019 --> 00:04:24,420
entonces

121
00:04:24,420 --> 00:04:27,699
¿qué idea se nos podría ocurrir?

122
00:04:27,779 --> 00:04:28,939
¿qué idea se os ocurriría?

123
00:04:29,139 --> 00:04:30,980
para tener un montón de datos

124
00:04:30,980 --> 00:04:34,360
recogidos bajo una única referencia

125
00:04:34,360 --> 00:04:35,620
y que además

126
00:04:35,620 --> 00:04:36,779
fuera facilísimo

127
00:04:36,779 --> 00:04:39,720
incorporar uno nuevo y eliminar

128
00:04:39,720 --> 00:04:41,339
que era la PRA list

129
00:04:41,339 --> 00:04:42,959
en realidad no tienes la lista

130
00:04:42,959 --> 00:04:44,800
no tienes un array con los datos

131
00:04:44,800 --> 00:04:46,740
tienes un array con las misiones de memoria de los datos

132
00:04:46,740 --> 00:04:48,779
entonces cambias

133
00:04:48,779 --> 00:04:53,220
A ver, lo que tú dices es...

134
00:04:53,220 --> 00:04:56,819
Pero eso es un array.

135
00:04:56,920 --> 00:04:59,279
Un array lo que tú tienes son las direcciones del dato.

136
00:04:59,420 --> 00:05:00,439
Eso es un array, en realidad.

137
00:05:03,800 --> 00:05:04,600
Sí, pero bueno,

138
00:05:04,759 --> 00:05:06,560
lo que hemos hecho antes, que era en string,

139
00:05:07,019 --> 00:05:08,779
también teníamos eso, porque era en string,

140
00:05:08,920 --> 00:05:11,459
entonces ya teníamos eso. En cualquier caso, si es un array,

141
00:05:12,120 --> 00:05:13,319
en cuanto haces uno nuevo,

142
00:05:13,639 --> 00:05:14,720
es que ya necesitas

143
00:05:14,720 --> 00:05:17,160
otro array para esa dirección extra.

144
00:05:17,160 --> 00:05:19,279
Entonces, ni crear ni borrar uno nuevo.

145
00:05:19,720 --> 00:05:21,279
Entonces, esto no utiliza

146
00:05:21,279 --> 00:05:22,720
Arrays ni nada que se le parezca.

147
00:05:23,639 --> 00:05:23,800
Di.

148
00:05:26,100 --> 00:05:26,819
Dime, dime.

149
00:05:31,240 --> 00:05:32,759
Bueno, con variables tienes que hacerlo así.

150
00:05:32,839 --> 00:05:35,160
Pero esas variables, ¿dónde están? ¿En Arrays o cómo?

151
00:05:37,139 --> 00:05:38,480
Un momento, que no oigo.

152
00:05:40,899 --> 00:05:43,100
Pero sueltas, ¿dónde? Porque si están sueltas,

153
00:05:43,800 --> 00:05:45,240
cada una tiene su propia

154
00:05:45,519 --> 00:05:47,100
referencia. Luego, la ventaja

155
00:05:47,100 --> 00:05:49,240
de las colecciones es que yo tengo una única referencia

156
00:05:49,240 --> 00:05:51,199
que es el nombre de la caja, un nombre

157
00:05:51,199 --> 00:05:53,199
único, nombre de la caja, y con ese

158
00:05:53,199 --> 00:05:55,360
nombre digo, mete esto, mete lo otro.

159
00:05:56,199 --> 00:05:57,079
Con lo que tú me dices, yo te he

160
00:05:57,079 --> 00:05:59,160
entendido, y eres un montón de

161
00:05:59,160 --> 00:06:01,360
nombres, uno por variable.

162
00:06:07,279 --> 00:06:08,360
¡Qué chica!

163
00:06:15,439 --> 00:06:17,019
O sea que los nombres de las

164
00:06:17,019 --> 00:06:18,839
variables, compartían una raíz común

165
00:06:18,839 --> 00:06:21,139
y a partir de...

166
00:06:21,139 --> 00:06:23,180
Pero, en cualquier caso

167
00:06:23,180 --> 00:06:23,959
es que tendrías ahí

168
00:06:23,959 --> 00:06:26,759
varias variables, tú dices que la raíz común

169
00:06:26,759 --> 00:06:28,560
fuera como si fuera el nombre de la caja

170
00:06:28,560 --> 00:06:30,399
y tú decís, vale, pero

171
00:06:30,399 --> 00:06:31,040
¿y cuándo?

172
00:06:32,100 --> 00:06:33,720
Pero es que eso es implanteable de programar.

173
00:06:34,379 --> 00:06:36,060
Entonces, cuando tú haces una variable nueva,

174
00:06:36,839 --> 00:06:38,220
construyes su nombre,

175
00:06:38,779 --> 00:06:40,279
es que el nombre lo tienes que poner por código,

176
00:06:40,379 --> 00:06:42,980
no puedes construir el nombre y darse un...

177
00:06:42,980 --> 00:06:44,579
Tú intenta programar eso y te das cuenta

178
00:06:44,579 --> 00:06:45,560
que no puedes programar eso.

179
00:06:47,019 --> 00:06:59,660
Que el nombre de una variable

180
00:06:59,660 --> 00:07:01,100
Tenga la I

181
00:07:01,100 --> 00:07:09,240
¿Qué tienes que hacer?

182
00:07:13,160 --> 00:07:16,240
Que tenga el nombre de otra variable

183
00:07:16,240 --> 00:07:18,839
Pero ese nombre luego no lo puedes usar

184
00:07:18,839 --> 00:07:20,180
Para ver si es real

185
00:07:20,180 --> 00:07:22,939
Esa idea no la puedes

186
00:07:22,939 --> 00:07:24,060
Suplementar en Java

187
00:07:24,060 --> 00:07:26,079
Vale

188
00:07:26,079 --> 00:07:28,220
El tío desde hace 80 años

189
00:07:28,220 --> 00:07:30,439
¿Creó esto con lo que ya sabemos?

190
00:07:30,680 --> 00:07:31,819
¿O nos falta algo por saber?

191
00:07:32,240 --> 00:07:34,459
Por supuestísimo con lo que ya sabéis

192
00:07:34,459 --> 00:07:35,300
Estos son

193
00:07:35,300 --> 00:07:38,819
Por supuestísimo con lo que ya sabéis

194
00:07:38,819 --> 00:07:40,980
Vale, a ver, os doy la primera pista

195
00:07:40,980 --> 00:07:42,480
Es como una serpiente

196
00:07:42,480 --> 00:07:43,139
Va siguiendo

197
00:07:43,139 --> 00:07:46,579
Sí, es como una serpiente

198
00:07:46,579 --> 00:07:47,079
Tiene razón

199
00:07:47,079 --> 00:07:51,639
A ver, es una forma de verlo

200
00:07:51,639 --> 00:07:53,339
Vale, a ver

201
00:07:53,339 --> 00:07:55,620
Primera pista

202
00:07:55,620 --> 00:07:57,319
Primera pista

203
00:07:57,319 --> 00:08:00,540
A ver, yo lo que creo es que

204
00:08:00,540 --> 00:08:02,120
Él ha puesto en internet linked list

205
00:08:02,120 --> 00:08:03,060
Y ha visto eso

206
00:08:03,060 --> 00:08:05,819
Vale

207
00:08:05,819 --> 00:08:09,879
A ver, primera pista

208
00:08:09,879 --> 00:08:10,860
La traducción

209
00:08:10,860 --> 00:08:13,120
Lista, enlazada

210
00:08:13,120 --> 00:08:16,040
enlazada

211
00:08:16,040 --> 00:08:19,019
suena que cada elemento está enlazado

212
00:08:19,019 --> 00:08:19,839
con el otro

213
00:08:19,839 --> 00:08:24,620
bueno, pues a ver

214
00:08:24,620 --> 00:08:26,180
la idea es, que es una idea muy sencilla

215
00:08:26,180 --> 00:08:26,959
de programación

216
00:08:26,959 --> 00:08:29,060
la lista enlazada, que es

217
00:08:29,060 --> 00:08:32,259
yo tengo, mis datos son estos

218
00:08:32,259 --> 00:08:34,120
mi dato 1

219
00:08:34,120 --> 00:08:36,419
mi dato 2

220
00:08:36,419 --> 00:08:38,679
mis cadenas

221
00:08:38,679 --> 00:08:39,440
los que sean

222
00:08:39,440 --> 00:08:41,879
mis datos son estos

223
00:08:41,879 --> 00:08:44,639
tengo que decidir dónde los guardo

224
00:08:44,639 --> 00:08:46,519
ya hemos descartado el array

225
00:08:46,519 --> 00:08:48,279
una opción sería la que hemos dicho

226
00:08:48,279 --> 00:08:49,879
todos al array

227
00:08:49,879 --> 00:08:52,679
esa es la versión

228
00:08:52,679 --> 00:08:53,799
de ArrayList que hemos dicho

229
00:08:53,799 --> 00:08:55,179
no, al array no va

230
00:08:55,179 --> 00:08:58,500
¿cómo los guardo bajo una referencia común?

231
00:08:59,059 --> 00:09:00,700
y que esa referencia le permita hacer el A

232
00:09:00,700 --> 00:09:01,879
¿cómo los guardo?

233
00:09:02,980 --> 00:09:03,860
vale, pues a ver

234
00:09:03,860 --> 00:09:05,960
la referencia común

235
00:09:05,960 --> 00:09:07,779
selecciono que sea

236
00:09:07,779 --> 00:09:10,039
la del primero de todos

237
00:09:10,039 --> 00:09:11,899
la dirección del primero

238
00:09:11,899 --> 00:09:14,240
si estos son objetos, recordad que un objeto

239
00:09:14,240 --> 00:09:15,700
en realidad, en Java

240
00:09:15,700 --> 00:09:18,059
cuando accedemos

241
00:09:18,059 --> 00:09:20,360
a su referencia

242
00:09:20,360 --> 00:09:21,580
a su nombre, sabemos que es la dirección

243
00:09:21,580 --> 00:09:22,879
bueno, pues la referencia común

244
00:09:22,879 --> 00:09:25,419
que sea la dirección del primero

245
00:09:25,419 --> 00:09:27,580
esa es la referencia común

246
00:09:27,580 --> 00:09:28,700
ya la pregunta es

247
00:09:28,700 --> 00:09:33,220
bueno, el nombre que tenga este objeto

248
00:09:33,220 --> 00:09:35,059
si este objeto es alumno 1

249
00:09:35,059 --> 00:09:36,320
pues alumno 1

250
00:09:36,320 --> 00:09:38,840
esa es la referencia común, en principio, es la idea

251
00:09:38,840 --> 00:10:01,659
Vale, y la pregunta sería ya, pero ahora con esta referencia yo puedo acceder a este sin problema, lógicamente, porque es su propia referencia, pero si quiero acceder al tercero, o quiero insertar uno nuevo, o quiero, ¿cómo hago? Vale, pues lo que se incorpora es esta idea muy sencilla, y es, cada objeto se le mete en un objeto un poquito más grande, que se le llama nodo,

252
00:10:01,659 --> 00:10:04,840
que además del dato en sí

253
00:10:04,840 --> 00:10:06,840
tenga la dirección

254
00:10:06,840 --> 00:10:08,559
del siguiente

255
00:10:08,559 --> 00:10:10,679
tenga la referencia

256
00:10:10,679 --> 00:10:13,299
la referencia del siguiente

257
00:10:13,299 --> 00:10:15,620
este se le mete

258
00:10:15,620 --> 00:10:17,659
en una cajita un pelín más grande

259
00:10:17,659 --> 00:10:18,759
que tiene dos partes

260
00:10:18,759 --> 00:10:21,639
el dato en sí, el objeto

261
00:10:21,639 --> 00:10:23,620
y la dirección del siguiente

262
00:10:24,220 --> 00:10:28,100
este se le mete

263
00:10:28,100 --> 00:10:29,620
en otra cajita

264
00:10:29,620 --> 00:10:30,879
llamémosla nodo

265
00:10:30,879 --> 00:10:34,759
que aparte del propio objeto,

266
00:10:35,580 --> 00:10:37,519
tiene la dirección del siguiente.

267
00:10:40,100 --> 00:10:42,100
¿Que este es el último en este caso?

268
00:10:42,240 --> 00:10:43,559
Pues estará en su cajita,

269
00:10:44,559 --> 00:10:46,179
pero esta dirección siguiente,

270
00:10:46,500 --> 00:10:48,580
ahora en particular lo que tendrá es null.

271
00:10:50,259 --> 00:10:52,360
Vale, pues esta es la estructura de lista enlazada.

272
00:10:52,500 --> 00:10:53,659
Una lista enlazada es

273
00:10:53,659 --> 00:10:56,500
un montón de objetos nodos,

274
00:10:56,500 --> 00:10:58,720
que se llaman nodos, ¿vale?

275
00:10:59,200 --> 00:11:00,679
Entonces, cada nodo tiene

276
00:11:00,679 --> 00:11:03,759
el dato en sí, el dato que yo quiero

277
00:11:03,759 --> 00:11:05,740
el alumno

278
00:11:05,740 --> 00:11:07,120
la cadena, lo que sea el dato

279
00:11:07,120 --> 00:11:09,200
pero además de tener este nodo, el dato en sí

280
00:11:09,200 --> 00:11:10,679
tiene otra parte

281
00:11:10,679 --> 00:11:13,899
y esa otra parte es la dirección

282
00:11:13,899 --> 00:11:15,320
la referencia al siguiente

283
00:11:15,320 --> 00:11:17,720
nodo, al siguiente nodo

284
00:11:17,720 --> 00:11:18,440
al completo

285
00:11:18,440 --> 00:11:21,559
no solamente a este objeto, la referencia al siguiente

286
00:11:21,559 --> 00:11:22,500
nodo al completo

287
00:11:22,500 --> 00:11:25,360
vale, este nodo tiene el objeto en sí

288
00:11:25,360 --> 00:11:27,559
que me interesa, alumno, cadena, lo que sea

289
00:11:27,559 --> 00:11:29,039
y además tiene

290
00:11:29,039 --> 00:11:31,580
esta otra propiedad que es la referencia

291
00:11:31,580 --> 00:11:33,259
del siguiente nodo

292
00:11:33,259 --> 00:11:35,480
cuando borras uno se sustituye la del anterior

293
00:11:35,480 --> 00:11:37,080
justo, exacto

294
00:11:37,080 --> 00:11:38,799
claro, entonces

295
00:11:38,799 --> 00:11:41,600
la estructura es esta, con lo cual la primera parte

296
00:11:41,600 --> 00:11:43,440
que es tener un montón

297
00:11:43,440 --> 00:11:45,059
de datos recogidos

298
00:11:45,059 --> 00:11:46,720
bajo una referencia común

299
00:11:46,720 --> 00:11:48,799
ya está

300
00:11:48,799 --> 00:11:51,639
¿por qué? porque si yo quiero recuperar

301
00:11:51,639 --> 00:11:53,860
este, por ejemplo, quiero consultar

302
00:11:53,860 --> 00:11:55,519
el de posición 3, como antes

303
00:11:55,519 --> 00:11:57,440
pues yo me cojo

304
00:11:57,440 --> 00:11:59,019
mi referencia común y voy avanzando

305
00:11:59,019 --> 00:12:02,639
me quedo con la segunda parte

306
00:12:02,639 --> 00:12:04,340
de esta

307
00:12:04,340 --> 00:12:06,679
y ahora de esta me quedo a su vez

308
00:12:06,679 --> 00:12:07,700
con su segunda parte

309
00:12:07,700 --> 00:12:10,740
y ahora de esta me quedo a su vez con su segunda parte

310
00:12:10,740 --> 00:12:11,559
y ya estoy

311
00:12:11,559 --> 00:12:13,320
pero no puedes añadir en una posición

312
00:12:13,320 --> 00:12:15,059
tendrías que hacer

313
00:12:15,059 --> 00:12:18,940
eso es lo más sencillo

314
00:12:18,940 --> 00:12:20,740
de hacer con la lista precisamente por eso inventaron

315
00:12:20,740 --> 00:12:21,419
para añadir

316
00:12:21,419 --> 00:12:24,799
añadir al fondo me parece bien

317
00:12:24,799 --> 00:12:26,220
claro pero

318
00:12:26,220 --> 00:12:28,200
añadir en una posición intermedia

319
00:12:28,200 --> 00:12:33,360
entonces tú ahora quieres insertar

320
00:12:33,360 --> 00:12:35,220
aquí un dato, en la posición 3

321
00:12:35,220 --> 00:12:36,580
vale, pues

322
00:12:36,580 --> 00:12:39,360
hay que construir la cajita nodo

323
00:12:39,360 --> 00:12:40,899
y le metes el dato

324
00:12:40,899 --> 00:12:42,899
y lo único que hay que hacer es

325
00:12:42,899 --> 00:12:44,200
dos asignaciones

326
00:12:44,200 --> 00:12:47,360
esta asignación es una asignación

327
00:12:47,360 --> 00:12:49,200
sencilla, que se va aquí

328
00:12:49,200 --> 00:12:51,360
y esta asignación

329
00:12:51,360 --> 00:12:52,679
que se va aquí

330
00:12:52,679 --> 00:12:55,000
vale

331
00:12:55,000 --> 00:12:57,500
entonces, insertar en una posición

332
00:12:57,500 --> 00:13:00,159
no es como un array que tienes que hacer uno nuevo

333
00:13:00,159 --> 00:13:01,460
copiar el viejo en el nuevo

334
00:13:01,460 --> 00:13:03,960
sino es, nodo nuevo

335
00:13:03,960 --> 00:13:06,000
este, muy bien, y dos asignaciones

336
00:13:06,000 --> 00:13:07,580
esta dirección

337
00:13:07,580 --> 00:13:10,340
pasa de apuntar aquí a apuntar aquí arriba

338
00:13:10,340 --> 00:13:11,960
y esta de aquí

339
00:13:11,960 --> 00:13:14,220
pasa a apuntar a este, a la que apuntaba el otro

340
00:13:14,220 --> 00:13:16,360
luego con dos asignaciones

341
00:13:16,360 --> 00:13:17,340
tienes el nuevo

342
00:13:17,340 --> 00:13:20,000
nodo metido, entonces por eso si es como

343
00:13:20,000 --> 00:13:22,080
una serpiente, porque estos nodos

344
00:13:22,080 --> 00:13:24,039
están en memoria donde sea, y bueno, cada uno

345
00:13:24,039 --> 00:13:26,220
va enlazando al siguiente, va enlazando y ya está

346
00:13:26,220 --> 00:13:27,399
¿vale?

347
00:13:27,500 --> 00:13:29,679
eliminar en un array

348
00:13:29,679 --> 00:13:30,879
eliminar era muy costoso

349
00:13:30,879 --> 00:13:33,039
porque eliminar era hacer otro array

350
00:13:33,039 --> 00:13:35,840
con una posición menos, copiar todo el viejo en el nuevo

351
00:13:35,840 --> 00:13:37,019
sobre escribir

352
00:13:37,019 --> 00:13:39,279
aquí eliminar es sencillísimo

353
00:13:39,279 --> 00:13:41,480
eliminar es hacer una asignación

354
00:13:41,480 --> 00:13:43,679
que es, por ejemplo

355
00:13:43,679 --> 00:13:44,779
queremos eliminar este

356
00:13:44,779 --> 00:13:47,519
queremos eliminar

357
00:13:47,519 --> 00:13:49,639
este primero, para no emborronar esta zona

358
00:13:49,639 --> 00:13:51,919
este primero, pues se trata de

359
00:13:51,919 --> 00:13:53,840
a esta dirección de aquí

360
00:13:53,840 --> 00:13:55,379
la sobre escribo

361
00:13:55,379 --> 00:13:56,580
con la del siguiente

362
00:13:56,580 --> 00:13:59,440
con lo cual una única asignación

363
00:13:59,440 --> 00:14:00,779
y se acabó, eliminado

364
00:14:00,779 --> 00:14:03,480
eso que va a implicar que este pobre nodo

365
00:14:03,480 --> 00:14:05,980
se ha quedado sin que nadie lo apunte

366
00:14:05,980 --> 00:14:08,159
porque el único que le apuntaba

367
00:14:08,159 --> 00:14:09,000
que era este

368
00:14:09,000 --> 00:14:11,440
ahora está apuntando al siguiente

369
00:14:11,440 --> 00:14:13,039
luego un objeto

370
00:14:13,039 --> 00:14:15,480
que se ha quedado sin que nadie lo apunte

371
00:14:15,480 --> 00:14:17,080
ha perdido toda su referencia

372
00:14:17,080 --> 00:14:19,220
y el recolector de basura lo elimina

373
00:14:19,220 --> 00:14:21,399
casi instantáneamente

374
00:14:21,399 --> 00:14:23,940
en cuanto un objeto se queda sin nadie

375
00:14:23,940 --> 00:14:24,600
que lo apunte

376
00:14:24,600 --> 00:14:26,940
el objeto no es que desaparezca

377
00:14:26,940 --> 00:14:29,580
el proceso recolector de basura

378
00:14:29,580 --> 00:14:30,700
pum

379
00:14:30,700 --> 00:14:33,179
lo libera de memoria

380
00:14:33,179 --> 00:14:34,419
lo hace desaparecer

381
00:14:34,419 --> 00:14:36,279
luego

382
00:14:36,279 --> 00:14:39,539
insertar es muy fácil

383
00:14:39,539 --> 00:14:40,779
hacer dos asignaciones

384
00:14:40,779 --> 00:14:43,480
eliminar es muy fácil

385
00:14:43,480 --> 00:14:44,480
hacer una asignación

386
00:14:44,480 --> 00:14:47,759
sin embargo aquí lo que se hace muy pesado

387
00:14:47,759 --> 00:14:49,240
es consultar

388
00:14:49,240 --> 00:14:51,179
porque en una raíz de inmediato

389
00:14:51,179 --> 00:14:52,340
consultar posición y

390
00:14:52,340 --> 00:14:54,080
te vas a esa posición del Array

391
00:14:54,080 --> 00:14:56,440
inmediato, pero aquí tienes que ir

392
00:14:56,440 --> 00:14:58,419
haciendo pa pa pa pa

393
00:14:58,419 --> 00:14:59,860
entonces

394
00:14:59,860 --> 00:15:02,100
una lista enlazada está

395
00:15:02,100 --> 00:15:04,159
fenomenal en una aplicación en la cual

396
00:15:04,159 --> 00:15:05,740
lo que sobre todo se hace con los datos

397
00:15:05,740 --> 00:15:08,100
es incorporar y borrar

398
00:15:08,100 --> 00:15:09,960
incorporar y borrar, cuando se hacen muchas

399
00:15:09,960 --> 00:15:11,620
incorporaciones y borrados de los datos

400
00:15:11,620 --> 00:15:14,360
esta va a ser muchísimo mejor que un ArrayList

401
00:15:14,360 --> 00:15:16,240
pero cuando se

402
00:15:16,240 --> 00:15:17,740
hacen muchas consultas

403
00:15:17,740 --> 00:15:20,399
un ArrayList va a ser mucho más rápido

404
00:15:20,399 --> 00:15:21,399
aquí consultar

405
00:15:21,399 --> 00:15:23,940
una dirección que está toda por tu lado

406
00:15:23,940 --> 00:15:25,759
claro, claro, entonces

407
00:15:25,759 --> 00:15:27,600
cuando tú tienes a lo mejor una aplicación

408
00:15:27,600 --> 00:15:29,379
en la que vas a tener siempre

409
00:15:29,379 --> 00:15:31,919
27 datos y luego ya

410
00:15:31,919 --> 00:15:34,000
con esos 27 ya no los mueves más

411
00:15:34,000 --> 00:15:35,960
como mucho mueves a uno más

412
00:15:35,960 --> 00:15:37,879
dos más y luego estar consultando, pues harías

413
00:15:37,879 --> 00:15:39,860
una ArrayList, pero

414
00:15:39,860 --> 00:15:41,799
si vas a tener que estar

415
00:15:41,799 --> 00:15:44,100
haciendo todo el rato inserciones y eliminaciones

416
00:15:44,100 --> 00:15:45,039
pues cogerías esta

417
00:15:45,039 --> 00:15:48,240
esencial, sí, esencialmente

418
00:15:48,240 --> 00:15:50,100
esa es la diferencia

419
00:15:50,100 --> 00:15:52,200
desde fuera, uno cuando las usa

420
00:15:52,200 --> 00:15:53,919
las va a usar igual, llamando a

421
00:15:53,919 --> 00:15:56,159
llamando a no se que, pero como sabemos

422
00:15:56,159 --> 00:15:58,080
como se comportan por dentro, pues podemos hacer

423
00:15:58,080 --> 00:15:59,320
seleccionar de forma

424
00:15:59,320 --> 00:16:02,019
seleccionarlas, particularizarlas en la que estén

425
00:16:02,019 --> 00:16:03,059
vale

426
00:16:03,059 --> 00:16:06,399
pues vamos a programar la lista enlazada

427
00:16:06,399 --> 00:16:07,980
que es un pelín más

428
00:16:07,980 --> 00:16:09,799
difícil de entender que la array list

429
00:16:09,799 --> 00:16:11,960
pero tampoco tiene, pues aquí habrá que

430
00:16:11,960 --> 00:16:14,000
programar una clase para

431
00:16:14,000 --> 00:16:15,879
empezar, la clase

432
00:16:15,879 --> 00:16:18,000
nodo, la clase nodo

433
00:16:18,000 --> 00:16:19,980
que tendrá dos partes, el tipo de

434
00:16:19,980 --> 00:16:20,600
dato que sea

435
00:16:20,600 --> 00:16:23,399
y la dirección del siguiente nodo

436
00:16:23,399 --> 00:16:24,960
la clase nodo

437
00:16:24,960 --> 00:16:27,759
y luego ya la clase colección concreta

438
00:16:27,759 --> 00:16:29,139
la clase en mi linked list

439
00:16:29,139 --> 00:16:32,320
que es la que tendrá la dirección del primer nodo

440
00:16:32,320 --> 00:16:33,860
pero la clase nodo

441
00:16:33,860 --> 00:16:34,799
habrá que programarla

442
00:16:34,799 --> 00:16:37,139
y luego habrá que programar

443
00:16:37,139 --> 00:16:38,460
mi clase colección

444
00:16:38,460 --> 00:16:41,139
la que ya ofrece los métodos y lo hace todo

445
00:16:41,139 --> 00:16:42,620
pues venga

446
00:16:42,620 --> 00:16:43,940
vamos a programarla

447
00:16:43,940 --> 00:16:49,159
si pero para usar ese ejemplo

448
00:16:49,159 --> 00:16:49,980
la vamos a programar por primero.

449
00:16:50,659 --> 00:16:51,879
Si no la programamos, ¿cuándo la vamos a usar?

450
00:16:53,139 --> 00:16:55,059
A programar, ¿qué por eso estás aquí?

451
00:17:03,019 --> 00:17:03,879
Vaya, por Dios.

452
00:17:06,119 --> 00:17:09,920
Nodo tiene dos propiedades.

453
00:17:22,549 --> 00:17:23,410
Vale, a ver.

454
00:17:25,470 --> 00:17:26,230
Venga, pues

455
00:17:26,230 --> 00:17:30,970
a ver, la colección

456
00:17:30,970 --> 00:17:32,309
ahora se va a llamar

457
00:17:32,309 --> 00:17:34,410
Mi Linked List.

458
00:17:35,029 --> 00:17:39,230
paciencia

459
00:17:39,230 --> 00:17:40,529
aunque ahora sí

460
00:17:40,529 --> 00:17:42,130
y no os bajéis la sábana

461
00:17:42,130 --> 00:17:42,890
¿algo más?

462
00:17:43,170 --> 00:17:43,269
¿no?

463
00:17:43,549 --> 00:17:43,950
un café

464
00:17:43,950 --> 00:17:45,809
¿no sirve un café?

465
00:17:49,769 --> 00:17:50,630
¿cafés no sirve?

466
00:17:50,690 --> 00:17:51,230
¿quieres un curasal?

467
00:17:51,569 --> 00:17:51,990
un mantequilla

468
00:17:51,990 --> 00:17:52,710
bueno

469
00:17:52,710 --> 00:17:54,190
pues eso luego

470
00:17:54,190 --> 00:17:55,490
venga

471
00:17:55,490 --> 00:17:57,029
mi linked list

472
00:17:57,029 --> 00:17:58,289
finish

473
00:17:58,289 --> 00:18:01,109
esta va a ser mi lista

474
00:18:01,109 --> 00:18:03,130
la que tiene dentro los datos

475
00:18:03,130 --> 00:18:07,269
la equivalente a mi array list que lo que tenía el array

476
00:18:07,269 --> 00:18:11,009
pero mi linked list con que tenga la dirección

477
00:18:11,009 --> 00:18:12,690
del primer nodo es suficiente

478
00:18:12,690 --> 00:18:16,390
la dirección del primer nodo es una referencia

479
00:18:16,390 --> 00:18:19,130
a la clase nodo que tendremos que hacer

480
00:18:19,130 --> 00:18:22,210
vamos a llamarla inicio por ejemplo

481
00:18:22,210 --> 00:18:24,170
inicio lista para que quede más claro

482
00:18:24,170 --> 00:18:28,529
entonces mi linked list lo único que tiene que tener dentro

483
00:18:28,529 --> 00:18:30,750
es la dirección del primer nodo

484
00:18:30,750 --> 00:18:32,190
la que se llama inicio lista

485
00:18:32,190 --> 00:18:33,069
vale

486
00:18:33,069 --> 00:18:35,869
nos falta la clase nodo, claro

487
00:18:35,869 --> 00:18:39,549
pues vamos a hacer la clase

488
00:18:39,549 --> 00:18:47,210
nodo, la clase

489
00:18:47,210 --> 00:18:49,410
nodo es la que tiene dos partes

490
00:18:49,410 --> 00:18:51,009
una la que tiene el dato

491
00:18:51,009 --> 00:18:52,509
vale

492
00:18:52,509 --> 00:18:57,390
vamos a

493
00:18:57,390 --> 00:19:01,809
como las dos van a ir en pack, aquí no tiene

494
00:19:01,809 --> 00:19:03,690
sentido que pongamos private porque esto no es una

495
00:19:03,690 --> 00:19:04,349
entidad de

496
00:19:04,349 --> 00:19:07,970
string

497
00:19:07,970 --> 00:19:08,970
dato

498
00:19:08,970 --> 00:19:11,849
esta propiedad es para el dato en sí

499
00:19:11,849 --> 00:19:13,869
para la cadena y nos falta

500
00:19:13,869 --> 00:19:15,809
otra propiedad que es la

501
00:19:15,809 --> 00:19:17,210
segunda parte de la cajita

502
00:19:17,210 --> 00:19:20,190
que es la dirección del siguiente nodo

503
00:19:20,190 --> 00:19:28,130
vale

504
00:19:28,130 --> 00:19:30,049
luego la clase nodo está

505
00:19:30,049 --> 00:19:31,690
clara ¿no? la clase nodo tiene

506
00:19:31,690 --> 00:19:33,369
una propiedad que es el dato

507
00:19:33,369 --> 00:19:35,910
y otra que es la dirección del siguiente

508
00:19:35,910 --> 00:19:46,589
y la clase

509
00:19:46,589 --> 00:19:48,829
mi linked list tiene

510
00:19:48,829 --> 00:19:50,289
la dirección del primero

511
00:19:50,289 --> 00:19:53,089
en cuanto a representación de la situación

512
00:19:53,089 --> 00:19:53,569
ya está

513
00:19:53,569 --> 00:19:56,750
a lo que hay es que hacer los métodos para que esto se

514
00:19:56,750 --> 00:19:57,769
comporte como hemos dicho

515
00:19:57,769 --> 00:20:02,529
vale, pues

516
00:20:02,529 --> 00:20:05,049
vamos a hacer

517
00:20:05,049 --> 00:20:06,450
el método insertar

518
00:20:06,450 --> 00:20:08,609
añadir, vamos

519
00:20:08,609 --> 00:20:10,950
añadir un dato

520
00:20:10,950 --> 00:20:12,990
un string, porque estamos trabajando con

521
00:20:12,990 --> 00:20:18,359
string, vale, a ver

522
00:20:18,359 --> 00:20:19,579
no vamos a complicarnos

523
00:20:19,579 --> 00:20:22,099
mucho la vida, vale

524
00:20:22,099 --> 00:20:24,380
porque lo único que quiero es que se

525
00:20:24,380 --> 00:20:26,220
refleje la idea de cómo funciona

526
00:20:26,220 --> 00:20:26,759
esto

527
00:20:26,759 --> 00:20:30,339
y luego ya vamos a usar linked list, lógicamente

528
00:20:30,339 --> 00:20:32,220
vale, pues para

529
00:20:32,220 --> 00:20:33,140
añadir el dato

530
00:20:33,140 --> 00:20:35,500
Vamos a pensar un momento

531
00:20:35,500 --> 00:20:39,000
Clase de pain

532
00:20:39,000 --> 00:20:41,759
Clase de pain

533
00:20:41,759 --> 00:20:42,920
Que me vendría muy bien

534
00:20:42,920 --> 00:20:43,960
Una clase de pain

535
00:20:43,960 --> 00:20:45,599
O un ordenador

536
00:20:45,599 --> 00:20:48,380
Eso sí que me vendría

537
00:20:48,380 --> 00:20:50,680
Vale, pero ya tengo wifi

538
00:20:50,680 --> 00:20:52,220
Ya, hombre

539
00:20:52,220 --> 00:20:54,000
Claro

540
00:20:54,000 --> 00:20:57,019
Después de 8 años que llevo aquí

541
00:20:57,019 --> 00:20:59,059
Venga

542
00:20:59,059 --> 00:21:00,019
Pues a ver

543
00:21:00,019 --> 00:21:02,259
Por eso por la wifi del instituto

544
00:21:02,259 --> 00:21:07,059
No sé si había una que nunca llegó

545
00:21:07,059 --> 00:21:08,400
A mí nunca me llegó a funcionar

546
00:21:08,400 --> 00:21:12,980
A ver, formas aquí

547
00:21:12,980 --> 00:21:18,720
No, no, a ver, le funciona igual que los demás

548
00:21:18,720 --> 00:21:21,240
Él no nos ocultaba la password

549
00:21:21,240 --> 00:21:22,240
Lo que pasa es que no

550
00:21:22,240 --> 00:21:23,940
La password la sabíamos, pero

551
00:21:23,940 --> 00:21:26,240
Tirar de ella era tontería

552
00:21:26,240 --> 00:21:29,700
Vale, pues a ver

553
00:21:29,700 --> 00:21:31,500
Esta es

554
00:21:31,500 --> 00:21:34,380
este sería

555
00:21:34,380 --> 00:21:37,140
el primer nodo, el inicio

556
00:21:37,140 --> 00:21:37,680
famoso

557
00:21:37,680 --> 00:21:40,819
que inicialmente

558
00:21:40,819 --> 00:21:43,339
está apuntando a nul, ¿verdad?

559
00:21:49,220 --> 00:21:49,779
¿Vale?

560
00:21:51,380 --> 00:21:52,299
Este sería

561
00:21:52,299 --> 00:21:54,279
inicialmente cuando la lista arranca

562
00:21:54,279 --> 00:21:55,079
y yo la instancie,

563
00:21:56,059 --> 00:21:58,259
cuando la instanciemos, inicio lista será nul

564
00:21:58,259 --> 00:21:59,400
porque está sin inicializar.

565
00:21:59,880 --> 00:22:00,740
Será nul, ¿vale?

566
00:22:01,900 --> 00:22:02,460
Entonces,

567
00:22:02,460 --> 00:22:05,619
cuando vamos a suponer

568
00:22:05,619 --> 00:22:07,359
vamos a hacer un añadir asumiendo

569
00:22:07,359 --> 00:22:09,640
que la lista ya tiene cosas

570
00:22:09,640 --> 00:22:10,599
para que sea más fácil

571
00:22:10,599 --> 00:22:13,279
no contemplamos el caso inicial que luego

572
00:22:13,279 --> 00:22:15,200
vale, entonces

573
00:22:15,200 --> 00:22:16,980
vamos a suponer que la lista ya tiene cosas

574
00:22:16,980 --> 00:22:18,660
vamos a hacer el add asumiendo que tiene cosas

575
00:22:18,660 --> 00:22:20,180
entonces

576
00:22:20,180 --> 00:22:23,220
la lista

577
00:22:23,220 --> 00:22:23,920
tiene aquí

578
00:22:23,920 --> 00:22:26,599
el dato

579
00:22:26,599 --> 00:22:32,059
y la dirección del siguiente

580
00:22:32,059 --> 00:22:38,339
y hacemos

581
00:22:38,339 --> 00:22:39,200
solo uno más

582
00:22:39,200 --> 00:22:43,980
y este nodo que tiene

583
00:22:43,980 --> 00:22:50,660
que tiene el dato

584
00:22:50,660 --> 00:22:54,000
y la dirección del siguiente

585
00:22:54,000 --> 00:22:56,160
y este ya

586
00:22:56,160 --> 00:23:00,140
este ya me lleva a nul

587
00:23:00,140 --> 00:23:03,160
vamos a poner una situación de la lista

588
00:23:03,160 --> 00:23:06,960
en la que estoy así

589
00:23:06,960 --> 00:23:12,690
vale, y este nul

590
00:23:12,690 --> 00:23:13,869
como si no existiera

591
00:23:13,869 --> 00:23:28,390
vale, a ver, relax

592
00:23:28,390 --> 00:23:29,890
chicas, por favor

593
00:23:29,890 --> 00:23:31,710
vale

594
00:23:31,710 --> 00:23:36,509
reírse, ¿te parece poco?

595
00:23:39,450 --> 00:23:40,609
ya, pero es que

596
00:23:40,609 --> 00:23:42,569
lo tuyo es fuera de categoría

597
00:23:42,569 --> 00:23:44,829
por eso te vamos a llevar

598
00:23:44,829 --> 00:23:45,849
a un sitio tan bonito

599
00:23:45,849 --> 00:23:48,990
venga

600
00:23:48,990 --> 00:23:50,869
a ver, ¿no ves que se ha abierto

601
00:23:50,869 --> 00:23:52,890
un perímetro de seguridad alrededor tuyo?

602
00:23:53,009 --> 00:23:53,789
¿se ha abierto un perímetro?

603
00:23:54,390 --> 00:23:55,509
no, ya vi, ya vi

604
00:23:55,509 --> 00:23:59,269
bueno, silencio

605
00:23:59,269 --> 00:24:00,690
vale, vamos a suponer que la situación

606
00:24:00,690 --> 00:24:02,849
de la lista es esta, vale, el método

607
00:24:02,849 --> 00:24:04,890
añadir un dato

608
00:24:04,890 --> 00:24:06,710
que implicará, implicará

609
00:24:06,710 --> 00:24:08,769
varias cosas, mi dato llega por aquí, yo al

610
00:24:08,769 --> 00:24:10,950
método de añadir, me limito a darle

611
00:24:10,950 --> 00:24:12,769
un dato, este dato, un

612
00:24:12,769 --> 00:24:14,789
string, una cadena. Y ahora el

613
00:24:14,789 --> 00:24:17,009
método de añadir tiene que hacer todo lo necesario

614
00:24:17,009 --> 00:24:18,869
para coger este dato,

615
00:24:18,990 --> 00:24:20,910
meterlo en un nodo, insertarlo en la lista,

616
00:24:21,069 --> 00:24:22,730
etcétera. Vale, pues

617
00:24:22,730 --> 00:24:24,349
entonces, lo primero que tendría que hacer el método,

618
00:24:25,210 --> 00:24:26,769
crear un

619
00:24:26,769 --> 00:24:28,730
objeto nodo y

620
00:24:28,730 --> 00:24:30,650
meter el dato en el objeto nodo.

621
00:24:31,029 --> 00:24:32,630
Eso es lo primero que tiene que hacer el método add.

622
00:24:32,630 --> 00:24:33,630
Vale, pues vamos a hacerlo.

623
00:24:34,349 --> 00:24:36,569
Lo primero que tiene que hacer el método add

624
00:24:36,569 --> 00:24:36,990
es

625
00:24:36,990 --> 00:24:48,490
No, pero si tú no viajas

626
00:24:48,490 --> 00:24:49,910
Si tú has hecho un new dato

627
00:24:49,910 --> 00:24:51,349
Ahí está, para el infinito

628
00:24:51,349 --> 00:24:53,789
Vale, tenemos un nuevo nodo

629
00:24:53,789 --> 00:24:55,730
Vale

630
00:24:55,730 --> 00:24:58,210
Este nodo, su dato

631
00:24:58,210 --> 00:25:01,029
Que sea

632
00:25:01,029 --> 00:25:03,130
El dato que me han dado

633
00:25:03,130 --> 00:25:06,549
O sea, el dato que me han dado

634
00:25:06,549 --> 00:25:08,390
se va a la propiedad

635
00:25:08,390 --> 00:25:10,630
dato de este nodo

636
00:25:10,630 --> 00:25:11,250
que he creado.

637
00:25:12,190 --> 00:25:14,250
Eso es lo primero que tendremos que hace el método A

638
00:25:14,250 --> 00:25:15,430
de este de aquí. Lo primero.

639
00:25:15,970 --> 00:25:16,490
¿Verdad?

640
00:25:18,730 --> 00:25:19,210
Claro.

641
00:25:20,710 --> 00:25:22,730
Pues lo primero que es esta parte.

642
00:25:23,309 --> 00:25:24,730
Crear el objeto nodo,

643
00:25:24,789 --> 00:25:26,809
la cajita grande y meter el

644
00:25:26,809 --> 00:25:28,789
dato ahí dentro. ¿Qué es lo siguiente

645
00:25:28,789 --> 00:25:30,730
que tiene que hacer? Pues la otra

646
00:25:30,730 --> 00:25:32,630
parte del nodo, que ahora mismo está.

647
00:25:33,930 --> 00:25:35,029
Esta parte del nodo

648
00:25:35,029 --> 00:25:36,970
tiene que apañárselas

649
00:25:36,970 --> 00:25:38,869
para que apunte

650
00:25:38,869 --> 00:25:40,170
a donde yo quiera que apunte

651
00:25:40,170 --> 00:25:42,589
vamos a hacer la versión fácil de add

652
00:25:42,589 --> 00:25:44,750
que es añadir al final

653
00:25:44,750 --> 00:25:48,230
la versión fácil de add

654
00:25:48,230 --> 00:25:49,309
que es añadir al final

655
00:25:49,309 --> 00:25:51,769
perdón, no, no, no

656
00:25:51,769 --> 00:25:53,589
la versión fácil de add que es añadir al principio

657
00:25:53,589 --> 00:25:55,269
al final no es nada fácil, es complicada

658
00:25:55,269 --> 00:25:57,690
es añadir al principio, que es insertar aquí

659
00:25:57,690 --> 00:25:59,549
la versión fácil sería

660
00:25:59,549 --> 00:26:01,349
hombre, pues lo tengo muy fácil

661
00:26:01,349 --> 00:26:03,829
a este de aquí

662
00:26:03,829 --> 00:26:04,410
primero

663
00:26:04,410 --> 00:26:07,170
le pongo

664
00:26:07,170 --> 00:26:09,289
lo que tiene la lista en ese

665
00:26:09,289 --> 00:26:11,190
momento. O sea, le asigno

666
00:26:11,190 --> 00:26:12,289
a este, le asigno a esto.

667
00:26:13,029 --> 00:26:15,190
Con lo cual, lo primero que consigo es

668
00:26:15,190 --> 00:26:16,250
esto de aquí.

669
00:26:17,430 --> 00:26:18,710
Lo primero que hacemos es este enlace.

670
00:26:20,029 --> 00:26:20,529
Es decir,

671
00:26:20,970 --> 00:26:22,970
a la dirección de inicio de mi lista,

672
00:26:23,170 --> 00:26:25,210
perdón, a la dirección siguiente del

673
00:26:25,210 --> 00:26:27,069
nodo nuevo, le asigno el inicio

674
00:26:27,069 --> 00:26:29,289
de mi lista. Vamos a hacer este enlace el primero de todos.

675
00:26:29,869 --> 00:26:30,690
Este enlace el primero.

676
00:26:31,750 --> 00:26:33,069
Vale, pues este enlace se

677
00:26:33,069 --> 00:26:43,309
corresponderá hacer esta sentencia, nodo punto siguiente, dirección siguiente, igual a inicio

678
00:26:43,309 --> 00:26:57,450
lista, ¿vale? Ya hemos hecho ese enlace, hemos hecho este, al siguiente del nodo que he hecho

679
00:26:57,450 --> 00:27:04,089
le asigno lo que tenía inicio lista, luego he construido este enlace y ahora ¿qué es lo

680
00:27:04,089 --> 00:27:30,519
Siguiente y último que hacemos, al inicio lista le quito lo que había, se lo quito y le hago que apunte al nuevo, le hago ahora que apunte a este, pataplón, y este se ha quedado insertado en la lista al principio, a inicio, luego lo único que me falta es a inicio lista darle la dirección de este nodo que he creado, es lo único que me falta,

681
00:27:30,519 --> 00:27:32,839
a inicio

682
00:27:32,839 --> 00:27:33,559
lista

683
00:27:33,559 --> 00:27:38,960
asignarle nodo.

684
00:27:41,609 --> 00:27:43,109
¿Vale? Porque nodo es la dirección

685
00:27:43,109 --> 00:27:43,930
del nodo que he creado.

686
00:27:45,289 --> 00:27:47,309
Pues ya está. El método add ya está.

687
00:27:48,390 --> 00:27:49,049
Es el add

688
00:27:49,049 --> 00:27:51,190
al principio. ¿Vale? Lo podríamos

689
00:27:51,190 --> 00:27:53,130
llamar, si queremos ser más...

690
00:27:53,990 --> 00:27:55,269
Añade al principio de la lista.

691
00:27:59,470 --> 00:28:00,650
Añade al primero.

692
00:28:02,490 --> 00:28:03,250
Ya está.

693
00:28:03,589 --> 00:28:04,470
Pues lo hemos metido ahí.

694
00:28:09,079 --> 00:28:10,000
Entonces, luego

695
00:28:10,000 --> 00:28:11,859
uno tendría que comprobar si en los casos

696
00:28:11,859 --> 00:28:13,940
extremos, cuando la lista está vacía, cuando

697
00:28:13,940 --> 00:28:15,920
no funciona. Pero claro que funciona, porque cuando

698
00:28:15,920 --> 00:28:18,200
esta apunta null, ¿qué estaremos haciendo?

699
00:28:18,339 --> 00:28:19,900
A este le damos null, perfecto.

700
00:28:19,960 --> 00:28:21,980
Y a este le damos el nuevo. Luego

701
00:28:21,980 --> 00:28:23,720
para el caso particular, lista vacía,

702
00:28:24,220 --> 00:28:25,500
este addFirst también funciona.

703
00:28:26,220 --> 00:28:27,640
Entonces este addFirst es el más.

704
00:28:28,359 --> 00:28:28,579
¿Vale?

705
00:28:29,859 --> 00:28:31,200
Entonces ya tenemos

706
00:28:31,200 --> 00:28:33,839
y claro, luego a esta colección se le pueden

707
00:28:33,839 --> 00:28:37,789
añadir más métodos. Vamos a

708
00:28:37,789 --> 00:28:39,690
añadirle solo dos más

709
00:28:39,690 --> 00:28:41,710
para poder recorrerla y ver que lo que metamos

710
00:28:41,710 --> 00:28:44,500
esta, vale

711
00:28:44,500 --> 00:28:47,140
vamos a darle

712
00:28:47,140 --> 00:28:49,180
recuperar el elemento de una

713
00:28:49,180 --> 00:28:49,680
posición

714
00:28:49,680 --> 00:28:59,410
tenemos que ir avanzando

715
00:28:59,410 --> 00:29:00,230
en las direcciones

716
00:29:00,230 --> 00:29:02,970
claro

717
00:29:02,970 --> 00:29:04,569
entonces

718
00:29:04,569 --> 00:29:07,089
a mi

719
00:29:07,089 --> 00:29:09,470
linked list le vamos a dar el método get

720
00:29:09,470 --> 00:29:10,750
hasta que ese número sea pos

721
00:29:10,750 --> 00:29:13,569
entonces aquí lo importante

722
00:29:13,569 --> 00:29:15,710
es entender que la sentencia clave

723
00:29:15,710 --> 00:29:16,789
es

724
00:29:16,789 --> 00:29:18,329
coger

725
00:29:18,329 --> 00:29:20,710
una referencia auxiliar

726
00:29:20,710 --> 00:29:21,710
un nodo auxiliar

727
00:29:21,710 --> 00:29:24,970
un nodito auxiliar que lo podemos poner por aquí

728
00:29:24,970 --> 00:29:26,750
por cualquier lado, o sea una referencia

729
00:29:26,750 --> 00:29:28,349
a nodo auxiliar

730
00:29:28,349 --> 00:29:34,940
¿vale? que inicialmente

731
00:29:34,940 --> 00:29:36,059
que apunte al principio

732
00:29:36,059 --> 00:29:38,980
y la vamos avanzando

733
00:29:38,980 --> 00:29:40,880
con la siguiente

734
00:29:40,880 --> 00:29:42,660
sentencia, vamos a suponer que hacemos

735
00:29:42,660 --> 00:29:44,339
un nodo auxiliar, este de aquí

736
00:29:44,339 --> 00:29:45,880
un nodo auxiliar que apunta al primero

737
00:29:45,880 --> 00:29:47,420
vamos a hacernos un auxiliar

738
00:29:47,420 --> 00:29:52,619
que apunte al principio de la lista

739
00:29:52,619 --> 00:29:56,019
un nodo auxiliar, vale

740
00:29:56,019 --> 00:29:58,440
y ahora, fijaos

741
00:29:58,440 --> 00:30:00,599
que cada vez que hacemos esta sentencia

742
00:30:00,599 --> 00:30:02,339
aux igual a

743
00:30:02,339 --> 00:30:04,500
aux.dir siguiente, que esta es la

744
00:30:04,500 --> 00:30:05,420
clave, la importante

745
00:30:05,420 --> 00:30:08,420
cada vez que hagamos

746
00:30:08,420 --> 00:30:10,380
esta sentencia, ¿qué hacemos con

747
00:30:10,380 --> 00:30:12,339
este nodo auxiliar? de aquí

748
00:30:12,339 --> 00:30:14,359
lo estamos haciendo que

749
00:30:14,359 --> 00:30:15,900
apunte al siguiente nodo

750
00:30:15,900 --> 00:30:18,359
luego este nodo auxiliar inicialmente

751
00:30:18,359 --> 00:30:19,019
apunta al primero

752
00:30:19,019 --> 00:30:21,900
pero cada vez que hagamos

753
00:30:21,900 --> 00:30:24,940
aux igual a aux.dir siguiente

754
00:30:24,940 --> 00:30:26,480
cada vez que hagamos esto

755
00:30:26,480 --> 00:30:28,579
este nodo

756
00:30:28,579 --> 00:30:30,240
se quedará apuntando a uno

757
00:30:30,240 --> 00:30:31,640
posterior y a uno posterior

758
00:30:31,640 --> 00:30:34,579
lo único que tenemos que hacer es un for

759
00:30:34,579 --> 00:30:36,559
que ejecute esa sentencia de avance

760
00:30:36,559 --> 00:30:37,980
tantas veces como posiciones

761
00:30:37,980 --> 00:30:39,579
y ya está

762
00:30:39,579 --> 00:30:52,279
entonces si pos me dan 0

763
00:30:52,279 --> 00:30:54,400
no se ejecutará nunca

764
00:30:54,400 --> 00:30:56,240
luego aux será la del primero, justo

765
00:30:56,240 --> 00:30:58,700
que me dan 1, se ejecutará

766
00:30:58,700 --> 00:31:00,799
una vez, luego aux se quedará

767
00:31:00,799 --> 00:31:02,839
apuntando al primero

768
00:31:02,839 --> 00:31:04,539
al siguiente

769
00:31:04,539 --> 00:31:06,640
¿vale? entonces esta

770
00:31:06,640 --> 00:31:08,720
sentencia avanza el nodo

771
00:31:08,720 --> 00:31:10,920
auxiliar una vez, cada vez que la ejecuto

772
00:31:10,920 --> 00:31:12,720
luego si lo meto en un for

773
00:31:12,720 --> 00:31:14,799
la sentencia de avanzar se va a

774
00:31:14,799 --> 00:31:16,359
hacer pos veces, que es justo lo que quiero

775
00:31:16,359 --> 00:31:18,440
luego cuando este for ha terminado

776
00:31:18,440 --> 00:31:20,799
cuando este for acabó, yo ya

777
00:31:20,799 --> 00:31:22,680
sé que mi auxiliar estará

778
00:31:22,680 --> 00:31:24,779
apuntando al nodo pos que me

779
00:31:24,779 --> 00:31:26,740
interesa, lo único que tengo que hacer

780
00:31:26,740 --> 00:31:28,680
es sacar el dato, porque

781
00:31:28,680 --> 00:31:30,680
el nodo es la caja completa, lo único que me

782
00:31:30,680 --> 00:31:32,619
falta sacar el dato. Una vez que el

783
00:31:32,619 --> 00:31:34,619
nodo auxiliar ya ha ido avanzando, ha ido avanzando

784
00:31:34,619 --> 00:31:36,640
por la lista, ya se ha

785
00:31:36,640 --> 00:31:38,420
quedado ahí, pues ahora ya

786
00:31:38,420 --> 00:31:40,700
return aux.dato

787
00:31:40,700 --> 00:31:43,799
y punto

788
00:31:43,799 --> 00:31:46,000
pelota. Se acabó el get por posición.

789
00:31:54,400 --> 00:31:54,839
Vale.

790
00:31:56,980 --> 00:31:57,900
El size

791
00:31:57,900 --> 00:31:59,700
pues sería hacer un

792
00:31:59,700 --> 00:32:01,619
for que hace esto hasta que

793
00:32:01,619 --> 00:32:02,980
mientras aux sea diferente de null

794
00:32:02,980 --> 00:32:05,720
y contar. Vale.

795
00:32:05,799 --> 00:32:07,799
Vamos a hacer ese y ya hacemos más métodos de la linked list.

796
00:32:07,819 --> 00:32:12,460
el size

797
00:32:12,460 --> 00:32:14,920
public int size

798
00:32:14,920 --> 00:32:17,279
este que tenemos que hacer

799
00:32:17,279 --> 00:32:19,259
pues hacemos de nuevo

800
00:32:19,259 --> 00:32:19,980
un nuevo auxiliar

801
00:32:19,980 --> 00:32:24,359
que apunte al primero

802
00:32:24,359 --> 00:32:28,740
y ahora un contador

803
00:32:28,740 --> 00:32:29,880
porque vamos a contar

804
00:32:29,880 --> 00:32:32,059
cuantos avances hemos hecho

805
00:32:32,059 --> 00:32:34,119
hasta que ha llegado a valer

806
00:32:34,119 --> 00:32:35,000
null ese aux

807
00:32:35,000 --> 00:32:37,140
y ahora ya hacemos un contador

808
00:32:37,140 --> 00:32:38,279
para contar

809
00:32:38,279 --> 00:32:42,430
y ahora podemos hacer

810
00:32:42,430 --> 00:32:43,630
mientras aux

811
00:32:43,630 --> 00:32:45,769
sea diferente

812
00:32:45,769 --> 00:32:47,730
de null

813
00:32:47,730 --> 00:32:52,420
avánzalo

814
00:32:52,420 --> 00:33:04,400
que no atino

815
00:33:04,400 --> 00:33:08,980
vaya diferente que he puesto más original

816
00:33:08,980 --> 00:33:10,640
así mejor

817
00:33:10,640 --> 00:33:11,960
vale

818
00:33:11,960 --> 00:33:13,960
de hecho

819
00:33:13,960 --> 00:33:16,559
si la lista estuviera vacía

820
00:33:16,559 --> 00:33:17,700
inicio lista sería null

821
00:33:17,700 --> 00:33:20,339
no entraría nunca aquí con lo cual me devolvería 0

822
00:33:20,339 --> 00:33:21,299
que es lo que me tiene que devolver

823
00:33:21,299 --> 00:33:24,160
si tuviera solo una posición avanzaría una vez me devolvería 1

824
00:33:24,160 --> 00:33:25,920
y ahora ya

825
00:33:25,920 --> 00:33:28,079
Y bueno, me falta incrementar el contador, lógicamente

826
00:33:28,079 --> 00:33:29,799
Entonces

827
00:33:29,799 --> 00:33:32,000
Aquí voy a tener que poner unas llavecitas

828
00:33:32,000 --> 00:33:38,740
Y ahora

829
00:33:38,740 --> 00:33:40,279
Una vez que mi bucle ha terminado

830
00:33:40,279 --> 00:33:41,700
Pues ya me devuelvo

831
00:33:41,700 --> 00:33:46,660
Vale

832
00:33:46,660 --> 00:33:49,720
Y sería un ejercicio maravilloso, lo vamos a dejar planteado

833
00:33:49,720 --> 00:33:52,000
Que hicierais el remove, no sé qué, no lo vamos a hacer aquí

834
00:33:52,000 --> 00:33:54,160
Vamos a usarlo

835
00:33:54,160 --> 00:33:55,900
En un ejemplo para ver si esta lista enlazada

836
00:33:55,900 --> 00:33:57,460
Efectivamente me permite meter cosas

837
00:33:57,460 --> 00:34:00,240
Y si realmente están dentro

838
00:34:00,240 --> 00:34:08,010
Entonces, como veis

839
00:34:08,010 --> 00:34:09,309
El código es muy sencillo

840
00:34:09,309 --> 00:34:11,650
Esto es mucho más fácil computacionalmente

841
00:34:11,650 --> 00:34:13,710
Que recorrer un array entero

842
00:34:13,710 --> 00:34:15,510
Copiar uno en otro, muchísimo más

843
00:34:15,510 --> 00:34:17,210
Es hacer cuatro asignaciones

844
00:34:17,210 --> 00:34:18,369
Dos, una

845
00:34:18,369 --> 00:34:21,230
El add de aquí

846
00:34:21,230 --> 00:34:22,769
Se ha quedado en nada

847
00:34:22,769 --> 00:34:24,789
Sin embargo, el add del array list

848
00:34:24,789 --> 00:34:25,929
Era un rollo

849
00:34:25,929 --> 00:34:27,909
De arrays para un lado y para otro

850
00:34:27,909 --> 00:34:32,670
El del end lo vas a hacer tú

851
00:34:32,670 --> 00:34:35,269
el remove no lo vamos a hacer

852
00:34:35,269 --> 00:34:35,650
pero

853
00:34:35,650 --> 00:34:39,420
hombre claro que está

854
00:34:39,420 --> 00:34:42,860
pero estaría muy bien

855
00:34:42,860 --> 00:34:44,159
que lo programaréis vosotros

856
00:34:44,159 --> 00:34:46,260
habría que avanzar aux igual a aux siguiente

857
00:34:46,260 --> 00:34:48,619
una vez que habéis llegado pues cambiar las direcciones

858
00:34:48,619 --> 00:34:49,519
para que puenten

859
00:34:49,519 --> 00:34:56,039
este pues

860
00:34:56,039 --> 00:34:59,289
lo hacéis vosotros

861
00:34:59,289 --> 00:35:01,769
que tiene su cosita, sí pero no ahora

862
00:35:01,769 --> 00:35:02,909
porque vamos a probar ahora mismo

863
00:35:02,909 --> 00:35:04,449
que esto que me he hecho está bien

864
00:35:04,449 --> 00:35:07,489
vosotros que sois listos

865
00:35:07,489 --> 00:35:09,429
y espabilados

866
00:35:09,429 --> 00:35:12,030
Vosotros, especie inferior

867
00:35:12,030 --> 00:35:13,030
Vais a hacer esto

868
00:35:13,030 --> 00:35:15,250
Venga, vámonos al main

869
00:35:15,250 --> 00:35:18,250
Venga, el main

870
00:35:18,250 --> 00:35:20,590
Nuestro ArrayList ha funcionado estupendamente

871
00:35:20,590 --> 00:35:24,090
Lo voy a hacer en mi main

872
00:35:24,090 --> 00:35:26,250
Como voy a subir esto, voy a hacerlo aquí en un

873
00:35:26,250 --> 00:35:27,429
Método aparte, prueba

874
00:35:27,429 --> 00:35:29,989
ArrayList, prueba LinkedList

875
00:35:29,989 --> 00:35:41,429
Vale, prueba mi ArrayList

876
00:35:41,429 --> 00:35:43,070
Metemos el código que hemos hecho

877
00:35:43,070 --> 00:35:43,750
Antes

878
00:35:43,750 --> 00:36:03,769
Ahí, vale

879
00:36:03,769 --> 00:36:04,809
y aquí lo dejamos

880
00:36:04,809 --> 00:36:06,869
comentado

881
00:36:06,869 --> 00:36:09,630
para ver que lo habíamos probado y que funcionaba

882
00:36:09,630 --> 00:36:14,690
vale, y ahora vamos a hacernos

883
00:36:14,690 --> 00:36:16,610
la prueba de esta estructura

884
00:36:16,610 --> 00:36:17,610
a ver si la hemos hecho bien

885
00:36:17,610 --> 00:36:33,869
vale

886
00:36:33,869 --> 00:36:35,769
pues vamos a hacer

887
00:36:35,769 --> 00:36:37,989
lo mismo saltándonos el borrar

888
00:36:37,989 --> 00:36:40,530
lo mismo pero con un linked list

889
00:36:40,530 --> 00:36:42,269
entonces el mismo código

890
00:36:42,269 --> 00:36:43,789
código

891
00:36:43,789 --> 00:36:46,329
copia y pega, el mismito

892
00:36:46,329 --> 00:36:52,420
el mismito código

893
00:36:52,420 --> 00:36:55,119
pero ahora en este mismito código

894
00:36:55,119 --> 00:36:57,400
el mismito para que veamos la plasticidad

895
00:36:57,400 --> 00:36:58,139
de las colecciones

896
00:36:58,139 --> 00:37:00,400
el mismo código, lo que pasa es que ahora

897
00:37:00,400 --> 00:37:02,639
en lugar de una estructura, mi ArrayList

898
00:37:02,639 --> 00:37:05,139
he decidido que cambio y que voy a usar

899
00:37:05,139 --> 00:37:07,480
una LinkedList, pero lo demás es igual

900
00:37:07,480 --> 00:37:09,159
bueno, los nombres de los métodos han cambiado

901
00:37:09,159 --> 00:37:10,159
pero tendrás que crearlo

902
00:37:10,159 --> 00:37:13,059
claro, sí, sí

903
00:37:13,059 --> 00:37:14,199
claro

904
00:37:14,199 --> 00:37:17,340
pero es una caja de nombres igual

905
00:37:17,340 --> 00:37:19,440
pero ahora funciona por dentro de otra manera

906
00:37:19,440 --> 00:37:21,820
vale

907
00:37:21,820 --> 00:37:23,960
mi linked list que la

908
00:37:23,960 --> 00:37:25,880
importamos

909
00:37:25,880 --> 00:37:27,800
y ahora

910
00:37:27,800 --> 00:37:30,139
yo en lugar de add

911
00:37:30,139 --> 00:37:32,199
como lo he llamado add first pues bueno lo cambio

912
00:37:32,199 --> 00:37:32,840
add first

913
00:37:32,840 --> 00:37:35,780
mostramos el primero

914
00:37:35,780 --> 00:37:38,119
mostramos el último remove no lo tenemos

915
00:37:38,119 --> 00:37:40,219
implementado así que no lo

916
00:37:40,219 --> 00:37:42,199
va a eliminar voy a quitarlo de hecho

917
00:37:42,199 --> 00:37:44,119
esta parte de código porque no haría

918
00:37:44,119 --> 00:37:47,559
nada y en lugar

919
00:37:47,559 --> 00:37:49,400
de los que quedan voy a poner los que hay

920
00:37:49,400 --> 00:37:53,219
vale pues he cambiado

921
00:37:53,219 --> 00:37:55,199
la cajita, el que usa esto

922
00:37:55,199 --> 00:37:57,059
le da igual como está hecho por dentro

923
00:37:57,059 --> 00:37:59,559
pero simplemente ha usado

924
00:37:59,559 --> 00:38:00,880
una cajita

925
00:38:00,880 --> 00:38:03,280
¿dónde estamos? aquí, mi linked list

926
00:38:03,280 --> 00:38:05,400
porque a él le interesa una cajita, mi linked list

927
00:38:05,400 --> 00:38:07,719
pues usa esta cajita, va metiendo

928
00:38:07,719 --> 00:38:09,880
va recuperando

929
00:38:09,880 --> 00:38:11,179
y ya está

930
00:38:11,179 --> 00:38:13,500
y ha cambiado una caja

931
00:38:13,500 --> 00:38:13,960
por otra

932
00:38:13,960 --> 00:38:17,480
los detalles internos de la implementación

933
00:38:17,480 --> 00:38:19,420
no importan

934
00:38:19,420 --> 00:38:21,260
pues vamos a ver

935
00:38:21,260 --> 00:38:22,760
si esto lo hemos hecho bien o mal

936
00:38:22,760 --> 00:38:33,030
venga, vamos a probar

937
00:38:33,030 --> 00:38:41,480
A, A, B, B, C, C, D, E

938
00:38:41,480 --> 00:38:51,559
vale, pues he metido los 10 nombres

939
00:38:51,559 --> 00:38:53,539
el primero

940
00:38:53,539 --> 00:38:55,340
JJ

941
00:38:55,340 --> 00:38:57,099
el último AA

942
00:38:57,099 --> 00:38:59,139
a ver, está bien, porque es que

943
00:38:59,139 --> 00:39:00,500
recordad que es un at first

944
00:39:00,500 --> 00:39:01,780
entonces

945
00:39:01,780 --> 00:39:04,500
los va introduciendo

946
00:39:04,500 --> 00:39:06,900
al principio de la lista

947
00:39:06,900 --> 00:39:33,199
Entonces, el BB se cuela por delante de la A, el CC se cuela por delante, el DD se cuela por delante, se están colando por delante, luego cuando el primero me muestra el último que he metido, porque nuestro adverses se están colando, cada uno que metemos se cuela el primero, luego efectivamente está bien, el último que he metido es este, que se ha quedado el primero de la lista, el último de la lista se ha quedado el primero que metí, que es este,

948
00:39:33,199 --> 00:39:35,760
Y cuantos tengo

949
00:39:35,760 --> 00:39:37,179
Pues tengo estos en el orden

950
00:39:37,179 --> 00:39:38,219
Que tienen que aparecer

951
00:39:38,219 --> 00:39:40,139
Cada uno que he metido se ha colado

952
00:39:40,139 --> 00:39:45,989
A ver, esta nuestra no

953
00:39:45,989 --> 00:39:47,050
Porque no hemos

954
00:39:47,050 --> 00:39:48,650
Habilitado eso

955
00:39:48,650 --> 00:39:49,929
En una colección normal sí

956
00:39:49,929 --> 00:39:55,070
No lo sé

957
00:39:55,070 --> 00:39:57,230
Para que con el for each

958
00:39:57,230 --> 00:39:58,969
Conecte con esto, no lo sé

959
00:39:58,969 --> 00:40:01,289
Tendríamos que mirar a ver como está hecho en el link

960
00:40:01,289 --> 00:40:02,949
No lo sé

961
00:40:02,949 --> 00:40:06,670
vale, pues esta es la idea

962
00:40:06,670 --> 00:40:08,610
de las colecciones, hemos hecho unas versiones

963
00:40:08,610 --> 00:40:09,829
muy muy muy reducidas

964
00:40:09,829 --> 00:40:12,530
de la ArrayList y del LinkedList

965
00:40:12,530 --> 00:40:14,369
que la idea de fondo es esta, lo que pasa es que luego

966
00:40:14,369 --> 00:40:16,590
la versión real incluye

967
00:40:16,590 --> 00:40:17,650
muchos más métodos

968
00:40:17,650 --> 00:40:20,969
y no solo incluye muchos más métodos

969
00:40:20,969 --> 00:40:22,670
sino que incluye algo que no todos hemos pasado

970
00:40:22,670 --> 00:40:23,969
por alto, que esto que hemos hecho

971
00:40:23,969 --> 00:40:25,730
solo nos vale para stream

972
00:40:25,730 --> 00:40:28,889
entonces nos tiene que servir para todo, entonces para que se haga por todos los datos

973
00:40:28,889 --> 00:40:30,510
hay que dar el salto a genéricos

974
00:40:30,510 --> 00:40:32,650
que es poner

975
00:40:32,650 --> 00:40:34,570
el, no exactamente

976
00:40:34,570 --> 00:40:36,750
no, eso exactamente

977
00:40:36,750 --> 00:40:38,809
no, pero cuando ves una T por ahí

978
00:40:38,809 --> 00:40:40,750
o una V mayúscula suelta, tiene más

979
00:40:40,750 --> 00:40:42,590
que ver con eso, eso que dices

980
00:40:42,590 --> 00:40:44,010
del obvio es más de los opcional

981
00:40:44,010 --> 00:40:44,969
dime

982
00:40:44,969 --> 00:40:50,409
claro, pero si estamos

983
00:40:50,409 --> 00:40:52,789
metiendo al principio, con lo cual se cuela al principio

984
00:40:52,789 --> 00:40:54,710
claro

985
00:40:54,710 --> 00:40:56,489
vale

986
00:40:56,489 --> 00:40:57,429
vale

987
00:40:57,429 --> 00:41:00,630
vale, pues el próximo día

988
00:41:00,630 --> 00:41:03,070
Vemos las listas reales

989
00:41:03,070 --> 00:41:04,570
Para ver

990
00:41:04,570 --> 00:41:06,869
No, hemos dicho que al final del día de hoy

991
00:41:06,869 --> 00:41:07,909
Que estaríais cansados

992
00:41:07,909 --> 00:41:09,929
Y retomamos lo del ejercicio de ayer

993
00:41:09,929 --> 00:41:11,369
A ver qué es lo que habíais hecho

994
00:41:11,369 --> 00:41:14,389
Antes de qué

995
00:41:14,389 --> 00:41:16,909
De que el mundo acabe y explote

996
00:41:16,909 --> 00:41:18,630
Pues espero que sí

997
00:41:18,630 --> 00:41:28,090
A ver

998
00:41:28,090 --> 00:41:30,489
yo estoy más harta que tú

999
00:41:30,489 --> 00:41:31,989
de estar aquí, seguro

1000
00:41:31,989 --> 00:41:34,309
pero claro, a mí me pagan

1001
00:41:34,309 --> 00:41:35,269
y tengo una responsabilidad

1002
00:41:35,269 --> 00:41:37,949
y la responsabilidad es que vosotros os quedéis aquí

1003
00:41:37,949 --> 00:41:39,869
o sea que aprovechéis las 10 horas que tenéis

1004
00:41:39,869 --> 00:41:41,409
venga

1005
00:41:41,409 --> 00:41:44,190
bueno, pues el próximo día

1006
00:41:44,190 --> 00:41:45,849
entonces ya conectamos con

1007
00:41:45,849 --> 00:41:48,230
lo ampliamos a datos

1008
00:41:48,230 --> 00:41:50,110
genéricos y luego ya vemos

1009
00:41:50,110 --> 00:41:52,110
las versiones reales y como

1010
00:41:52,110 --> 00:41:54,190
se usan, porque ahí ya tenemos que empezar a

1011
00:41:54,190 --> 00:41:56,389
meter cuestiones que no podemos olvidar

1012
00:41:56,389 --> 00:41:59,070
Pues, como el equals, etcétera, ¿vale?

1013
00:42:02,690 --> 00:42:06,070
Venga, pues, ¿cuál era nuestro ejercicio?

1014
00:42:06,309 --> 00:42:06,809
A ver, a ver.

1015
00:42:08,969 --> 00:42:12,369
Sí, pero lo retomamos el próximo día.

1016
00:42:15,579 --> 00:42:17,059
Ejercicio, ¿dónde estaba eso?

1017
00:42:17,159 --> 00:42:18,019
Alumnos, títulos.

1018
00:42:18,179 --> 00:42:19,400
Menudo cuñazo.

1019
00:42:19,579 --> 00:42:20,079
Vamos a ver.

1020
00:42:20,800 --> 00:42:21,880
Lo compó.

1021
00:42:21,880 --> 00:42:26,659
Con todas las letras.

1022
00:42:27,800 --> 00:42:28,079
Vale.

1023
00:42:29,079 --> 00:42:30,639
¿Necesitáis parar dos, tres minutos?