1
00:00:00,370 --> 00:00:04,830
Voy a grabar esta clase, si habláis me dais el permiso de grabar vuestras voces

2
00:00:04,830 --> 00:00:10,650
Entonces, hoy vamos a empezar a ver, bueno, repasar porque empezamos a verla otra vez

3
00:00:10,650 --> 00:00:12,189
Las estructuras dinámicas, ¿vale?

4
00:00:13,089 --> 00:00:18,469
La diferencia con lo que hemos visto antes es que nosotros para almacenar datos

5
00:00:18,469 --> 00:00:23,170
Hemos siempre utilizado los arrays que son estáticos en el sentido que tienes que darle un tamaño inicial

6
00:00:23,170 --> 00:00:29,510
Y ese tamaño es el que tiene el array, luego puedes rellenarlo un poco o rellenarlo entero

7
00:00:29,510 --> 00:00:31,629
eso no pasa nada, pero el tamaño del array

8
00:00:31,629 --> 00:00:32,450
es siempre el mismo

9
00:00:32,450 --> 00:00:34,729
y que a la hora de

10
00:00:34,729 --> 00:00:37,509
rellenar un array y tengo que añadir un dato nuevo

11
00:00:37,509 --> 00:00:39,590
lo que tenía que hacer es crearme un nuevo

12
00:00:39,590 --> 00:00:41,170
array con más espacio

13
00:00:41,170 --> 00:00:43,329
y luego borrar

14
00:00:43,329 --> 00:00:44,990
o sea, destruir el anterior

15
00:00:44,990 --> 00:00:47,210
después de haber copiado todos los valores

16
00:00:47,210 --> 00:00:48,369
que quería copiar

17
00:00:48,369 --> 00:00:49,969
pero en sustancia

18
00:00:49,969 --> 00:00:52,549
un array no se modifica

19
00:00:52,549 --> 00:00:54,310
no varía de su tamaño

20
00:00:54,310 --> 00:00:57,270
lo que puedo hacer yo es construirme un array más grande

21
00:00:57,270 --> 00:00:59,270
y copiar lo que tenía antes

22
00:00:59,509 --> 00:01:28,730
Las estructuras dinámicas en vez quieren ser una colección de datos que puede cambiar su tamaño en tiempo de ejecución, o sea que cuando yo la estoy compilando no sé cuántos datos contendrán estas colecciones, luego en tiempo de ejecución lo iré llenando, llenando, llenando y estas colecciones, estas estructuras dinámicas podrán hacerse más grandes a medida que yo añado nuevos datos.

23
00:01:28,730 --> 00:01:34,590
Eso no implica que yo no pueda utilizar Array por debajo y hacer lo que hemos hecho siempre de extender Array

24
00:01:34,590 --> 00:01:40,129
Si yo la implementación, como implemento esta estructura dinámica es a través de un Array

25
00:01:40,129 --> 00:01:41,930
Pues tendré que hacer lo que hemos hecho hasta ahora

26
00:01:41,930 --> 00:01:45,790
Pero hemos visto por ejemplo en el caso de la lista enlazada

27
00:01:45,790 --> 00:01:52,769
Que hay otras alternativas que puedo utilizar para implementar estas estructuras dinámicas

28
00:01:52,769 --> 00:01:59,469
Vale, entonces, estructuras dinámicas básicas que veremos son las listas, las colas, las pilas y los árboles

29
00:01:59,469 --> 00:02:07,030
Las listas ya las hemos visto, es sustancialmente una estructura dinámica que permite almacenar objetos

30
00:02:07,030 --> 00:02:15,030
Y sustancialmente yo voy añadiendo a esta lista los objetos que se ponen unos detrás de otros

31
00:02:15,030 --> 00:02:35,030
En un cierto sentido, el orden con el que introduzco los objetos tiene un valor, tiene un sentido, porque independientemente de si los añado delante o detrás, cuando voy añadiendo los objetos, estos se van ordenando según el orden de inserción.

32
00:02:35,030 --> 00:02:54,430
inserción. Veremos que hay otras colecciones, otras estructuras dinámicas en el que el orden no se mantiene, en el sentido que yo añado objetos pero no se me almacenan con el orden de inserción, sino se me almacenan de otra forma.

33
00:02:54,430 --> 00:03:00,229
La lista se puede insertar objetos

34
00:03:00,229 --> 00:03:06,930
En realidad la lista me permite también insertar objetos al fondo, al principio o a mitad de la lista

35
00:03:06,930 --> 00:03:11,870
Así como me permite recorrer la lista

36
00:03:11,870 --> 00:03:19,889
Que normalmente se hace desde un inicio y saltando a los otros elementos de la lista

37
00:03:19,889 --> 00:03:22,629
Me permite quitar un elemento, etc.

38
00:03:22,629 --> 00:03:25,710
En principio en la lista yo puedo hacer

39
00:03:25,710 --> 00:03:27,830
Un acceso aleatorio

40
00:03:27,830 --> 00:03:29,969
A los elementos

41
00:03:29,969 --> 00:03:31,030
Que están ahí dentro

42
00:03:31,030 --> 00:03:34,090
Me puede costar más o menos dependiendo de la implementación

43
00:03:34,090 --> 00:03:35,229
Pero yo puedo decir

44
00:03:35,229 --> 00:03:36,530
Acceda al tercer objeto

45
00:03:36,530 --> 00:03:39,550
¿Vale? Sin embargo hay otras

46
00:03:39,550 --> 00:03:41,710
Lo veremos ahora, otras estructuras dinámicas

47
00:03:41,710 --> 00:03:44,090
En que yo no puedo acceder al tercer objeto

48
00:03:44,090 --> 00:03:44,969
¿Si?

49
00:03:46,550 --> 00:03:48,430
Esto es un poco lo que decías tú también

50
00:03:48,430 --> 00:03:50,110
La lista si permite

51
00:03:50,110 --> 00:03:52,530
Decir, oye, remuéveme este objeto de aquí

52
00:03:52,530 --> 00:03:55,449
Como lista, la cola no debería

53
00:03:55,449 --> 00:03:58,330
Pero como la cola muchas veces deriva de la lista

54
00:03:58,330 --> 00:03:59,509
Implementa también list

55
00:03:59,509 --> 00:04:00,629
Pues entonces es como

56
00:04:00,629 --> 00:04:03,169
La función la hay

57
00:04:03,169 --> 00:04:05,650
Pero luego no la usas

58
00:04:05,650 --> 00:04:06,590
Si la quieres utilizar como

59
00:04:06,590 --> 00:04:12,550
La cola es parecida a una lista

60
00:04:12,550 --> 00:04:16,569
Pero tiene un comportamiento más definido

61
00:04:16,569 --> 00:04:18,829
Es decir que vamos a utilizar

62
00:04:18,829 --> 00:04:20,850
El concepto de FIFO

63
00:04:20,850 --> 00:04:22,370
O sea, first in, first out

64
00:04:22,370 --> 00:04:29,970
Es decir que cuando yo añado un objeto pues eso se va poniéndose en la cola

65
00:04:29,970 --> 00:04:37,170
Al principio pongamos y cuando yo voy a sacar un objeto no puedo sacar uno cualquiera

66
00:04:37,170 --> 00:04:39,750
Tengo que sacar el primero de la cola

67
00:04:39,750 --> 00:04:43,689
Entonces en esta estructura de datos cuando yo utilizo una cola

68
00:04:43,689 --> 00:04:48,750
Es porque quiero que el orden de inserción en un cierto sentido

69
00:04:48,750 --> 00:04:52,930
Sea importante a la hora de recuperar estos datos

70
00:04:52,930 --> 00:04:54,850
No puedo recuperar el dato que me da la gana

71
00:04:54,850 --> 00:04:56,490
Si yo he puesto tres objetos

72
00:04:56,490 --> 00:04:58,389
Los tengo que recuperar en orden

73
00:04:58,389 --> 00:05:00,410
Según como los he insertado

74
00:05:00,410 --> 00:05:01,250
¿Sí?

75
00:05:01,470 --> 00:05:03,709
Entonces el primero que he metido

76
00:05:03,709 --> 00:05:05,389
Será el primero que puedo utilizar

77
00:05:05,389 --> 00:05:07,730
Si quiero utilizar el tercer objeto

78
00:05:07,730 --> 00:05:10,329
Tendré que sacar antes los primeros dos

79
00:05:10,329 --> 00:05:11,750
Y llegar al tercero

80
00:05:11,750 --> 00:05:13,550
¿Sí?

81
00:05:16,680 --> 00:05:19,300
Una pila en vez utiliza

82
00:05:19,300 --> 00:05:22,060
LIFO, o sea Last In First Out

83
00:05:22,060 --> 00:05:24,240
Es siempre parecido

84
00:05:24,240 --> 00:05:24,860
A una lista

85
00:05:24,860 --> 00:05:27,379
Pero su comportamiento es que

86
00:05:27,379 --> 00:05:29,639
El último elemento que he insertado

87
00:05:29,639 --> 00:05:32,399
Es el primero que puedo sacar

88
00:05:32,399 --> 00:05:33,240
¿Vale?

89
00:05:33,459 --> 00:05:35,920
Si yo inserto tres elementos

90
00:05:35,920 --> 00:05:38,339
El primero

91
00:05:38,339 --> 00:05:40,540
Que puedo sacar es el tercero

92
00:05:40,540 --> 00:05:41,120
¿Vale?

93
00:05:41,220 --> 00:05:44,399
Si quiero volver a pillar el primer elemento que he insertado

94
00:05:44,399 --> 00:05:46,000
Pues tendré antes que

95
00:05:46,000 --> 00:05:48,259
Quitar el tercero, quitar el segundo

96
00:05:48,259 --> 00:05:50,699
Y ese punto tendrá a disposición el primero

97
00:05:50,699 --> 00:05:53,379
Se van acumulando uno encima del otro

98
00:05:53,379 --> 00:05:57,860
Pensadlo como una pila de cajas

99
00:05:57,860 --> 00:05:59,920
Y voy poniendo una caja encima de otra

100
00:05:59,920 --> 00:06:02,100
Entonces la última caja que meto encima

101
00:06:02,100 --> 00:06:03,379
Es la primera que puedo pillar

102
00:06:03,379 --> 00:06:07,860
No puedo pillar la caja que está a la base de la columna de cajas

103
00:06:07,860 --> 00:06:15,259
El árbol en vez es una estructura que no es lineal

104
00:06:15,259 --> 00:06:18,079
Las listas hasta ahora en un cierto sentido

105
00:06:18,079 --> 00:06:19,839
Son una línea uno detrás de otro

106
00:06:19,839 --> 00:06:27,279
Sin embargo, el árbol obtiene una forma como la de la figura

107
00:06:27,279 --> 00:06:31,500
El nodo principal, el de arriba, se llama nodo raíz

108
00:06:31,500 --> 00:06:33,220
Este es un árbol al revés

109
00:06:33,220 --> 00:06:36,819
La raíz está arriba y las hojas están abajo

110
00:06:36,819 --> 00:06:43,939
El nodo primero, el primer nodo de acceso que no tiene padre

111
00:06:43,939 --> 00:06:45,879
Pues ese es el nodo raíz

112
00:06:45,879 --> 00:06:49,480
A partir de allí, cuelgan uno o varios hijos

113
00:06:49,480 --> 00:06:56,459
Y puede haber alguna lógica de cómo organizo estos hijos

114
00:06:56,459 --> 00:07:00,019
Si lo pongo por un lado o por el otro o cosa por el estilo

115
00:07:00,019 --> 00:07:08,319
Veremos por ejemplo que hay algunas estructuras como los árboles binarios de búsqueda

116
00:07:08,319 --> 00:07:13,079
En el que estos nodos son organizados de tal forma

117
00:07:13,079 --> 00:07:19,319
Que si el nodo que quiero insertar es mayor del nodo padre

118
00:07:19,319 --> 00:07:20,800
Pues lo pondré a su derecha

119
00:07:20,800 --> 00:07:23,120
Y si es menor lo pondré a su izquierda

120
00:07:23,120 --> 00:07:26,160
Y esto me permite luego de hacer búsquedas mucho más eficientes

121
00:07:26,160 --> 00:07:27,959
Hablaremos de ellos más adelante

122
00:07:27,959 --> 00:07:33,740
Los nodos que no tienen hijos se llaman hojas

123
00:07:33,740 --> 00:07:34,600
¿Vale?

124
00:07:34,740 --> 00:07:36,540
Y son los últimos aquí abajo

125
00:07:36,540 --> 00:07:41,019
Y luego, bueno, un nodo interior es un nodo que no es hoja

126
00:07:41,019 --> 00:07:46,899
El nivel del árbol es cuantas generaciones tiene un árbol

127
00:07:46,899 --> 00:07:53,160
O sea, en este caso, esto tendría 1, 2, 3, 4 generaciones

128
00:07:53,160 --> 00:07:55,259
El nivel sería 4

129
00:07:55,259 --> 00:07:58,899
El grado de un nodo es cuantos hijos tiene

130
00:07:58,899 --> 00:08:02,600
Por ejemplo, esto tiene grado 3

131
00:08:02,600 --> 00:08:04,920
Esto tiene grado 1

132
00:08:04,920 --> 00:08:12,680
Y el grado de un árbol es el máximo grado de los nodos

133
00:08:12,680 --> 00:08:15,639
O sea, si yo miro este árbol de aquí

134
00:08:15,639 --> 00:08:17,620
El grado de este árbol es 3

135
00:08:17,620 --> 00:08:19,800
Porque ya hay este nodo con 3 hijos

136
00:08:19,800 --> 00:08:21,019
Que es el máximo

137
00:08:21,019 --> 00:08:22,959
¿Sí?

138
00:08:24,220 --> 00:08:27,259
Un árbol de búsqueda, por ejemplo

139
00:08:27,259 --> 00:08:28,779
Es de grado 2

140
00:08:28,779 --> 00:08:32,059
Siempre los hijos máximos son 2

141
00:08:32,059 --> 00:08:33,399
O mayor o menor

142
00:08:33,399 --> 00:08:38,929
Entonces

143
00:08:38,929 --> 00:08:42,250
Estos son conceptos muy genéricos

144
00:08:42,250 --> 00:08:44,289
Nosotros ya con las herramientas que tenemos

145
00:08:44,289 --> 00:08:46,289
Lo que hemos hecho hasta ahora

146
00:08:46,289 --> 00:08:47,889
Podríamos implementar estas cosas

147
00:08:47,889 --> 00:08:49,730
Hacer nuestra propia implementación

148
00:08:49,730 --> 00:08:52,750
De colas, pilas, listas, etc

149
00:08:52,750 --> 00:08:53,990
De hecho

150
00:08:53,990 --> 00:08:56,409
Hemos hecho una implementación de lista

151
00:08:56,409 --> 00:08:58,750
Tanto con array como con

152
00:08:58,750 --> 00:09:02,429
Nodos enlazados entre ellos

153
00:09:02,429 --> 00:09:04,610
Y os dije

154
00:09:04,610 --> 00:09:07,029
Lo que podéis intentar es modificar una de estas

155
00:09:07,029 --> 00:09:08,429
Para que hagáis una cola

156
00:09:08,429 --> 00:09:11,370
En vez de poder elegir lo que me da la gana

157
00:09:11,370 --> 00:09:14,149
Es elegir siempre el primero de la lista

158
00:09:14,149 --> 00:09:16,470
Y insertar siempre al fondo de la lista

159
00:09:16,470 --> 00:09:18,230
Entonces modificar los métodos

160
00:09:18,230 --> 00:09:19,789
Para que cuando añado algo

161
00:09:19,789 --> 00:09:20,909
Se añada al final

162
00:09:20,909 --> 00:09:23,070
Y que cuando pillo algo

163
00:09:23,070 --> 00:09:24,330
Pues pille siempre el primero

164
00:09:24,330 --> 00:09:26,649
Lo podéis ya hacer

165
00:09:26,649 --> 00:09:29,049
Vamos a ver un poco en Java

166
00:09:29,049 --> 00:09:31,750
Estas cosas de las que hemos hablado

167
00:09:31,750 --> 00:09:33,090
Cómo se llaman

168
00:09:33,090 --> 00:09:34,529
Qué implementaciones hay

169
00:09:34,529 --> 00:09:36,129
Que diferenciar entre ellas

170
00:09:36,129 --> 00:09:38,490
Vamos a ver algunas de ellas

171
00:09:38,490 --> 00:09:40,389
Primero empezar

172
00:09:40,389 --> 00:09:42,629
Por el hecho que está

173
00:09:42,629 --> 00:09:44,169
Una interfaz que se llama Collection

174
00:09:44,169 --> 00:09:46,149
Que es sustancialmente

175
00:09:46,149 --> 00:09:48,529
La abstracción más alta

176
00:09:48,529 --> 00:09:50,990
De este tipo de

177
00:09:50,990 --> 00:09:52,129
Estructuras dinámicas

178
00:09:52,129 --> 00:09:54,070
Es una colección de datos

