1
00:00:02,480 --> 00:00:04,540
Vale, pues todo el mundo está situado, ¿no?

2
00:00:04,900 --> 00:00:06,660
Nos habíamos hecho esta clase.

3
00:00:07,839 --> 00:00:10,759
Para instanciarla yo ya desde mi main, que era este,

4
00:00:11,820 --> 00:00:15,380
desde mi main voy a instanciar un objeto de esta clase

5
00:00:15,380 --> 00:00:19,800
ya parametrizado para el tipo que yo quiera,

6
00:00:20,120 --> 00:00:23,000
para el tipo que yo quiera en este ejemplo, pues de stream, por ejemplo.

7
00:00:24,640 --> 00:00:26,920
Pero aquí en la clase está todavía genérico.

8
00:00:27,300 --> 00:00:28,260
Vale, parametrizado.

9
00:00:28,260 --> 00:00:49,259
Y cuando yo la instancie, lo único que quiero con este objeto es poder usarlo para meter cadenas, también me gustaría poder usarlo para recorrer las cadenas que he metido, habilitándome un método get que me permita recuperar por posición, habilitándome un método size.

10
00:00:49,259 --> 00:00:49,820
Dime.

11
00:00:55,140 --> 00:00:59,500
Sí, aquí lo puedes poner.

12
00:01:01,079 --> 00:01:03,880
No, no, no, no, no, no, no hace nada negativo.

13
00:01:04,359 --> 00:01:09,489
Vale, pues entonces, este es el uso.

14
00:01:10,069 --> 00:01:11,849
Entonces, ¿qué oculta el uso?

15
00:01:12,390 --> 00:01:15,750
El uso oculta esta complejidad que estábamos programando ayer.

16
00:01:16,170 --> 00:01:16,870
¿Qué oculta?

17
00:01:17,290 --> 00:01:19,870
Pues oculta que cuando uno instancia este objeto

18
00:01:19,870 --> 00:01:23,150
para meter cosas, recuperarlas, etcétera,

19
00:01:23,530 --> 00:01:24,890
cuando uno instancia este objeto,

20
00:01:24,890 --> 00:01:28,709
lo que realmente está instanciando

21
00:01:28,709 --> 00:01:30,810
es la dirección

22
00:01:30,810 --> 00:01:33,549
de un primer nodo

23
00:01:33,549 --> 00:01:35,510
es lo que realmente está instanciando

24
00:01:35,510 --> 00:01:36,790
cuando instancia ese objeto

25
00:01:36,790 --> 00:01:49,030
¿vale?

26
00:01:49,109 --> 00:01:50,510
eso es lo que estamos instanciando

27
00:01:50,510 --> 00:01:51,829
cuando instanciamos este objeto

28
00:01:51,829 --> 00:01:54,290
esto

29
00:01:54,290 --> 00:01:55,250
¿y esto qué es?

30
00:01:56,269 --> 00:01:56,989
esto es

31
00:01:56,989 --> 00:01:59,469
la dirección de un primer nodo

32
00:01:59,469 --> 00:02:00,989
inicialmente

33
00:02:00,989 --> 00:02:02,609
cuando se instancia este objeto

34
00:02:02,609 --> 00:02:03,569
por primera vez

35
00:02:03,569 --> 00:02:06,430
esto es lo que hemos instanciado

36
00:02:06,430 --> 00:02:08,430
la propiedad inicio

37
00:02:08,430 --> 00:02:09,909
que es la dirección de un objeto

38
00:02:09,909 --> 00:02:11,770
nodo P sin inicializar

39
00:02:11,770 --> 00:02:14,169
un objeto sin inicializar apuntando

40
00:02:14,169 --> 00:02:14,870
vale

41
00:02:14,870 --> 00:02:17,750
ahora cuando nosotros

42
00:02:17,750 --> 00:02:20,770
llamamos

43
00:02:20,770 --> 00:02:21,750
al

44
00:02:21,750 --> 00:02:24,610
añadir una nueva cadena

45
00:02:24,610 --> 00:02:25,990
añadir una nueva cadena

46
00:02:25,990 --> 00:02:28,689
esa cadena se va dentro de la lista enlazada

47
00:02:28,689 --> 00:02:30,610
y para el

48
00:02:30,610 --> 00:02:32,430
main y para cualquiera que use ese objeto

49
00:02:32,430 --> 00:02:34,030
la complejidad está ahí escondida

50
00:02:34,030 --> 00:02:36,389
¿qué complejidad está ahí escondida

51
00:02:36,389 --> 00:02:37,750
debajo de este add first?

52
00:02:38,250 --> 00:02:39,849
pues lo que programamos ayer

53
00:02:39,849 --> 00:02:41,889
debajo de este add first

54
00:02:41,889 --> 00:02:42,969
está escondida

55
00:02:42,969 --> 00:02:45,370
esta complejidad de aquí

56
00:02:45,370 --> 00:02:47,710
¿qué es lo que hace?

57
00:02:48,629 --> 00:02:50,650
con el dato que tú quieres meter

58
00:02:50,650 --> 00:02:52,210
en este caso

59
00:02:52,210 --> 00:02:53,990
en el caso de nuestro main con el string

60
00:02:53,990 --> 00:02:56,169
el dato que tú quieres meter, este

61
00:02:56,169 --> 00:02:57,969
hazte un nodo

62
00:02:57,969 --> 00:03:00,389
que tenga ese dato

63
00:03:00,389 --> 00:03:02,409
dentro, hazte un nodo

64
00:03:02,409 --> 00:03:03,509
vale

65
00:03:03,509 --> 00:03:06,590
y con la segunda propiedad de nodo

66
00:03:06,590 --> 00:03:08,150
pues entonces se quedará apuntando a nul

67
00:03:08,150 --> 00:03:09,889
ahora

68
00:03:09,889 --> 00:03:12,210
¿qué haces con este nodo?

69
00:03:12,449 --> 00:03:15,110
hacer que su siguiente

70
00:03:15,110 --> 00:03:16,909
apunte a donde apuntaba

71
00:03:16,909 --> 00:03:18,550
inicio, vale

72
00:03:18,550 --> 00:03:20,650
el inicio original

73
00:03:20,650 --> 00:03:21,389
estaba nul

74
00:03:21,389 --> 00:03:23,069
en este caso

75
00:03:23,069 --> 00:03:28,099
entonces cuando metes el primer elemento en la lista

76
00:03:28,099 --> 00:03:29,120
cuando está todavía vacía

77
00:03:29,120 --> 00:03:32,199
pues con esta sentencia en realidad no estás haciendo nada

