1
00:00:00,110 --> 00:00:04,769
Vale, voy a grabar la clase hoy, por lo tanto si habláis me dais el permiso de grabar vuestra voz.

2
00:00:04,870 --> 00:00:18,469
La última vez estuvimos haciendo un ejercicio de intentar esconder detrás de un objeto lo que era un array.

3
00:00:18,769 --> 00:00:23,670
O sea, nosotros hemos llegado a un momento en que los arrays nos molestan, entre comillas,

4
00:00:23,850 --> 00:00:28,410
o sea, son útiles, seguiremos utilizando y cosas así, pero son engorrosos de utilizar.

5
00:00:28,410 --> 00:00:36,590
Entonces hemos dicho, ¿por qué no creamos unos métodos que nos esconden lo que hacemos normalmente con los arrays?

6
00:00:37,710 --> 00:00:41,030
Es un poco el mecanismo que hacemos siempre, ¿vale?

7
00:00:41,149 --> 00:00:50,289
Es decir, nosotros aprendemos cómo se hacen las cosas y luego abstraemos estas cosas y hacemos que otros más las hagan para nosotros.

8
00:00:50,289 --> 00:00:54,049
todo lo que es el API de Java, todo lo que es el JDK

9
00:00:54,049 --> 00:00:59,210
que viene con un mogollón de clases ya hechas

10
00:00:59,210 --> 00:01:01,850
y que nosotros utilizamos, in primis string

11
00:01:01,850 --> 00:01:04,909
nosotros desde el día uno estamos utilizando la clase string

12
00:01:04,909 --> 00:01:08,689
y no la hemos hecho nosotros, es un objeto que ha hecho alguien más

13
00:01:08,689 --> 00:01:11,409
sin embargo lo utilizamos como abstracción

14
00:01:11,409 --> 00:01:14,810
si no deberíamos estar trabajando con Array de Char

15
00:01:14,810 --> 00:01:17,909
y nosotros no queremos trabajar con Array de Char

16
00:01:17,909 --> 00:01:22,590
entonces a partir de allí lo que hemos hecho es crear este objeto milista

17
00:01:22,590 --> 00:01:26,310
habíamos creado al principio un milista que trabajaba con string

18
00:01:26,310 --> 00:01:29,409
os acordáis que aquí había un array de string

19
00:01:29,409 --> 00:01:35,950
y lo que hacíamos era identificar un constructor para crear un nuevo objeto de este milista

20
00:01:35,950 --> 00:01:41,969
y luego teníamos una serie de métodos como añadir un string

21
00:01:41,969 --> 00:01:45,189
Saber el tamaño de la lista

22
00:01:45,189 --> 00:01:47,930
Escribir la lista en pantalla

23
00:01:47,930 --> 00:01:52,569
Pillar un cierto elemento en una posición

24
00:01:52,569 --> 00:01:56,629
Que te paso como parámetro y me devolvía un string, etc, etc, etc

25
00:01:56,629 --> 00:02:01,069
Vimos que esto del string se nos quedaba un poquito corto

26
00:02:01,069 --> 00:02:05,870
Porque debería haber hecho un milista por cada clase que existe

27
00:02:05,870 --> 00:02:07,010
Ok, utilice

28
00:02:07,010 --> 00:02:09,750
Quiero hacer un milista de string, pues tengo que hacer una clase

29
00:02:09,750 --> 00:02:10,770
Milista string

30
00:02:10,770 --> 00:02:14,810
¿Quiero hacer ahora una lista de animales?

31
00:02:14,990 --> 00:02:16,490
Debería hacer mi lista de animales

32
00:02:16,490 --> 00:02:20,129
¿Ahora quiero hacer de coches?

33
00:02:20,289 --> 00:02:21,569
Pues mi lista de coches

34
00:02:21,569 --> 00:02:22,990
Y así, así, así, así

35
00:02:22,990 --> 00:02:24,889
Esto sería inviable

36
00:02:24,889 --> 00:02:26,990
Porque clases hay infinitas

37
00:02:26,990 --> 00:02:29,509
Y cada vez que yo quiera hacer una lista de estas clases

38
00:02:29,509 --> 00:02:31,169
Debería crearme un nuevo mi lista

39
00:02:31,169 --> 00:02:31,849
¿Vale?

40
00:02:32,389 --> 00:02:35,050
Entonces, vinieron a ayudarnos

41
00:02:35,050 --> 00:02:38,509
El concepto de tipos genéricos

42
00:02:38,509 --> 00:02:38,930
¿Vale?

43
00:02:38,930 --> 00:02:47,990
que veremos también ahora en el próximo tema, que son las listas, las colas, las ashmap y set y cosas por el estilo.

44
00:02:48,530 --> 00:02:51,650
Volverá a existir esta cosa aquí, entonces aprenderemos a utilizarlo.

45
00:02:52,150 --> 00:02:59,849
Pero esto es un comodín que me dice, yo no voy a saber qué me vas a dar tú como tipo,

46
00:03:00,430 --> 00:03:06,689
pero cuando crearás un milista me dirás el tipo que quieres insertar en este milista

47
00:03:06,689 --> 00:03:14,669
y yo usaré este t aquí dentro para referirme a este tipo que todavía no sé cuál es, ¿vale?

48
00:03:14,889 --> 00:03:21,310
Entonces, donde antes tenía string, voy a poner este t y aquí tengo lista que es un array de t.

49
00:03:21,449 --> 00:03:22,550
¿Qué es t? No lo sé.

50
00:03:22,930 --> 00:03:26,770
Cuando crearé mi lista, si le digo eres de string, será un array de string.

51
00:03:27,090 --> 00:03:29,110
Si le digo animal, eres un array de animal.

52
00:03:30,490 --> 00:03:33,370
Cuando esto... Llego aquí en un momento.

53
00:03:33,370 --> 00:03:35,590
Cuando añado algo

54
00:03:35,590 --> 00:03:37,590
Le digo que añado un tipo T

55
00:03:37,590 --> 00:03:39,729
Porque yo digo, hago una lista

56
00:03:39,729 --> 00:03:41,710
De vehículos

57
00:03:41,710 --> 00:03:43,509
Pues entonces voy a añadir

58
00:03:43,509 --> 00:03:45,169
Un vehículo, vale

59
00:03:45,169 --> 00:03:47,990
Y aquí dentro el método que me permite

60
00:03:47,990 --> 00:03:50,090
Extender, crear un array

61
00:03:50,090 --> 00:03:52,229
Un poquito más grande, de una posición más grande

62
00:03:52,229 --> 00:03:54,250
Copiar todos los vehículos

63
00:03:54,250 --> 00:03:56,389
Que tenía antes en el nuevo array

64
00:03:56,389 --> 00:03:58,310
Añadir al final del array

65
00:03:58,310 --> 00:04:00,229
El elemento que me has pasado tú

66
00:04:00,229 --> 00:04:01,449
Que es un vehículo

67
00:04:01,449 --> 00:04:06,830
y a este punto te digo que la lista, esta lista de aquí, es este nuevo array,

68
00:04:07,030 --> 00:04:09,789
que es el más grande con el nuevo elemento insertado.

69
00:04:10,189 --> 00:04:15,909
Para saber el tamaño, pues fácil, busco cuántos elementos tengo en mi array de lista

70
00:04:15,909 --> 00:04:17,370
y te lo digo, ya está.

71
00:04:17,870 --> 00:04:22,810
Para pillar algo, pues te digo la posición, la voy a buscar y lo devuelvo.

72
00:04:23,389 --> 00:04:25,410
Cuidado que lo que devuelvo es un objeto T.

73
00:04:25,990 --> 00:04:28,629
¿Qué es T? Pues siempre dependerá de cómo lo has creado.

74
00:04:28,629 --> 00:04:36,350
¿Cómo se crea? Cuando yo creo aquí un miLista, le digo que este miLista va a contener string.

75
00:04:37,029 --> 00:04:41,629
Lo llamo de algún nombre y creo un nuevo miLista de string.

76
00:04:42,250 --> 00:04:46,529
Esto quiere decir que ahora dentro tendré string.

77
00:04:46,649 --> 00:04:50,769
De hecho, estos métodos de aquí son métodos T.

78
00:04:52,670 --> 00:04:55,949
Por ejemplo, si yo miro este, este es un add de T.

79
00:04:55,949 --> 00:04:58,269
¿Sí? Pero si yo hago

80
00:04:58,269 --> 00:04:59,629
M punto

81
00:04:59,629 --> 00:05:01,829
Y voy a mirar el add

82
00:05:01,829 --> 00:05:03,810
No hago zoom porque no puedo

83
00:05:03,810 --> 00:05:05,089
Si no se bloquea la cosa

84
00:05:05,089 --> 00:05:08,589
Pues veis que aquí como parámetro me da string

85
00:05:08,589 --> 00:05:09,750
No T

86
00:05:09,750 --> 00:05:12,290
No object, no cualquier cosa

87
00:05:12,290 --> 00:05:13,589
Me da string porque

88
00:05:13,589 --> 00:05:16,250
Este se ha asociado