179
00:09:54,070 --> 00:09:56,909
Representa lo que se puede

180
00:09:56,909 --> 00:09:58,870
Hacer en una colección de datos

181
00:09:58,870 --> 00:10:00,570
La interfaz Collection

182
00:10:00,570 --> 00:10:02,190
Acordaros que la interfaz me define

183
00:10:02,190 --> 00:10:04,190
Un comportamiento, me define una serie de métodos

184
00:10:04,529 --> 00:10:06,370
Que luego yo tendré que implementar

185
00:10:06,370 --> 00:10:09,169
Cuando estoy hablando de una colección en general

186
00:10:09,169 --> 00:10:11,149
Pues habrá un conjunto de métodos

187
00:10:11,149 --> 00:10:11,850
Que ahora veremos

188
00:10:11,850 --> 00:10:13,409
Que son los métodos básicos

189
00:10:13,409 --> 00:10:15,950
Que valen para cualquier colección

190
00:10:15,950 --> 00:10:17,870
Como por ejemplo añadir un objeto

191
00:10:17,870 --> 00:10:19,230
Quitar un objeto

192
00:10:19,230 --> 00:10:21,590
Preguntarme el tamaño de un objeto

193
00:10:21,590 --> 00:10:22,830
Más o menos

194
00:10:22,830 --> 00:10:26,190
Es lo que nosotros hemos hecho

195
00:10:26,190 --> 00:10:28,250
En nuestra interfaz

196
00:10:28,250 --> 00:10:29,909
Lista

197
00:10:29,909 --> 00:10:30,629
Mi lista

198
00:10:30,629 --> 00:10:32,250
Cuando nosotros hemos creado mi lista

199
00:10:32,250 --> 00:10:34,389
Hemos dado unas informaciones básicas

200
00:10:34,389 --> 00:10:37,409
Que eran la de colección en Java

201
00:10:37,409 --> 00:10:38,090
¿Vale?

202
00:10:38,250 --> 00:10:39,490
Ahora lo que digo

203
00:10:39,490 --> 00:10:42,750
¿Colección sería como objeto en herencia?

204
00:10:44,450 --> 00:10:46,789
¿Como objeto en herencia?

205
00:10:47,529 --> 00:10:48,970
No, esto es un interfaz

206
00:10:48,970 --> 00:10:50,049
No es un objeto

207
00:10:50,049 --> 00:10:50,970
Claro, claro

208
00:10:50,970 --> 00:10:53,269
La función es la misma, ¿no?

209
00:10:53,370 --> 00:10:54,870
Es de donde parte todo, ¿no?

210
00:10:56,830 --> 00:10:58,190
No es de donde parte todo

211
00:10:58,190 --> 00:10:59,169
Porque es un interfaz

212
00:10:59,169 --> 00:11:00,110
No es una herencia

213
00:11:00,110 --> 00:11:03,350
No me está generando un árbol de herencia

214
00:11:03,350 --> 00:11:07,009
Pero cuando yo estoy dentro de las estructuras dinámicas

215
00:11:07,009 --> 00:11:11,350
Digamos que las funciones básicas de una estructura dinámica

216
00:11:11,350 --> 00:11:12,789
Están definidas en collection

217
00:11:12,789 --> 00:11:15,629
Eso es lo mínimo que puedes hacer para hacer una collection

218
00:11:15,629 --> 00:11:20,809
A partir de allí, si tú quieres hacer algo más específico

219
00:11:20,809 --> 00:11:25,549
Una cola, una stack, un árbol, una cosa por el estilo

220
00:11:25,549 --> 00:11:28,970
Pues entonces tendrás otras interfaces que implementar

221
00:11:28,970 --> 00:11:30,590
Otras clases que extender

222
00:11:30,590 --> 00:11:32,309
Y ahora lo veremos un poquito

223
00:11:32,309 --> 00:11:36,870
La colección representa un grupo de objetos denominados elementos

224
00:11:36,870 --> 00:11:40,750
Aquí cuando se habla de elementos se habla de algo que se pone ahí dentro

225
00:11:40,750 --> 00:11:45,350
Entonces yo tengo mi estructura dinámica y la relleno con elementos

226
00:11:45,350 --> 00:11:49,649
Podemos encontrar distintos tipos de colecciones

227
00:11:49,649 --> 00:11:55,250
Según si sus elementos están ordenados como las listas o no ordenados como los conjuntos

228
00:11:55,250 --> 00:11:56,470
Lo que se llaman los sets

229
00:11:56,470 --> 00:11:59,750
Si permitimos que los elementos se repiten

230
00:11:59,750 --> 00:12:03,710
Si permitimos que sea null o no, etc, etc, etc

231
00:12:03,710 --> 00:12:06,929
En base a esto hay varias implementaciones distintas

232
00:12:06,929 --> 00:12:10,690
Y repito, yo tengo que ver qué quiero poder hacer en mi sistema

233
00:12:10,690 --> 00:12:13,830
Y en base a eso elegir la implementación correcta

234
00:12:13,830 --> 00:12:18,669
El tipo de estructura dinámica correcto para hacer lo que quiero decir

235
00:12:18,669 --> 00:12:19,330
¿Vale?

236
00:12:19,750 --> 00:12:24,009
Este es el tipo más genérico en cuanto se refiere a cualquier tipo que contenga un grupo de elementos

237
00:12:24,009 --> 00:12:24,450
¿Vale?

238
00:12:24,529 --> 00:12:25,870
Es una colección de elementos

239
00:12:25,870 --> 00:12:28,509
Es muy genérico, no sabemos cómo funciona

240
00:12:28,509 --> 00:12:30,769
Es muy muy alto nivel

241
00:12:30,769 --> 00:12:32,590
Luego en base a cuál es el subfuncionamiento

242
00:12:32,590 --> 00:12:33,970
¿Funciona el IFO?

243
00:12:34,350 --> 00:12:36,610
Pues entonces buscaré stack por algún lado

244
00:12:36,610 --> 00:12:39,590
¿Funciona como FIFO?

245
00:12:39,710 --> 00:12:41,470
Pues entonces buscaré una cola

246
00:12:41,470 --> 00:12:42,929
Etcétera, etcétera

247
00:12:42,929 --> 00:12:45,129
Pero todas estas cosas al fin y al cabo

248
00:12:45,129 --> 00:12:46,970
Implementarán

249
00:12:46,970 --> 00:12:48,029
Collection

250
00:12:48,029 --> 00:12:49,090
¿Sí?

251
00:12:51,230 --> 00:12:52,789
En esta defensa tenemos

252
00:12:52,789 --> 00:12:54,970
Métodos, vale, que son

253
00:12:54,970 --> 00:12:56,690
Si no me equivoco, estos

254
00:12:56,690 --> 00:12:59,330
Esta es la interfaz collection

255
00:12:59,330 --> 00:13:00,769
Las operaciones que me da

256
00:13:00,769 --> 00:13:03,509
Para que tu implementes

257
00:13:03,509 --> 00:13:05,409
Collection tienes que poder

258
00:13:05,409 --> 00:13:06,690
Añadir un elemento

259
00:13:06,690 --> 00:13:09,230
Que será que almacena

260
00:13:09,230 --> 00:13:10,669
Este elemento dentro de la colección

261
00:13:10,669 --> 00:13:13,070
Preguntarme cuantos elementos

262
00:13:13,070 --> 00:13:14,210
Has almacenado hasta ahora

263
00:13:14,210 --> 00:13:16,889
Iterator

264
00:13:16,889 --> 00:13:18,129
Que ahora veremos que es

265
00:13:18,129 --> 00:13:20,629
Contains

266
00:13:20,629 --> 00:13:21,649
Que es un programa

267
00:13:21,649 --> 00:13:23,710
Es un método que me dice

268
00:13:23,710 --> 00:13:24,909
Oye te doy un elemento

269
00:13:24,909 --> 00:13:26,470
Dime si este elemento

270
00:13:26,470 --> 00:13:28,350
Está dentro de esta colección

271
00:13:28,350 --> 00:13:30,370
Y remove de un elemento

272
00:13:30,370 --> 00:13:32,490
Que me dice, oye mira, pilla este elemento

273
00:13:32,490 --> 00:13:34,570
Y quítalo, esté donde esté

274
00:13:34,570 --> 00:13:35,190
¿Vale?

275
00:13:35,529 --> 00:13:38,750
Y repito que todas las colecciones

276
00:13:38,750 --> 00:13:41,009
Derivan de esto, entonces todas las colecciones

277
00:13:41,009 --> 00:13:42,269
Sea queue, sea

278
00:13:42,269 --> 00:13:44,850
Stack, sea lo que sea

279
00:13:44,850 --> 00:13:46,669
Pues tendrán que tener

280
00:13:46,669 --> 00:13:48,029
Al menos estas cinco

281
00:13:48,029 --> 00:13:50,429
Funciones

282
00:13:50,429 --> 00:13:52,169
¿Y terretor qué es?

283
00:13:52,750 --> 00:13:54,730
Pues terretor es una forma

284
00:13:54,730 --> 00:13:56,210
De

285
00:13:56,210 --> 00:13:58,830
Poder acceder a una colección

286
00:13:58,830 --> 00:14:01,230
Y decirme, oye, mira, yo quiero hacer algo

287
00:14:01,230 --> 00:14:03,129
Sobre todos los

288
00:14:03,129 --> 00:14:04,990
Objetos de esta colección

289
00:14:04,990 --> 00:14:07,090
¿Vale? No sé cuántos son

290
00:14:07,090 --> 00:14:08,269
¿Vale?

291
00:14:08,269 --> 00:14:09,490
Pero yo quiero

292
00:14:09,490 --> 00:14:11,830
Pillar cada uno de estos elementos

293
00:14:11,830 --> 00:14:13,629
Y hacer algo sobre ello

294
00:14:13,629 --> 00:14:15,370
Por ejemplo, que se yo

295
00:14:15,370 --> 00:14:17,889
Compararlo con otro elemento

296
00:14:17,889 --> 00:14:20,210
Llamar un método sobre

297
00:14:20,210 --> 00:14:21,929
Este objeto, si es un objeto

298
00:14:21,929 --> 00:14:23,950
De este elemento, etc, etc

299
00:14:23,950 --> 00:14:25,789
¿Vale? Para poder hacer eso

300
00:14:25,789 --> 00:14:28,230
Necesito un método, necesito algo

301
00:14:28,230 --> 00:14:29,789
Que me permita

302
00:14:29,789 --> 00:14:33,029
Iterar sobre los elementos

303
00:14:33,029 --> 00:14:34,470
Es decir, la colección

304
00:14:34,470 --> 00:14:36,230
Yo no sé cómo está hecho, no sé cómo está

305
00:14:36,230 --> 00:14:37,830
Implementada, es un array

306
00:14:37,830 --> 00:14:40,309
Pues no lo sé, porque si por debajo está

307
00:14:40,309 --> 00:14:42,649
Implementado con un array, bien, si no está implementado con un array

308
00:14:42,649 --> 00:14:44,570
No, pero dame tú

309
00:14:44,570 --> 00:14:45,470
Una forma

310
00:14:45,470 --> 00:14:47,929
De poder

311
00:14:47,929 --> 00:14:50,549
Navegar en todos

312
00:14:50,549 --> 00:14:52,789
Los elementos de esta colección

313
00:14:52,789 --> 00:14:54,490
¿Vale? En base

314
00:14:54,490 --> 00:14:56,409
a la implementación que estás haciendo

315
00:14:56,409 --> 00:14:57,769
y al tipo de

316
00:14:57,769 --> 00:14:59,889
colección que es

317
00:14:59,889 --> 00:15:01,950
pues tú me dirás una forma u otra

318
00:15:01,950 --> 00:15:04,330
si lo que tengo por debajo

319
00:15:04,330 --> 00:15:06,110
es un array, nosotros sabemos

320
00:15:06,110 --> 00:15:08,549
una forma de recorrer

321
00:15:08,549 --> 00:15:09,970
un array entero

322
00:15:09,970 --> 00:15:12,070
forra y cosas por el estilo

323
00:15:12,070 --> 00:15:14,629
pues el iterator hará algo parecido

324
00:15:14,629 --> 00:15:15,190
¿si?

325
00:15:16,929 --> 00:15:18,009
en particular

326
00:15:18,009 --> 00:15:18,950
iterator

327
00:15:18,950 --> 00:15:22,110
viene de iterable

328
00:15:22,110 --> 00:15:24,409
o sea, iterable es otra

329
00:15:24,409 --> 00:15:27,529
Interfaz

330
00:15:27,529 --> 00:15:28,049
¿Vale?

331
00:15:28,169 --> 00:15:30,450
Donde dentro tiene sustancialmente un método

332
00:15:30,450 --> 00:15:32,750
Para decir, oye, mira, en un determinado momento

333
00:15:32,750 --> 00:15:34,610
Dame un objeto iterador

334
00:15:34,610 --> 00:15:36,549
El objeto iterador

335
00:15:36,549 --> 00:15:38,330
Lo que permite hacer es

336
00:15:38,330 --> 00:15:41,070
Navegar en todos

337
00:15:41,070 --> 00:15:43,149
Recorrer toda la colección

338
00:15:43,149 --> 00:15:44,450
De alguna forma

339
00:15:44,450 --> 00:15:45,029
¿Vale?

340
00:15:45,029 --> 00:15:47,149
Lo más eficiente posible

341
00:15:47,149 --> 00:15:49,289
Dependiendo de la colección en la que estoy

342
00:15:49,289 --> 00:15:50,789
Está claro que una lista

343
00:15:50,789 --> 00:15:53,009
La recorrerás desde principio a final

344
00:15:53,009 --> 00:15:55,409
Un árbol como lo recorre

345
00:15:55,409 --> 00:16:01,470
Así

346
00:16:01,470 --> 00:16:04,970
Hay dos formas de recorrer un árbol

347
00:16:04,970 --> 00:16:06,429
En anchura

348
00:16:06,429 --> 00:16:07,629
O en profundidad

349
00:16:07,629 --> 00:16:10,289
En profundidad voy lo más profundo

350
00:16:10,289 --> 00:16:12,250
Y cuando no puedo ir más profundo

351
00:16:12,250 --> 00:16:13,850
Vuelvo atrás y más profundo

352
00:16:13,850 --> 00:16:15,950
Vuelvo atrás y más profundo

353
00:16:15,950 --> 00:16:17,610
Vuelvo atrás y más profundo

354
00:16:17,610 --> 00:16:18,950
Vuelvo atrás y más profundo

355
00:16:18,950 --> 00:16:21,789
En anchura es

356
00:16:21,789 --> 00:16:23,370
Nivel 1 está esto

357
00:16:23,370 --> 00:16:25,309
Nivel 2 está esto y luego esto

358
00:16:25,309 --> 00:16:27,710
Nivel 3 está esto, esto, esto

359
00:16:27,710 --> 00:16:29,129
Esto, esto y así, así

360
00:16:29,129 --> 00:16:31,409
¿Vale? Entonces dependiendo de como

361
00:16:31,409 --> 00:16:33,549
Quiero hacerlo, pues tendré que

362
00:16:33,549 --> 00:16:35,429
Implementarlo y tendré que hacer algo

363
00:16:35,429 --> 00:16:36,610
En función, ¿sí?

364
00:16:36,909 --> 00:16:39,370
Por nuestra suerte estas cosas ya están implementadas

365
00:16:39,370 --> 00:16:41,309
Porque todas las cosas que tenemos de Java

366
00:16:41,309 --> 00:16:43,690
Las implementaciones que tenemos de Java

367
00:16:43,690 --> 00:16:44,970
Que son al fin y al cabo estas

368
00:16:44,970 --> 00:16:47,370
Las verdes, ¿vale?

369
00:16:47,830 --> 00:16:49,450
Pues tendrán ya dentro

370
00:16:49,450 --> 00:16:51,850
Definido la posibilidad

371
00:16:51,850 --> 00:16:53,929
De pillar un objeto iterator

372
00:16:53,929 --> 00:16:55,629
Y el objeto iterator

373
00:16:55,629 --> 00:16:57,210
Veremos que se utiliza para decir

374
00:16:57,210 --> 00:16:58,769
Oye mira, dame el siguiente elemento

375
00:16:58,769 --> 00:17:00,450
Aquí lo tienes, dame el siguiente elemento

376
00:17:00,450 --> 00:17:01,049
Aquí lo tienes

377
00:17:01,049 --> 00:17:03,250
Y yo puedo hacer lo que quiera con este elemento

378
00:17:03,250 --> 00:17:04,569
¿Vale?

379
00:17:07,190 --> 00:17:08,609
En este esquema de aquí

380
00:17:08,609 --> 00:17:10,609
Que más o menos define

381
00:17:10,609 --> 00:17:15,009
Un 70% de lo que es esta

382
00:17:15,009 --> 00:17:16,890
Esta parte, ¿vale?

383
00:17:16,890 --> 00:17:17,910
De las estructuras dinámicas