78
00:03:32,199 --> 00:03:33,740
porque inicio ya apunta a nul

79
00:03:33,740 --> 00:03:35,680
pues al hacer nodo siguiente

80
00:03:35,680 --> 00:03:37,340
esto es siguiente igual a inicio

81
00:03:37,340 --> 00:03:39,599
le estás volviendo a dar nulo otra vez

82
00:03:39,599 --> 00:03:41,639
y ahora

83
00:03:41,639 --> 00:03:43,199
¿qué haces? a inicio

84
00:03:43,199 --> 00:03:45,479
dale a la dirección inicio

85
00:03:45,479 --> 00:03:46,939
dale la dirección de nodo

86
00:03:46,939 --> 00:03:48,699
luego esto ya sí que lo haces

87
00:03:48,699 --> 00:03:50,259
esto ya

88
00:03:50,259 --> 00:03:53,520
estás borrando esto y a la dirección inicio

89
00:03:53,520 --> 00:03:55,180
dale la del nodo que te has creado

90
00:03:55,180 --> 00:03:57,740
¿vale? esto es la complejidad

91
00:03:57,740 --> 00:03:59,680
que está escondida dentro de este add first

92
00:03:59,680 --> 00:04:01,719
que volvemos a

93
00:04:01,719 --> 00:04:03,699
llamar al add first como hemos

94
00:04:03,699 --> 00:04:04,800
hecho aquí en el main

95
00:04:04,800 --> 00:04:11,870
que volvemos a llamarle para otro más

96
00:04:11,870 --> 00:04:14,110
pues el main le da igual

97
00:04:14,110 --> 00:04:16,089
como está hecho, solo sabe que eso es hola

98
00:04:16,089 --> 00:04:17,910
Dios, esas cadenas están cayendo dentro

99
00:04:17,910 --> 00:04:19,610
sabe que están cayendo dentro

100
00:04:19,610 --> 00:04:22,490
¿cómo? nosotros lo sabemos porque lo hemos programado

101
00:04:22,490 --> 00:04:27,079
¿cómo están cayendo dentro?

102
00:04:27,540 --> 00:04:28,819
pues la situación que teníamos

103
00:04:28,819 --> 00:04:30,660
después del primer adfer será esta

104
00:04:30,660 --> 00:04:32,720
teníamos el inicio

105
00:04:32,720 --> 00:04:34,720
apuntando

106
00:04:34,720 --> 00:04:36,920
al primer nodo dato que hemos metido

107
00:04:36,920 --> 00:04:37,740
el hola

108
00:04:37,740 --> 00:04:40,199
esta es la situación

109
00:04:40,199 --> 00:04:41,959
que se había quedado

110
00:04:41,959 --> 00:04:44,160
después del primer add first, se había quedado esta situación

111
00:04:44,160 --> 00:04:46,160
ahora, hacemos el segundo

112
00:04:46,160 --> 00:04:47,819
add first, ¿vale? pues que

113
00:04:47,819 --> 00:04:50,199
con el adiós, pues que ha hecho

114
00:04:50,199 --> 00:04:52,079
primero, se construye

115
00:04:52,079 --> 00:04:55,810
un nodo, donde el

116
00:04:55,810 --> 00:04:57,829
dato es, la cadena

117
00:04:57,829 --> 00:04:59,829
esa, y el

118
00:04:59,829 --> 00:05:02,250
campo siguiente, sin inicializar

119
00:05:02,250 --> 00:05:03,209
lo que es lo mismo, anul

120
00:05:03,209 --> 00:05:05,050
eso es lo que hacemos con la primera

121
00:05:05,050 --> 00:05:07,769
línea, ¿qué hacemos con

122
00:05:07,769 --> 00:05:08,529
la segunda línea?

123
00:05:09,250 --> 00:05:11,870
que su siguiente, el siguiente de ese nodo

124
00:05:11,870 --> 00:05:14,170
vaya a donde va Inicio.

125
00:05:14,310 --> 00:05:15,050
Inicio va aquí.

126
00:05:15,689 --> 00:05:16,930
Pues este deja de ir a Null

127
00:05:16,930 --> 00:05:19,370
y empieza a ir aquí.

128
00:05:21,009 --> 00:05:21,250
Vale.

129
00:05:21,910 --> 00:05:23,790
A este primero, que era el primero,

130
00:05:23,870 --> 00:05:24,589
le apuntan ya dos.

131
00:05:25,029 --> 00:05:26,329
¿Y ahora qué es lo siguiente que hacemos?

132
00:05:26,810 --> 00:05:29,310
Que Inicio empiece a ir

133
00:05:29,310 --> 00:05:31,470
a donde iba Nodo.

134
00:05:31,910 --> 00:05:33,310
¿Vale? Que es este. Este es Nodo.

135
00:05:33,470 --> 00:05:35,550
Luego Inicio se borra de aquí

136
00:05:35,550 --> 00:05:37,790
y empieza a ir aquí.

137
00:05:38,490 --> 00:05:40,069
¿Vale? Pues efectivamente

138
00:05:40,069 --> 00:05:41,509
ahora mi lista enlazada

139
00:05:41,509 --> 00:05:42,370
tiene dos elementos.

140
00:05:43,569 --> 00:05:44,470
Este primero

141
00:05:44,470 --> 00:05:46,269
y este segundo.

142
00:05:47,050 --> 00:05:48,009
Y así todo el rato.

143
00:05:48,689 --> 00:05:48,889
Dime.

144
00:05:58,790 --> 00:06:00,310
Perdón, hacer un...

145
00:06:00,310 --> 00:06:04,430
A ver, es que

146
00:06:04,430 --> 00:06:06,149
no hace falta

147
00:06:06,149 --> 00:06:07,709
meter tanta complejidad

148
00:06:07,709 --> 00:06:08,069
porque

149
00:06:08,069 --> 00:06:09,769
ahora no estamos hablando

150
00:06:09,769 --> 00:06:10,930
de entidades de un modelo.

151
00:06:11,509 --> 00:06:13,689
de una aplicación que tiene cliente, factura.

152
00:06:14,529 --> 00:06:16,029
Nodo, en realidad, es una clase

153
00:06:16,029 --> 00:06:19,490
que su único uso va a ir asociado a mi LinkedIn List,

154
00:06:19,550 --> 00:06:20,269
que es esta clase.

155
00:06:21,110 --> 00:06:23,089
Entonces, esto no es una entidad modelo, en realidad,

156
00:06:23,230 --> 00:06:26,350
que represente una entidad con la que trabaja mi aplicación.

157
00:06:26,490 --> 00:06:27,329
Esta está oculta.