89
00:05:16,250 --> 00:05:18,009
Con este T de aquí

90
00:05:18,009 --> 00:05:19,329
Con este T de aquí

91
00:05:19,329 --> 00:05:22,029
Y por lo tanto allá donde yo tenga un T

92
00:05:22,029 --> 00:05:23,230
Pues ahora es un string

93
00:05:23,230 --> 00:05:24,750
¿Sí?

94
00:05:25,949 --> 00:05:39,550
Si yo cambio esto y pongo otra cosa, aquí pongo scanner, que es otro objeto, ¿vale?

95
00:05:40,550 --> 00:05:44,459
M2, no lo tengo que importar.

96
00:05:48,199 --> 00:05:55,060
Pues ahora, cuando yo hago M2 punto, la add me dice que puede añadir un scanner, ¿no? Un string.

97
00:05:55,699 --> 00:06:02,180
Porque ahora este scanner se ha asociado con el T, por lo tanto estoy trabajando con scanner, ¿vale?

98
00:06:02,180 --> 00:06:05,160
Esto es un poquito el concepto de tipo genérico.

99
00:06:05,680 --> 00:06:13,800
Yo creo una clase sin decir qué tipo es, pero a la hora de utilizarla, instancio ese tipo, en un cierto sentido.

100
00:06:14,399 --> 00:06:18,420
Es como si fuera una variable que en vez de jugar con valores, juega con tipos.

101
00:06:19,860 --> 00:06:20,620
¿Sí? Vale.

102
00:06:21,199 --> 00:06:24,560
La única cosa que nos quedó un poquito así rara es esto.

103
00:06:25,699 --> 00:06:26,220
¿Vale?

104
00:06:26,220 --> 00:06:35,879
Porque a la hora de crear este objeto, de implementarlo, de instanciarlo, no lo puedo hacer con T directamente.

105
00:06:37,279 --> 00:06:42,279
Se enfada, porque el compilador necesita saber este T que es.

106
00:06:42,699 --> 00:06:50,920
Y como este T solo se ejecutará en un futuro cuando ya la uso y le digo que es, pues aquí se enfada.

107
00:06:50,920 --> 00:07:09,740
Entonces, la solución que hemos encontrado nosotros es crear un tipo de objetos, o sea, una red de objetos, porque la red de objetos me admite cualquier cosa, ¿vale? Como es object, desde object hereda cualquier clase, pues en algún punto de la cadena de adherencia de cualquier objeto llegamos a object.

108
00:07:09,740 --> 00:07:14,240
Entonces, si yo me he creado un objeto, pues aquí podré poner todos los objetos que me da la gana.

109
00:07:14,639 --> 00:07:19,180
Y a este punto, lo que hago es decirle, pero no quiero, una vez que lo has creado,

110
00:07:19,300 --> 00:07:23,240
has creado una red de objetos, castéalo a un objeto de tipo T.

111
00:07:24,019 --> 00:07:29,060
Y esto es peligroso, porque normalmente esto podría dar problemas.

112
00:07:29,420 --> 00:07:34,360
Si aquí en esta red de objetos yo había puesto gatos, coches y aviones,

113
00:07:34,360 --> 00:07:36,879
y ahora le digo, hazme este de aquí

114
00:07:36,879 --> 00:07:38,660
un casteo a string, pues

115
00:07:38,660 --> 00:07:40,519
explotaría, le daría problemas

116
00:07:40,519 --> 00:07:42,720
pero a mí no me da problemas porque

117
00:07:42,720 --> 00:07:44,779
está de toda forma controlado, esta es una

118
00:07:44,779 --> 00:07:46,339
cosa que estamos haciendo en el constructor

119
00:07:46,339 --> 00:07:48,420
y por lo tanto esto cuando se crea

120
00:07:48,420 --> 00:07:50,639
está vacío, no hay ningún objeto

121
00:07:50,639 --> 00:07:52,800
dentro, por lo tanto no hay

122
00:07:52,800 --> 00:07:54,759
problema de que había un gato y ahora le he dicho que es

123
00:07:54,759 --> 00:07:56,899
un string, pues no, no había nada

124
00:07:56,899 --> 00:07:58,740
y ahora le digo que a partir de ahora

125
00:07:58,740 --> 00:08:00,360
es esto, y fijaos que

126
00:08:00,360 --> 00:08:02,720
en mi lista nadie puede

127
00:08:02,720 --> 00:08:04,720
acceder directamente a la lista, entonces nadie

128
00:08:04,720 --> 00:08:06,620
puede acceder a la lista y decir, meto dentro un gato

129
00:08:06,620 --> 00:08:08,839
no obstante sea una lista

130
00:08:08,839 --> 00:08:11,079
de vehículos, y que el añadir

131
00:08:11,079 --> 00:08:12,899
no me permita añadir cualquier

132
00:08:12,899 --> 00:08:14,779
cosa, me permite añadir sólo lo que

133
00:08:14,779 --> 00:08:16,720
tú me has dicho, por lo tanto

134
00:08:16,720 --> 00:08:18,459
estoy seguro que dentro de object

135
00:08:18,459 --> 00:08:21,040
no pueda ir algo que no es

136
00:08:21,040 --> 00:08:22,959
un T

137
00:08:22,959 --> 00:08:24,759
¿se entiende?

138
00:08:26,480 --> 00:08:27,060
todo esto

139
00:08:27,060 --> 00:08:28,899
repaso, la última vez

140
00:08:28,899 --> 00:08:30,600
os dejé con, bueno

141
00:08:30,600 --> 00:08:51,320
Decimos el contains, decimos cosas por el estilo, hablamos de esta cosa de que el contains va a buscar la igualdad entre los objetos de la lista y el objeto que me ha pasado aquí.

142
00:08:51,320 --> 00:08:59,779
Y esto se hará con un equals y funciona porque en automático él elegirá el equals de la instancia.

143
00:08:59,779 --> 00:09:02,240
vale, entonces si aquí había elegido string

144
00:09:02,240 --> 00:09:04,000
pues esto será el equals de string

145
00:09:04,000 --> 00:09:06,259
si yo aquí había elegido como t animal

146
00:09:06,259 --> 00:09:08,539
pues me irá a buscar el equals de animal

147
00:09:08,539 --> 00:09:09,740
por lo tanto me funciona

148
00:09:09,740 --> 00:09:12,360
pero lo que tengo que hacer es claramente

149
00:09:12,360 --> 00:09:14,320
definir un equals dentro

150
00:09:14,320 --> 00:09:16,440
de mi objeto, si no lo hago

151
00:09:16,440 --> 00:09:18,279
el equals será el igual

152
00:09:18,279 --> 00:09:20,279
igual, como es el

153
00:09:20,279 --> 00:09:21,259
equals de object

154
00:09:21,259 --> 00:09:23,019
¿sabes?

155
00:09:24,559 --> 00:09:25,799
os dejé

156
00:09:25,799 --> 00:09:27,620
la última vez

157
00:09:27,620 --> 00:09:29,919
haciendo esto

158
00:09:29,919 --> 00:09:31,539
el remove

159
00:09:31,539 --> 00:09:34,679
no sé si lo habéis hecho, lo más probable es que no

160
00:09:34,679 --> 00:09:36,360
¿por qué? porque no estudiáis en casa

161
00:09:36,360 --> 00:09:38,340
y hay dos

162
00:09:38,340 --> 00:09:40,000
opciones de hacer el remove

163
00:09:40,000 --> 00:09:42,460
el remove de una posición o remove

164
00:09:42,460 --> 00:09:43,240
de un objeto

165
00:09:43,240 --> 00:09:46,519
el remove de un objeto se podría

166
00:09:46,519 --> 00:09:48,460
ver como busco ese objeto

167
00:09:48,460 --> 00:09:50,440
cuando sé que posición es

168
00:09:50,440 --> 00:09:51,759
llamo el remove

169
00:09:51,759 --> 00:09:54,120
de la posición donde está

170
00:09:54,120 --> 00:09:56,539
entonces rápidamente

171
00:09:56,539 --> 00:09:58,080
vamos a implementar solo esto

172
00:09:58,080 --> 00:10:00,340
para ver cómo se hace, ¿vale?

173
00:10:00,360 --> 00:10:02,360
Pero muy rápidamente porque quiero hacer otras cosas hoy.

174
00:10:03,940 --> 00:10:04,340
Entonces,

175
00:10:04,580 --> 00:10:06,220
el remove me han dado una posición

176
00:10:06,220 --> 00:10:08,440
del array, por lo tanto yo tengo que

177
00:10:08,440 --> 00:10:10,360
remover esa posición.

178
00:10:10,960 --> 00:10:12,360
El hecho es que nosotros queremos que

179
00:10:12,360 --> 00:10:14,539
el array sea siempre compacto, no haya

180
00:10:14,539 --> 00:10:16,399
null allí, porque

181
00:10:16,399 --> 00:10:18,460
si pudiera emitir los null, sería

182
00:10:18,460 --> 00:10:20,379
simplemente lista de

183
00:10:20,379 --> 00:10:21,460
posición