384
00:17:17,910 --> 00:17:19,569
Porque luego hay la parte de maps

385
00:17:19,569 --> 00:17:20,690
Que aquí no viene

386
00:17:20,690 --> 00:17:22,329
Lo veremos más adelante

387
00:17:22,329 --> 00:17:26,589
Los que son azules son interfaces

388
00:17:26,589 --> 00:17:30,750
Los que son verdes son implementaciones reales

389
00:17:30,750 --> 00:17:33,910
Entonces nunca crearéis un new collection

390
00:17:33,910 --> 00:17:35,910
Porque collection es una interfaz

391
00:17:35,910 --> 00:17:36,869
No se puede hacer

392
00:17:36,869 --> 00:17:41,690
Si podréis crear collection x es igual a no se que

393
00:17:41,690 --> 00:17:42,930
Eso si lo podéis hacer

394
00:17:42,930 --> 00:17:46,789
Se puede hacer una referencia cuyo tipo sea una interfaz

395
00:17:46,789 --> 00:17:47,589
Lo hemos hecho

396
00:17:47,589 --> 00:17:50,490
Lo que no se puede hacer

397
00:17:50,490 --> 00:17:51,329
Es

398
00:17:51,329 --> 00:17:53,789
Implementar

399
00:17:53,789 --> 00:17:55,970
Crear una instancia

400
00:17:55,970 --> 00:17:57,089
De una interfaz

401
00:17:57,089 --> 00:18:00,069
Las verdes en vez de si me permiten crear

402
00:18:00,069 --> 00:18:01,730
Las verdes son implementaciones

403
00:18:01,730 --> 00:18:04,289
Concretas, no tienen nada abstracto

404
00:18:04,289 --> 00:18:06,009
No tienen métodos abstractos

405
00:18:06,009 --> 00:18:07,869
Yo puedo crear una ArrayList

406
00:18:07,869 --> 00:18:09,529
Puedo crear un LinkedList

407
00:18:09,529 --> 00:18:10,990
Un Vector, Stack

408
00:18:10,990 --> 00:18:14,109
ArrayDeck, PriorityQueue

409
00:18:14,109 --> 00:18:15,250
HashSet

410
00:18:15,250 --> 00:18:16,829
Linker-set

411
00:18:16,829 --> 00:18:17,809
Y triset

412
00:18:17,809 --> 00:18:19,869
Cada una de ellas

413
00:18:19,869 --> 00:18:22,829
Tiene sus características propias

414
00:18:22,829 --> 00:18:24,490
¿Dudas hasta aquí?

415
00:18:27,490 --> 00:18:28,789
Los métodos

416
00:18:28,789 --> 00:18:29,950
Harán siempre los mismos

417
00:18:29,950 --> 00:18:32,869
Todas estas verdes tienen add

418
00:18:32,869 --> 00:18:33,930
¿Vale?

419
00:18:34,009 --> 00:18:36,750
Pero cada uno lo implementa de una forma distinta

420
00:18:36,750 --> 00:18:38,329
Como nosotros hemos visto que el add

421
00:18:38,329 --> 00:18:40,609
En nuestra lista de array

422
00:18:40,609 --> 00:18:42,990
Lo que hacía era añadir una celda

423
00:18:42,990 --> 00:18:44,690
Al array y añadir el objeto

424
00:18:44,690 --> 00:18:47,150
Mientras si yo lo hacía como lista enlazada

425
00:18:47,150 --> 00:18:48,490
Era crearme un nuevo objeto

426
00:18:48,490 --> 00:18:50,170
Y enlazarlo al último de la cosa

427
00:18:50,170 --> 00:18:51,890
¿Sí? De la lista

428
00:18:51,890 --> 00:18:54,569
Entonces, cada uno de estos

429
00:18:54,569 --> 00:18:56,410
Tendrá sus características

430
00:18:56,410 --> 00:18:59,109
Y se comportará como se tiene que comportar

431
00:18:59,109 --> 00:18:59,710
Por ejemplo

432
00:18:59,710 --> 00:19:01,450
Si yo estoy aquí

433
00:19:01,450 --> 00:19:05,009
Esta rama de aquí, Q, es cola en inglés

434
00:19:05,009 --> 00:19:07,089
¿Vale? Entonces, estas son

435
00:19:07,089 --> 00:19:08,569
Como funcionan colas

436
00:19:08,569 --> 00:19:10,730
¿Sí? Entonces, cuando estoy aquí

437
00:19:10,730 --> 00:19:11,809
Y tengo una Priority Q

438
00:19:11,809 --> 00:19:14,329
Me espero que funcione como una cola

439
00:19:14,329 --> 00:19:17,109
En el sentido que cuando inserto las cosas

440
00:19:17,109 --> 00:19:19,009
Pues el primero insertado

441
00:19:19,009 --> 00:19:21,109
Sea el primero

442
00:19:21,109 --> 00:19:21,970
Que pueda pillar

443
00:19:21,970 --> 00:19:25,089
Si me pongo

444
00:19:25,089 --> 00:19:27,089
Por ejemplo insert que son conjuntos

445
00:19:27,089 --> 00:19:29,190
Pues aquí tendrán las características

446
00:19:29,190 --> 00:19:29,990
De los conjuntos

447
00:19:29,990 --> 00:19:32,509
Todavía no los hemos empezado a ver

448
00:19:32,509 --> 00:19:34,450
Por lo tanto estamos allí

449
00:19:34,450 --> 00:19:36,490
Lo único que conocemos son estas dos

450
00:19:36,490 --> 00:19:39,410
Porque estas dos nosotros hemos hecho nuestra propia implementación

451
00:19:39,410 --> 00:19:40,869
Por lo tanto más o menos

452
00:19:40,869 --> 00:19:41,670
Los conocemos

453
00:19:41,670 --> 00:19:43,589
Java me da mucho más

454
00:19:43,589 --> 00:19:46,430
Métodos, mucho más métodos

455
00:19:46,430 --> 00:19:47,569
Con respecto a lo que hemos visto

456
00:19:47,569 --> 00:19:49,890
Repito que esta es la interfaz collection

457
00:19:49,890 --> 00:19:52,730
Todos los que están aquí dentro

458
00:19:52,730 --> 00:19:54,750
Tienen estos cinco métodos

459
00:19:54,750 --> 00:19:57,069
Lo que me garantiza

460
00:19:57,069 --> 00:19:59,170
Que sea cual sea la implementación

461
00:19:59,170 --> 00:20:00,789
Yo puedo añadir un objeto

462
00:20:00,789 --> 00:20:02,329
Puedo preguntar, oye mira

463
00:20:02,329 --> 00:20:04,849
Cuántos objetos se han insertado

464
00:20:04,849 --> 00:20:06,789
Puedo decir, puedo encontrar

465
00:20:06,789 --> 00:20:08,670
Un método para que tú me digas

466
00:20:08,670 --> 00:20:10,710
Cómo recorrer esta estructura

467
00:20:10,710 --> 00:20:12,630
Sea lo que sea esta estructura dinámica

468
00:20:12,630 --> 00:20:15,589
Puedo preguntar si hay algo en esta estructura

469
00:20:15,589 --> 00:20:17,950
Y puedo quitar algo de esta estructura

470
00:20:17,950 --> 00:20:18,250
Sí

471
00:20:18,250 --> 00:20:22,069
En una clase yo estoy obligado

472
00:20:22,069 --> 00:20:23,069
A tener

473
00:20:23,069 --> 00:20:25,789
A tener la interfaz colección

474
00:20:25,789 --> 00:20:27,509
¿Puedo yo por ejemplo

475
00:20:27,509 --> 00:20:29,529
Si en una clase particular

476
00:20:29,529 --> 00:20:31,750
No me interesa por ejemplo el size

477
00:20:31,750 --> 00:20:33,509
Lo puedo

478
00:20:33,509 --> 00:20:35,269
Vamos a ver, en el momento que tú

479
00:20:35,269 --> 00:20:37,329
Implementas collection

480
00:20:37,329 --> 00:20:39,130
Size tiene que estar

481
00:20:39,130 --> 00:20:41,829
Si no, no es una colección

482
00:20:41,829 --> 00:20:45,789
Tú te quieres hacer tu propia interfaz

483
00:20:45,789 --> 00:20:47,730
Que sea collection menos size

484
00:20:47,730 --> 00:20:49,849
Te lo haces sin esto

485
00:20:49,849 --> 00:20:51,769
Y luego te implementas con la collection menos size

486
00:20:51,769 --> 00:20:53,829
Pero claro, no es lo mismo

487
00:20:53,829 --> 00:20:54,950
Que estas

488
00:20:54,950 --> 00:20:58,990
Ahora, otra cosa

489
00:20:58,990 --> 00:21:00,970
Es que esto es un contrato

490
00:21:00,970 --> 00:21:03,890
Vale, tú me aseguras

491
00:21:03,890 --> 00:21:05,329
Que en el momento en que tú dices

492
00:21:05,329 --> 00:21:07,009
Oye, implemento collection

493
00:21:07,009 --> 00:21:09,690
Tú hayas sobrescrito size

494
00:21:09,690 --> 00:21:11,230
Y implementado

495
00:21:11,230 --> 00:21:13,990
Que luego tú size dices return 0

496
00:21:13,990 --> 00:21:17,769
Entonces independientemente de cuantas cosas

497
00:21:17,769 --> 00:21:19,869
Te haya puesto me devuelve siempre 0

498
00:21:19,869 --> 00:21:20,890
Vale

499
00:21:20,890 --> 00:21:24,269
Pero estás incumpliendo en un cierto sentido

500
00:21:24,269 --> 00:21:24,869
El contrato

501
00:21:24,869 --> 00:21:26,690
Otro programador del mundo

502
00:21:26,690 --> 00:21:28,309
Cuando ve tu

503
00:21:28,309 --> 00:21:31,529
Código, tu clase

504
00:21:31,529 --> 00:21:32,829
Y ve que tu clase

505
00:21:32,829 --> 00:21:35,529
Extended Collection

506
00:21:35,529 --> 00:21:38,170
Se espera que si llama size

507
00:21:38,170 --> 00:21:40,109
Recibirá el tamaño

508
00:21:40,109 --> 00:21:40,890
De tu colección

509
00:21:40,890 --> 00:21:42,630
Y tú lo has implementado mal

510
00:21:42,630 --> 00:21:45,329
Entonces no lo deberías hacer

511
00:21:45,329 --> 00:21:46,730
Bueno, lo puedes hacer

512
00:21:46,730 --> 00:21:47,950
Puedes hacer lo que te haga

513
00:21:47,950 --> 00:21:50,230
Puedes hacer que la add cuando una add

514
00:21:50,230 --> 00:21:51,529
En vez de añadir, remueva

515
00:21:51,529 --> 00:21:54,730
Pero es un error semántico

516
00:21:54,730 --> 00:21:55,690
A nivel de programación

517
00:21:55,690 --> 00:21:57,930
Estás complicando las cosas

518
00:21:57,930 --> 00:22:00,150
¿Quieres hacer eso?

519
00:22:00,509 --> 00:22:02,170
Pues en vez de utilizar collection

520
00:22:02,170 --> 00:22:03,990
Create tu propia interfaz

521
00:22:03,990 --> 00:22:05,529
Y haz lo que quieras

522
00:22:05,529 --> 00:22:06,309
Solo que luego

523
00:22:06,309 --> 00:22:09,509
Todas estas implementaciones

524
00:22:09,509 --> 00:22:10,990
En cierto sentido son intercambiables

525
00:22:10,990 --> 00:22:13,029
Allá donde alguien use collection

526
00:22:13,029 --> 00:22:15,170
Puedes usar una cualquiera de estas

527
00:22:15,170 --> 00:22:16,750
La tuya nueva no

528
00:22:16,750 --> 00:22:18,250
Porque no implementa collection

529
00:22:18,250 --> 00:22:19,710
Implementaría mi collection

530
00:22:19,710 --> 00:22:20,910
Pero puedo saltar

531
00:22:20,910 --> 00:22:25,450
En principio no deberías

532
00:22:25,450 --> 00:22:26,910
Saltar

533
00:22:26,910 --> 00:22:28,849
Claro, es obligatorio

534
00:22:28,849 --> 00:22:31,450
Pero si me voy a la cabeza y decido saltar

535
00:22:31,450 --> 00:22:33,289
Java no te va a decir

536
00:22:33,289 --> 00:22:35,210
Oye mira lo has implementado mal

537
00:22:35,210 --> 00:22:37,289
Porque Java no puede saber

538
00:22:37,289 --> 00:22:38,750
Si lo has implementado mal o no

539
00:22:38,750 --> 00:22:40,869
Te puede decir, oye mira

540
00:22:40,869 --> 00:22:42,190
Te falta esto

541
00:22:42,190 --> 00:22:44,569
Porque tú has dicho que implementas

542
00:22:44,569 --> 00:22:46,269
Collection

543
00:22:46,269 --> 00:22:49,150
Entonces esto tiene que estar

544
00:22:49,150 --> 00:22:51,009
Y no lo has puesto, esto te lo puede decir

545
00:22:51,009 --> 00:22:52,529
Pero una vez que tú lo has puesto

546
00:22:52,529 --> 00:22:54,589
Que tú dices, devuelve siempre mi

547
00:22:54,589 --> 00:22:56,410
Java dice

548
00:22:56,410 --> 00:22:58,910
Será que tu colección siempre

549
00:22:58,910 --> 00:23:00,809
Tiene solo mil objetos, no lo sé

550
00:23:00,809 --> 00:23:03,250
Java en eso no se mete

551
00:23:03,250 --> 00:23:05,329
Es la diferencia entre errores

552
00:23:05,329 --> 00:23:06,690
Sintácticos

553
00:23:06,690 --> 00:23:08,109
que Java te los puede pillar

554
00:23:08,109 --> 00:23:09,269
a tiempo de compilación

555
00:23:09,269 --> 00:23:11,589
que es, oye mira, falta esto

556
00:23:11,589 --> 00:23:14,309
y yo puedo comprobarlo porque no lo has escrito

557
00:23:14,309 --> 00:23:16,009
entonces falta y me has dicho que

558
00:23:16,009 --> 00:23:18,309
implementabas collection y tiene que estar

559
00:23:18,309 --> 00:23:20,329
y error semántico

560
00:23:20,329 --> 00:23:22,089
en el que te has equivocado

561
00:23:22,089 --> 00:23:23,349
a calcular el factorial

562
00:23:23,349 --> 00:23:25,650
y en vez de factorial me calculas

563
00:23:25,650 --> 00:23:27,369
la raíz cuadrada

564
00:23:27,369 --> 00:23:29,829
pero yo Java, eso no lo puedo saber

565
00:23:29,829 --> 00:23:31,329
y puedo utilizar el plan de clave

566
00:23:31,329 --> 00:23:32,549
ese método y decir

567
00:23:32,549 --> 00:23:35,049
el plan de clave es 6-2

568
00:23:35,049 --> 00:23:38,329
Pero no está en la colección

569
00:23:38,329 --> 00:23:40,150
Si tú haces

570
00:23:40,150 --> 00:23:42,589
Collection x es igual a

571
00:23:42,589 --> 00:23:44,589
New tu implementación

572
00:23:44,589 --> 00:23:46,910
En ese collection no está size2

573
00:23:46,910 --> 00:23:48,869
Está size

574
00:23:48,869 --> 00:23:50,890
Para poder utilizar

575
00:23:50,890 --> 00:23:52,670
Size2 tengo que hacer un

576
00:23:52,670 --> 00:23:55,029
Downcasting a tu implementación

577
00:23:55,029 --> 00:23:56,809
Y entonces ahí aparecerá

578
00:23:56,809 --> 00:23:57,430
También size2

579
00:23:57,430 --> 00:24:01,009
La potencia de las interfaces

580
00:24:01,009 --> 00:24:02,029
Es que

581
00:24:02,029 --> 00:24:04,509
Si yo por algún lado declaro

582
00:24:04,509 --> 00:24:07,470
Oye, aquí collectionX es igual a

583
00:24:07,470 --> 00:24:10,210
Dame uno cualquiera de estos verdes

584
00:24:10,210 --> 00:24:11,190
Y funciona

585
00:24:11,190 --> 00:24:13,230
Y puedo añadir, quitar

586
00:24:13,230 --> 00:24:16,430
Contains, iterator

587
00:24:16,430 --> 00:24:17,069
Y no sé qué

588
00:24:17,069 --> 00:24:20,549
Pero los métodos propios de PriorityQ

589
00:24:20,549 --> 00:24:21,789
Por ejemplo, no los tendré

590
00:24:21,789 --> 00:24:23,650
Porque los estoy utilizando como collection

591
00:24:23,650 --> 00:24:26,170
Repito que nadie me prohíbe

592
00:24:26,170 --> 00:24:27,710
Si yo sé que quiero utilizar

593
00:24:27,710 --> 00:24:29,130
Y quiero utilizar una PriorityQ