158
00:06:27,870 --> 00:06:28,990
Esta la aplicación no la ve.

159
00:06:29,470 --> 00:06:32,709
Esta sirve solo para que la use esta otra.

160
00:06:33,149 --> 00:06:34,149
Van las dos como en pack.

161
00:06:34,149 --> 00:06:35,649
Van las dos siempre juntas.

162
00:06:36,709 --> 00:06:40,170
Entonces, el único uso de nodo va a ser desde esta.

163
00:06:40,350 --> 00:06:41,230
Solo desde esta.

164
00:06:41,509 --> 00:06:43,449
entonces ponerle get y set

165
00:06:43,449 --> 00:06:45,449
solo lo va a usar esta, va a ir en pack

166
00:06:45,449 --> 00:06:47,290
pues bueno, podríamos

167
00:06:47,290 --> 00:06:48,990
pero pierde un poco su sentido

168
00:06:48,990 --> 00:06:51,649
es más cómodo, escribamos directamente

169
00:06:51,649 --> 00:06:52,569
la propiedad y ya está

170
00:06:52,569 --> 00:06:54,990
lo de los get y los set son para entidades

171
00:06:54,990 --> 00:06:57,649
de modelo, genéricas, que tú ofreces

172
00:06:57,649 --> 00:06:59,670
yo expongo un modelo, expongo mi modelo

173
00:06:59,670 --> 00:07:01,889
de lógica de negocio, de facturas de clientes

174
00:07:01,889 --> 00:07:03,829
y ahora yo expongo mi modelo

175
00:07:03,829 --> 00:07:05,310
que va a ser

176
00:07:05,310 --> 00:07:09,250
accedido

177
00:07:09,250 --> 00:07:11,490
desde mis sitios, desde un framework

178
00:07:11,490 --> 00:07:13,470
de no sé qué, desde mis propias clases de mi mail

179
00:07:13,470 --> 00:07:15,449
pues ahí expongo mi modelo con mis

180
00:07:15,449 --> 00:07:16,970
get me set porque me ofrezco al mundo

181
00:07:16,970 --> 00:07:19,069
y mi forma de ofrecerme al mundo

182
00:07:19,069 --> 00:07:21,230
es con get me set, porque es la que tenemos

183
00:07:21,230 --> 00:07:23,610
todos por convenio

184
00:07:23,610 --> 00:07:26,050
que nos ofrecemos a los desconocidos

185
00:07:26,050 --> 00:07:27,730
con get me set, pero nodo

186
00:07:27,730 --> 00:07:29,149
no se ofrece a los desconocidos

187
00:07:29,149 --> 00:07:31,649
nodo está pensada solo

188
00:07:31,649 --> 00:07:33,990
solo para que la use

189
00:07:33,990 --> 00:07:36,050
mi linked list, es el único

190
00:07:36,050 --> 00:07:38,170
sentido de nodo, para que la use

191
00:07:38,170 --> 00:07:40,430
la otra clase, Nodo está oculta, nadie la va a usar

192
00:07:40,430 --> 00:07:40,829
¿vale?

193
00:07:41,310 --> 00:07:43,910
de hecho, Nodo

194
00:07:43,910 --> 00:07:45,329
es que no debería ser

195
00:07:45,329 --> 00:07:47,189
ni pública

196
00:07:47,189 --> 00:07:50,779
¿vale?

197
00:07:52,860 --> 00:07:54,459
Nodo no debería ser ni pública

198
00:07:54,459 --> 00:07:56,360
porque solo la va a usar mi linked list

199
00:07:56,360 --> 00:07:57,899
que en principio van a estar en mi baquete

200
00:07:57,899 --> 00:07:59,500
¿vale?

201
00:08:00,839 --> 00:08:02,579
entonces esta no tiene que ofrecerse

202
00:08:02,579 --> 00:08:03,300
al mundo

203
00:08:03,300 --> 00:08:09,959
¿vale? pues entonces

204
00:08:09,959 --> 00:08:13,980
ahora ya

205
00:08:13,980 --> 00:08:17,160
añadir a la lista, añadir al principio

206
00:08:17,160 --> 00:08:18,259
ya lo sabemos, pero claro

207
00:08:18,259 --> 00:08:20,680
hicimos en el main, probamos esto

208
00:08:20,680 --> 00:08:22,519
y vimos que efectivamente esto se ejecutaba

209
00:08:22,519 --> 00:08:23,959
y no daba error

210
00:08:23,959 --> 00:08:25,860
no daba error, pero hombre

211
00:08:25,860 --> 00:08:28,240
para ver si le hemos hecho bien nuestra lista

212
00:08:28,240 --> 00:08:30,319
que menos que añadir un get

213
00:08:30,319 --> 00:08:31,319
y un size

214
00:08:31,319 --> 00:08:34,559
para poder recorrerla y ver lo que tiene

215
00:08:34,559 --> 00:08:36,679
dentro, y hacer una lista

216
00:08:36,679 --> 00:08:37,639
mínimamente operativa

217
00:08:37,639 --> 00:08:40,299
bueno, pues vamos a

218
00:08:40,299 --> 00:08:42,039
hacer el método get

219
00:08:42,039 --> 00:08:43,240
con el método get

220
00:08:43,240 --> 00:08:46,279
ya vamos a ver el proceso de avanzar

221
00:08:46,279 --> 00:08:48,100
por la lista y con el proceso de avanzar

222
00:08:48,100 --> 00:08:50,039
uno ya puede hacer remove y lo que dé la gana

223
00:08:50,039 --> 00:08:51,559
vale

224
00:08:51,559 --> 00:08:54,259
pues como sería el método get

225
00:08:54,259 --> 00:08:55,360
pues el método get

226
00:08:55,360 --> 00:08:58,320
sería un método

227
00:08:58,320 --> 00:09:00,259
de mi linked list

228
00:09:00,259 --> 00:09:01,720
que esta si que tendría que ser pública

229
00:09:01,720 --> 00:09:03,419
porque esta si que la puede usar cualquiera

230
00:09:03,419 --> 00:09:06,500
esta clase la usa cualquiera para instanciarla

231
00:09:06,500 --> 00:09:09,759
vale pues

232
00:09:09,759 --> 00:09:11,919
esta el método get me tiene que devolver

233
00:09:11,919 --> 00:09:13,000
un objeto de tipo T

234
00:09:13,000 --> 00:09:15,779
get a partir

235
00:09:15,779 --> 00:09:17,399
de una posición

236
00:09:17,399 --> 00:09:27,360
vale, pues aquí

237
00:09:27,360 --> 00:09:28,559
la