184
00:10:21,460 --> 00:10:27,980
es igual a null. Ya está.

185
00:10:29,120 --> 00:10:29,659
Ningún problema.

186
00:10:30,120 --> 00:10:36,659
vale pero como no quiero esto yo quiero que el lista siempre porque si no si yo hiciera esto

187
00:10:36,659 --> 00:10:45,299
funciona pero ya el 6 no funciona porque ahora me diría tienes 10 elementos pero había borrado uno

188
00:10:45,299 --> 00:10:49,860
y ahora en realidad hay nueve elementos pero la casilla sigue restando por lo tanto no funcionaría

189
00:10:49,860 --> 00:10:55,919
el 6 como lo he hecho así pues tengo hacer algo un poquito más distinto que es parecido a cuando

190
00:10:55,919 --> 00:10:58,159
lo hemos extendido, solo que esta vez tengo que encogerlo.

191
00:10:58,580 --> 00:10:59,919
Tengo que crear un

192
00:10:59,919 --> 00:11:01,080
array nuevo

193
00:11:01,080 --> 00:11:03,799
de t, como

194
00:11:03,799 --> 00:11:04,320
hacía aquí,

195
00:11:06,299 --> 00:11:08,240
pero en vez de crearlo

196
00:11:08,240 --> 00:11:10,080
más

197
00:11:10,080 --> 00:11:12,159
grande, lo creo

198
00:11:12,159 --> 00:11:13,120
más pequeño,

199
00:11:13,820 --> 00:11:15,059
porque voy a quitar uno.

200
00:11:18,740 --> 00:11:19,379
Luego,

201
00:11:20,600 --> 00:11:21,600
for int

202
00:11:21,600 --> 00:11:25,759
y es igual a 0

203
00:11:25,759 --> 00:11:26,860
y menor

204
00:11:26,860 --> 00:11:30,539
que posición

205
00:11:30,539 --> 00:11:37,700
y más más, o sea, por todos los números

206
00:11:37,700 --> 00:11:42,019
anteriores a posición, excluyendo posición, la posición

207
00:11:42,019 --> 00:11:45,580
que me has dicho no la quiero, entonces no pongo menor o igual

208
00:11:45,580 --> 00:11:49,639
¿vale? Tengo que copiar simplemente lista

209
00:11:49,639 --> 00:11:52,940
dentro del nuevo, no se ven afectados los que están antes

210
00:11:52,940 --> 00:11:56,679
entonces nuevo de y es igual

211
00:11:56,679 --> 00:11:58,379
a lista

212
00:11:58,379 --> 00:11:59,539
de ahí

213
00:11:59,539 --> 00:12:01,860
ahora

214
00:12:01,860 --> 00:12:03,600
cuando he hecho esto

215
00:12:03,600 --> 00:12:05,000
he llegado a la posición

216
00:12:05,000 --> 00:12:06,679
y ahora tengo un problemita

217
00:12:06,679 --> 00:12:10,059
yo tenía este

218
00:12:10,059 --> 00:12:11,820
array de aquí antes

219
00:12:11,820 --> 00:12:13,720
he creado un array

220
00:12:13,720 --> 00:12:15,620
un poquito más pequeño

221
00:12:15,620 --> 00:12:17,960
esta es la posición

222
00:12:17,960 --> 00:12:18,779
que quiero quitar

223
00:12:18,779 --> 00:12:21,440
entonces hasta llegar a esta posición

224
00:12:21,440 --> 00:12:23,299
es simplemente copiado

225
00:12:23,299 --> 00:12:25,620
cuando

226
00:12:25,620 --> 00:12:27,600
llego a esta posición, lo que

227
00:12:27,600 --> 00:12:29,399
tengo que empezar a hacer es copiar

228
00:12:29,399 --> 00:12:30,820
la posición más 1

229
00:12:30,820 --> 00:12:35,230
dentro de la anterior.

230
00:12:36,610 --> 00:12:37,070
¿Se entiende?

231
00:12:39,379 --> 00:12:40,860
¿Sí? O sea, hasta

232
00:12:40,860 --> 00:12:42,720
la posición, copio

233
00:12:42,720 --> 00:12:44,960
directamente la 0 en la 0, la 1

234
00:12:44,960 --> 00:12:47,100
en la 1. Cuando encuentro

235
00:12:47,100 --> 00:12:48,039
esta de aquí,

236
00:12:48,720 --> 00:12:50,500
empiezo a copiar la

237
00:12:50,500 --> 00:12:52,840
3, 0,

238
00:12:52,899 --> 00:12:54,740
1, 2, 3, la 3 en la 2,

239
00:12:55,039 --> 00:12:56,919
la 4 en la 3, la 5

240
00:12:56,919 --> 00:12:57,679
en la 4.

241
00:12:58,879 --> 00:13:02,700
¿Sí? Hasta el final, saltándome la que me has dado tú.

242
00:13:03,379 --> 00:13:06,940
Entonces, hago esta de aquí que copia la primera parte.

243
00:13:07,379 --> 00:13:08,879
La parte a la izquierda de la posición.

244
00:13:09,860 --> 00:13:23,289
Luego empiezo otro for, que for int y es igual a posición y menor que...

245
00:13:25,389 --> 00:13:27,570
Depende, aquí lo puedo hacer...

246
00:13:27,570 --> 00:13:28,250
Ponemos uno.

247
00:13:28,950 --> 00:13:30,710
Razonamos siempre sobre lista, ¿vale?

248
00:13:30,710 --> 00:13:35,250
Y menor que lista.length

249
00:13:35,250 --> 00:13:38,389
Y más más

250
00:13:38,389 --> 00:13:40,090
No, porque es menor

251
00:13:40,090 --> 00:13:42,929
Y estoy trabajando sobre lista

252
00:13:42,929 --> 00:13:47,450
O sea que este Y será el recorrido de este array de aquí

253
00:13:47,450 --> 00:13:49,570
Ha llegado a posición

254
00:13:49,570 --> 00:13:53,210
Se la salta y empieza desde posición más uno

255
00:13:53,210 --> 00:13:57,190
Entonces, si ahora me vale posición más uno

256
00:13:57,190 --> 00:14:07,490
Tendré que copiar en nuevo de i-1 lo que está en lista de i.

257
00:14:12,870 --> 00:14:28,769
Si lista de i me vale 3, copio lo que hay en lista de 3 en nuevo de i-1, o sea, en nuevo de 2.

258
00:14:29,750 --> 00:14:35,009
Si vale la posición 4, lo copio en i-1, o sea, en 3.

259
00:14:35,450 --> 00:14:37,309
Y así hasta que acabo este array.

260
00:14:40,159 --> 00:14:45,139
Al final, lista, es igual a 9.

261
00:14:49,129 --> 00:14:52,110
Esto no es la primera vez que lo hacemos.

262
00:14:53,409 --> 00:14:56,090
Esto hay ejercicios sobre array que hacen esto.

263
00:14:56,789 --> 00:14:58,610
Otra cosa que no lo hayáis hecho en vuestra vida.

264
00:14:59,330 --> 00:15:06,909
Pero estos ejercicios de aquí son ejercicios básicos de arrays que nosotros hemos hecho ya en la primera evaluación,

265
00:15:07,029 --> 00:15:14,009
que están en los enunciados, buscadlos, de añade un elemento a un array o quita un elemento al array sin que haya null.

266
00:15:14,950 --> 00:15:19,710
Son ejercicios que deberíais ya saber hacer y simplemente ahora le estamos dando un significado.

267
00:15:19,889 --> 00:15:26,710
Hemos aprendido a hacer las cosas sin significado, a hacer ejercicios generales y ahora lo utilizamos para cosas útiles.

268
00:15:26,710 --> 00:15:31,190
Repito que esto sería

269
00:15:31,190 --> 00:15:34,789
Búscame el elemento S dentro del array

270
00:15:34,789 --> 00:15:36,049
Cuando lo has encontrado

271
00:15:36,049 --> 00:15:37,649
Me dice la posición

272
00:15:37,649 --> 00:15:39,429
Y llamas este método de aquí

273
00:15:39,429 --> 00:15:40,169
De esa posición

274
00:15:40,169 --> 00:15:40,990
Ya está

275
00:15:40,990 --> 00:15:47,330
Si ya hemos hecho el contains

276
00:15:47,330 --> 00:15:48,549
Lo hemos hecho con boolean

277
00:15:48,549 --> 00:15:50,070
Si en vez de hacerlo con boolean

278
00:15:50,070 --> 00:15:51,549
Hacemos contains que me devuelve

279
00:15:51,549 --> 00:15:52,929
O esta misma cosa de aquí

280
00:15:52,929 --> 00:15:56,610
Que me devuelve las posiciones

281
00:15:56,610 --> 00:15:58,529
Y yo puedo llamar este método de aquí

282
00:15:58,529 --> 00:16:00,629
Me devuelve las posiciones donde estás

283
00:16:00,629 --> 00:16:05,190
Y luego llamo por cada posición de este array que me ha devuelto

284
00:16:05,190 --> 00:16:09,710
Pues llamo remove de esa posición