594
00:24:29,130 --> 00:24:32,029
Pues puedo hacer PriorityQX es igual a

595
00:24:32,029 --> 00:24:32,809
NewPriorityQ

596
00:24:32,809 --> 00:24:36,049
Y uso los métodos de Priority Queue

597
00:24:36,049 --> 00:24:37,869
Que incluyen los de Collection

598
00:24:37,869 --> 00:24:39,329
Los de Queue, los de Terrible

599
00:24:39,329 --> 00:24:41,809
¿Sí?

600
00:24:44,880 --> 00:24:45,519
¿Dudas?

601
00:24:46,779 --> 00:24:47,420
¿Ya no?

602
00:24:49,910 --> 00:24:50,549
Entonces

603
00:24:50,549 --> 00:24:55,519
Las interfaces que extienden Collection

604
00:24:55,519 --> 00:24:56,559
Estamos aquí

605
00:24:56,559 --> 00:24:57,920
¿Vale?

606
00:24:58,299 --> 00:24:59,579
A partir de Collection

607
00:24:59,579 --> 00:25:03,519
Hay tres interfaces que extienden Collection

608
00:25:03,519 --> 00:25:06,700
O sea que además de lo que tiene Collection

609
00:25:06,700 --> 00:25:08,480
Añado cosillas más

610
00:25:08,480 --> 00:25:09,400
¿Qué son?

611
00:25:10,920 --> 00:25:13,559
Set, que en inglés quiere decir conjunto

612
00:25:13,559 --> 00:25:14,339
¿Vale?

613
00:25:14,720 --> 00:25:17,380
Sería un saco donde dentro

614
00:25:17,380 --> 00:25:18,599
Pongo los elementos

615
00:25:18,599 --> 00:25:20,920
Cuidado, mientras que en una lista

616
00:25:20,920 --> 00:25:22,720
Normalmente tienen un orden

617
00:25:22,720 --> 00:25:24,500
Porque van uno tras de otro

618
00:25:24,500 --> 00:25:26,299
En el conjunto no

619
00:25:26,299 --> 00:25:27,980
El conjunto es

620
00:25:27,980 --> 00:25:30,420
Estos son los elementos que tengo en cuenta

621
00:25:30,420 --> 00:25:32,480
Mi colección son estos elementos

622
00:25:32,480 --> 00:25:34,019
Pero no tienen un orden

623
00:25:34,019 --> 00:25:36,079
Son estos, ¿vale?

624
00:25:36,700 --> 00:25:42,339
Y la cosa particular de los conjuntos es que no se admiten elementos repetidos.

625
00:25:43,380 --> 00:25:47,619
No puedo poner dos veces el mismo elemento en un set.

626
00:25:49,279 --> 00:25:49,480
¿Vale?

627
00:25:49,779 --> 00:25:53,740
Es como si vosotros pilláis el conjunto de los números naturales.

628
00:25:54,299 --> 00:25:57,380
El conjunto de los números naturales son 1, 2, 3, 4.

629
00:25:57,700 --> 00:26:00,900
No son 1, 2, 2, 2, 2, 2, 3 y 4.

630
00:26:01,180 --> 00:26:01,759
2 es 1.

631
00:26:02,779 --> 00:26:03,680
2 es un elemento.

632
00:26:03,680 --> 00:26:09,480
Si tú intentas insertar otra vez 2, te dicen, no, mira, 2 ya está, y ya lo tenemos en el conjunto.

633
00:26:10,740 --> 00:26:17,740
Sin embargo, en una lista, que es la lista de las edades de los alumnos, yo podría poner 1, 2, 2, 2, 3.

634
00:26:17,960 --> 00:26:20,079
Eso quiere decir que hay 3 alumnos que tienen 2 años.

635
00:26:20,759 --> 00:26:22,220
Se puede repetir el elemento.

636
00:26:23,319 --> 00:26:24,559
¿Se entiende la diferencia?

637
00:26:24,559 --> 00:26:36,539
El conjunto me puede servir para aquellos programas en el que yo lo que quiero es añadir elementos

638
00:26:36,539 --> 00:26:46,359
Ese elemento me representa un elemento único en este tipo de problema, en este espacio del problema

639
00:26:46,359 --> 00:26:54,519
Por ejemplo, si yo tengo el concepto de soy una tienda y lo que hago es crear un catálogo

640
00:26:54,519 --> 00:26:56,559
Y saber cuáles son mis productos

641
00:26:56,559 --> 00:26:57,420
¿Vale?

642
00:26:57,819 --> 00:27:01,019
El producto ordenador con 8 kilobytes

643
00:27:01,019 --> 00:27:01,619
¿Vale?

644
00:27:01,680 --> 00:27:03,559
Lo puedo considerar de dos formas

645
00:27:03,559 --> 00:27:06,519
O un objeto físico real

646
00:27:06,519 --> 00:27:07,119
¿Vale?

647
00:27:07,140 --> 00:27:09,880
Yo tengo tres de estos en el almacén

648
00:27:09,880 --> 00:27:12,640
Y por lo tanto quiero tres objetos distintos

649
00:27:12,640 --> 00:27:15,180
Entonces no me interesa el set

650
00:27:15,180 --> 00:27:16,960
Lo debería hacer como una lista

651
00:27:16,960 --> 00:27:17,680
O como otra cosa

652
00:27:17,680 --> 00:27:21,119
Pero si yo lo pienso como catálogo

653
00:27:21,119 --> 00:27:22,599
Como menú

654
00:27:22,599 --> 00:27:37,859
Es decir, oye, alguien a mí me puede pedir un ordenador de 8 GB y luego yo se lo haré, pero hay un solo ordenador de este tipo, luego habrá otro ordenador de otra marca, luego habrá otro ordenador con 16 GB, ¿vale? Estoy haciendo un catálogo.

655
00:27:37,859 --> 00:27:40,559
Pues entonces, esto podría ser un set

656
00:27:40,559 --> 00:27:44,200
No existen dos ordenadores

657
00:27:44,200 --> 00:27:45,559
Con la misma característica

658
00:27:45,559 --> 00:27:47,240
El producto es uno solo

659
00:27:47,240 --> 00:27:58,529
Si, si quieres verlo así

660
00:27:58,529 --> 00:28:00,190
También cuando haces libro

661
00:28:00,190 --> 00:28:01,190
Tienes el mismo problema

662
00:28:01,190 --> 00:28:03,170
Libro de una biblioteca

663
00:28:03,170 --> 00:28:06,390
Pensar que si tú tienes tres distintos

664
00:28:06,390 --> 00:28:08,250
Copias

665
00:28:08,250 --> 00:28:09,730
Ejemplares del mismo libro

666
00:28:09,730 --> 00:28:12,109
Pues esto tiene que ser tres objetos distintos

667
00:28:12,109 --> 00:28:13,710
Entonces set no te vale

668
00:28:13,710 --> 00:28:16,369
O podrías pensar, mira, en mi biblioteca

669
00:28:16,369 --> 00:28:17,990
Yo tengo este libro aquí, tengo

670
00:28:17,990 --> 00:28:20,349
El señor de los anillos, vale, fenomenal, es un libro

671
00:28:20,349 --> 00:28:22,490
Luego puedo tener seis copias

672
00:28:22,490 --> 00:28:24,089
Pero del señor de los anillos

673
00:28:24,089 --> 00:28:25,609
Hay uno solo, vale

674
00:28:25,609 --> 00:28:28,250
Entonces sí que lo podría modelizar por un set

675
00:28:28,250 --> 00:28:29,349
¿Se entiende?

676
00:28:31,069 --> 00:28:31,450
¿Vale?

677
00:28:31,450 --> 00:28:32,690
¿Qué es lo que interesa?

678
00:28:33,390 --> 00:28:35,009
¿Se interesa por cantidades, no?

679
00:28:35,569 --> 00:28:36,650
¿Me interesa más

680
00:28:36,650 --> 00:28:43,519
La cantidad de...

681
00:28:43,519 --> 00:28:45,880
Esto, no es que me interese

682
00:28:45,880 --> 00:28:48,259
Si tú lo quieres hacer de esta forma

683
00:28:48,259 --> 00:28:49,940
O sea que tu objeto libro

684
00:28:49,940 --> 00:28:52,359
Es un objeto físico

685
00:28:52,359 --> 00:28:54,119
Corresponde a un objeto físico concreto

686
00:28:54,119 --> 00:28:56,140
Que luego tendrá un identificador para diferenciarlo

687
00:28:56,140 --> 00:28:57,079
De las otras copias

688
00:28:57,079 --> 00:28:58,839
Entonces set no lo puede usar

689
00:28:58,839 --> 00:29:01,859
Porque cuando intentas meter dos libros distintos

690
00:29:01,859 --> 00:29:03,779
Pues es el mismo libro

691
00:29:03,779 --> 00:29:06,099
O repito

692
00:29:06,099 --> 00:29:08,480
Si tú haces el objeto con dentro un identificador

693
00:29:08,480 --> 00:29:11,119
Que en los tres libros

694
00:29:11,119 --> 00:29:12,319
Que se llaman enseñar el renguillo

695
00:29:12,319 --> 00:29:13,720
Tienen un identificador distinto

696
00:29:13,720 --> 00:29:15,859
También puedes utilizar un set

697
00:29:15,859 --> 00:29:18,940
Pero conceptualmente no tiene mucho sentido

698
00:29:18,940 --> 00:29:20,519
Sería mejor utilizar

699
00:29:20,519 --> 00:29:21,660
Otros tipos de cosas

700
00:29:21,660 --> 00:29:23,859
Este de aquí es si tú quieres

701
00:29:23,859 --> 00:29:24,960
Tú eres un editorial

702
00:29:24,960 --> 00:29:28,019
Y tienes que hacer un programa

703
00:29:28,019 --> 00:29:30,240
Que dice los libros que tienes como editorial

704
00:29:30,240 --> 00:29:32,779
Tú como editorial puedes imprimir

705
00:29:32,779 --> 00:29:33,920
Las propias que quieres

706
00:29:33,920 --> 00:29:36,359
Pero tú tienes o no tienes

707
00:29:36,359 --> 00:29:37,420
El señor de los anillos

708
00:29:37,420 --> 00:29:39,920
Si tú eres editorial y no tienes los derechos

709
00:29:39,920 --> 00:29:41,079
Para el señor de los anillos

710
00:29:41,079 --> 00:29:42,619
No lo metes en tu sistema

711
00:29:42,619 --> 00:29:45,099
Entonces en este caso

712
00:29:45,099 --> 00:29:46,900
No cuenta cuantos hay

713
00:29:46,900 --> 00:29:48,599
Si hay una línea, uno

714
00:29:48,599 --> 00:29:50,599
O otro libro

715
00:29:50,599 --> 00:29:53,660
Y entonces en este caso

716
00:29:53,660 --> 00:29:55,740
Podrías trabajar con un set

717
00:29:55,740 --> 00:29:56,180
¿Vale?

718
00:29:56,400 --> 00:29:59,099
La clave es que no se pueden repetir los elementos

719
00:29:59,099 --> 00:30:01,299
Oye, ¿y cuando un elemento se repite?

720
00:30:03,299 --> 00:30:04,839
Yo tengo mi conjunto

721
00:30:04,839 --> 00:30:06,140
Ya he metido cosas

722
00:30:06,140 --> 00:30:08,099
Quiero añadir un nuevo elemento

723
00:30:08,099 --> 00:30:09,319
¿Sí?

724
00:30:10,460 --> 00:30:12,259
¿Cuando este elemento te digo

725
00:30:12,259 --> 00:30:14,779
Oye, mira, no, no lo puedes insertar porque ya existe

726
00:30:14,779 --> 00:30:24,779
Con el equals

727
00:30:24,779 --> 00:30:29,319
El equals lo que hace es

728
00:30:29,319 --> 00:30:30,980
Definirme

729
00:30:30,980 --> 00:30:32,980
El concepto de identidad

730
00:30:32,980 --> 00:30:34,880
Dos objetos

731
00:30:34,880 --> 00:30:36,440
Mios son iguales

732
00:30:36,440 --> 00:30:38,259
Cuando yo hago este objeto

733
00:30:38,259 --> 00:30:40,000
Punto equals este otro objeto

734
00:30:40,000 --> 00:30:41,299
Y me devuelve true

735
00:30:41,299 --> 00:30:44,880
Soy yo que defino cuando son iguales

736
00:30:44,880 --> 00:30:46,599
Entonces los set

737
00:30:46,599 --> 00:30:48,819
Añaden

738
00:30:48,819 --> 00:30:51,619
Objetos, elementos a su conjunto

739
00:30:51,619 --> 00:30:53,500
Cuando yo añado

740
00:30:53,500 --> 00:30:55,500
Uno nuevo, pillan este

741
00:30:55,500 --> 00:30:57,259
Nuevo y van a llamar

742
00:30:57,259 --> 00:30:59,319
Equals, sobre todo

743
00:30:59,319 --> 00:31:01,359
Los objetos que ya están allí

744
00:31:01,359 --> 00:31:03,380
Dentro y si uno de ellos

745
00:31:03,380 --> 00:31:05,200
Da true, dice

746
00:31:05,200 --> 00:31:07,279
No, no lo puedes añadir

747
00:31:07,279 --> 00:31:11,160
Te dice que este elemento

748
00:31:11,160 --> 00:31:12,619
Ya existe, no se puede añadir

749
00:31:12,619 --> 00:31:14,799
Al conjunto, porque no tiene

750
00:31:14,799 --> 00:31:16,700
Sentido añadir señores de

751
00:31:16,700 --> 00:31:19,440
De los anillos cuando ya tienes el sueño de los anillos

752
00:31:19,440 --> 00:31:20,779
¿Es una excepción o no?

753
00:31:21,640 --> 00:31:22,400
No, no

754
00:31:22,400 --> 00:31:24,759
No lo sé, no me acuerdo

755
00:31:24,759 --> 00:31:26,099
Que devuelve, ahora lo miramos con el ADD

756
00:31:26,099 --> 00:31:28,079
Pero probablemente no, o devuelve null

757
00:31:28,079 --> 00:31:29,980
O true or false, no me acuerdo

758
00:31:29,980 --> 00:31:33,200
Ahora lo miramos luego más específicamente

759
00:31:33,200 --> 00:31:34,680
Porque dependerá también de la implementación

760
00:31:34,680 --> 00:31:37,200
También en algunos casos

761
00:31:37,920 --> 00:31:41,000
En vez de utilizar solo equals

762
00:31:41,000 --> 00:31:43,559
También puede utilizar hashcode

763
00:31:43,559 --> 00:31:45,500
¿Qué es hashcode?

764
00:31:45,500 --> 00:31:46,980
Es un código hash

765
00:31:46,980 --> 00:31:48,720
¿Vale? ¿Qué es hash?

766
00:31:49,079 --> 00:31:50,579
Pues lo veremos dentro de un rato

767
00:31:50,579 --> 00:31:53,279
¿Vale? Porque es un concepto

768
00:31:53,279 --> 00:31:53,799
Un poquito

769
00:31:53,799 --> 00:31:56,180
Raro, ¿vale?

770
00:31:56,519 --> 00:31:58,619
Y que hay algunas implementaciones

771
00:31:58,619 --> 00:32:00,700
Que son, por inciso

772
00:32:00,700 --> 00:32:03,579
Las implementaciones más rápidas y más eficientes

773
00:32:03,579 --> 00:32:05,740
Que necesitan esta cosa aquí

774
00:32:05,740 --> 00:32:07,180
¿Vale?

775
00:32:08,279 --> 00:32:09,000
Entonces

776
00:32:09,000 --> 00:32:09,940
Un segundo solo

777
00:32:09,940 --> 00:32:12,720
Por ejemplo, aquí, set

778
00:32:12,720 --> 00:32:14,619
En hash set

779
00:32:14,619 --> 00:32:17,180
HashSet utiliza este

780
00:32:17,180 --> 00:32:17,839
HashCode

781
00:32:17,839 --> 00:32:21,339
Para poder comprobar si la has metido o no

782
00:32:21,339 --> 00:32:22,759
También el equals

783
00:32:22,759 --> 00:32:24,200
Pero principalmente el HashSet

784
00:32:24,200 --> 00:32:25,019
¿No sabemos que es?

785
00:32:25,380 --> 00:32:27,640
Pues lo veremos cuando empezaremos a mirar esto

786
00:32:27,640 --> 00:32:28,660
O el HashMap

787
00:32:28,660 --> 00:32:30,220
O cuando hablaremos de hash

788
00:32:30,220 --> 00:32:32,299
Pues entonces hablaremos de que es una tabla hash

789
00:32:32,299 --> 00:32:33,279
¿Vale?

790
00:32:33,359 --> 00:32:33,980
Por ahora

791
00:32:33,980 --> 00:32:38,500
No es una encriptación

792
00:32:38,500 --> 00:32:42,140
Pero se usa en encriptación

793
00:32:42,140 --> 00:32:43,880
Alguna vez más bien como digest