238
00:09:28,559 --> 00:09:31,379
sentencia

239
00:09:31,379 --> 00:09:33,779
de avance

240
00:09:33,779 --> 00:09:48,389
vale, pues aquí

241
00:09:48,389 --> 00:09:49,809
tenemos nuestra listita

242
00:09:49,809 --> 00:10:00,059
con un dato

243
00:10:00,059 --> 00:10:02,100
y siguiente

244
00:10:02,100 --> 00:10:06,750
siguiente me lleva a otro objeto nodo

245
00:10:06,750 --> 00:10:08,450
con el siguiente dato

246
00:10:08,450 --> 00:10:09,309
de la lista

247
00:10:09,309 --> 00:10:12,509
y siguiente

248
00:10:12,509 --> 00:10:14,830
siguiente

249
00:10:14,830 --> 00:10:16,529
me lleva

250
00:10:16,529 --> 00:10:18,850
a

251
00:10:18,850 --> 00:10:21,090
otro objeto

252
00:10:21,090 --> 00:10:22,289
nodo y ya el último

253
00:10:22,289 --> 00:10:27,940
con otro objeto de la lista y siguiente

254
00:10:27,940 --> 00:10:29,500
que este ya nodo

255
00:10:29,500 --> 00:10:31,320
el inicio es otro nodo

256
00:10:31,320 --> 00:10:32,519
como cualquier otro

257
00:10:32,519 --> 00:10:35,600
si el inicio es un objeto nodo igual que

258
00:10:35,600 --> 00:10:37,759
siguiente es un objeto nodo es que la dirección

259
00:10:37,759 --> 00:10:39,679
y el objeto a la hora de escribirlo en java es lo mismo

260
00:10:39,679 --> 00:10:41,740
es decir de hecho inicio

261
00:10:41,740 --> 00:10:42,580
está declarado

262
00:10:42,580 --> 00:10:45,820
Inicio

263
00:10:45,820 --> 00:10:46,840
está declarado

264
00:10:46,840 --> 00:10:47,980
como

265
00:10:47,980 --> 00:10:55,190
¿Ves?

266
00:10:55,950 --> 00:10:56,690
¿Dónde está Inicio?

267
00:10:57,409 --> 00:10:58,470
Aquí, ¿ves?

268
00:10:59,789 --> 00:11:02,269
Inicio está declarado como nodo, porque es la dirección

269
00:11:02,269 --> 00:11:03,149
de un nodo.

270
00:11:03,470 --> 00:11:06,169
Inicio está declarado como nodo.

271
00:11:06,169 --> 00:11:06,529
Vale.

272
00:11:08,549 --> 00:11:09,710
A lo que íbamos.

273
00:11:10,889 --> 00:11:12,250
Vale. Y esto

274
00:11:12,250 --> 00:11:14,049
también está declarado como nodo,

275
00:11:14,049 --> 00:11:15,230
porque es la dirección de un nodo.

276
00:11:15,230 --> 00:11:17,370
Luego el campo siguiente de nodo...

277
00:11:17,370 --> 00:11:18,169
¿Cómo lo pone distinto?

278
00:11:19,289 --> 00:11:20,509
¿Cómo lo pone distinto?

279
00:11:23,070 --> 00:11:26,070
Bueno, porque cuando representamos un objeto siempre lo hemos representado así.

280
00:11:27,210 --> 00:11:30,610
Esto y el objeto con sus propiedades, siempre lo hemos representado así.

281
00:11:31,350 --> 00:11:34,009
Entonces, este imagínate que es el objeto alumno.

282
00:11:34,809 --> 00:11:35,470
Alumno A.

283
00:11:37,669 --> 00:11:38,309
Alumno A.

284
00:11:38,950 --> 00:11:40,509
Pues, ¿qué es A realmente?

285
00:11:40,509 --> 00:12:03,669
A realmente es el espacio en memoria que contiene la dirección donde están los datos del alumno, ¿vale? Los datos del alumno, ¿vale? Es decir, A no es esto en realidad. A es el espacio en memoria que tiene la dirección que tiene ya sí que sí los datos, pero el objeto está en otra dirección de memoria, ¿vale?

286
00:12:03,669 --> 00:12:37,809
Vale, pues entonces, vale, pues a ver, recuperar por posición. Esta es la parte complicada de la lista. Que yo tengo acceso solamente al primer dato, ¿vale? Yo puedo hacer, uy, puedo hacer inicio.dato e inicio.dato es el primero.

287
00:12:37,809 --> 00:12:59,490
Pero el siguiente, ¿cuál sería? Pues sería inicio, punto, siguiente, punto, dato. Este sería este. Pero este, ¿cuál sería? Pues este sería inicio, punto, siguiente, punto, siguiente, punto, dato.

288
00:12:59,490 --> 00:13:01,370
luego

289
00:13:01,370 --> 00:13:03,429
¿qué tengo que hacer para avanzar

290
00:13:03,429 --> 00:13:05,429
por la lista? ir encadenando

291
00:13:05,429 --> 00:13:07,409
llamadas a siguiente todo el rato

292
00:13:07,409 --> 00:13:09,549
no es tan sencillo

293
00:13:09,549 --> 00:13:10,809
es decir, tengo que hacer un bucle

294
00:13:10,809 --> 00:13:13,669
¿vale? ya preveo que tengo que hacer un bucle

295
00:13:13,669 --> 00:13:15,870
que está avanzando

296
00:13:15,870 --> 00:13:16,750
todo el rato

297
00:13:16,750 --> 00:13:18,509
¿vale? pues ¿cómo hacemos esto?

298
00:13:19,250 --> 00:13:20,210
vamos a hacernos

299
00:13:20,210 --> 00:13:22,769
un objetito auxiliar aquí

300
00:13:22,769 --> 00:13:25,330
que inicialmente apunte

301
00:13:25,330 --> 00:13:26,370
donde apuntaba inicio

302
00:13:26,370 --> 00:13:28,370
y yo lo voy avanzando

303
00:13:28,370 --> 00:13:30,409
lo voy avanzando

304
00:13:30,409 --> 00:13:32,649
y me paro donde me quiera parar

305
00:13:32,649 --> 00:13:35,070
no debería poner al inicio también

306
00:13:35,070 --> 00:13:35,830
¿eh?

307
00:13:36,129 --> 00:13:37,350
al inicio no debería apuntar también

308
00:13:37,350 --> 00:13:41,049
es que inicio no es un objeto, al inicio no le apunta a nadie

309
00:13:41,049 --> 00:13:42,750
inicio es apuntador

310
00:13:42,750 --> 00:13:44,730
al inicio nadie le apunta