285
00:16:09,710 --> 00:16:11,409
Y ya está

286
00:16:11,409 --> 00:16:19,679
Pues esto completa lo del otro día

287
00:16:19,679 --> 00:16:23,200
Vale, entonces hoy lo que vamos a hacer es lo siguiente

288
00:16:23,200 --> 00:16:24,519
Paso número A

289
00:16:24,519 --> 00:16:27,820
Recordarme esto, mi lista

290
00:16:27,820 --> 00:16:28,559
¿Vale?

291
00:16:29,039 --> 00:16:30,860
Hemos hecho este mi lista

292
00:16:30,860 --> 00:16:31,700
Perfecto

293
00:16:31,700 --> 00:16:37,340
Ahora, si nosotros vemos, mi lista tiene una serie de funcionalidades

294
00:16:37,340 --> 00:16:44,980
Que son quita, que son añade, que son escribirlo como array

295
00:16:44,980 --> 00:16:48,460
La idea que tengo hoy es decir

296
00:16:48,460 --> 00:16:51,179
Vale, yo quiero hacer ahora la misma cosa

297
00:16:51,179 --> 00:16:54,820
Pero con una implementación completamente distinta

298
00:16:54,820 --> 00:16:57,159
¿Qué quiere decir?

299
00:16:57,740 --> 00:17:03,500
Quiere decir que como primer paso me creo una interfaz

300
00:17:03,500 --> 00:17:08,359
La interfaz, listas, por ejemplo

301
00:17:08,359 --> 00:17:14,559
Y aquí escribo lo que yo quiero que haga una lista en general

302
00:17:14,559 --> 00:17:21,380
O sea, mis listas, habíamos dicho que podía añadir un elemento

303
00:17:21,380 --> 00:17:26,240
Pues esto de aquí, lo pongo aquí

304
00:17:26,240 --> 00:17:31,599
Cuidado, ¿qué es este t?

305
00:17:32,000 --> 00:17:35,960
Pues lo tendré que decir, es un tipo genérico

306
00:17:35,960 --> 00:17:44,880
O sea, que la interfaz de listas de dime tú qué, pues tendrán que tener un método que añade un no sé qué.

307
00:17:45,720 --> 00:17:47,819
Si string, un string. Si un animal, un animal.

308
00:17:49,420 --> 00:17:52,220
¿Qué más puede hacer una lista en general?

309
00:17:52,500 --> 00:17:54,339
¿Qué estoy haciendo aquí en un cierto sentido?

310
00:17:56,779 --> 00:17:58,640
Estoy haciendo como una generalización.

311
00:17:59,039 --> 00:18:03,200
No es lo mismo porque eso era inherencia, pero estoy haciendo algo por estilo.

312
00:18:03,200 --> 00:18:06,059
Lo estoy diciendo, vale, me he hecho una lista, ¿vale?

313
00:18:06,259 --> 00:18:11,140
Pero yo quiero sacar de la lista lo que todas las listas tienen que tener en común.

314
00:18:11,539 --> 00:18:15,680
Y todas las listas tienen que poder añadir un elemento.

315
00:18:16,299 --> 00:18:19,299
Por lo tanto, he puesto aquí un método para añadir un elemento.

316
00:18:20,619 --> 00:18:22,839
Ahora, ¿qué más pueden hacer todas las listas?

317
00:18:22,839 --> 00:18:25,339
Pues decir cuántos elementos tienen.

318
00:18:25,920 --> 00:18:29,819
Pues aquí añado esto.

319
00:18:32,200 --> 00:18:34,240
¿Qué más puede hacer una lista?

320
00:18:34,240 --> 00:18:36,779
pues se puede escribir en pantalla

321
00:18:36,779 --> 00:18:37,640
vale

322
00:18:37,640 --> 00:18:40,819
tiene que tener un toString

323
00:18:40,819 --> 00:18:44,640
que luego en realidad lo tiene siempre

324
00:18:44,640 --> 00:18:45,819
porque tiene el de object

325
00:18:45,819 --> 00:18:48,380
¿qué más? pues quiero poder

326
00:18:48,380 --> 00:18:50,460
pillar el elemento n

327
00:18:50,460 --> 00:18:53,099
de una lista

328
00:18:53,099 --> 00:18:57,369
quiero poder

329
00:18:57,369 --> 00:19:00,930
saber si un elemento

330
00:19:00,930 --> 00:19:02,309
está o no en la lista

331
00:19:02,309 --> 00:19:07,710
y finalmente

332
00:19:07,710 --> 00:19:10,329
para no complicarlo demasiado

333
00:19:10,329 --> 00:19:11,990
quiero saber

334
00:19:11,990 --> 00:19:21,789
Quiero poder eliminar un cierto elemento de la lista

335
00:19:21,789 --> 00:19:30,460
Y asumamos que aquí había otros métodos

336
00:19:30,460 --> 00:19:33,859
Como este método de aquí, como este método de aquí

337
00:19:33,859 --> 00:19:37,440
Pero asumamos que estos son propios de mi lista

338
00:19:37,440 --> 00:19:42,259
Las listas en general lo que tienen que hacer es implementar estos

339
00:19:42,259 --> 00:19:47,210
Una vez que lo he guardado

340
00:19:47,210 --> 00:19:49,750
Yo lo que podría hacer es que mi lista

341
00:19:49,750 --> 00:19:54,779
Implements

342
00:19:54,779 --> 00:19:58,140
Listas

343
00:19:58,140 --> 00:20:06,599
Y no me da errores

344
00:20:06,599 --> 00:20:08,420
Porque ya estos métodos de aquí

345
00:20:08,420 --> 00:20:09,500
Los tengo implementados

346
00:20:09,500 --> 00:20:12,180
¿Están de acuerdo en lo que he hecho?

347
00:20:14,940 --> 00:20:15,920
¿Sí? Vale

348
00:20:15,920 --> 00:20:18,519
Entonces, lo que voy a hacer hoy en vez

349
00:20:18,519 --> 00:20:20,000
Es el siguiente, vale

350
00:20:20,000 --> 00:20:21,519
Ahora quiero hacer otra lista

351
00:20:21,519 --> 00:20:24,140
Quiero hacer un objeto que haga lo mismo que esto

352
00:20:24,140 --> 00:20:26,319
Que me esconda los arrays otra vez

353
00:20:26,319 --> 00:20:28,400
Que sea lo que se llama una estructura

354
00:20:28,400 --> 00:20:29,680
De datos dinámicas

355
00:20:29,680 --> 00:20:32,200
Y veremos el lunes por qué es dinámica

356
00:20:32,200 --> 00:20:34,000
Que yo tenga este objeto

357
00:20:34,000 --> 00:20:36,140
Le puedo decir, añádeme un string, añádeme un animal

358
00:20:36,140 --> 00:20:36,920
Añádeme lo que sea

359
00:20:36,920 --> 00:20:38,700
Y él lo vaya añadiendo

360
00:20:38,700 --> 00:20:41,500
Sin con un array decir

361
00:20:41,500 --> 00:20:43,920
Mira, se ha acabado el espacio, tengo que poner otra cosa

362
00:20:43,920 --> 00:20:45,599
Para esto

363
00:20:45,599 --> 00:20:48,559
Me creo una nueva implementación

364
00:20:48,559 --> 00:20:49,700
De listas

365
00:20:49,700 --> 00:20:50,460
La llamaré

366
00:20:50,460 --> 00:20:53,700
MiListaEnlazada

367
00:20:54,140 --> 00:21:20,119
sí mi lista enlazada tendrá un tipo e implementará listas se enfada porque dice hoy mira me estás

368
00:21:20,119 --> 00:21:26,960
diciendo que implementa listas pero no has implementado nada pues aquí le digo añade

369
00:21:26,960 --> 00:21:33,019
los métodos no implementados y él me lo pone aquí tienes que hacer estos tengo acuerdo hasta aquí

370
00:21:33,019 --> 00:21:44,660
O sea, que yo ahora aquí tengo una estructura, un esqueleto de una nueva clase que hará lo mismo que mi lista, pero en una versión distinta.

371
00:21:45,819 --> 00:21:47,759
Ahora vamos a ver cómo lo hacemos distinto.

372
00:21:48,119 --> 00:21:56,440
Pero una vez que yo la tenga, yo podré aquí hacer tranquilamente una mi lista enlazada de string, llamándola como quiera,

373
00:21:56,440 --> 00:22:01,740
hago new mi lista enlazada de string y ponerle dentro gato, perro, banana, murciélago

374
00:22:01,740 --> 00:22:04,000
y hacer todo lo que pueda hacer esta cosa aquí.

375
00:22:04,119 --> 00:22:11,809
O sea, hacer la get, hacer el tu array, hacer el size.

376
00:22:12,930 --> 00:22:13,990
¿Se entiende lo que quiero decir?

377
00:22:15,109 --> 00:22:15,549
¿Dudas?

378
00:22:16,849 --> 00:22:17,109
Vale.

379
00:22:18,190 --> 00:22:23,309
Ahora, en esta implementación yo no quiero usar los arrays.