794
00:32:43,880 --> 00:32:45,839
Para comprobar que

795
00:32:45,839 --> 00:32:48,579
Lo que sea, el objeto que tienes

796
00:32:48,579 --> 00:32:50,220
Efectivamente es el objeto que tienes

797
00:32:50,220 --> 00:32:52,819
Que deberías haber tenido

798
00:32:52,819 --> 00:32:53,240
¿Vale?

799
00:32:54,460 --> 00:32:56,240
O sea que algunas cosas

800
00:32:56,240 --> 00:32:58,900
De la seguridad informática

801
00:32:58,900 --> 00:33:00,579
Pues se basan sobre la

802
00:33:00,579 --> 00:33:02,119
Ashing para poder

803
00:33:02,119 --> 00:33:04,200
Sacar algunas propiedades, ¿vale?

804
00:33:06,539 --> 00:33:08,420
Entonces este es el conjunto, ¿vale?

805
00:33:08,480 --> 00:33:10,359
La lista, la lista es la más fácil y más

806
00:33:10,359 --> 00:33:12,640
¿Cómo se dice?

807
00:33:12,640 --> 00:33:15,099
Más intuitiva porque es una lista de objetos

808
00:33:15,099 --> 00:33:15,579
¿Vale?

809
00:33:16,039 --> 00:33:18,079
Entonces, la colección que es el finalista

810
00:33:18,079 --> 00:33:20,819
Los elementos de la colección tienen un orden

811
00:33:20,819 --> 00:33:21,299
¿Vale?

812
00:33:21,720 --> 00:33:25,220
Este orden no siempre es el orden de inserción

813
00:33:25,220 --> 00:33:26,500
¿Vale? Lo veremos

814
00:33:26,500 --> 00:33:28,839
Puede que sea otro tipo de orden

815
00:33:28,839 --> 00:33:30,319
Pero el concepto es que

816
00:33:30,319 --> 00:33:33,099
La lista está pensada para que tenga un orden

817
00:33:33,099 --> 00:33:34,359
Es como cuando hacéis una lista

818
00:33:34,359 --> 00:33:36,380
Que ponéis 1, 2, 3, 4, 5

819
00:33:36,380 --> 00:33:38,940
¿Vale? El primer elemento es este libro

820
00:33:38,940 --> 00:33:39,900
El segundo elemento es este libro

821
00:33:39,900 --> 00:33:42,339
Hay un orden interno

822
00:33:42,339 --> 00:33:43,559
¿Vale? De la lista

823
00:33:43,559 --> 00:33:46,900
Que este orden puede no ser intuitivo

824
00:33:46,900 --> 00:33:49,660
Puede no ser el de inserción

825
00:33:49,660 --> 00:33:54,220
Puede ser, como por ejemplo el Priority Queue

826
00:33:54,220 --> 00:33:57,160
Una prioridad, ¿vale?

827
00:33:57,220 --> 00:34:01,480
Definida por el mismo desarrollador

828
00:34:01,480 --> 00:34:05,200
¿Vale? Mis objetos se ordenan según estos criterios

829
00:34:05,200 --> 00:34:05,500
¿Vale?

830
00:34:05,799 --> 00:34:08,860
Quien viene antes, pues tendrá más prioridad que quien viene después

831
00:34:08,860 --> 00:34:11,300
Y no necesariamente el orden de inserción

832
00:34:11,300 --> 00:34:17,440
Pero, inherentemente, list tiene un orden, un determinado orden dentro

833
00:34:17,440 --> 00:34:23,679
Existen una secuencia de elementos, en ellas cada elemento estará en una determinada posición, índice de la lista

834
00:34:23,679 --> 00:34:28,659
¿Vale? Entonces la lista tiene la posibilidad de tener un índice, como en un array

835
00:34:28,659 --> 00:34:33,559
Pero, como cuando nosotros hemos hecho, en vez que con el array, con la lista enlazada

836
00:34:33,559 --> 00:34:37,099
Pues también hemos podido acceder al elemento 5 y pillarlo

837
00:34:37,099 --> 00:34:40,139
¿Vale? En una lista, la lista está ordenada

838
00:34:40,139 --> 00:34:43,340
Entonces puedo pillar un índice

839
00:34:43,340 --> 00:34:44,400
Y decir, vete al quinto

840
00:34:44,400 --> 00:34:47,780
Cosa que no puedo hacer en el set

841
00:34:47,780 --> 00:34:49,659
En el set no existe

842
00:34:49,659 --> 00:34:51,679
El quinto elemento de un conjunto

843
00:34:51,679 --> 00:34:53,000
No se puede

844
00:34:53,000 --> 00:34:54,159
No es tan ordenado

845
00:34:54,159 --> 00:34:56,780
Porque como se ordenan dentro

846
00:34:56,780 --> 00:34:58,059
Es un problema suyo

847
00:34:58,059 --> 00:35:00,000
No es el mismo orden de inserción

848
00:35:00,000 --> 00:35:00,440
Ni otro

849
00:35:00,440 --> 00:35:04,059
También en las listas

850
00:35:04,059 --> 00:35:05,559
Típicamente se pueden

851
00:35:05,559 --> 00:35:07,579
Duplicar

852
00:35:07,579 --> 00:35:10,239
Los elementos que pongo dentro

853
00:35:10,239 --> 00:35:12,199
¿Vale? Puedo poner dos, tres, cuatro veces

854
00:35:12,199 --> 00:35:13,679
El mismo elemento, ningún problema

855
00:35:13,679 --> 00:35:15,119
¿Sí?

856
00:35:16,420 --> 00:35:19,019
Y luego están las que son

857
00:35:19,019 --> 00:35:21,199
Parecidos a una lista

858
00:35:21,199 --> 00:35:22,960
¿Vale? Pero siguen el patrón

859
00:35:22,960 --> 00:35:23,500
FIFO

860
00:35:23,500 --> 00:35:25,219
First in, first out

861
00:35:25,219 --> 00:35:28,599
¿Vale? Entonces la idea es que yo cuando uso una cola

862
00:35:28,599 --> 00:35:30,900
Me baso sobre el hecho que

863
00:35:30,900 --> 00:35:33,139
El primer elemento se pone aquí

864
00:35:33,139 --> 00:35:34,539
El segundo elemento se pone detrás

865
00:35:34,539 --> 00:35:35,739
El tercer elemento se pone detrás

866
00:35:35,739 --> 00:35:38,900
Y cuando voy a pillar uno de estos elementos

867
00:35:38,900 --> 00:35:40,500
Tengo que empezar desde el primero

868
00:35:40,500 --> 00:35:42,280
Oye, pero yo no quiero

869
00:35:42,280 --> 00:35:44,260
Pues no uses una cola

870
00:35:44,260 --> 00:35:45,760
Ningún problema, usa una lista

871
00:35:45,760 --> 00:35:48,579
Que puedes acceder al tercero tranquilamente

872
00:35:48,579 --> 00:35:50,639
La clave aquí

873
00:35:50,639 --> 00:35:52,440
No es lo que puedo o no puedo hacer

874
00:35:52,440 --> 00:35:54,059
Es lo que quiero y no quiero hacer

875
00:35:54,059 --> 00:35:56,840
Si yo tengo que hacer un programa

876
00:35:56,840 --> 00:36:00,219
Donde el almacenamiento de estas cosas

877
00:36:00,219 --> 00:36:01,179
Se basa

878
00:36:01,179 --> 00:36:02,980
Sobre el hecho que

879
00:36:02,980 --> 00:36:04,960
Si han llegado antes unas peticiones

880
00:36:04,960 --> 00:36:06,960
Quiero empezar desde la primera

881
00:36:06,960 --> 00:36:08,199
Y seguir ordenadamente

882
00:36:08,199 --> 00:36:10,360
Pues entonces lo que quiero dar es una cola

883
00:36:10,360 --> 00:36:11,980
Si esto no me interesa

884
00:36:11,980 --> 00:36:13,860
Pues entonces no uso una cola, uso otra cosa

885
00:36:13,860 --> 00:36:16,920
¿Los nodos lo utilizan?

886
00:36:19,480 --> 00:36:20,139
Los nodos

887
00:36:20,139 --> 00:36:23,039
A ver, los nodos no es nada

888
00:36:23,039 --> 00:36:24,320
Los nodos es una implementación

889
00:36:24,320 --> 00:36:26,860
Es un, elija que quieres hacer

890
00:36:26,860 --> 00:36:28,860
Y lo puedes implementar con nodos

891
00:36:28,860 --> 00:36:30,880
Lo que pasa es que el nodo es uno de estos

892
00:36:30,880 --> 00:36:33,599
Yo puedo hacer un conjunto usando nodos

893
00:36:33,599 --> 00:36:35,739
Puedo hacer una lista usando nodos

894
00:36:35,739 --> 00:36:37,599
Puedo hacer una queue usando nodos

895
00:36:37,599 --> 00:36:39,320
Puedo hacer una stack usando nodos

896
00:36:39,320 --> 00:36:48,039
Bienvenido al mundo de los objetos

897
00:36:48,039 --> 00:36:51,719
Lo que cambia con el nodo no nodo

898
00:36:51,719 --> 00:36:53,260
No es

899
00:36:53,260 --> 00:36:54,940
Lo que estás haciendo

900
00:36:54,940 --> 00:36:57,320
Es la implementación de lo que estás haciendo

901
00:36:57,320 --> 00:36:59,619
O sea, yo puedo utilizar para hacer un set

902
00:36:59,619 --> 00:37:00,420
Un array

903
00:37:00,420 --> 00:37:02,039
O un nodo

904
00:37:02,039 --> 00:37:03,599
O otra forma de hacer

905
00:37:03,599 --> 00:37:06,239
Para una lista

906
00:37:06,239 --> 00:37:08,039
Lo puedo hacer ArrayList

907
00:37:08,039 --> 00:37:09,139
Entonces estoy usando Array

908
00:37:09,139 --> 00:37:10,480
Lo puedo hacer LinkedList

909
00:37:10,480 --> 00:37:11,719
Entonces estoy usando los nodos

910
00:37:11,719 --> 00:37:14,679
Para árboles, pues es utilizar nodos

911
00:37:14,679 --> 00:37:16,320
Cada árbol tiene sus nodos

912
00:37:16,320 --> 00:37:17,699
Entrelazados entre ellos

913
00:37:17,699 --> 00:37:20,659
Pero nadie me prohíbe

914
00:37:20,659 --> 00:37:22,300
De crear un Array

915
00:37:22,300 --> 00:37:24,280
Y interpretarlo como un árbol

916
00:37:24,280 --> 00:37:26,400
Que la posición 0 es la raíz

917
00:37:26,400 --> 00:37:28,820
La posición 1 es el hijo de la raíz

918
00:37:28,820 --> 00:37:30,380
La posición 2 es el hijo derecho

919
00:37:30,380 --> 00:37:33,219
El 3 es el hijo

920
00:37:33,219 --> 00:37:35,659
Me creo una fórmula

921
00:37:35,659 --> 00:37:37,059
Y lo utilizo así

922
00:37:37,059 --> 00:37:38,800
Tip

923
00:37:38,800 --> 00:37:47,420
Ah, no, esto no es class

924
00:37:47,420 --> 00:37:49,039
Todas las verdes son class

925
00:37:49,039 --> 00:37:51,739
Y fíjate que hay list

926
00:37:51,739 --> 00:37:54,139
Y hay una, dos, tres y cuatro

927
00:37:54,139 --> 00:37:55,780
Implementaciones de list

928
00:37:55,780 --> 00:37:58,019
¿Vale? Estas dos

929
00:37:58,019 --> 00:37:59,659
Son las que hemos hecho nosotros

930
00:37:59,659 --> 00:38:01,559
Lista implementada con array

931
00:38:01,559 --> 00:38:04,340
Y lista implementada con nodos entrelazados entre ellos

932
00:38:04,340 --> 00:38:05,860
Y luego aquí está vector

933
00:38:05,860 --> 00:38:07,340
Que es igual a array list

934
00:38:07,340 --> 00:38:09,519
Solo que tiene algunas características distintas

935
00:38:09,519 --> 00:38:11,300
En particular está sincronizado

936
00:38:11,300 --> 00:38:13,360
Que nosotros no tenemos idea de que es

937
00:38:13,360 --> 00:38:14,900
Si queréis saber que es

938
00:38:14,900 --> 00:38:16,880
Pues en segundo de DAM

939
00:38:16,880 --> 00:38:18,019
¿Vale?

940
00:38:19,480 --> 00:38:20,719
Y de vector

941
00:38:20,719 --> 00:38:22,500
Está la stack

942
00:38:22,500 --> 00:38:23,800
Que es la pila

943
00:38:23,800 --> 00:38:26,340
¿Vale? Entonces la pila en Java

944
00:38:26,340 --> 00:38:27,780
Está implementada como una lista

945
00:38:27,780 --> 00:38:30,579
¿Si? Y todo esto son

946
00:38:30,579 --> 00:38:32,619
Implementaciones de esta

947
00:38:32,619 --> 00:38:32,960
Tierra

948
00:38:32,960 --> 00:38:40,630
De esta clase podemos crear objetos

949
00:38:40,630 --> 00:38:42,750
Podemos extender esta clase

950
00:38:42,750 --> 00:38:45,769
Como pasa, no pasa en ningún lado

951
00:38:45,769 --> 00:38:50,949
Sí, aquí

952
00:38:50,949 --> 00:38:54,630
Stack hereda de vector

953
00:38:54,630 --> 00:38:56,710
Esto es

954
00:38:56,710 --> 00:38:59,969
Esto es todo lo que tenemos

955
00:38:59,969 --> 00:39:01,610
Tú te puedes crear

956
00:39:01,610 --> 00:39:02,989
Tu propia lista

957
00:39:02,989 --> 00:39:05,869
Y decir, mi propia lista hereda de

958
00:39:05,869 --> 00:39:06,710
ArrayList

959
00:39:06,710 --> 00:39:09,030
Y pilla todo ArrayList

960
00:39:09,030 --> 00:39:11,750
Y le añade unos métodos que te interesan a ti

961
00:39:11,750 --> 00:39:13,329
Que son importantes para tu proyecto

962
00:39:13,329 --> 00:39:15,750
Más dudas

963
00:39:15,750 --> 00:39:20,570
¿Por qué no puedes?

964
00:39:21,349 --> 00:39:27,840
En el set

965
00:39:27,840 --> 00:39:30,380
¿Por qué no puedes quitar?

966
00:39:31,719 --> 00:39:33,039
Es el acceso

967
00:39:33,039 --> 00:39:34,139
Que no es aleatorio

968
00:39:34,139 --> 00:39:36,559
En el sentido de que no hay un orden

969
00:39:36,559 --> 00:39:38,400
Prefijado

970
00:39:38,400 --> 00:39:40,320
Como orden de inserción o cosa por el estilo

971
00:39:40,320 --> 00:39:42,199
Entonces puedes decir, haced al tercero

972
00:39:42,199 --> 00:39:44,340
Cuando tú insertas dentro

973
00:39:44,340 --> 00:39:44,820
De los

974
00:39:44,820 --> 00:39:47,480
De los sets

975
00:39:47,480 --> 00:39:49,320
Por cómo están hechos dentro

976
00:39:49,320 --> 00:39:51,559
No necesariamente respetan

977
00:39:51,559 --> 00:39:52,920
El orden de inserción

978
00:39:52,920 --> 00:39:54,599
Por ejemplo, triset

979
00:39:54,599 --> 00:39:56,679
¿Vale? Triset es

980
00:39:56,679 --> 00:39:58,440
Voy almacenando objetos

981
00:39:58,440 --> 00:39:59,980
Según un árbol

982
00:39:59,980 --> 00:40:03,039
¿Vale? La forma con que

983
00:40:03,039 --> 00:40:05,400
Tú pones aquí o aquí

984
00:40:05,400 --> 00:40:07,119
O aquí o aquí en los nodos

985
00:40:07,119 --> 00:40:08,199
Depende

986
00:40:08,199 --> 00:40:10,119
De otras cosas

987
00:40:10,119 --> 00:40:12,820
¿Vale? Y entonces llega un momento

988
00:40:12,820 --> 00:40:15,119
En que tú a lo mejor insertas 5 elementos

989
00:40:15,119 --> 00:40:16,900
Y el quinto elemento te viene aquí

990
00:40:16,900 --> 00:40:19,079
No necesariamente

991
00:40:19,079 --> 00:40:20,840
te viene ordenado

992
00:40:20,840 --> 00:40:22,780
entonces lo tengo más abajo

993
00:40:22,780 --> 00:40:24,760
de los demás, o sea que el primero

994
00:40:24,760 --> 00:40:26,780
lo ponga aquí, el segundo lo ponga aquí, el tercero lo ponga aquí

995
00:40:26,780 --> 00:40:28,800
el cuarto lo ponga aquí, el quinto me viene a ponerlo aquí

996
00:40:28,800 --> 00:40:30,639
entonces está más alto de niveles