311
00:13:44,730 --> 00:13:47,230
inicio es el que apunta a este objeto

312
00:13:47,230 --> 00:13:48,450
pero inicio también puede tener datos

313
00:13:48,450 --> 00:13:50,590
no, inicio tiene una dirección de memoria

314
00:13:50,590 --> 00:13:52,610
apunto pelota, no tiene más

315
00:13:52,610 --> 00:13:54,710
inicio tiene una dirección de memoria

316
00:13:54,710 --> 00:13:56,750
que es la dirección de memoria donde está

317
00:13:56,750 --> 00:13:58,730
el dato y a su vez

318
00:13:58,730 --> 00:13:59,909
otra dirección de memoria

319
00:13:59,909 --> 00:14:02,490
donde está el dato y a su vez

320
00:14:02,490 --> 00:14:03,629
otra dirección de memoria

321
00:14:03,629 --> 00:14:08,129
claro, por eso significa

322
00:14:08,129 --> 00:14:10,450
soy la dirección de un nodo

323
00:14:10,450 --> 00:14:11,929
cuando tú haces

324
00:14:11,929 --> 00:14:15,620
alumno a

325
00:14:15,620 --> 00:14:18,379
estás diciendo

326
00:14:18,379 --> 00:14:20,080
yo a soy

327
00:14:20,080 --> 00:14:22,419
la dirección de un alumno

328
00:14:22,419 --> 00:14:23,919
y cuando tú haces

329
00:14:23,919 --> 00:14:25,139
a punto nombre

330
00:14:25,139 --> 00:14:27,080
estás diciendo

331
00:14:27,080 --> 00:14:29,559
el espacio nombre que está

332
00:14:29,559 --> 00:14:31,100
en el cacho de memoria

333
00:14:31,100 --> 00:14:32,700
a dónde llego

334
00:14:32,700 --> 00:14:35,360
desde la dirección A, no dentro de A

335
00:14:35,360 --> 00:14:37,179
sino a dónde llego

336
00:14:37,179 --> 00:14:38,139
desde la dirección A

337
00:14:38,139 --> 00:14:40,840
entonces cuando dices inicio

338
00:14:40,840 --> 00:14:42,419
punto dato

339
00:14:42,419 --> 00:14:44,000
estás diciendo

340
00:14:44,000 --> 00:14:46,460
el cacho dato

341
00:14:46,460 --> 00:14:49,480
que llego desde la dirección

342
00:14:49,480 --> 00:14:51,120
de memoria que tengo yo

343
00:14:51,120 --> 00:14:51,860
metida dentro

344
00:14:51,860 --> 00:14:55,019
no dato es lo que

345
00:14:55,019 --> 00:14:56,799
tengo yo metido dentro, no

346
00:14:56,799 --> 00:14:59,120
porque inicio no tiene nada metido dentro, es una dirección

347
00:14:59,120 --> 00:15:00,759
inicio es una dirección

348
00:15:00,759 --> 00:15:02,799
que te lleva a un sitio

349
00:15:02,799 --> 00:15:04,799
el punto sería como decir

350
00:15:04,799 --> 00:15:05,940
navega hasta allí

351
00:15:05,940 --> 00:15:09,000
el punto no significa métete dentro de inicio

352
00:15:09,000 --> 00:15:10,679
y coge el dato, lo que pasa es que

353
00:15:10,679 --> 00:15:12,340
como programamos así normalmente

354
00:15:12,340 --> 00:15:14,440
pues ya como que tenemos interiorizado

355
00:15:14,440 --> 00:15:17,059
pero inicio sería, estaría mejor

356
00:15:17,059 --> 00:15:18,899
expresado si Java hubiera

357
00:15:18,899 --> 00:15:20,000
decidido hacerlo así

358
00:15:20,000 --> 00:15:23,039
significa, coge la dirección inicio

359
00:15:23,039 --> 00:15:24,960
navega a través de ella

360
00:15:24,960 --> 00:15:27,039
donde te lleve y a donde

361
00:15:27,039 --> 00:15:28,879
te ha llevado, coge datos

362
00:15:28,879 --> 00:15:31,379
¿vale? estaría mejor expresado así

363
00:15:31,379 --> 00:15:32,799
que en los tiempos de C

364
00:15:32,799 --> 00:15:35,379
se usaba más ese operador

365
00:15:35,379 --> 00:15:40,980
¿vale? no es fácil esto de entender

366
00:15:40,980 --> 00:15:42,779
la diferencia entre objeto

367
00:15:42,779 --> 00:15:45,480
espacio y memoria, referencia

368
00:15:45,480 --> 00:15:46,240
y espacio y memoria

369
00:15:46,240 --> 00:15:47,519
pero bueno, más o menos

370
00:15:47,519 --> 00:15:51,019
a fuerza de que nos veamos

371
00:15:51,019 --> 00:15:52,100
con situaciones similares

372
00:15:52,100 --> 00:15:53,259
pues lo entendemos

373
00:15:53,259 --> 00:15:54,620
bueno, pues entonces

374
00:15:54,620 --> 00:15:57,059
esta variable auxiliar

375
00:15:57,059 --> 00:15:59,159
yo la inicializaría

376
00:15:59,159 --> 00:16:00,840
con lo que tenga inicio

377
00:16:00,840 --> 00:16:04,240
y ahora esta variable auxiliar

378
00:16:04,240 --> 00:16:05,299
ya me va a permitir

379
00:16:05,299 --> 00:16:08,179
consultar todos los

380
00:16:08,179 --> 00:16:08,980
valores

381
00:16:08,980 --> 00:16:11,179
por ejemplo

382
00:16:11,179 --> 00:16:13,720
esto me permite ser

383
00:16:13,720 --> 00:16:15,860
cóncavo, es alucinante

384
00:16:15,860 --> 00:16:17,899
a ver si yo

385
00:16:17,899 --> 00:16:23,919
si yo hago

386
00:16:23,919 --> 00:16:32,200
esto, no me deja

387
00:16:32,200 --> 00:16:34,179
una figura

388
00:16:34,179 --> 00:16:36,399
cóncavo, vale

389
00:16:36,399 --> 00:16:39,940
bueno, pues entonces yo aux

390
00:16:39,940 --> 00:16:42,759
la inicializo a inicio

391
00:16:42,759 --> 00:16:44,299
con lo cual se queda aquí apuntando

392
00:16:44,299 --> 00:16:46,600
ahora, ya podría consultar

393
00:16:46,600 --> 00:16:47,820
el dato de la primera posición

394
00:16:47,820 --> 00:16:49,759
el de la primera posición está claro