380
00:22:23,309 --> 00:22:35,569
Si os acordáis, aquí la base de mi implementación era usar un array. Tengo un array y almacenaba las cosas allí, hacía más grande o más pequeño el array, contaba sobre el array, etc.

381
00:22:36,710 --> 00:22:48,250
Aquí, esta de aquí, quiero que sea una implementación distinta. ¿Por qué? Porque a lo mejor implementación distintas me dan ventajas o desventajas en determinados casos.

382
00:22:48,250 --> 00:23:00,819
Por ejemplo, yo he visto que usar el array es un poco engorroso en el añadir y quitar, ¿sí?

383
00:23:01,420 --> 00:23:10,779
Añadir un elemento o quitar un elemento, esta implementación lo hace complejo, porque tengo que hacer un nuevo array, copiarlo, es lento.

384
00:23:11,480 --> 00:23:19,859
Sin embargo, es súper rápido, es súper eficaz en size, porque me lo da así directamente, no hace ningún cálculo.

385
00:23:19,859 --> 00:23:28,160
Y también en esta, la get de una posición es súper eficiente dentro de una red.

386
00:23:29,900 --> 00:23:35,319
Pero imaginaos que yo tengo una lista donde no se hace mucho la get, se hace pocas veces,

387
00:23:35,819 --> 00:23:38,940
pero sí lo que se hace mucho es insertar y quitar elementos.

388
00:23:38,940 --> 00:24:00,480
Entonces, esta implementación podría ser lenta. Y a lo mejor yo hago ahora un sistema completamente distinto, un modo completamente distinto de hacer lo mismo, de almacenar estos datos, que a lo mejor es muy bueno para añadir y quitar objetos, pero a lo mejor muy lento para pillar uno, no lo sé.

389
00:24:00,480 --> 00:24:05,779
Pero se entiende la idea de hacer distintas implementaciones

390
00:24:05,779 --> 00:24:09,319
Se pueden hacer para lograr lo mismo

391
00:24:09,319 --> 00:24:14,430
Pero que luego en términos de eficiencia

392
00:24:14,430 --> 00:24:17,869
Puede ser eficiente en ciertas cosas y menos eficiente en otras

393
00:24:17,869 --> 00:24:20,809
Yo tengo implementaciones distintas

394
00:24:20,809 --> 00:24:23,809
Y a la hora de hacer mi programa me pregunto

395
00:24:23,809 --> 00:24:25,190
¿Qué hago yo mucho?

396
00:24:25,529 --> 00:24:28,369
Si hago muchas veces este tipo de operación

397
00:24:28,369 --> 00:24:30,150
Pon esta operación de aquí

398
00:24:30,150 --> 00:24:33,109
pues mejor que tú uses esta implementación.

399
00:24:33,730 --> 00:24:39,130
Si en vez haces muchas veces esta operación de aquí, mejor que haga esta otra implementación.

400
00:24:39,490 --> 00:24:46,650
Entonces elegiré entre mi lista o mi lista enlazada dependiendo de si hago muchos estos o si hago muchos estos.

401
00:24:47,170 --> 00:24:47,569
¿Se entiende?

402
00:24:52,890 --> 00:24:57,150
Entonces, ¿cómo vamos a hacer esta nueva implementación?

403
00:24:57,150 --> 00:25:08,690
Es decir, si no podemos usar los arrays, ¿qué elemento de los que conocemos vamos a utilizar para poder crear una lista enlazada?

404
00:25:08,690 --> 00:25:16,170
Y lo que vamos a utilizar son nuestros mejores amigos, los objetos.

405
00:25:18,910 --> 00:25:27,049
Es decir, que aquí en vez de basarme sobre el array, me baso sobre un objeto.

406
00:25:27,049 --> 00:25:59,670
¿Qué objeto? Pues un objeto que vaya a definir. No, array también es un objeto, pero array hemos dicho que no lo vamos a usar. Vamos a usar nodo. ¿Qué es nodo? Nodo es un objeto que tiene un valor y luego tiene un puntero a otro nodo.

407
00:25:59,670 --> 00:26:04,559
entonces tendrá

408
00:26:04,559 --> 00:26:06,359
un objeto

409
00:26:06,359 --> 00:26:08,619
un valor

410
00:26:08,619 --> 00:26:09,740
¿cómo se lo pongo el valor?

411
00:26:11,259 --> 00:26:12,680
que tiene que contener

412
00:26:12,680 --> 00:26:21,069
este nodo

413
00:26:21,069 --> 00:26:22,529
¿qué le hacemos contener este nodo?

414
00:26:32,170 --> 00:26:32,769
probablemente

415
00:26:32,769 --> 00:26:34,630
no lo sé

416
00:26:34,630 --> 00:26:38,630
porque si mi lista es de cocodrilos

417
00:26:38,630 --> 00:26:40,309
quiero que controle cocodrilos

418
00:26:40,309 --> 00:26:43,009
si mi lista es de gatos

419
00:26:43,009 --> 00:26:45,430
quiero que contenga gatos

420
00:26:45,430 --> 00:26:46,390
podría

421
00:26:46,390 --> 00:26:48,450
hacer una trampilla y decir

422
00:26:48,450 --> 00:26:55,970
cualquier objeto, ¿sí? Pero como ya tengo

423
00:26:55,970 --> 00:27:07,960
los de aquí, pongámoslos así. Entonces el

424
00:27:07,960 --> 00:27:16,210
nodo, el nodo es un objeto

425
00:27:16,210 --> 00:27:24,259
es un objeto que tiene un campo valor

426
00:27:24,259 --> 00:27:28,039
aquí dentro tiene el valor de este objeto, un string

427
00:27:28,039 --> 00:27:32,059
un gat, lo que sea, ¿vale? Y luego tiene una otra

428
00:27:32,059 --> 00:27:35,380
variable que lo que hace es

429
00:27:35,380 --> 00:27:39,180
apuntar a otro nodo.

430
00:27:44,019 --> 00:27:48,220
Y este tendrá un valor y apuntará a otro nodo.

431
00:27:48,220 --> 00:27:52,220
Y esto tendrá otro valor y apuntará a otro nodo.

432
00:27:54,730 --> 00:27:57,569
Sustancialmente, en vez de tener un array

433
00:27:57,569 --> 00:28:02,269
con dentro todas las cosas, tengo una cadena

434
00:28:02,269 --> 00:28:12,859
de objetos. ¿Qué es esto?

435
00:28:16,609 --> 00:28:19,450
¿Cómo plasmo esto aquí dentro?

436
00:28:19,450 --> 00:28:38,240
Ahora vamos a ver cómo lo hacemos

437
00:28:38,240 --> 00:28:42,670
¿Qué es esto?

438
00:28:45,099 --> 00:28:46,759
Este es un campo siguiente

439
00:28:46,759 --> 00:28:48,240
¿Vale?

440
00:28:48,640 --> 00:28:50,920
Que apunta a otro nodo

441
00:28:50,920 --> 00:28:53,140
Porque os acordáis que cuando yo creo un objeto

442
00:28:53,140 --> 00:28:54,759
Cuando yo creo el objeto

443
00:28:54,759 --> 00:28:58,400
Animal x es igual a animal

444
00:28:58,400 --> 00:29:00,019
¿Qué contiene x?

445
00:29:02,539 --> 00:29:03,460
Contiene un objeto

446
00:29:03,460 --> 00:29:06,039
Nope

447
00:29:06,039 --> 00:29:10,299
El objeto animal se crea por algún lado con sus características

448
00:29:10,299 --> 00:29:13,740
Y dentro de x yo tengo un puntero a este objeto

449
00:29:16,859 --> 00:29:20,059
David, hola, porque si no, no salimos de esta.

450
00:29:21,180 --> 00:29:26,119
Cuando yo hago animal x es igual a animal, aquí se crea el animal, este es el animal.

451
00:29:26,900 --> 00:29:31,720
Pero dentro de mi variable x, dentro de mi referencia x, no está el objeto.

452
00:29:32,200 --> 00:29:36,660
Está una coordinada en la que puedo encontrar el objeto.

453
00:29:38,480 --> 00:29:45,920
Ahora, cuando yo creo un objeto así, ¿qué hay dentro del siguiente?

454
00:29:46,200 --> 00:29:56,309
Un puntero, una referencia a otro objeto de tipo nodo de T, que será el siguiente nodo.

455
00:29:57,470 --> 00:29:57,789
Esto.

456
00:29:59,250 --> 00:30:00,069
Espera un segundo.

457
00:30:00,869 --> 00:30:09,589
Entonces, si yo, por alguna magia, tengo este objeto de aquí, y este objeto de aquí se llama N,

458
00:30:11,779 --> 00:30:16,579
¿cómo puedo, dado este objeto de aquí, obtener este objeto de aquí?

459
00:30:21,640 --> 00:30:22,740
Repito la pregunta.

460
00:30:22,740 --> 00:30:27,650
Imaginaos que yo tengo una variable n

461
00:30:27,650 --> 00:30:29,309
Hecha de alguna forma

462
00:30:29,309 --> 00:30:31,009
Que desde aquí