997
00:40:30,639 --> 00:40:32,420
con respecto al segundo, tercero y cuarto

998
00:40:32,420 --> 00:40:34,159
se te mezclan dentro

999
00:40:34,159 --> 00:40:36,659
por eso luego no puedes decir, accedeme al quinto

1000
00:40:36,659 --> 00:40:38,639
porque se ha perdido esta información

1001
00:40:38,639 --> 00:40:40,500
que a ti te interesa esa información

1002
00:40:40,500 --> 00:40:42,099
no uses un set

1003
00:40:42,099 --> 00:40:46,820
pero que a ti no te interesa

1004
00:40:46,820 --> 00:40:48,679
lo de antes, los libros

1005
00:40:48,679 --> 00:40:51,079
A mí me interesa saber los libros que tengo

1006
00:40:51,079 --> 00:40:51,900
¿Vale?

1007
00:40:52,079 --> 00:40:54,900
Me interesa saber que he añadido hoy

1008
00:40:54,900 --> 00:40:56,019
El Señor de los Anillos

1009
00:40:56,019 --> 00:40:58,519
O lo he añadido pasado mañana

1010
00:40:58,519 --> 00:41:01,139
O es el quinto que he añadido en mi cosa

1011
00:41:01,139 --> 00:41:01,820
Pues a lo mejor no

1012
00:41:01,820 --> 00:41:04,699
A mí me interesa saber que mi editorial puede editar

1013
00:41:04,699 --> 00:41:05,739
El Señor de los Anillos

1014
00:41:05,739 --> 00:41:07,800
Lo he añadido, vale, ahora lo tengo allí

1015
00:41:07,800 --> 00:41:10,940
No me interesa saber si lo he puesto antes o después de otro

1016
00:41:10,940 --> 00:41:13,340
A lo mejor me interesa otra forma

1017
00:41:13,340 --> 00:41:14,239
De organizarlo

1018
00:41:14,239 --> 00:41:16,739
En plan, el número de páginas

1019
00:41:16,739 --> 00:41:19,519
Entonces cuando busco estarán organizados

1020
00:41:19,519 --> 00:41:21,559
Por nombre de página o que se yo

1021
00:41:21,559 --> 00:41:25,260
Reset por ejemplo

1022
00:41:25,260 --> 00:41:26,760
Si que creo que se basa sobre

1023
00:41:26,760 --> 00:41:28,980
Comparable, ahora lo miramos

1024
00:41:28,980 --> 00:41:29,500
No me acuerdo

1025
00:41:29,500 --> 00:41:33,969
¿Dudas?

1026
00:41:35,630 --> 00:41:36,349
Entonces

1027
00:41:36,349 --> 00:41:38,849
Esto es, tengo collection

1028
00:41:38,849 --> 00:41:40,730
Desde collection heredan

1029
00:41:40,730 --> 00:41:42,570
Tres tipos de

1030
00:41:42,570 --> 00:41:44,570
Interfaces más que son

1031
00:41:44,570 --> 00:41:45,989
Set, list, queue

1032
00:41:45,989 --> 00:41:52,010
Cada una de ellas añade a los 5 métodos básicos de collection

1033
00:41:52,010 --> 00:41:57,210
Otros métodos adicionales

1034
00:41:57,210 --> 00:42:02,469
O modifica un poco el funcionamiento de estos

1035
00:42:02,469 --> 00:42:07,030
O sea, en una collection añadir es añadir el objeto que te han dado

1036
00:42:07,030 --> 00:42:08,809
Te han dado un elemento, añádelo

1037
00:42:08,809 --> 00:42:15,090
En un set añadir es añadir el elemento

1038
00:42:15,090 --> 00:42:18,650
Siempre y cuando no esté ya en el set

1039
00:42:18,650 --> 00:42:21,150
He pillado esto

1040
00:42:21,150 --> 00:42:23,269
Y lo he modificado un poco

1041
00:42:23,269 --> 00:42:26,550
Entonces la idea es esa

1042
00:42:26,550 --> 00:42:27,789
Yo tengo

1043
00:42:27,789 --> 00:42:33,599
Collection que me define una colección genérica

1044
00:42:33,599 --> 00:42:36,639
Y luego este collection está especificado

1045
00:42:36,639 --> 00:42:38,840
En tres posibles colecciones

1046
00:42:38,840 --> 00:42:40,239
Un poquito más concretas

1047
00:42:40,239 --> 00:42:43,639
Que son listas, colas o conjuntos

1048
00:42:43,639 --> 00:42:45,420
Y cada uno de ellos

1049
00:42:45,420 --> 00:42:46,780
O añade

1050
00:42:46,780 --> 00:42:48,719
Métodos nuevos

1051
00:42:48,719 --> 00:42:50,039
O

1052
00:42:50,039 --> 00:42:53,940
Especializa

1053
00:42:53,940 --> 00:42:55,539
Métodos que ya existían

1054
00:42:55,539 --> 00:42:57,940
En un comportamiento más

1055
00:42:57,940 --> 00:42:59,880
Concreto para ese set

1056
00:42:59,880 --> 00:43:01,099
O las dos cosas a la vez

1057
00:43:01,099 --> 00:43:09,780
Sí, porque esta hereda de esta

1058
00:43:09,780 --> 00:43:11,800
Entonces, esos cinco básicos

1059
00:43:11,800 --> 00:43:12,719
Los va a llevar

1060
00:43:12,719 --> 00:43:15,139
Pero a lo mejor el set tiene

1061
00:43:15,139 --> 00:43:17,219
Un método que no tiene sentido

1062
00:43:17,219 --> 00:43:19,380
Para todas las colecciones, pero para el set

1063
00:43:19,380 --> 00:43:20,940
En concreto sí, y lo añade

1064
00:43:20,940 --> 00:43:23,260
Y a lo mejor en collection tú puedes

1065
00:43:23,260 --> 00:43:25,159
Añadir un objeto todas las veces que quieres

1066
00:43:25,159 --> 00:43:27,000
Pero set no quiere, entonces te dice

1067
00:43:27,000 --> 00:43:29,139
Oye mira, en la especificación del set

1068
00:43:29,139 --> 00:43:30,900
Aquí te dice, como si estoy

1069
00:43:30,900 --> 00:43:33,659
Sobrescribiendo el set de collection

1070
00:43:33,659 --> 00:43:34,679
Diciendo, oye mira

1071
00:43:34,679 --> 00:43:36,960
En el set, collection

1072
00:43:36,960 --> 00:43:38,880
No puede añadir un elemento

1073
00:43:38,880 --> 00:43:41,119
Si ese elemento ya existe en la colección

1074
00:43:41,119 --> 00:43:42,159
En el set

1075
00:43:42,159 --> 00:43:49,170
Esto ya lo hemos visto

1076
00:43:49,170 --> 00:43:50,309
Esto ya lo hemos visto

1077
00:43:50,309 --> 00:43:51,929
Entonces la interfaz list

1078
00:43:51,929 --> 00:43:54,210
De estas tres

1079
00:43:54,210 --> 00:43:56,230
Empezamos por aquí

1080
00:43:56,230 --> 00:43:57,050
Que es la más fácil

1081
00:43:57,050 --> 00:44:01,610
Define una sucesión de elementos

1082
00:44:01,610 --> 00:44:04,110
Amite elementos duplicados

1083
00:44:04,110 --> 00:44:05,869
Entonces puedo poner un elemento

1084
00:44:05,869 --> 00:44:06,730
Y otra vez el mismo

1085
00:44:06,730 --> 00:44:08,170
Le da igual

1086
00:44:08,170 --> 00:44:10,070
No hace comprobación de no

1087
00:44:10,070 --> 00:44:11,670
Mira que este elemento ya estaba

1088
00:44:11,670 --> 00:44:13,010
Hago un ejemplo

1089
00:44:13,010 --> 00:44:18,590
Yo puedo tener una lista de citas para mi tutoría

1090
00:44:18,590 --> 00:44:23,289
Y si un alumno me pide dos tutorías, una hora y una próxima semana

1091
00:44:23,289 --> 00:44:27,409
Yo añado dos veces en la lista al mismo alumno, sin ningún problema

1092
00:44:27,409 --> 00:44:28,750
¿Vale?

1093
00:44:28,929 --> 00:44:30,889
Si fuera un set no lo podría hacer

1094
00:44:30,889 --> 00:44:32,889
Entonces uso la lista

1095
00:44:32,889 --> 00:44:34,349
¿Se entiende?

1096
00:44:35,349 --> 00:44:35,590
Vale

1097
00:44:35,590 --> 00:44:40,190
Aparte de los métodos heredados de collection

1098
00:44:40,190 --> 00:44:43,090
Añade métodos que permiten mejorar los siguientes puntos

1099
00:44:43,090 --> 00:44:43,610
O sea

1100
00:44:43,610 --> 00:44:46,469
Esto tiene todo lo que tiene

1101
00:44:46,469 --> 00:44:48,550
Collection, los cinco métodos

1102
00:44:48,550 --> 00:44:50,309
Pero además tiene

1103
00:44:50,309 --> 00:44:52,349
Acceso posicional al elemento

1104
00:44:52,349 --> 00:44:55,070
Un, dame el tercer elemento

1105
00:44:55,070 --> 00:44:56,510
Fijaos

1106
00:44:56,510 --> 00:44:59,800
Que aquí no está

1107
00:44:59,800 --> 00:45:03,489
Aquí no está un

1108
00:45:03,489 --> 00:45:04,829
Dame el tercer elemento

1109
00:45:04,829 --> 00:45:07,789
Aquí está el, dame el elemento

1110
00:45:07,789 --> 00:45:08,369
Este de aquí

1111
00:45:08,369 --> 00:45:11,250
En cierto sentido

1112
00:45:11,250 --> 00:45:12,730
Que esto remove también es

1113
00:45:12,730 --> 00:45:18,909
Esto yo asumiría que

1114
00:45:18,909 --> 00:45:21,269
Lo quita y te lo devuelve a ti

1115
00:45:21,269 --> 00:45:22,889
De esta forma si lo estás buscando

1116
00:45:22,889 --> 00:45:23,989
Lo puedes obtener

1117
00:45:23,989 --> 00:45:25,329
Pero independientemente

1118
00:45:25,329 --> 00:45:27,190
Aquí no pilla un entero

1119
00:45:27,190 --> 00:45:28,829
No pilla una posición

1120
00:45:28,829 --> 00:45:30,269
Pilla un elemento

1121
00:45:30,269 --> 00:45:31,710
Tú tienes esta colección

1122
00:45:31,710 --> 00:45:33,929
Y te dice me das este libro de aquí

1123
00:45:33,929 --> 00:45:36,329
Y yo voy allí

1124
00:45:36,329 --> 00:45:37,670
Lo busco y este de aquí

1125
00:45:37,670 --> 00:45:39,989
Pero no hay forma

1126
00:45:39,989 --> 00:45:41,869
Me quitas el quinto libro

1127
00:45:41,869 --> 00:45:43,789
Eso no lo puede hacer, no está

1128
00:45:43,789 --> 00:45:45,550
¿No entendéis la diferencia?

1129
00:45:47,309 --> 00:45:48,309
No, no, lo añade

1130
00:45:48,309 --> 00:45:49,809
Es un método nuevo

1131
00:45:49,809 --> 00:45:50,849
¿Sí?

1132
00:45:52,610 --> 00:45:54,550
¿Con el elemento puede ser un objeto

1133
00:45:54,550 --> 00:45:55,909
O un string o lo que sea, no?

1134
00:45:57,050 --> 00:45:58,090
¿String es un objeto?

1135
00:45:58,889 --> 00:46:00,050
Sustantemente son objetos

1136
00:46:00,050 --> 00:46:02,190
Pero hay como una idea más

1137
00:46:02,190 --> 00:46:04,389
Genera, porque si luego tú haces

1138
00:46:04,389 --> 00:46:06,030
Una, te pones

1139
00:46:06,030 --> 00:46:08,610
Como cosas que metes

1140
00:46:08,610 --> 00:46:10,469
Dentro, un tipo de interfaz

1141
00:46:10,469 --> 00:46:11,489
Que se podría hacer

1142
00:46:11,489 --> 00:46:13,909
¿Vale? Pues haces una lista de listas

1143
00:46:13,909 --> 00:46:15,809
Por ejemplo, pues entonces es un objeto

1144
00:46:15,809 --> 00:46:17,329
Pues sí, pero no, sí, pero no

1145
00:46:17,329 --> 00:46:19,809
Un elemento, más que menos

1146
00:46:19,809 --> 00:46:21,670
¿Vale? Entonces

1147
00:46:21,670 --> 00:46:24,050
Primero, hacer suposicionar un elemento

1148
00:46:24,050 --> 00:46:25,969
Manipula elementos en función de su posición

1149
00:46:25,969 --> 00:46:28,050
De la lista, ¿vale? Entonces puede decir

1150
00:46:28,050 --> 00:46:29,170
Añade

1151
00:46:29,170 --> 00:46:31,889
Dice, pues, no sé, pero añade en tercera

1152
00:46:31,889 --> 00:46:33,809
Posición, o píllame el elemento

1153
00:46:33,809 --> 00:46:35,630
Que está en tercera posición, ¿vale?

1154
00:46:35,750 --> 00:46:38,090
Cosa que un collection no puede

1155
00:46:38,090 --> 00:46:40,070
Hacer, y un list sí puede

1156
00:46:40,070 --> 00:46:42,349
Más cosas

1157
00:46:42,349 --> 00:46:43,530
Búsqueda de elementos

1158
00:46:43,530 --> 00:46:45,469
Busca un elemento concreto en la lista

1159
00:46:45,469 --> 00:46:46,949
Y devuelve su posición

1160
00:46:46,949 --> 00:46:48,809
¿Vale?

1161
00:46:49,210 --> 00:46:51,050
Cosa que no hace collection

1162
00:46:51,050 --> 00:46:53,469
Pero aquí, como la lista

1163
00:46:53,469 --> 00:46:55,809
Tiene asociado una posición

1164
00:46:55,809 --> 00:46:56,409
Un número

1165
00:46:56,409 --> 00:46:59,530
Un orden

1166
00:46:59,530 --> 00:47:00,090
¿Vale?

1167
00:47:00,309 --> 00:47:02,969
Yo le puedo decir, mira, mira este elemento de aquí

1168
00:47:02,969 --> 00:47:05,809
Dime en qué posición de la lista está

1169
00:47:05,809 --> 00:47:08,130
Y me va a leer tres

1170
00:47:08,130 --> 00:47:09,829
¿Qué es una cosa que hemos implementado nosotros?

1171
00:47:09,829 --> 00:47:12,530
Nosotros devolvíamos al objeto

1172
00:47:12,530 --> 00:47:13,730
Directamente

1173
00:47:13,730 --> 00:47:15,789
Nosotros nos hemos implementado esto

1174
00:47:15,789 --> 00:47:18,070
Le damos una posición y nos da el objeto

1175
00:47:18,070 --> 00:47:18,849
Este no

1176
00:47:18,849 --> 00:47:22,170
Literación sobre elementos

1177
00:47:22,170 --> 00:47:25,389
Mejora el iterador por defecto

1178
00:47:25,389 --> 00:47:25,670
¿Vale?

1179
00:47:26,190 --> 00:47:27,909
O sea que iterador

1180
00:47:27,909 --> 00:47:29,909
A nivel de colección es

1181
00:47:29,909 --> 00:47:31,829
Una cosa mágica

1182
00:47:31,829 --> 00:47:33,789
Que me permite iterar

1183
00:47:33,789 --> 00:47:35,929
Sobre todos los objetos de la colección

1184
00:47:35,929 --> 00:47:37,690
Ir a mirar todos los objetos

1185
00:47:37,690 --> 00:47:38,730
Que están en mi colección

1186
00:47:38,730 --> 00:47:40,690
Pues en list

1187
00:47:40,690 --> 00:47:42,530
Se mejora esto

1188
00:47:42,530 --> 00:47:44,789
Basándome sobre, ahora yo además

1189
00:47:44,789 --> 00:47:47,110
Tengo una posición, entonces es más fácil

1190
00:47:47,110 --> 00:47:48,489
Es más eficiente poder

1191
00:47:48,489 --> 00:47:51,050
Variabilizar, porque la lista está pensada

1192
00:47:51,050 --> 00:47:52,690
Por, entro aquí y lo puedo recorrer

1193
00:47:52,690 --> 00:47:54,670
De forma fácil, por lo tanto

1194
00:47:54,670 --> 00:47:56,130
Mejoro el básico

1195
00:47:56,130 --> 00:47:58,670
Que me dice collection y hago uno

1196
00:47:58,670 --> 00:48:00,289
Específico para list

1197
00:48:00,289 --> 00:48:02,510
En cierto sentido esto está sobre escribiendo

1198
00:48:02,510 --> 00:48:03,809
El iterador de arriba

1199
00:48:03,809 --> 00:48:04,730
¿Sí?

1200
00:48:05,829 --> 00:48:08,610
Y rango de operaciones, permítase realizar