395
00:16:49,759 --> 00:16:52,200
sería aux.data

396
00:16:52,200 --> 00:16:53,679
ese sería el de la primera

397
00:16:53,679 --> 00:16:57,080
pero claro, para consultar el de la segunda

398
00:16:57,080 --> 00:16:59,019
tengo que mover aux

399
00:16:59,019 --> 00:17:01,740
para que apunte aquí

400
00:17:01,740 --> 00:17:04,200
¿qué sentencia se os ocurre

401
00:17:04,200 --> 00:17:06,039
que tengo yo que escribir?

402
00:17:06,400 --> 00:17:09,099
para que aux deje de apuntar a este objeto

403
00:17:09,099 --> 00:17:10,660
y empiece a apuntar a este otro.

404
00:17:15,380 --> 00:17:15,859
Díctamela.

405
00:17:16,859 --> 00:17:19,740
¿Qué sentencia tengo que poner yo ahí para que aux?

406
00:17:22,319 --> 00:17:24,180
¿Qué le tengo yo que asignar a aux

407
00:17:24,180 --> 00:17:25,599
para que aux salte de aquí

408
00:17:25,599 --> 00:17:27,680
y empiece a apuntar aquí?

409
00:17:31,140 --> 00:17:32,859
No, es aux la que quiero cambiar,

410
00:17:33,000 --> 00:17:34,299
con lo cual la asignación es hacia aux.

411
00:17:34,299 --> 00:17:36,200
¿Aux igual a?

412
00:17:37,779 --> 00:17:40,019
Bueno, me estás llevando hasta aquí

413
00:17:40,019 --> 00:17:40,339
Entonces

414
00:17:40,339 --> 00:17:43,799
Inicio punto siguiente me lleva aquí

415
00:17:43,799 --> 00:17:45,839
Sí

416
00:17:45,839 --> 00:17:46,839
Inicio es esta

417
00:17:46,839 --> 00:17:48,420
Inicio punto siguiente es esta

418
00:17:48,420 --> 00:17:53,440
Vale, a ver, con lo que me habéis dicho

419
00:17:53,440 --> 00:17:55,359
Inicio punto siguiente

420
00:17:55,359 --> 00:17:57,859
Efectivamente

421
00:17:57,859 --> 00:17:59,599
He cambiado aux

422
00:17:59,599 --> 00:18:00,420
Y ahora aux

423
00:18:00,420 --> 00:18:02,619
Ha pasado a apuntar aquí

424
00:18:02,619 --> 00:18:04,240
¿Vale?

425
00:18:04,539 --> 00:18:07,519
Lo que pasa es que si ahora quiero que me llevéis a la tercera

426
00:18:07,519 --> 00:18:09,980
Pues tenéis que hacer inicio, punto y tiempo

427
00:18:09,980 --> 00:18:10,980
O sea, es más fácil

428
00:18:10,980 --> 00:18:12,680
Más compacta

429
00:18:12,680 --> 00:18:14,240
O sea, si ahora quiero que me lleves a la tercera

430
00:18:14,240 --> 00:18:15,940
Tendría que hacer esto

431
00:18:15,940 --> 00:18:19,759
Inicio, punto siguiente, punto siguiente

432
00:18:19,759 --> 00:18:21,259
¿Qué quiero decir?

433
00:18:21,400 --> 00:18:23,599
No es la misma sentencia idéntica

434
00:18:23,599 --> 00:18:24,819
No puedo meterla en un bucle

435
00:18:24,819 --> 00:18:27,200
Yo quiero una que pueda meter en un bucle

436
00:18:27,200 --> 00:18:29,460
Para repetirla tantas veces

437
00:18:29,460 --> 00:18:30,240
Como haga falta

438
00:18:30,240 --> 00:18:33,779
Porque esta no la puedo meter en un bucle

439
00:18:33,779 --> 00:18:35,299
¿Aux igual a?

440
00:18:36,779 --> 00:18:38,140
Pues inicio

441
00:18:38,140 --> 00:18:45,950
Ya está

442
00:18:45,950 --> 00:18:47,390
Ya está

443
00:18:47,390 --> 00:18:48,829
Ya la he avanzado

444
00:18:48,829 --> 00:18:51,589
Aux.siguiente es esta

445
00:18:51,589 --> 00:18:53,269
Lo haces a Aux, saltó

446
00:18:53,269 --> 00:18:56,549
Ahora Aux está aquí, vamos a volver a ejecutarla

447
00:18:56,549 --> 00:18:58,190
Aux.siguiente es esta

448
00:18:58,190 --> 00:18:59,289
Pues saltó

449
00:18:59,289 --> 00:19:02,250
Ahora quiero avanzarla otra vez

450
00:19:02,250 --> 00:19:04,410
Aux.siguiente es esta

451
00:19:04,410 --> 00:19:05,450
Pues saltó

452
00:19:05,450 --> 00:19:08,410
Es decir, cada vez que hagamos esta sentencia

453
00:19:09,009 --> 00:19:10,450
Aux

454
00:19:10,450 --> 00:19:12,390
da un salto y pasa a apuntar

455
00:19:12,390 --> 00:19:13,210
de un nodo al siguiente.

456
00:19:14,250 --> 00:19:16,470
¿Verdad? Cada vez que ejecutemos

457
00:19:16,470 --> 00:19:18,369
esto, AUX, pum, da un salto al siguiente

458
00:19:18,369 --> 00:19:20,430
nodo, pum, da un salto al siguiente, da un salto al siguiente.

459
00:19:20,990 --> 00:19:22,210
Cada vez que hagamos esa sentencia.

460
00:19:23,990 --> 00:19:24,349
Luego,

461
00:19:24,829 --> 00:19:26,230
yo ya meto esa sentencia

462
00:19:26,230 --> 00:19:28,210
en un bucle y puedo avanzar

463
00:19:28,210 --> 00:19:30,309
las veces que me dé la gana. Puedo avanzar

464
00:19:30,309 --> 00:19:31,049
las veces que quiera.

465
00:19:34,369 --> 00:19:36,289
Depende de lo que quiera hacer, si quiero recorrer hasta el final

466
00:19:36,289 --> 00:19:38,250
o si quiero quedarme en una posición como en el caso del

467
00:19:38,250 --> 00:19:40,309
GET. En el caso del GET, pues hasta

468
00:19:40,309 --> 00:19:42,269
un contador, ¿vale?

469
00:19:42,289 --> 00:19:44,349
Un contador y avanzo tantas veces como me diga

470
00:19:44,349 --> 00:19:46,309
en posición, que sería el caso