463
00:30:31,009 --> 00:30:33,730
Me apunta este objeto

464
00:30:33,730 --> 00:30:35,950
O sea, yo tengo una referencia a este objeto

465
00:30:35,950 --> 00:30:37,410
¿Cómo hago?

466
00:30:37,650 --> 00:30:38,809
A partir de n

467
00:30:38,809 --> 00:30:40,829
A pillar este objeto

468
00:30:40,829 --> 00:30:48,549
No es una red

469
00:30:48,549 --> 00:30:51,250
Y el valor que tengo aquí

470
00:30:51,250 --> 00:30:53,329
Pongámoslo que sea nodo de string

471
00:30:53,329 --> 00:30:54,549
Esto es gato

472
00:30:54,549 --> 00:30:57,130
Escrito como string gato

473
00:30:57,130 --> 00:30:59,609
Esto es perro

474
00:30:59,609 --> 00:31:01,630
como string pair.

475
00:31:02,890 --> 00:31:04,549
Y esto es

476
00:31:04,549 --> 00:31:05,910
Cormorano.

477
00:31:08,779 --> 00:31:09,819
El valor no me interesa.

478
00:31:10,160 --> 00:31:13,279
Si desde n acedo a este

479
00:31:13,279 --> 00:31:15,740
señor y hago n.valor

480
00:31:15,740 --> 00:31:17,299
me dirá

481
00:31:17,299 --> 00:31:19,079
gato

482
00:31:19,079 --> 00:31:23,230
¿Cómo acedo a este señor?

483
00:31:25,569 --> 00:31:28,930
n.siguiente

484
00:31:28,930 --> 00:31:36,230
n.siguiente

485
00:31:36,230 --> 00:31:37,809
me dirá vete a este de aquí

486
00:31:37,809 --> 00:31:40,490
y desde aquí me pillas el objeto

487
00:31:40,490 --> 00:31:43,410
el valor, lo que hay dentro

488
00:31:43,410 --> 00:31:45,250
del siguiente, que es este campo de aquí

489
00:31:45,250 --> 00:31:46,869
es su segunda variable

490
00:31:46,869 --> 00:31:52,440
ahí, ahora ya

491
00:31:52,440 --> 00:31:54,180
lo veremos, todavía

492
00:31:54,180 --> 00:31:56,079
estamos pillando la idea

493
00:31:56,079 --> 00:31:58,279
luego ya veremos como lo enlazamos

494
00:31:58,279 --> 00:32:00,500
como lo enlazamos

495
00:32:00,500 --> 00:32:01,799
como lo enlazas, pues será

496
00:32:01,799 --> 00:32:04,299
el encargado, este método de aquí

497
00:32:04,299 --> 00:32:06,660
aquí tendremos que ver como lo enlazamos

498
00:32:06,660 --> 00:32:08,339
pero por ahora, estamos

499
00:32:08,339 --> 00:32:09,819
solo hablando del nodo

500
00:32:09,819 --> 00:32:11,380
¿si?

501
00:32:11,380 --> 00:32:38,759
Entonces, mi nodo tendrá, cuando yo haré en algún main, en un main de prueba, yo puedo hacer nodo de string igual a new nodo string.

502
00:32:38,759 --> 00:32:44,440
Imaginamos que funcione

503
00:32:44,440 --> 00:32:46,099
Luego ahora vemos que hacemos

504
00:32:46,099 --> 00:32:47,259
No string

505
00:32:47,259 --> 00:32:50,140
Mi nodo

506
00:32:50,140 --> 00:32:51,920
¿Si?

507
00:32:52,920 --> 00:32:54,779
Y ahora si yo quiero saber

508
00:32:54,779 --> 00:32:56,980
Lo que hay dentro de este nodo

509
00:32:56,980 --> 00:32:58,640
Haría mi nodo

510
00:32:58,640 --> 00:32:59,599
Punto valor

511
00:32:59,599 --> 00:33:05,019
Esto

512
00:33:05,019 --> 00:33:06,960
Sería

513
00:33:06,960 --> 00:33:08,220
Lo que hay aquí dentro

514
00:33:08,220 --> 00:33:10,410
¿Si o no?

515
00:33:11,009 --> 00:33:13,809
Y si yo quiero saber el siguiente nodo

516
00:33:13,809 --> 00:33:19,569
El que viene después de esto, pues haría mi nodo punto siguiente.

517
00:33:22,650 --> 00:33:27,250
Esto es un objeto de tipo nodo que apunta.

518
00:33:27,329 --> 00:33:31,990
Y si quiero saber el nodo, el valor del siguiente nodo, ¿cómo lo haría?

519
00:33:33,130 --> 00:33:34,809
Punto nodo, punto valor.

520
00:33:37,099 --> 00:33:44,839
Esto es, empieza de mi nodo, vete al siguiente nodo al que apunta él, y luego mira su valor.

521
00:33:44,839 --> 00:33:48,160
entonces en nuestro día sería

522
00:33:48,160 --> 00:33:50,319
si esto es el primero, si este es mi nodo

523
00:33:50,319 --> 00:33:52,240
estaría aquí, sería

524
00:33:52,240 --> 00:33:54,380
siguiente, iría a este de aquí

525
00:33:54,380 --> 00:33:56,559
y miraría su valor, miraría perro

526
00:33:56,559 --> 00:34:06,380
no estamos en la lista, estamos en el concepto

527
00:34:06,380 --> 00:34:07,480
de nodo, ahora luego

528
00:34:07,480 --> 00:34:09,179
luchamos

529
00:34:09,179 --> 00:34:11,639
y pensamos a cómo se hacen estas cosas

530
00:34:11,639 --> 00:34:13,679
¿dudas?

531
00:34:15,139 --> 00:34:16,219
ahora, para entender

532
00:34:16,219 --> 00:34:17,940
esto, tenéis que saber

533
00:34:17,940 --> 00:34:18,880
que es un objeto

534
00:34:18,880 --> 00:34:20,880
y que es una referencia

535
00:34:20,880 --> 00:34:23,739
si no tenéis idea de estas dos cosas

536
00:34:23,739 --> 00:34:25,800
que son un mes y medio que estamos

537
00:34:25,800 --> 00:34:26,840
hablando de estas cosas

538
00:34:26,840 --> 00:34:29,300
pues tenemos un problema serio

539
00:34:29,300 --> 00:34:34,570
¿sí? y probablemente

540
00:34:34,570 --> 00:34:35,510
no vais a entender

541
00:34:35,510 --> 00:34:37,110
las próximas

542
00:34:37,110 --> 00:34:39,070
hora y media de clase

543
00:34:39,070 --> 00:34:41,070
¿sí?

544
00:34:42,469 --> 00:34:43,230
pero

545
00:34:43,230 --> 00:34:45,369
asumamos que esto más o menos

546
00:34:45,369 --> 00:34:47,210
está aquí, ahora, yo necesito un constructor

547
00:34:47,210 --> 00:34:49,250
¿vale? ¿cómo

548
00:34:49,250 --> 00:34:50,750
construyo un nodo?

549
00:34:51,530 --> 00:34:53,449
public nodo

550
00:34:53,449 --> 00:34:59,329
No sé si tengo que ponerle t aquí

551
00:34:59,329 --> 00:35:01,829
Que pillará un

552
00:35:01,829 --> 00:35:03,590
T valor

553
00:35:03,590 --> 00:35:07,880
Lo que hará es que

554
00:35:07,880 --> 00:35:11,760
This.valor

555
00:35:11,760 --> 00:35:13,559
Es igual

556
00:35:13,559 --> 00:35:15,059
A valor

557
00:35:15,059 --> 00:35:18,380
Perfecto

558
00:35:18,380 --> 00:35:20,179
¿Qué le pongo en siguiente?

559
00:35:29,480 --> 00:35:29,780
Null

560
00:35:29,780 --> 00:35:34,230
Y yo estoy creando un nodo

561
00:35:34,230 --> 00:35:37,469
No sé todavía a quién tiene que apuntar

562
00:35:37,469 --> 00:35:38,909
Se lo diré después

563
00:35:38,909 --> 00:35:41,739
¿Sí?

564
00:35:41,739 --> 00:35:45,840
Puedo hacer que estos sean accesibles directamente

565
00:35:45,840 --> 00:35:48,059
Puedo ponerlos privados

566
00:35:48,059 --> 00:35:53,730
Para que los maneje yo

567
00:35:53,730 --> 00:35:55,710
Si los manejo yo

568
00:35:55,710 --> 00:36:02,710
Tendré que poner un public tgetValor

569
00:36:02,710 --> 00:36:07,139
Que hará return valor

570
00:36:07,139 --> 00:36:11,250
Y luego quiero un public

571
00:36:11,250 --> 00:36:16,750
Siguiente

572
00:36:16,750 --> 00:36:40,829
public nodo siguiente, que lo que hace es return this.siguiente, fijaos que esto es siguiente como método, esto es siguiente como variable, son dos cosas distintas.