1201
00:48:08,610 --> 00:48:10,670
Ciertas operaciones sobre el rango de elementos

1202
00:48:10,670 --> 00:48:11,630
Dentro de la propia lista

1203
00:48:11,630 --> 00:48:14,730
En plan, añádeme estos 5 elementos de golpe

1204
00:48:14,730 --> 00:48:15,969
En vez que uno en uno

1205
00:48:15,969 --> 00:48:19,190
O remuéveme estos 7 elementos de golpe

1206
00:48:19,190 --> 00:48:23,929
Ahí también estaría mejorando

1207
00:48:23,929 --> 00:48:27,230
No es mejorar

1208
00:48:27,230 --> 00:48:29,869
Sino añadir nuevas funcionalidades

1209
00:48:29,869 --> 00:48:31,829
Que en este contexto tienen sentido

1210
00:48:31,829 --> 00:48:33,590
En un contexto de colección

1211
00:48:33,590 --> 00:48:35,030
Que es mucho más genérico

1212
00:48:35,030 --> 00:48:35,590
A lo mejor no

1213
00:48:35,590 --> 00:48:38,809
Entonces la diferencia entre añadir y sobreescribir

1214
00:48:38,809 --> 00:48:40,869
Que cuando tú añades

1215
00:48:40,869 --> 00:48:42,369
Es una cosa que en Collection no está

1216
00:48:42,369 --> 00:48:44,130
Y ahora sí está

1217
00:48:44,130 --> 00:48:45,610
¿Vale? He añadido

1218
00:48:45,610 --> 00:48:48,369
Esto en Collection no está, lo he añadido yo

1219
00:48:48,369 --> 00:48:50,869
Sobrescribir es algo que ya

1220
00:48:50,869 --> 00:48:52,070
Existe en Collection

1221
00:48:52,070 --> 00:48:54,789
Y yo lo sobreescribo para mejorarlo

1222
00:48:54,789 --> 00:48:57,050
Con los datos y con la característica

1223
00:48:57,050 --> 00:48:58,570
Que tengo ahora, como por ejemplo

1224
00:48:58,570 --> 00:48:59,050
Iterador

1225
00:48:59,050 --> 00:49:01,989
En Iterador ya está en Collection

1226
00:49:01,989 --> 00:49:03,309
Pero yo lo que hago es lo pillo

1227
00:49:03,309 --> 00:49:04,909
Lo modifico para

1228
00:49:04,909 --> 00:49:06,369
Que sea más

1229
00:49:06,369 --> 00:49:09,010
Eficiente en el contexto

1230
00:49:09,010 --> 00:49:10,469
De la lista que estoy utilizando

1231
00:49:10,469 --> 00:49:20,519
¿Cómo?

1232
00:49:22,940 --> 00:49:25,280
Es un objeto del que tú

1233
00:49:25,280 --> 00:49:27,840
Pillas iterator y tiene dos metoditos

1234
00:49:27,840 --> 00:49:28,699
Que nos interesan

1235
00:49:28,699 --> 00:49:30,219
HasNext y Next

1236
00:49:30,219 --> 00:49:33,500
HasNext te dice si hay un elemento más

1237
00:49:33,500 --> 00:49:35,800
Y Next te da ese elemento

1238
00:49:35,800 --> 00:49:37,599
Entonces tú vas

1239
00:49:37,599 --> 00:49:39,659
En un while iterator hasNext

1240
00:49:39,659 --> 00:49:40,800
Pues dame el Next

1241
00:49:40,800 --> 00:49:43,780
Lo veremos

1242
00:49:43,780 --> 00:49:46,000
Sí, entonces

1243
00:49:46,000 --> 00:49:47,280
Lista, pilla

1244
00:49:47,280 --> 00:49:50,820
Tened en cuenta que esto no es un objeto

1245
00:49:50,820 --> 00:49:52,179
No es una clase

1246
00:49:52,179 --> 00:49:53,800
Es una interfaz

1247
00:49:53,800 --> 00:49:55,340
¿Vale?

1248
00:49:55,539 --> 00:49:58,599
Es una clase abstracta con todos sus métodos abstractos

1249
00:49:58,599 --> 00:50:01,019
Y pilla todos los métodos abstractos

1250
00:50:01,019 --> 00:50:01,699
De collection

1251
00:50:01,699 --> 00:50:03,820
Y añade

1252
00:50:03,820 --> 00:50:05,619
Estos métodos de aquí

1253
00:50:05,619 --> 00:50:08,739
Que no son cinco

1254
00:50:08,739 --> 00:50:09,360
Son más

1255
00:50:09,360 --> 00:50:12,880
La idea es que pueda hacer estas cosas

1256
00:50:12,880 --> 00:50:16,039
Y desde la interfaz list

1257
00:50:16,039 --> 00:50:18,260
En Java se conocen

1258
00:50:18,260 --> 00:50:20,860
Tres implementaciones directas

1259
00:50:20,860 --> 00:50:23,099
ArrayList, LinkedList

1260
00:50:23,099 --> 00:50:23,940
Y Vector

1261
00:50:23,940 --> 00:50:27,199
Y desde Vector hereda stack

1262
00:50:27,199 --> 00:50:28,780
Que en inglés quiere decir pila

1263
00:50:28,780 --> 00:50:30,820
O sea que si queréis hacer una pila

1264
00:50:30,820 --> 00:50:33,079
En Java es implementado como una lista

1265
00:50:33,079 --> 00:50:35,320
Y será un vector

1266
00:50:35,320 --> 00:50:37,099
Al que le habrá añadido

1267
00:50:37,099 --> 00:50:38,739
Los métodos propios

1268
00:50:38,739 --> 00:50:40,400
De la lista, de la pila

1269
00:50:40,400 --> 00:50:42,780
Y ahora lo vamos a ver si queréis

1270
00:50:42,780 --> 00:50:45,659
De uno en uno

1271
00:50:45,659 --> 00:50:47,659
ArrayList

1272
00:50:47,659 --> 00:50:49,380
ArrayList es una lista

1273
00:50:49,380 --> 00:50:50,980
Es una implementación típica

1274
00:50:50,980 --> 00:50:53,380
95% de las veces que utilizáis

1275
00:50:53,380 --> 00:50:55,539
Una lista en Java

1276
00:50:55,539 --> 00:50:56,960
Pues utilizáis ArrayList

1277
00:50:56,960 --> 00:51:00,440
Se basa en un array dinámico

1278
00:51:00,440 --> 00:51:01,679
Que aumenta su tamaño

1279
00:51:01,679 --> 00:51:02,880
Según crece la colección

1280
00:51:02,880 --> 00:51:04,820
¿Existen array dinámicos? No

1281
00:51:04,820 --> 00:51:06,300
Es un array estático que

1282
00:51:06,300 --> 00:51:08,420
Pero, automáticamente

1283
00:51:08,420 --> 00:51:09,820
Aumenta de su tamaño

1284
00:51:09,820 --> 00:51:12,539
Como hemos hecho nosotros, copiándose en otro array

1285
00:51:12,539 --> 00:51:14,260
Sin que tenga que hacerlo yo

1286
00:51:14,260 --> 00:51:16,300
¿Vale? Por eso dice array dinámico

1287
00:51:16,300 --> 00:51:17,739
¿Eh?

1288
00:51:20,639 --> 00:51:21,199
Porque

1289
00:51:21,199 --> 00:51:24,280
Es fácil

1290
00:51:24,280 --> 00:51:26,300
De utilizar, es fácil de pensar

1291
00:51:26,300 --> 00:51:27,760
¿Vale? De todas formas

1292
00:51:27,760 --> 00:51:28,900
No es que sea peor que el otro

1293
00:51:28,900 --> 00:51:30,099
Ahora lo veremos

1294
00:51:30,099 --> 00:51:32,519
Aquí

1295
00:51:32,519 --> 00:51:35,079
En la lucha directa

1296
00:51:35,079 --> 00:51:35,360
¿Vale?

1297
00:51:35,360 --> 00:51:38,500
Puede contener elementos duplicados

1298
00:51:38,500 --> 00:51:40,579
Puedo poner dos elementos que si hiciera

1299
00:51:40,579 --> 00:51:42,380
Equals entre ellos me darían true

1300
00:51:42,380 --> 00:51:43,460
Pues los puedo añadir

1301
00:51:43,460 --> 00:51:46,239
Puedes insertar al final

1302
00:51:46,239 --> 00:51:48,280
Una posición concreta, ¿vale?

1303
00:51:48,860 --> 00:51:50,300
Normalmente se inserta al final

1304
00:51:50,300 --> 00:51:52,340
Si tú haces add a secas

1305
00:51:52,340 --> 00:51:53,860
Pues te lo añade al final

1306
00:51:53,860 --> 00:51:56,199
Si haces add este elemento

1307
00:51:56,199 --> 00:51:57,639
Coma en posición 3

1308
00:51:57,639 --> 00:52:00,079
Te lo pone en posición 3

1309
00:52:00,079 --> 00:52:02,340
¿Vale? Fijaos que la lista

1310
00:52:02,340 --> 00:52:03,420
Puede hacer lo que le haga la gana

1311
00:52:03,420 --> 00:52:05,880
Si esto lo quiero hacer como cola

1312
00:52:05,880 --> 00:52:08,260
Pues entonces no lo debería

1313
00:52:08,260 --> 00:52:09,480
Poder hacer esto

1314
00:52:09,480 --> 00:52:12,260
Aún si lo hago a lo mejor lo puede hacer

1315
00:52:12,260 --> 00:52:13,940
Pero, y tened en cuenta

1316
00:52:13,940 --> 00:52:14,980
Que si voy a cola

1317
00:52:14,980 --> 00:52:17,440
No estoy aquí

1318
00:52:17,440 --> 00:52:18,519
Voy aquí

1319
00:52:18,519 --> 00:52:21,099
Que si quiero hacer una cola

1320
00:52:21,099 --> 00:52:23,940
No es una lista, es otra interfaz

1321
00:52:24,539 --> 00:52:28,860
¿Qué más?

1322
00:52:29,500 --> 00:52:31,860
Permite el acceso alatorio porque al ser implementado

1323
00:52:31,860 --> 00:52:33,400
Con un array, permite acceder a la posición

1324
00:52:33,400 --> 00:52:35,280
Usando el índice del array mismo

1325
00:52:35,280 --> 00:52:36,500
Este es super potente

1326
00:52:36,500 --> 00:52:39,219
Si yo digo accedo al elemento 5

1327
00:52:39,219 --> 00:52:41,920
Como es un array, accedo a la posición 5

1328
00:52:41,920 --> 00:52:43,119
Y ya me encuentro el objeto

1329
00:52:43,119 --> 00:52:46,420
Es muy rápido a la hora del acceso aleatorio

1330
00:52:46,420 --> 00:52:47,719
Acceso aleatorio quiere decir

1331
00:52:47,719 --> 00:52:49,300
Que yo tengo todos mis objetos

1332
00:52:49,300 --> 00:52:50,099
Y quiero este

1333
00:52:50,099 --> 00:52:56,340
La manipulación

1334
00:52:56,340 --> 00:52:57,659
De estos objetos

1335
00:52:57,659 --> 00:52:58,500
Es lenta

1336
00:52:58,500 --> 00:53:01,300
Cada vez que yo añado uno

1337
00:53:01,300 --> 00:53:02,659
O quito uno

1338
00:53:02,659 --> 00:53:04,500
Es un problema

1339
00:53:04,500 --> 00:53:07,139
Porque tengo que rehacer el array entero

1340
00:53:07,139 --> 00:53:08,500
Lo hemos visto nosotros

1341
00:53:08,500 --> 00:53:11,539
Cada vez que añadía uno tenía que copiar el array entero

1342
00:53:11,539 --> 00:53:12,900
Añadir un espacito

1343
00:53:12,900 --> 00:53:14,199
Y añadir una nueva cosa

1344
00:53:14,199 --> 00:53:15,920
Y esto es costoso

1345
00:53:15,920 --> 00:53:17,260
Entonces

1346
00:53:17,260 --> 00:53:20,079
Maravilloso

1347
00:53:20,079 --> 00:53:23,260
Para accesos directos

1348
00:53:23,260 --> 00:53:24,420
Accesos aleatorios

1349
00:53:24,420 --> 00:53:26,920
O sea, un programa

1350
00:53:26,920 --> 00:53:29,320
Que me rellena una colección

1351
00:53:29,320 --> 00:53:30,440
De datos una vez

1352
00:53:30,440 --> 00:53:33,559
Y luego la usa un millón de veces

1353
00:53:33,559 --> 00:53:35,219
Arraylist fenomenal

1354
00:53:35,219 --> 00:53:39,840
Un programa que está constantemente

1355
00:53:39,840 --> 00:53:41,559
Insertando y quitando datos

1356
00:53:41,559 --> 00:53:42,820
Desde la colección

1357
00:53:42,820 --> 00:53:44,420
Arraylist fatal

1358
00:53:44,420 --> 00:54:07,329
Pero si la colección es la misma

1359
00:54:07,329 --> 00:54:08,989
El problema no es la clase que hace

1360
00:54:08,989 --> 00:54:10,530
Es que la colección es esa

1361
00:54:10,530 --> 00:54:13,250
Si tú la colección la has implementado con Arraylist

1362
00:54:13,250 --> 00:54:15,130
Y tienes una clase que la rellena

1363
00:54:15,130 --> 00:54:17,130
Y una clase que hace de ella

1364
00:54:17,130 --> 00:54:18,730
Pero igualmente es una relis

1365
00:54:18,730 --> 00:54:20,650
El problema es de la implementación

1366
00:54:20,650 --> 00:54:22,889
Tener duplicado

1367
00:54:22,889 --> 00:54:24,989
O sea, tener los mismos datos

1368
00:54:24,989 --> 00:54:26,630
Implementados una vez como relis

1369
00:54:26,630 --> 00:54:27,949
Y una vez como linked list

1370
00:54:27,949 --> 00:54:30,289
Y cuando tengo que añadir cosas, lo añado aquí

1371
00:54:30,289 --> 00:54:32,309
Luego llega un momento que no son las mismas

1372
00:54:32,309 --> 00:54:35,590
Nunca duplicar datos

1373
00:54:35,590 --> 00:54:37,150
Esto de consistencia de datos

1374
00:54:37,150 --> 00:54:39,250
Creo que lo habéis visto en algo en base de datos

1375
00:54:39,250 --> 00:54:39,449
¿No?

1376
00:54:41,449 --> 00:54:42,969
Cuidado con la tabla

1377
00:54:42,969 --> 00:54:45,190
De poner el mismo dato en una tabla y en otra

1378
00:54:45,190 --> 00:54:47,230
Porque luego cuando actualizáis aquí

1379
00:54:47,230 --> 00:54:48,670
Si no actualizáis el otro es para todo

1380
00:54:48,670 --> 00:54:49,409
¿No?

1381
00:54:50,809 --> 00:54:52,010
¿Hay listas de Google?

1382
00:54:52,170 --> 00:54:52,409
Sí, ¿no?

1383
00:54:54,090 --> 00:54:54,929
Está con él

1384
00:54:54,929 --> 00:54:58,929
La manipulación es lenta

1385
00:54:58,929 --> 00:55:00,710
Porque es necesario realizar muchos cambios

1386
00:55:00,710 --> 00:55:02,070
Si se elimina algún elemento, ¿vale?

1387
00:55:02,429 --> 00:55:03,789
No está sincronizado

1388
00:55:03,789 --> 00:55:04,989
¿Qué es esto de sincronizar?

1389
00:55:05,170 --> 00:55:07,070
Os lo digo en pincelada rápida

1390
00:55:07,070 --> 00:55:09,510
Vosotros estáis acostumbrados a hacer

1391
00:55:09,510 --> 00:55:12,809
Programas que tienen un hilo de ejecución

1392
00:55:12,809 --> 00:55:13,730
El main

1393
00:55:13,730 --> 00:55:16,030
Empieza aquí, hace esta cosa

1394
00:55:16,030 --> 00:55:17,650
Llama otro método, hace esta cosa

1395
00:55:17,650 --> 00:55:18,750
Y se acabó

1396
00:55:18,750 --> 00:55:20,550
Pero es siempre un solo

1397
00:55:20,550 --> 00:55:24,110
Una sola secuencia

1398
00:55:24,110 --> 00:55:25,110
Una secuencia clara

1399
00:55:25,110 --> 00:55:27,130
En segundo de Damm

1400
00:55:27,130 --> 00:55:30,489
Un profesor muy bueno

1401
00:55:30,489 --> 00:55:32,789
De orígenes

1402
00:55:32,789 --> 00:55:34,289
Italianas

1403
00:55:34,289 --> 00:55:36,769
Os podría enseñar

1404
00:55:36,769 --> 00:55:38,449
Como se hacen programas

1405
00:55:38,449 --> 00:55:41,070
Que lanzan varios hilos de ejecución

1406
00:55:41,070 --> 00:55:41,530
A la vez