471
00:19:46,309 --> 00:19:51,259
del get de aquí, ¿vale?

472
00:19:53,279 --> 00:19:55,720
Entonces, ahora ya entendiendo esta sentencia,

473
00:19:56,440 --> 00:19:57,539
vamos a meterla en el

474
00:19:57,539 --> 00:19:59,660
en el get nuestro.

475
00:20:12,339 --> 00:20:14,359
No, desde el gol del dato, porque

476
00:20:14,359 --> 00:20:16,619
desde fuera tú los nodos ni los conoces

477
00:20:16,619 --> 00:20:18,440
ni quieres saber nada de ellos, tú trabajas con datos.

478
00:20:19,220 --> 00:20:20,440
De hecho, nuestro get

479
00:20:20,440 --> 00:20:23,200
Yo lo he hecho para que te devuelva un P

480
00:20:23,200 --> 00:20:29,900
Claro, en cada nodo solo hay un dato

481
00:20:29,900 --> 00:20:31,900
El dato nuevo implica

482
00:20:31,900 --> 00:20:32,779
Nodo nuevo

483
00:20:32,779 --> 00:20:34,700
Enlazado al anterior

484
00:20:34,700 --> 00:20:37,019
Vale, pues entonces getPosición

485
00:20:37,019 --> 00:20:40,460
Pues vamos a hacernos este nodo aus

486
00:20:40,460 --> 00:20:51,210
No

487
00:20:51,210 --> 00:20:53,829
Pero para que quieres meterlo dentro de un nodo

488
00:20:53,829 --> 00:21:04,240
No, es que para eso ya tenemos

489
00:21:04,240 --> 00:21:04,839
el ArrayList

490
00:21:04,839 --> 00:21:06,200
Claro

491
00:21:06,200 --> 00:21:09,859
Para eso ya tenemos el ArrayList, esto está pensado

492
00:21:09,859 --> 00:21:12,440
para que cada dato sea un nodo enlazado con su siguiente

493
00:21:12,440 --> 00:21:19,059
Es que me da igual, el tipo T

494
00:21:19,059 --> 00:21:21,319
ya será lo que sea, tú luego ahí

495
00:21:21,319 --> 00:21:23,319
yo metí un string, pero podía meter

496
00:21:23,319 --> 00:21:25,519
un objeto alumno que tuviera

497
00:21:25,519 --> 00:21:27,380
mil cosas dentro, eso ya es otro tema

498
00:21:27,380 --> 00:21:28,900
da igual, lo que tenga dato

499
00:21:28,900 --> 00:21:31,140
eso da igual, eso ya estará metido ahí

500
00:21:31,140 --> 00:21:33,359
en el campo dato, que a su vez puede tener

501
00:21:33,359 --> 00:21:35,099
un montón de campos, pero eso ya

502
00:21:35,099 --> 00:21:36,900
a esta estructura le da igual

503
00:21:36,900 --> 00:21:37,960
¿vale?

504
00:21:46,769 --> 00:21:48,490
pues como lo estamos haciendo ahora

505
00:21:48,490 --> 00:21:50,670
estamos habilitando métodos

506
00:21:50,670 --> 00:21:52,190
para poder acceder a esa información

507
00:21:52,190 --> 00:21:54,490
ya hemos hecho el método de añadir

508
00:21:54,490 --> 00:21:56,529
vamos a hacer el de recuperar un nodo

509
00:21:56,529 --> 00:21:58,230
por una posición, vale, vamos a

510
00:21:58,230 --> 00:22:00,130
programar lo que hemos escrito antes.

511
00:22:00,250 --> 00:22:02,630
Mi nodo auxiliar, que inicialmente

512
00:22:02,630 --> 00:22:04,390
está a inicio. Y ahora

513
00:22:04,390 --> 00:22:05,990
vamos a avanzarlo

514
00:22:05,990 --> 00:22:08,210
tantas veces como

515
00:22:08,210 --> 00:22:09,309
posición me ha dicho.

516
00:22:11,970 --> 00:22:12,190
¿Vale?

517
00:22:14,130 --> 00:22:16,089
Este bucle ya sabemos que se ejecuta

518
00:22:16,089 --> 00:22:17,950
posición veces, que es las veces que yo

519
00:22:17,950 --> 00:22:18,710
quiero avanzar.

520
00:22:19,529 --> 00:22:21,490
Si me han dado cero, no quiero avanzar ninguna.

521
00:22:21,490 --> 00:22:23,329
Entonces devuelvo el propio aux

522
00:22:23,329 --> 00:22:24,430
que está apuntando a inicio.

523
00:22:25,930 --> 00:22:27,289
¿Vale? Pues aux igual

524
00:22:27,289 --> 00:22:29,309
a aux punto siguiente.

525
00:22:29,670 --> 00:22:33,609
Con este bucle de aquí

526
00:22:33,609 --> 00:22:37,150
Estamos haciendo esa operación

527
00:22:37,150 --> 00:22:39,089
De coger el aux y hacerle saltar

528
00:22:39,089 --> 00:22:40,930
Una, otra, otra

529
00:22:40,930 --> 00:22:42,990
¿Cuántas veces va a saltar?

530
00:22:43,529 --> 00:22:44,869
Tantas como me diga el for

531
00:22:44,869 --> 00:22:46,309
Que es lo que yo le he dicho

532
00:22:46,309 --> 00:22:48,970
Si le digo devuélveme la posición 3

533
00:22:48,970 --> 00:22:50,730
Me salta 3 veces

534
00:22:50,730 --> 00:22:52,829
La primera me apunta a 0

535
00:22:52,829 --> 00:22:53,390
1, 2

536
00:22:53,390 --> 00:22:56,579
Entonces

537
00:22:56,579 --> 00:23:00,839
Una vez que ya he avanzado

538
00:23:00,839 --> 00:23:02,299
Tantas veces como hacía falta

539
00:23:02,299 --> 00:23:03,880
el dato a devolver

540
00:23:03,880 --> 00:23:06,799
ya sé dónde está, en aux.dato

541
00:23:06,799 --> 00:23:09,119
pues ese es el que tengo que devolver

542
00:23:09,119 --> 00:23:12,680
¿vale? una vez, después de haber acabado

543
00:23:12,680 --> 00:23:14,819
este for, ya habiendo avanzado

544
00:23:14,819 --> 00:23:17,240
todo lo que tengo que avanzar

545
00:23:17,240 --> 00:23:18,859
ya está

546
00:23:18,859 --> 00:23:23,170
ya puedo devolver

547
00:23:23,170 --> 00:23:24,289
el dato

548
00:23:24,289 --> 00:23:29,640
¿vale? aquí, para no dejarlo tan feo