573
00:36:40,829 --> 00:37:14,969
Y luego tendré un publicNodo, public void, setSiguiente, en el que me darás un nodo, en el que si tú llamas este método sobre un nodo, le estás pasando otro nodo y le estás diciendo que this.Siguiente es igual al siguiente nodo.

574
00:37:19,590 --> 00:37:20,750
Estos son getter y setter.

575
00:37:22,329 --> 00:37:24,110
Ahora yo aquí pondría esto.

576
00:37:25,349 --> 00:37:26,449
Para estar seguros.

577
00:37:26,849 --> 00:37:30,389
Todas las veces que ponéis nodo, ponéisle la T.

578
00:37:34,340 --> 00:37:34,940
Esto se enfada.

579
00:37:39,239 --> 00:37:39,579
Así no.

580
00:37:39,900 --> 00:37:40,500
Bueno, ya está.

581
00:37:41,340 --> 00:37:41,500
¿Sí?

582
00:37:42,539 --> 00:37:45,139
Entonces yo tengo mi nodito que no es nada.

583
00:37:45,219 --> 00:37:46,599
No hace nada nodo por sí mismo.

584
00:37:46,840 --> 00:37:48,420
Es solo el objeto que voy a utilizar.

585
00:37:48,420 --> 00:37:52,420
Es el elemento que me permite crear lo que se llama una lista enlazada.

586
00:37:53,340 --> 00:37:55,380
Estoy enlazando nodos.

587
00:37:55,500 --> 00:38:00,179
donde acaba mi lista

588
00:38:00,179 --> 00:38:07,260
esto apunta aquí, esto apunta aquí, donde acaba

589
00:38:07,260 --> 00:38:14,099
en aquel nodo cuyo siguiente

590
00:38:14,099 --> 00:38:20,280
de null, si yo tengo un nodo

591
00:38:20,280 --> 00:38:24,940
voy a mirar su siguiente y me dice null, he acabado al final de la lista

592
00:38:24,940 --> 00:38:30,440
¿make sense? ¿donde empieza mi lista?

593
00:38:35,980 --> 00:38:38,960
en el primer nodo, yo tendré un nodo especial

594
00:38:38,960 --> 00:38:41,139
que es el primer nodo, que me lo guardaré

595
00:38:41,139 --> 00:38:43,239
y diré, aquí es donde empieza la lista

596
00:38:43,239 --> 00:38:44,820
¿y cómo es una lista vacía?

597
00:38:50,820 --> 00:38:52,739
si este inicio de lista

598
00:38:52,739 --> 00:38:54,000
apunta null

599
00:38:54,000 --> 00:38:56,059
pues la lista es vacía

600
00:38:56,059 --> 00:38:58,159
¿se entiende?

601
00:39:01,099 --> 00:39:02,460
entonces, con estos

602
00:39:02,460 --> 00:39:04,480
elementos, vamos a trabajar

603
00:39:04,480 --> 00:39:06,559
entonces, nodo no lo tengo

604
00:39:06,559 --> 00:39:08,460
aquí, ¿vale? si lo tengo que modificar

605
00:39:08,460 --> 00:39:10,480
el considera que esta cosa aquí no me sirve

606
00:39:10,480 --> 00:39:12,380
si tengo que modificarla o cosarla

607
00:39:12,380 --> 00:39:14,079
pues puedo venir aquí y cambiarla

608
00:39:14,079 --> 00:39:15,880
si se me ha olvidado algo, cosa por el estilo

609
00:39:15,880 --> 00:39:17,900
Por ahora, vamos a mi lista enlazada.

610
00:39:18,460 --> 00:39:25,980
¿Qué necesito como variable, como atributo, como cosa interesante para mi lista?

611
00:39:31,019 --> 00:39:31,719
Tipo lo tengo aquí.

612
00:39:32,719 --> 00:39:33,320
Atributos.

613
00:39:33,659 --> 00:39:38,940
Como aquí estaban atributos, aquí como atributo había puesto esto.

614
00:39:39,500 --> 00:39:41,659
Aquí como atributo he puesto estos de aquí.

615
00:39:41,659 --> 00:39:47,320
No, porque estoy haciendo todo esto para no usar los arrays.

616
00:39:47,320 --> 00:39:54,630
Efectivamente, tengo un nodo de T

617
00:39:54,630 --> 00:39:57,289
Que es el señor primero

618
00:39:57,289 --> 00:40:05,099
Si este señor es nul, mi lista es vacía

619
00:40:05,099 --> 00:40:08,099
Si este señor apunta un nodo

620
00:40:08,099 --> 00:40:10,840
A partir de ese nodo puedo recorrer mi lista

621
00:40:10,840 --> 00:40:14,599
Yendo al siguiente, al siguiente, al siguiente, al siguiente, al siguiente, al siguiente

622
00:40:14,599 --> 00:40:17,139
Hasta que encuentre un siguiente nul

623
00:40:17,139 --> 00:40:18,639
Y ahí se ha acabado mi lista

624
00:40:18,639 --> 00:40:25,500
Cuando ponga nodo 2

625
00:40:25,500 --> 00:40:27,840
No pongo nodo 2

626
00:40:27,840 --> 00:40:30,460
no pongo nodo segundo

627
00:40:30,460 --> 00:40:34,429
no lo necesito

628
00:40:34,429 --> 00:40:36,829
porque no necesito

629
00:40:36,829 --> 00:40:39,650
esta en mi lista

630
00:40:39,650 --> 00:40:41,050
enlazada

631
00:40:41,050 --> 00:40:43,530
que tiene el puntero

632
00:40:43,530 --> 00:40:44,050
primero

633
00:40:44,050 --> 00:40:47,469
todos estos elementos de aquí

634
00:40:47,469 --> 00:40:49,769
no los necesito aquí dentro

635
00:40:49,769 --> 00:40:51,489
a mi me interesa solo

636
00:40:51,489 --> 00:40:53,409
el puntero

637
00:40:53,409 --> 00:40:55,050
al primer elemento

638
00:40:55,050 --> 00:40:57,710
luego a partir de aquí puedo seguir

639
00:40:57,710 --> 00:40:58,710
la cadena

640
00:40:58,710 --> 00:41:00,190
Siguiendo

641
00:41:00,190 --> 00:41:01,949
Toda mi lista

642
00:41:01,949 --> 00:41:05,670
Entonces, aquí dentro lo que necesito es el primero

643
00:41:05,670 --> 00:41:11,429
Vale

644
00:41:11,429 --> 00:41:15,539
Podría

645
00:41:15,539 --> 00:41:16,719
Si quiero

646
00:41:16,719 --> 00:41:18,559
Tener un int

647
00:41:18,559 --> 00:41:21,539
De elementos

648
00:41:21,539 --> 00:41:23,760
Para saber

649
00:41:23,760 --> 00:41:25,719
Cuantos elementos hay en mi lista

650
00:41:25,719 --> 00:41:27,900
Para simplificar

651
00:41:27,900 --> 00:41:28,739
El size

652
00:41:28,739 --> 00:41:30,159
Pero no es necesario

653
00:41:30,159 --> 00:41:32,380
Por lo tanto no lo pongo

654
00:41:32,380 --> 00:41:35,400
O si queremos lo añadimos después para modificación

655
00:41:35,400 --> 00:41:42,960
Entonces, ahora voy a empezar, por ejemplo, la añadir

656
00:41:42,960 --> 00:41:52,219
Para hacer la añadir, lo que tengo que hacer yo es añadir un nuevo elemento

657
00:41:52,219 --> 00:41:53,420
¿Dónde se añade?

658
00:41:54,519 --> 00:41:55,699
Dos opciones

659
00:41:55,699 --> 00:41:58,420
O lo añado al principio de la lista

660
00:41:58,420 --> 00:42:01,500
O lo añado al final de la lista

661
00:42:01,500 --> 00:42:04,679
podría tener un add

662
00:42:04,679 --> 00:42:06,860
que me pille un elemento

663
00:42:06,860 --> 00:42:08,119
coma una posición

664
00:42:08,119 --> 00:42:10,559
y que me añade este elemento

665
00:42:10,559 --> 00:42:12,760
en esta posición, lo podría hacer

666
00:42:12,760 --> 00:42:14,179
pero por ahora

667
00:42:14,179 --> 00:42:16,199
mantenemos en lo easy

668
00:42:16,199 --> 00:42:18,800
¿vale? y tengo añade un elemento

669
00:42:18,800 --> 00:42:20,420
¿dónde lo queréis añadir?

670
00:42:26,179 --> 00:42:27,980
si lo queréis

671
00:42:27,980 --> 00:42:28,980
en la primera posición

672
00:42:28,980 --> 00:42:31,099
estáis creando una lista invertida

673
00:42:31,099 --> 00:42:33,780
yo te digo gato, cocodrilo y cebra

674
00:42:33,780 --> 00:42:38,340
y él almacenará, cuando la voy a mirar, cebra, cocodrilo, gato.

675
00:42:39,420 --> 00:42:42,300
Porque el primero que se encontrará es el último que has metido.

676
00:42:42,599 --> 00:42:43,960
A lo mejor es lo que quieras.