1407
00:55:41,530 --> 00:55:43,829
Tú lanzas un solo proceso

1408
00:55:43,829 --> 00:55:45,769
Pero ese proceso se divide

1409
00:55:45,769 --> 00:55:48,150
En varias cosas que van por separado

1410
00:55:48,150 --> 00:55:49,789
Y se hacen cosas completamente separadas

1411
00:55:49,789 --> 00:55:51,690
Para hacer un ejemplo plano

1412
00:55:51,690 --> 00:55:53,150
Cuando vosotros usáis el Word

1413
00:55:53,150 --> 00:55:54,489
Y estáis tecleando

1414
00:55:54,489 --> 00:55:57,269
Y alguien mágico os dice

1415
00:55:57,269 --> 00:55:58,809
Esta palabra está mal escrita

1416
00:55:58,809 --> 00:56:00,469
Pues ahí hay dos threads

1417
00:56:00,469 --> 00:56:04,050
Un thread que está recibiendo tus datos

1418
00:56:04,050 --> 00:56:05,849
Desde el teclado y lo está escribiendo allí

1419
00:56:05,849 --> 00:56:07,650
Y otro thread que a la vez

1420
00:56:07,650 --> 00:56:09,690
Está pillando esto de allí y lo está comprobando

1421
00:56:09,690 --> 00:56:11,409
Con la gramática española y te está diciendo

1422
00:56:11,409 --> 00:56:12,429
Esto lleva acento

1423
00:56:12,429 --> 00:56:14,449
¿Sí?

1424
00:56:15,030 --> 00:56:17,590
Pues cuando hay casos de eso

1425
00:56:17,590 --> 00:56:19,510
Cuando hay multithreading

1426
00:56:19,510 --> 00:56:23,550
Los objetos tienen que ser

1427
00:56:23,550 --> 00:56:24,590
Sincronizados

1428
00:56:24,590 --> 00:56:27,409
Porque si este intenta escribir

1429
00:56:27,409 --> 00:56:28,630
Algo en un string

1430
00:56:28,630 --> 00:56:31,469
Mientras este escribe en el mismo string

1431
00:56:31,469 --> 00:56:33,429
Puede que hagan caos

1432
00:56:33,429 --> 00:56:35,170
¿Se entiende?

1433
00:56:36,469 --> 00:56:36,769
Vale

1434
00:56:36,769 --> 00:56:39,210
ArrayList no es sincronizado

1435
00:56:39,210 --> 00:56:40,170
Hace caos

1436
00:56:40,170 --> 00:56:42,269
Si tú tienes dos threads

1437
00:56:42,269 --> 00:56:44,269
Que trabajan sobre el mismo ArrayList

1438
00:56:44,269 --> 00:56:46,570
Antes o después te cargas algo

1439
00:56:46,570 --> 00:56:53,590
Y luego está LinkedList

1440
00:56:53,590 --> 00:56:57,969
LinkedList es una lista doblemente enlazada

1441
00:56:57,969 --> 00:57:00,349
No es la implementación nuestra

1442
00:57:00,349 --> 00:57:02,050
Aquí os acordáis que os dije

1443
00:57:02,050 --> 00:57:05,210
Podría hacer que el nodo tenga un link al siguiente

1444
00:57:05,210 --> 00:57:07,289
Y también un enlace al anterior

1445
00:57:07,289 --> 00:57:10,989
Pues esta es la implementación que hace Java

1446
00:57:10,989 --> 00:57:14,550
Java es una lista doblemente enlazada

1447
00:57:14,550 --> 00:57:17,369
Desde un elemento, desde un nodo de la lista

1448
00:57:17,369 --> 00:57:19,489
Puedo ir al anterior o al siguiente

1449
00:57:19,489 --> 00:57:20,929
Tranquilamente

1450
00:57:20,929 --> 00:57:24,909
Puede contener elementos duplicados

1451
00:57:24,909 --> 00:57:27,789
Se puede insertar al final o en una posición concreta

1452
00:57:27,789 --> 00:57:30,210
Yo digo añadir una posición 3

1453
00:57:30,210 --> 00:57:32,150
Él entrará en el primer elemento

1454
00:57:32,150 --> 00:57:34,110
Va al siguiente, va al siguiente

1455
00:57:34,110 --> 00:57:36,769
Aquí es donde inserta el nuevo

1456
00:57:36,769 --> 00:57:39,030
Y lo concadena con el siguiente de la lista

1457
00:57:39,030 --> 00:57:40,429
Se puede hacer

1458
00:57:40,429 --> 00:57:45,369
La lista permite insertar en una posición aleatoria

1459
00:57:45,369 --> 00:57:48,710
Esta implementación con respecto a la lista

1460
00:57:48,710 --> 00:57:51,130
Mejora la velocidad de manipulación de los objetos

1461
00:57:51,130 --> 00:57:51,650
Lo vimos

1462
00:57:51,650 --> 00:57:55,650
Añadir o quitar nodos es mucho más rápido

1463
00:57:55,650 --> 00:57:59,090
Con respecto a copiar el entero array

1464
00:57:59,090 --> 00:58:01,969
Añadir una posición y poner allí un nuevo objeto

1465
00:58:01,969 --> 00:58:06,510
Lo que pasa es que el acceso aleatorio es mucho peor

1466
00:58:06,510 --> 00:58:10,710
Porque antes podía acceder directamente a la posición 6 de la array

1467
00:58:10,710 --> 00:58:12,670
Y ahora para llegar a la posición 6

1468
00:58:12,670 --> 00:58:14,530
Tengo que entrar en el primero

1469
00:58:14,530 --> 00:58:16,230
Desde el primero ir al segundo

1470
00:58:16,230 --> 00:58:17,550
Del segundo al tercero

1471
00:58:17,550 --> 00:58:18,610
Del tercero al cuarto

1472
00:58:18,610 --> 00:58:20,489
Y así hasta llegar al sexto

1473
00:58:20,489 --> 00:58:21,449
Es mucho más lento

1474
00:58:21,449 --> 00:58:25,849
Entonces, un sistema en que yo estoy constantemente

1475
00:58:25,849 --> 00:58:28,469
Insertando y quitando datos desde mi colección

1476
00:58:28,469 --> 00:58:30,110
LinkedList es muy bueno

1477
00:58:30,110 --> 00:58:34,409
Un sistema en el que al principio carga la colección

1478
00:58:34,409 --> 00:58:36,489
Y luego lo único que hace es acceder

1479
00:58:36,489 --> 00:58:38,449
A los datos dentro de la colección

1480
00:58:38,449 --> 00:58:39,730
Link list mal

1481
00:58:39,730 --> 00:58:44,389
Este también estaría en el set

1482
00:58:44,389 --> 00:58:45,969
No, este es un list

1483
00:58:45,969 --> 00:58:47,869
¿Cierto? No tiene que ver

1484
00:58:47,869 --> 00:58:52,000
¿List?

1485
00:58:52,780 --> 00:58:53,340
Si, si, si

1486
00:58:53,340 --> 00:58:55,500
Nosotros estamos aquí

1487
00:58:55,500 --> 00:58:56,539
Si, te lo digo

1488
00:58:56,539 --> 00:58:58,199
Si es bueno para eso

1489
00:58:58,199 --> 00:59:01,820
También sería bueno tenerlo en el set

1490
00:59:01,820 --> 00:59:03,000
Porque como ves todo

1491
00:59:03,000 --> 00:59:04,159
Sin ordenar

1492
00:59:04,159 --> 00:59:09,440
Y de hecho, linkedh set es una implementación con nodos del set

1493
00:59:09,440 --> 00:59:10,360
Pero no estamos aquí

1494
00:59:10,360 --> 00:59:13,420
Estamos implementando listas

1495
00:59:13,420 --> 00:59:14,119
¿Vale?

1496
00:59:17,659 --> 00:59:19,380
Este señor de aquí

1497
00:59:19,380 --> 00:59:21,960
Utilizado

1498
00:59:21,960 --> 00:59:26,719
Si miráis la cosa, ahora lo veremos

1499
00:59:26,719 --> 00:59:28,619
Pues se puede utilizar como lista

1500
00:59:28,619 --> 00:59:30,559
Se puede utilizar como pila

1501
00:59:30,559 --> 00:59:32,019
Y se puede utilizar como cola

1502
00:59:32,019 --> 00:59:35,039
Utilizando los métodos correctos

1503
00:59:35,039 --> 00:59:37,400
Esta misma implementación

1504
00:59:37,400 --> 00:59:38,980
Te permite usar las tres cosas

1505
00:59:38,980 --> 00:59:43,690
O sea que esta de aquí

1506
00:59:43,690 --> 00:59:45,690
Además de lo que viene en lista

1507
00:59:45,690 --> 00:59:47,530
Además de lo que viene en collection

1508
00:59:47,530 --> 00:59:49,289
Añade métodos

1509
00:59:49,289 --> 00:59:51,489
Que si tú usas los métodos correctos

1510
00:59:51,489 --> 00:59:52,489
Ahora veremos cuáles son

1511
00:59:52,489 --> 00:59:54,650
Pues te funciona como una lista

1512
00:59:54,650 --> 00:59:56,030
O te funciona como una pila

1513
00:59:56,030 --> 00:59:56,949
O te funciona como una cola

1514
00:59:56,949 --> 01:00:05,929
Comparación entre RList y LinkedList

1515
01:00:05,929 --> 01:00:06,949
Que es un poco un repaso

1516
01:00:06,949 --> 01:00:07,929
De lo que hemos dicho hasta ahora

1517
01:00:07,929 --> 01:00:11,489
Este señor por debajo usa un array dinámico

1518
01:00:11,489 --> 01:00:13,030
Este señor por debajo

1519
01:00:13,030 --> 01:00:14,769
Usa una lista doblemente enlazada

1520
01:00:14,769 --> 01:00:16,630
Los nodos estos que se conectan

1521
01:00:16,630 --> 01:00:19,349
La manipulación

1522
01:00:19,349 --> 01:00:20,469
De la array es lenta

1523
01:00:20,469 --> 01:00:22,389
Porque internamente es un array

1524
01:00:22,389 --> 01:00:24,349
Si se elimina algún elemento del array

1525
01:00:24,349 --> 01:00:26,769
Todos los bits se desplazan en la memoria

1526
01:00:26,769 --> 01:00:27,750
Se cambia todo

1527
01:00:27,750 --> 01:00:31,210
La manipulación de linked list

1528
01:00:31,210 --> 01:00:32,329
Es más rápida

1529
01:00:32,329 --> 01:00:34,909
Porque son como listas vinculadas

1530
01:00:34,909 --> 01:00:35,989
Con objetos vinculados

1531
01:00:35,989 --> 01:00:37,230
Por lo tanto si elimino uno

1532
01:00:37,230 --> 01:00:38,530
Pues el resto se queda igual

1533
01:00:38,530 --> 01:00:43,530
Una clase relist puede actuar

1534
01:00:43,530 --> 01:00:44,329
Como una lista

1535
01:00:44,329 --> 01:00:47,349
Solo porque implementa

1536
01:00:47,349 --> 01:00:48,030
Solo list

1537
01:00:48,030 --> 01:00:51,250
Sin embargo la linked list

1538
01:00:51,250 --> 01:00:53,170
Puede actuar como una lista y una cola

1539
01:00:53,170 --> 01:00:54,829
Y también como la otra

1540
01:00:54,829 --> 01:00:57,489
Ya que implementa también las otras

1541
01:00:57,489 --> 01:00:58,590
Si os fijáis

1542
01:00:58,590 --> 01:01:02,440
Linked list

1543
01:01:02,440 --> 01:01:03,480
Implementa list

1544
01:01:03,480 --> 01:01:05,940
Pero implementa también deck

1545
01:01:05,940 --> 01:01:08,059
Que es

1546
01:01:08,059 --> 01:01:09,119
La cola

1547
01:01:09,119 --> 01:01:10,980
Es por eso que esto

1548
01:01:10,980 --> 01:01:14,159
Puede funcionar como lista, puede funcionar como cola

1549
01:01:14,159 --> 01:01:15,000
Puede funcionar como

1550
01:01:15,000 --> 01:01:16,239
Pila

1551
01:01:16,239 --> 01:01:17,800
¿Sí?

1552
01:01:21,280 --> 01:01:22,380
Deriva de esto

1553
01:01:22,380 --> 01:01:24,260
En realidad la pila oficial

1554
01:01:24,260 --> 01:01:25,360
Es esta, stack

1555
01:01:25,360 --> 01:01:27,400
Pero la deck

1556
01:01:27,400 --> 01:01:30,239
Que es una double ended queue

1557
01:01:30,239 --> 01:01:31,699
No hemos llegado todavía allí

1558
01:01:31,699 --> 01:01:33,280
Es una cola

1559
01:01:33,280 --> 01:01:36,019
Que puedes añadir cosas por aquí y por aquí

1560
01:01:36,019 --> 01:01:37,440
¿Vale?

1561
01:01:37,500 --> 01:01:39,539
Entonces esto te permite utilizarla

1562
01:01:39,539 --> 01:01:41,460
Como pila o como cola

1563
01:01:41,460 --> 01:01:42,079
O como lista

1564
01:01:42,079 --> 01:01:46,500
Lo veremos más después

1565
01:01:46,500 --> 01:01:46,739
¿Vale?

1566
01:01:49,679 --> 01:01:50,280
Finalmente

1567
01:01:50,280 --> 01:01:52,239
ArrayList es mejor para almacenar

1568
01:01:52,239 --> 01:01:53,360
Y acceder a datos

1569
01:01:53,360 --> 01:01:55,639
¿Vale? Porque el acceso es muy rápido

1570
01:01:55,639 --> 01:01:58,360
LinkList es mejor para manipular datos

1571
01:01:58,360 --> 01:02:00,000
Para cambiarlos y cosas por el estilo

1572
01:02:00,000 --> 01:02:03,159
Ponerlo y quitarlo

1573
01:02:03,159 --> 01:02:10,000
base de datos ninguno de estos

1574
01:02:10,000 --> 01:02:12,159
¿vale? porque la base de datos

1575
01:02:12,159 --> 01:02:13,519
ya está a otro nivel

1576
01:02:13,519 --> 01:02:15,880
¿vale? para hacer una base de datos

1577
01:02:15,880 --> 01:02:18,139
lo que necesitas es un sistema gestor

1578
01:02:18,139 --> 01:02:18,820
de base de datos

1579
01:02:18,820 --> 01:02:22,199
entonces ya nos alejamos de esto

1580
01:02:22,199 --> 01:02:24,059
esto es más bien, tú tienes

1581
01:02:24,059 --> 01:02:26,139
un programa que al principio tiene que cargar

1582
01:02:26,139 --> 01:02:28,019
los datos y tenerlos ahí

1583
01:02:28,019 --> 01:02:30,559
a disposición y como los almacenas

1584
01:02:30,559 --> 01:02:31,940
de otra forma

1585
01:02:31,940 --> 01:02:33,860
yo accedo a la base de datos

1586
01:02:33,860 --> 01:02:35,860
me pillo todo el

1587
01:02:35,860 --> 01:02:37,599
Magollón de datos que están allí

1588
01:02:37,599 --> 01:02:38,679
Según una select

1589
01:02:38,679 --> 01:02:41,639
Asterisco, fraume, no sé qué

1590
01:02:41,639 --> 01:02:43,820
Y ahora estos datos

1591
01:02:43,820 --> 01:02:45,800
Que he recuperado

1592
01:02:45,800 --> 01:02:48,099
De la base de datos, pues los tengo que almacenar

1593
01:02:48,099 --> 01:02:49,639
En alguna colección

1594
01:02:49,639 --> 01:02:52,099
Para luego poderlo utilizar en mi programa

1595
01:02:52,099 --> 01:02:53,960
¿Vale? Porque si no estaría

1596
01:02:53,960 --> 01:02:55,659
Constantemente haciendo peticiones

1597
01:02:55,659 --> 01:02:57,679
A la base de datos, que a lo mejor están en otro servidor

1598
01:02:57,679 --> 01:02:59,000
Eso es lentísimo

1599
01:02:59,000 --> 01:03:09,949
Y ahora

1600
01:03:09,949 --> 01:03:12,289
Voy a hacer lo que tengo que hacer

1601
01:03:12,289 --> 01:03:13,610
No necesariamente clasificarlo

1602
01:03:13,610 --> 01:03:19,610
Pero necesito los alumnos porque me han pedido el listado de todos los alumnos

1603
01:03:19,610 --> 01:03:23,829
divididos por, qué sé yo, clases.

1604
01:03:24,329 --> 01:03:28,849
Voy a la base de datos, dame todos los alumnos con su clase al lado,

1605
01:03:29,250 --> 01:03:32,210
recibo esta información, la meto en una colección mía

1606
01:03:32,210 --> 01:03:34,250
y ahora empiezo a trabajar con esta colección.

1607
01:03:37,349 --> 01:03:37,949
¡Dudas!