549
00:23:29,640 --> 00:23:30,579
convendría hacer

550
00:23:30,579 --> 00:23:35,599
bueno, una validación

551
00:23:35,599 --> 00:23:37,619
¿vale? y ya la

552
00:23:37,619 --> 00:23:39,240
bueno, antes de

553
00:23:39,240 --> 00:23:41,279
qué posición me la han dado

554
00:23:41,279 --> 00:23:43,920
comprendida en el número

555
00:23:43,920 --> 00:23:44,799
de nodos que tiene

556
00:23:44,799 --> 00:23:47,400
pero bueno, espera, antes de hacerla

557
00:23:47,400 --> 00:23:48,119
porque vamos a editar

558
00:23:48,119 --> 00:23:51,500
yo ahora voy a usarla desde aquí

559
00:23:51,500 --> 00:23:54,000
esto todavía

560
00:23:54,000 --> 00:23:55,940
no porque el método 6 no lo tengo hecho

561
00:23:55,940 --> 00:23:57,880
por ejemplo, vamos a ver si funciona

562
00:23:57,880 --> 00:24:00,339
vamos a mostrar la cadena

563
00:24:00,339 --> 00:24:03,119
de posición 0

564
00:24:03,119 --> 00:24:05,380
a ver cuál me sale

565
00:24:05,380 --> 00:24:07,180
y luego vamos a mostrar

566
00:24:07,180 --> 00:24:09,619
la cadena que está en la posición 1

567
00:24:09,619 --> 00:24:18,720
vamos a ver si

568
00:24:18,720 --> 00:24:21,819
si esto me funciona

569
00:24:21,819 --> 00:24:29,440
perfecto

570
00:24:29,440 --> 00:24:33,930
en la posición 0

571
00:24:33,930 --> 00:24:35,349
está la cadena a Dios

572
00:24:35,349 --> 00:24:37,890
porque recordad que cada lo está colando

573
00:24:37,890 --> 00:24:39,789
al principio

574
00:24:39,789 --> 00:24:42,150
en la primera posición está a Dios

575
00:24:42,150 --> 00:24:46,809
y en la siguiente está a Ola

576
00:24:46,809 --> 00:24:48,650
y si yo metiera otra

577
00:24:48,650 --> 00:24:57,359
pues esta estaría

578
00:24:57,359 --> 00:24:59,039
ahora ya esto cambiaría

579
00:24:59,039 --> 00:25:01,579
voy a mostrar las tres que tengo

580
00:25:01,579 --> 00:25:12,039
ah, es que he puesto tres en vez de dos

581
00:25:12,039 --> 00:25:13,259
vale, vale

582
00:25:13,259 --> 00:25:18,069
ya está, otra, adiós y hola

583
00:25:18,069 --> 00:25:19,329
las tres cadenas que he metido

584
00:25:19,329 --> 00:25:22,009
esta se quedó

585
00:25:22,009 --> 00:25:24,210
en la primera posición porque se cuela al principio

586
00:25:24,210 --> 00:25:25,269
al hacer el add first

587
00:25:25,269 --> 00:25:30,680
vale, lo que pasa es que efectivamente

588
00:25:30,680 --> 00:25:32,980
este get lo queremos usar

589
00:25:32,980 --> 00:25:34,980
dentro de un bucle de este estilo

590
00:25:34,980 --> 00:25:36,220
yo quiero

591
00:25:36,220 --> 00:25:38,480
en los arrays siempre recorremos

592
00:25:38,480 --> 00:25:40,519
en función de su longitud, si tenemos un parámetro

593
00:25:40,519 --> 00:25:42,819
length, hombre, pues aquí que menos

594
00:25:42,819 --> 00:25:44,539
que ponerle un método a mi

595
00:25:44,539 --> 00:25:45,859
ArrayList, que menos

596
00:25:45,859 --> 00:25:48,440
que me devuelva la cantidad de posiciones que tiene

597
00:25:48,440 --> 00:25:50,299
porque es que si no se lo pongo

598
00:25:50,299 --> 00:25:52,799
pues hasta donde recorro

599
00:25:52,799 --> 00:25:54,220
que menos, ¿no?

600
00:25:54,220 --> 00:25:56,460
que hacer este método size, bueno, pero es que hacer este

601
00:25:56,460 --> 00:25:58,819
pues no es tan complicado

602
00:25:58,819 --> 00:26:00,599
porque se trata

603
00:26:00,599 --> 00:26:02,460
de ir avanzando y contando hasta que

604
00:26:02,460 --> 00:26:03,059
lleguemos a null

605
00:26:03,059 --> 00:26:04,480
a ver

606
00:26:04,480 --> 00:26:11,240
pero entonces

607
00:26:11,240 --> 00:26:12,759
pero entonces ese led

608
00:26:12,759 --> 00:26:14,720
lo tienes que mantener siempre

609
00:26:14,720 --> 00:26:16,980
cada vez que hagas un add o un remove

610
00:26:16,980 --> 00:26:19,000
si es que se hace el remove, mantenerlo sincronizado

611
00:26:19,000 --> 00:26:20,680
entonces bueno, a ver

612
00:26:20,680 --> 00:26:22,279
es una opción, ¿vale?

613
00:26:22,299 --> 00:26:24,619
lo mantienes sincronizado siempre

614
00:26:24,619 --> 00:26:26,859
y no te olvidas nunca de que si añades un método

615
00:26:26,859 --> 00:26:29,000
que cambia el tamaño, pues de cambiarlo

616
00:26:29,000 --> 00:26:30,680
se podría hacer así

617
00:26:30,680 --> 00:26:33,000
¿vale? pero vamos a hacer el método size tal cual

618
00:26:33,000 --> 00:26:34,140
para no poner una propiedad nueva

619
00:26:34,140 --> 00:26:35,460
entonces

620
00:26:35,460 --> 00:26:37,720
pues este método

621
00:26:37,720 --> 00:26:43,859
¿qué tiene que hacer?

622
00:26:43,859 --> 00:26:45,200
contar

623
00:26:45,200 --> 00:26:48,019
la cantidad de saltos que hay que hacer

624
00:26:48,019 --> 00:26:49,859
hasta llegar a nul, eso es lo que tiene que hacer

625
00:26:49,859 --> 00:26:50,539
¿vale?

626
00:26:51,480 --> 00:26:53,519
pues venga, vamos a parar aquí un momentito

627
00:26:53,519 --> 00:26:54,680
y

628
00:26:54,680 --> 00:26:57,319
lo hacéis

629
00:26:57,319 --> 00:26:59,019
si os parece