677
00:42:45,360 --> 00:42:46,820
Normalmente cuando yo hago una lista,

678
00:42:47,440 --> 00:42:50,960
lo que me espero es que los últimos que he añadido estén al final.

679
00:42:52,059 --> 00:42:57,659
Entonces hagamos lo que es más conceptualmente fácil de ver,

680
00:42:58,880 --> 00:43:00,420
aun si es más difícil de programar.

681
00:43:00,420 --> 00:43:03,719
luego nadie me prohíbe de poner

682
00:43:03,719 --> 00:43:05,840
at the first, que en vez de añadirla

683
00:43:05,840 --> 00:43:07,179
al final, pues la añade al principio

684
00:43:07,179 --> 00:43:08,739
pero ya no estaría

685
00:43:08,739 --> 00:43:10,679
en mi lista

686
00:43:10,679 --> 00:43:13,559
es un método propio de mi lista enlazada

687
00:43:13,559 --> 00:43:15,480
entonces, añadíamos

688
00:43:15,480 --> 00:43:17,619
¿cómo hago esto?

689
00:43:18,500 --> 00:43:19,400
paso número uno

690
00:43:19,400 --> 00:43:29,599
no, paso número uno

691
00:43:29,599 --> 00:43:33,690
¿el?

692
00:43:35,789 --> 00:43:36,630
¿en qué sentido?

693
00:43:42,940 --> 00:43:45,219
efectivamente, primera cosa, miro si

694
00:43:45,219 --> 00:43:47,239
primer nodo es

695
00:43:47,239 --> 00:43:49,139
Null

696
00:43:49,139 --> 00:43:50,920
Porque si es null

697
00:43:50,920 --> 00:43:54,079
Este que estás añadiendo es el primer nodo

698
00:43:54,079 --> 00:43:54,840
Y es fácil

699
00:43:54,840 --> 00:43:56,420
Si no es null

700
00:43:56,420 --> 00:43:58,079
Pues a ver qué hago

701
00:43:58,079 --> 00:44:01,480
Entonces, asumamos que

702
00:44:01,480 --> 00:44:05,730
Me han añadido

703
00:44:05,730 --> 00:44:06,750
Me están añadiendo

704
00:44:06,750 --> 00:44:08,349
Un objeto T

705
00:44:08,349 --> 00:44:09,909
Añadir un objeto T

706
00:44:09,909 --> 00:44:12,670
Quiere decir que no me están añadiendo un nodo

707
00:44:12,670 --> 00:44:15,070
Me están añadiendo un valor

708
00:44:15,070 --> 00:44:17,670
Entonces, la primera cosa que hago

709
00:44:17,670 --> 00:44:19,050
Es crearme un nodo

710
00:44:19,050 --> 00:44:29,190
Nodo de tipo T nuevo es igual a new nodo de tipo T de S.

711
00:44:33,179 --> 00:44:39,139
A mí me han dicho, trabajando como string, a mí me ha dicho añade cebra.

712
00:44:39,139 --> 00:44:47,460
Y yo lo que he hecho es crearme un nodo nuevo que contiene cebra y cuyo nuevo punto siguiente, ¿qué será?

713
00:44:49,670 --> 00:44:50,230
Null.

714
00:44:50,230 --> 00:44:55,230
Y esto es el que va aquí.

715
00:44:56,710 --> 00:45:01,369
Este nuevo elemento que he hecho es el que pondré aquí y apuntará a null.

716
00:45:02,369 --> 00:45:05,150
Perfecto, tiene que apuntar a null porque es el último de la lista.

717
00:45:09,980 --> 00:45:11,880
No, lo estás implementando tú.

718
00:45:13,920 --> 00:45:17,119
Es como lo queremos hacer nosotros, como hemos dicho que lo vamos a hacer nosotros.

719
00:45:21,239 --> 00:45:26,179
Porque en una lista tiene sentido que el último que añadas sea el último de la lista.

720
00:45:27,400 --> 00:45:28,219
Pero no necesariamente.

721
00:45:29,219 --> 00:45:32,679
Hay estructuras de datos en que lo último que pones tiene que ser el primero.

722
00:45:33,059 --> 00:45:34,960
Pues entonces lo implementas como que sea el primero.

723
00:45:35,380 --> 00:45:36,599
Pero no es lo que estamos haciendo.

724
00:45:37,239 --> 00:45:43,159
Nosotros hemos decidido que lo implementamos, que el añadir añade al fondo de la lista.

725
00:45:44,059 --> 00:45:44,219
¿Vale?

726
00:45:44,639 --> 00:45:47,139
Entonces, me creo lo que quiero añadir.

727
00:45:48,239 --> 00:45:48,440
¿Sí?

728
00:45:48,440 --> 00:45:55,679
Y ahora me pregunto, si primero es null, ¿qué hago?

729
00:46:00,530 --> 00:46:02,449
Primero es igual a nuevo.

730
00:46:05,940 --> 00:46:08,179
He creado un nuevo objeto, ¿sí?

731
00:46:08,659 --> 00:46:14,260
Y si mi lista está vacía, no apunta nada, le digo, vale, tú eres el primer objeto.

732
00:46:15,559 --> 00:46:16,599
Y se acabó.

733
00:46:19,280 --> 00:46:21,440
Estamos de acuerdo que este tiene el siguiente null.

734
00:46:22,860 --> 00:46:25,239
Habría hecho lo siguiente, ¿vale?

735
00:46:29,280 --> 00:46:30,579
Creo mi lista.

736
00:46:30,840 --> 00:46:32,760
Mi lista tiene primero, ¿vale?

737
00:46:32,760 --> 00:46:34,579
Este es primero, que es null.

738
00:46:36,300 --> 00:46:39,539
Ahora hago add de cebra, por ejemplo.

739
00:46:39,539 --> 00:46:50,869
Entonces, me creo un nodo nuevo que tiene dentro cebra y que apunta null, ¿sí?

740
00:46:51,489 --> 00:46:57,449
Y luego le digo, primero, tú eres esto.

741
00:47:02,739 --> 00:47:07,599
Y entonces ahora tengo mi lista que se acceda primero, accederá a su primer elemento.

742
00:47:10,480 --> 00:47:10,860
¿Sí o no?

743
00:47:11,860 --> 00:47:12,099
Vale.

744
00:47:12,099 --> 00:47:23,880
Ahora, asumamos en vez que no es así, que primero no da null, por lo tanto primero hay algo en primero.

745
00:47:24,699 --> 00:47:49,590
¿Qué hago si hay algo en primero? No, crear no puedo crear otro, porque yo tengo que añadir un solo elemento.

746
00:47:50,590 --> 00:47:54,150
Entonces, ahora estaría en la situación en la que esto lo tengo ya,

747
00:47:58,389 --> 00:48:01,409
tengo esto, imaginamos que esto ya está,

748
00:48:02,010 --> 00:48:09,489
y yo quiero añadir un nuevo objeto que sea jirafa, no, que sea gato,

749
00:48:09,489 --> 00:48:11,469
porque se escribe rápido, ¿vale?

750
00:48:11,690 --> 00:48:17,090
Entonces, este primer paso me habrá creado el nuevo elemento.

751
00:48:17,469 --> 00:48:24,760
Aquí ahora tengo gato, que apunta null, ¿sí?

752
00:48:25,219 --> 00:48:33,800
Ahora, lo que pasa es que antes IOPET lo tenía nul, entonces solo he dicho apunta aquí y se acabó.

753
00:48:34,480 --> 00:48:35,579
Ahora no lo puede hacer.

754
00:48:36,659 --> 00:48:37,800
¿Qué tengo que hacer?

755
00:48:47,449 --> 00:48:47,849
El código.

756
00:48:55,369 --> 00:48:55,469
No.

757
00:48:55,849 --> 00:48:56,949
Nuevo punto siguiente, ¿qué es?

758
00:48:57,150 --> 00:48:57,650
Seguramente.

759
00:49:00,000 --> 00:49:01,519
¿Qué es nuevo punto siguiente?

760
00:49:02,460 --> 00:49:03,239
¿Cuánto vale?

761
00:49:03,360 --> 00:49:04,500
¿Qué hay dentro de nuevo punto siguiente?

762
00:49:04,679 --> 00:49:04,960
Nul.

763
00:49:05,099 --> 00:49:09,219
Por lo tanto, porque lo acabo de crear y se crea nul.

764
00:49:09,219 --> 00:49:21,760
Lo que tendré que hacer es, partiendo de primero, recorrerme toda la lista.

765
00:49:24,420 --> 00:49:31,559
De primero al siguiente, a esto al siguiente, a esto al siguiente, hasta encontrar un nodo cuyo siguiente sea nul.

766
00:49:34,099 --> 00:49:41,539
Y eso será el último nodo de la anterior lista.

767
00:49:41,780 --> 00:49:47,860
Entonces, lo que tendré que hacer es, a ese nodo, cambiarle el siguiente al nuevo objeto.

768
00:49:48,659 --> 00:49:50,699
Eso es lo que tengo que hacer

769
00:49:50,699 --> 00:49:54,210
Después de recreo lo hago