1
00:00:00,110 --> 00:00:06,589
Entonces, voy a grabar esta clase. Si habláis, es porque me autorizáis a grabar vuestra voz.

2
00:00:07,509 --> 00:00:12,570
Entonces, ayer estuvimos viendo un poquito de las colecciones y llegamos hasta la list.

3
00:00:12,689 --> 00:00:19,949
La list es una interfaz importante porque, a diferencia de set, admite elementos duplicados.

4
00:00:20,089 --> 00:00:22,530
Puedo insertar varias veces el mismo elemento si quiero.

5
00:00:23,670 --> 00:00:26,870
Si es que no quiero, pues posiblemente deberías utilizar un set.

6
00:00:26,870 --> 00:00:30,089
o siempre que yo quiera

7
00:00:30,089 --> 00:00:32,490
puedo hacerme mi propia lista

8
00:00:32,490 --> 00:00:34,310
que no admita duplicados

9
00:00:34,310 --> 00:00:36,049
en el que cuando hace la add

10
00:00:36,049 --> 00:00:36,969
sobre escribo la add

11
00:00:36,969 --> 00:00:39,490
para que antes de añadir el objeto

12
00:00:39,490 --> 00:00:41,969
antes de llamar la add de la lista oficial

13
00:00:41,969 --> 00:00:45,429
lo que hace es comprobar que no exista

14
00:00:45,429 --> 00:00:47,329
o sea, el hecho que no lo haga

15
00:00:47,329 --> 00:00:49,310
no quiere decir que no se pueda hacer

16
00:00:49,310 --> 00:00:50,030
¿vale?

17
00:00:50,049 --> 00:00:51,530
vosotros podéis hacer lo que os da la gana

18
00:00:51,530 --> 00:00:52,750
solo que hay que programar

19
00:00:52,750 --> 00:00:56,030
tiene acceso posicional a elementos

20
00:00:56,030 --> 00:01:03,490
es decir, que no es necesario que trabaje al principio o al final, puede trabajar también en el medio dándole una posición, etc.

21
00:01:04,430 --> 00:01:11,930
Puede buscar los elementos concretos y devolver su posición en la lista, puede iterar sobre los elementos como todas las colecciones

22
00:01:11,930 --> 00:01:19,010
y puede trabajar con rango de operaciones, o sea que en vez de hacer añade un elemento, añade otro elemento, añade otro elemento,

23
00:01:19,150 --> 00:01:24,230
puede decir añádeme todos estos elementos, por ejemplo, puede añadir una colección de elementos.

24
00:01:24,230 --> 00:01:47,709
Esto se ve aquí. Arrelist, arrelist, arrelist. Esto es vector. Bueno, vector se verá igual. Está un comando addall que pilla una colección. ¿Lo veis? Y aquí le puedo pasar una colección que puede ser un set y meterlo en mi lista. O puedo pasarle una queue y meterla en mi lista. Porque aquí va cualquier colección posible.

25
00:01:47,709 --> 00:01:53,290
este de aquí hará sustancialmente por debajo un iterador

26
00:01:53,290 --> 00:01:56,109
irá iterando en toda la colección

27
00:01:56,109 --> 00:01:59,049
y por cada elemento que pilla lo añadirá a mi lista

28
00:01:59,049 --> 00:02:04,890
y nosotros

29
00:02:04,890 --> 00:02:08,490
esto es un zoom del dibujito

30
00:02:08,490 --> 00:02:09,409
que hemos visto antes

31
00:02:09,409 --> 00:02:14,050
consideramos cuatro implementaciones de list

32
00:02:14,050 --> 00:02:15,210
en particular dos

33
00:02:15,210 --> 00:02:19,810
que son las que estudiaremos un poquito más en profundidad

34
00:02:19,810 --> 00:02:47,289
Y nosotros ahora veremos ArrayList y LinkedList, del que hemos hecho o intentado hacer nosotros una implementación para entender qué hay por detrás. Vector es muy parecido a un ArrayList, pero tiene la ventaja de ser thread safe, o sea que si yo tengo programación multi-threading con varios hilos, pues acceder a un ArrayList puede dar problemas, mientras acceder a un Vector no.

35
00:02:47,289 --> 00:02:54,129
pero esta cosa incluye implica que se hagan unos controles para decir hoy mira si alguien me está

36
00:02:54,129 --> 00:02:59,610
usando alguien que me quiera usar tendrá que esperar su turno y esto hace que el vector sea

37
00:02:59,610 --> 00:03:04,150
más lento entonces si yo tengo un solo hilo de ejecución como es el caso de aquí de todos los

38
00:03:04,150 --> 00:03:08,349
ejercicios que hacemos pues la realista es mucho más práctico que el vector porque es mucho más

39
00:03:08,349 --> 00:03:13,270
eficiente sin embargo si tengo multiplicación multi trading pues el vector pues puede tener

40
00:03:13,270 --> 00:03:17,449
más sentido. Y stack, que es la implementación de la pila, que hereda

41
00:03:17,449 --> 00:03:21,210
de vector y por lo tanto será thread safe esa también, pero será más lento

42
00:03:21,210 --> 00:03:25,210
que esta otra cosa. Pero si lo que yo quiero utilizar es una cola, es una pila,

43
00:03:25,550 --> 00:03:29,110
pues aquí tengo mi implementación. Centrémonos sobre la primera de las dos.

44
00:03:30,550 --> 00:03:32,189
ArrayList es una implementación típica,

45
00:03:32,669 --> 00:03:37,069
venimos de los arrays, antes conocíamos los arrays, existían los arrays, pues

46
00:03:37,069 --> 00:03:41,430
uso un array para implementar una lista, para escondo detrás de un objeto

47
00:03:41,430 --> 00:03:46,090
con sus metoditos todas las operaciones que había hecho hasta ahora con los arrays.

48
00:03:46,189 --> 00:03:51,810
En un cierto sentido, si os acordáis, cuando yo empecé a hacer mi clase ArrayUtils,

49
00:03:52,289 --> 00:03:57,509
pues eso era un prototipo inicial de una ArrayList, ¿vale?

50
00:03:57,710 --> 00:04:05,629
Os empecé a dar pinceladas de estos métodos aquí, estas operaciones que hacemos una y otra vez y otra vez,

51
00:04:05,930 --> 00:04:10,129
¿por qué no las guardamos en una clase y luego usamos esa clase para hacer cosas?

52
00:04:10,129 --> 00:04:13,949
fue un primer paso, un primer intento de hacer esto

53
00:04:13,949 --> 00:04:17,490
luego no podíamos hacerlo, primero porque era una clase estática

54
00:04:17,490 --> 00:04:20,170
entonces no era un objeto por sí mismo

55
00:04:20,170 --> 00:04:22,990
y segunda cosa porque no teníamos las clases genéricas

56
00:04:22,990 --> 00:04:27,430
entonces cada vez que añadía una nueva clase para poderla utilizar allí

57
00:04:27,430 --> 00:04:30,730
tenía que copiar los métodos, cambiarla, era engorroso

58
00:04:30,730 --> 00:04:35,029
pero ahí está, es el futuro, bueno es el pasado, pero me entendéis

59
00:04:35,029 --> 00:04:38,610
se pasa a un array dinámico que aumenta su tamaño

60
00:04:38,610 --> 00:04:43,470
cuando crece la colección de elementos, ¿vale? Arraigo dinámico es lo que crea, ¿vale?

61
00:04:43,470 --> 00:04:45,069
Porque en realidad los arraigos no son dinámicos.

62
00:04:46,029 --> 00:04:50,970
Puede contener elementos duplicados, puede insertar al final o en una posición concreta, ¿vale?

63
00:04:51,370 --> 00:04:54,449
El orden final es importante, ¿vale?

64
00:04:54,490 --> 00:04:59,569
Si yo no inserto en una posición concreta e inserto A, B y C,

65
00:04:59,970 --> 00:05:05,129
pues luego cuando haré el iterator encontraré A, B y C, porque el orden de inserción tiene sentido.

66
00:05:05,129 --> 00:05:27,649
Está claro que si yo pongo A, B y C y luego digo D, pónmelo como segunda posición, pues cuando haré el iterator me dará A, D, porque lo he metido en segunda posición, B, C. Entonces, la posición tiene sentido y es útil. No es que el último elemento que inserto luego lo pueda encontrar en otros sitios como pasará con set.

67
00:05:27,649 --> 00:05:32,250
Aquí tú defines un orden, defines una posición donde ponerla

68
00:05:32,250 --> 00:05:35,829
Y mantener esa posición es importante para la lista

69
00:05:35,829 --> 00:05:39,889
Permite el acceso aleatorio a ArrayList

70
00:05:39,889 --> 00:05:43,709
Porque al ser implementado con un array yo le puedo decir accede a la posición 3

71
00:05:43,709 --> 00:05:46,709
Y como por debajo de un array puede acceder a la posición 3

72
00:05:46,709 --> 00:05:48,449
Pues me accede directamente a esa cosa

73
00:05:48,449 --> 00:05:50,990
Es muy eficiente, lo vimos ayer en los ejemplos

74
00:05:50,990 --> 00:05:55,550
Es muy eficiente cuando accede a mitad

75
00:05:55,550 --> 00:05:57,470
Mucho más eficiente de la LinkedList

76
00:05:57,470 --> 00:06:00,769
la manipulación es lenta

77
00:06:00,769 --> 00:06:02,790
porque es necesaria gracias a muchos cambios

78
00:06:02,790 --> 00:06:04,050
si se elimina algún elemento

79
00:06:04,050 --> 00:06:06,149
principalmente es la eliminación

80
00:06:06,149 --> 00:06:08,910
yo pensaba también en la inserción pero ayer vimos que con la inserción

81
00:06:08,910 --> 00:06:09,870
era bastante rápido

82
00:06:09,870 --> 00:06:12,730
era la eliminación que si

83
00:06:12,730 --> 00:06:13,930
molestaba mucho al array

84
00:06:13,930 --> 00:06:15,509
¿os acordáis? al array list

85
00:06:15,509 --> 00:06:18,470
no está sincronizado, esto quiere decir que no es

86
00:06:18,470 --> 00:06:20,569
thread safe, esto quiere decir que no

87
00:06:20,569 --> 00:06:24,470
no es bueno

88
00:06:24,470 --> 00:06:27,129
si lo uso entre dos threads paralelos

89
00:06:27,129 --> 00:06:28,810
que nosotros no utilizaremos, por lo tanto

90
00:06:28,810 --> 00:06:32,750
si tenéis más interés

91
00:06:32,750 --> 00:06:34,410
sobre profundizar eso

92
00:06:34,410 --> 00:06:37,029
hay un mogollón de páginas web

93
00:06:37,029 --> 00:06:38,810
donde se explican estas cosas

94
00:06:38,810 --> 00:06:40,649
que vosotros seguramente ya tendréis

95
00:06:40,649 --> 00:06:42,810
vuestra favorita porque desde el principio de año

96
00:06:42,810 --> 00:06:44,870
que estaréis buscando varios

97
00:06:44,870 --> 00:06:46,689
recursos en internet como

98
00:06:46,689 --> 00:06:48,490
Stack Overflow

99
00:06:48,490 --> 00:06:51,129
o cosas por el estilo, incluido hoy en día

100
00:06:51,129 --> 00:06:52,569
la inteligencia artificial

101
00:06:52,569 --> 00:06:55,189
y entonces si esta cosa aquí queréis saber más

102
00:06:55,189 --> 00:06:56,589
habláis con Gemini

103
00:06:56,589 --> 00:07:02,050
Y le decís, Gemini, explícame por favor qué es una ArrayList y cuándo lo tengo que utilizar.

104
00:07:02,389 --> 00:07:05,250
Y él estará muy contento de explicártelo una y otra vez.

105
00:07:05,550 --> 00:07:09,350
Si no, vais a este sitio de aquí y aquí explica un poquito de la ArrayList, ¿vale?

106
00:07:09,410 --> 00:07:12,230
En inglés, porque el inglés es el idioma del futuro.

107
00:07:14,129 --> 00:07:14,850
LinkedList.

108
00:07:16,050 --> 00:07:18,250
¿Qué es LinkedList, vale?

109
00:07:18,430 --> 00:07:25,689
Es la implementación de una lista, pero actualmente, pero no pensada como un Array,

110
00:07:25,689 --> 00:07:29,370
sino pensada como objetos que se puedan enlazar uno a otro

111
00:07:29,370 --> 00:07:34,269
tened en cuenta que esta implementación se basa sobre una lista doblemente enlazada

112
00:07:34,269 --> 00:07:38,949
nosotros hemos hecho un link que me permitía ir al siguiente y nada más

113
00:07:38,949 --> 00:07:44,850
mientras que el linked list tiene la posibilidad de ir en un sentido y en el otro

114
00:07:44,850 --> 00:07:49,029
o sea que cada nodo que yo añado le digo cuál es su siguiente

115
00:07:49,029 --> 00:07:51,629
pero le digo también cuál es su anterior

116
00:07:52,449 --> 00:07:56,250
Entonces, el nodo N está enlazado al nodo N más 1,

117
00:07:56,410 --> 00:08:00,290
y el nodo N más 1 está enlazado también al nodo N.

118
00:08:01,730 --> 00:08:05,410
Entonces, cada nodo tiene la posibilidad de recorrer en un sentido o en el otro.

119
00:08:06,889 --> 00:08:08,829
Y esto me puede servir, si os acordáis,

120
00:08:08,910 --> 00:08:13,490
si hicimos un método en el que necesitaba un nodo y el siguiente para remover.

121
00:08:14,769 --> 00:08:16,529
Entonces, para remover un nodo,

122
00:08:16,529 --> 00:08:21,550
yo lo que tenía que hacer es decirle al anterior que saltara directamente al siguiente.

123
00:08:21,629 --> 00:08:24,149
entonces si tengo una lista doblemente

124
00:08:24,149 --> 00:08:26,389
enlazada, busco el elemento

125
00:08:26,389 --> 00:08:28,509
que tengo que eliminar y de aquí puedo acceder

126
00:08:28,509 --> 00:08:30,389
al anterior y decirle que vaya

127
00:08:30,389 --> 00:08:32,169
al siguiente, más fácil

128
00:08:32,169 --> 00:08:34,350
un poquito más complejo

129
00:08:34,350 --> 00:08:36,629
de gestionar, pero vosotros

130
00:08:36,629 --> 00:08:38,730
que sois alumnos perfectos

131
00:08:38,730 --> 00:08:40,490
y que queréis ser programadores

132
00:08:40,490 --> 00:08:42,970
seguramente, como yo os la dije

133
00:08:42,970 --> 00:08:44,789
la posibilidad de poder hacer nodos

134
00:08:44,789 --> 00:08:46,470
en los dos sitios, en casa

135
00:08:46,470 --> 00:08:48,629
este fin de semana, habéis vuelto

136
00:08:48,629 --> 00:08:50,409
a hacer la linked list por vuestra cuenta

137
00:08:50,409 --> 00:08:52,490
con nodos doblemente enlazados.

138
00:08:53,350 --> 00:09:19,279
Sí, sí, ahí está.

139
00:09:23,419 --> 00:09:33,190
O sea, yo creo que la respuesta a tu pregunta es, creo que no.

140
00:09:33,889 --> 00:09:37,230
Tú estás diciendo, ¿puedo hacer una implementación de list

141
00:09:37,230 --> 00:09:41,470
que tenga la ventaja de los dos sin tener la desventaja de los dos?

142
00:09:42,070 --> 00:09:42,870
Creo que no.

143
00:09:44,610 --> 00:09:49,090
Y la razón de por qué no es porque no existe aquí.

144
00:09:50,129 --> 00:09:53,149
Si existiera, lo más probable es que alguien le habría pensado,

145
00:09:53,149 --> 00:09:55,509
había dicho, en vez de usar ArrayList o LinkedList

146
00:09:55,509 --> 00:09:57,309
usa LinkedArrayList

147
00:09:57,309 --> 00:09:59,289
que es la mejor de todas

148
00:09:59,289 --> 00:10:01,210
entonces yo no estaría aquí a explicar

149
00:10:01,210 --> 00:10:03,210
la diferencia entre ArrayList y LinkedList

150
00:10:03,210 --> 00:10:05,629
más te diría, se usa siempre LinkedArrayList

151
00:10:05,629 --> 00:10:07,029
pero es que no lo veo

152
00:10:07,029 --> 00:10:09,269
¿vale? ¿cómo puede hacerlo?

153
00:10:17,340 --> 00:10:18,779
lo mismo que ArrayList

154
00:10:18,779 --> 00:10:20,419
son iguales

155
00:10:20,419 --> 00:10:21,980
lo mismo que cualquier colección

156
00:10:21,980 --> 00:10:24,220
la única cosa es que tú

157
00:10:24,220 --> 00:10:26,259
si estás utilizando un LinkedList

158
00:10:26,259 --> 00:10:27,080
es porque

159
00:10:27,080 --> 00:10:29,879
quieres elementos duplicados

160
00:10:29,879 --> 00:10:34,299
te interesa el orden, por eso no has elegido un set, ¿vale?

161
00:10:34,460 --> 00:10:38,440
Quieres hacer una lista, por eso estás pensando en las listas,

162
00:10:38,899 --> 00:10:47,960
y utilizas LinkedList cuando quieres manipular mucho los objetos.

163
00:10:49,139 --> 00:10:52,399
Si lo que quieres hacer tú es insertar y quitar muchos objetos,

164
00:10:53,039 --> 00:10:55,039
pues posiblemente la LinkedList es útil.

165
00:10:55,720 --> 00:10:59,399
Quiero hacer una gestión de productos, ¿vale?

166
00:10:59,399 --> 00:11:02,259
en el que me llegan materias primas

167
00:11:02,259 --> 00:11:04,379
y yo gasto estas materias primas

168
00:11:04,379 --> 00:11:06,120
para construir productos, ¿vale?

169
00:11:06,440 --> 00:11:07,480
Entonces, sustancialmente,

170
00:11:07,679 --> 00:11:09,360
cada vez que llega un plan de materia prima,

171
00:11:09,519 --> 00:11:11,440
lo añado a una lista de materias primas,

172
00:11:11,700 --> 00:11:13,220
cada vez que gasto una de esas,

173
00:11:13,340 --> 00:11:14,220
la quito de la cosa.

174
00:11:14,419 --> 00:11:16,460
Es constantemente inserta, quita, inserta, quita,

175
00:11:16,539 --> 00:11:16,980
inserta, quita.

176
00:11:17,299 --> 00:11:18,620
Pues posiblemente una linked list

177
00:11:18,620 --> 00:11:22,720
es más útil que una relista.

178
00:11:22,960 --> 00:11:25,620
Más todavía, si tú estás, sostancialmente,

179
00:11:26,100 --> 00:11:29,059
no estás accediendo a las materias primas

180
00:11:29,059 --> 00:11:31,000
al azar, la estás haciendo

181
00:11:31,000 --> 00:11:31,759
ordenadamente

182
00:11:31,759 --> 00:11:34,919
ahora, al revés

183
00:11:34,919 --> 00:11:37,159
imagínate que en vez

184
00:11:37,159 --> 00:11:39,399
tú tienes, insertas alumnos

185
00:11:39,399 --> 00:11:41,340
que a principio de año insertas todos los alumnos

186
00:11:41,340 --> 00:11:42,899
difícilmente lo removes

187
00:11:42,899 --> 00:11:44,899
porque pocos se quitan

188
00:11:44,899 --> 00:11:47,100
desde la base de datos de los

189
00:11:47,100 --> 00:11:49,000
alumnos, y pero tú quieres acceder

190
00:11:49,000 --> 00:11:50,960
a los alumnos en base a su

191
00:11:50,960 --> 00:11:52,820
número de identificador

192
00:11:52,820 --> 00:11:54,799
que es un número secuencial que

193
00:11:54,799 --> 00:11:57,000
representa la posición del array en el que

194
00:11:57,000 --> 00:11:58,059
ha sido metido

195
00:11:58,059 --> 00:12:00,419
Entonces con eso

196
00:12:00,419 --> 00:12:01,980
Es mucho mejor una revista

197
00:12:01,980 --> 00:12:04,279
Porque el acceso aleatorio a la estructura

198
00:12:04,279 --> 00:12:05,259
Es mucho más rápido

199
00:12:05,259 --> 00:12:08,139
Entonces, ¿cuándo se usa una y la otra?

200
00:12:08,299 --> 00:12:09,899
Pues se pueden usar las dos

201
00:12:09,899 --> 00:12:11,879
Independientemente, lo que pasa es que

202
00:12:11,879 --> 00:12:13,919
Si te equivocas, y lo vimos ayer

203
00:12:13,919 --> 00:12:15,500
Con, ¿qué estamos haciendo?

204
00:12:15,559 --> 00:12:18,220
Estamos simplemente mirándolos

205
00:12:18,220 --> 00:12:19,419
Todos, pillándolos todos

206
00:12:19,419 --> 00:12:22,080
Y hemos visto que uno tardaba dos segundos

207
00:12:22,080 --> 00:12:24,139
Y el otro le hemos dado play

208
00:12:24,139 --> 00:12:26,019
Y hemos esperado un minuto

209
00:12:26,019 --> 00:12:27,840
Y todavía no había acabado

210
00:12:27,840 --> 00:12:31,460
Entonces, si eso lo extendes a tu programa,

211
00:12:32,139 --> 00:12:34,200
tenés la razón de por qué cuando le das a un botón

212
00:12:34,200 --> 00:12:35,919
te quedas ahí esperando cinco minutos

213
00:12:35,919 --> 00:12:37,820
porque está haciendo una operación

214
00:12:37,820 --> 00:12:40,340
que habría sido mejor hacerla con otro botón.

215
00:12:41,879 --> 00:12:48,679
¿Puedo yo decir, oye, mira, me implemento

216
00:12:48,679 --> 00:12:52,820
las dos listas?

217
00:12:53,460 --> 00:12:56,299
O sea, yo tengo lista de alumnos como lista rey

218
00:12:56,299 --> 00:12:58,120
el lista de...

219
00:12:58,120 --> 00:13:00,240
cosa como linked list

220
00:13:00,240 --> 00:13:02,039
y luego uso una o la otra

221
00:13:02,039 --> 00:13:03,480
dependiendo de lo que tengo que hacer

222
00:13:03,480 --> 00:13:06,419
sí, pero al nivel de inserción

223
00:13:06,419 --> 00:13:08,279
y quitar, pues lo tendrás que insertar

224
00:13:08,279 --> 00:13:10,100
en los dos o quitar en los dos, entonces es

225
00:13:10,100 --> 00:13:11,779
más lento, a ese punto

226
00:13:11,779 --> 00:13:13,860
no sé qué estás ganando

227
00:13:13,860 --> 00:13:14,559
¿vale?

228
00:13:16,200 --> 00:13:18,039
puede contener elementos

229
00:13:18,039 --> 00:13:20,000
duplicados, puede insertar al final

230
00:13:20,000 --> 00:13:22,120
o en una posición concreta, como todas las

231
00:13:22,120 --> 00:13:24,059
listas, ¿vale? el orden es

232
00:13:24,059 --> 00:13:26,120
importante, mantiene el orden como todas las

233
00:13:26,120 --> 00:13:28,440
listas. Esta implementación

234
00:13:28,440 --> 00:13:30,039
con respecto a relist mejora la velocidad

235
00:13:30,039 --> 00:13:32,120
de manipulación de los objetos, o sea, insertar

236
00:13:32,120 --> 00:13:33,980
y remover, pero empeora el

237
00:13:33,980 --> 00:13:35,879
acceso aleatorio, porque para acceder a la

238
00:13:35,879 --> 00:13:37,879
posición 7, tengo que entrar desde

239
00:13:37,879 --> 00:13:39,799
el principio e ir a la siguiente,

240
00:13:39,940 --> 00:13:42,000
a las siguientes, a las siguientes, a las siguientes, hasta llegar

241
00:13:42,000 --> 00:13:44,120
a la 7, mientras que con la relist accedía directamente

242
00:13:44,120 --> 00:13:44,879
a la posición 7.

243
00:13:45,799 --> 00:13:47,860
No está sincronizada como la relist,

244
00:13:47,960 --> 00:13:50,000
no se usa con threads, se puede

245
00:13:50,000 --> 00:13:52,000
usar como lista, pila o cola.

246
00:13:52,899 --> 00:13:53,960
¿Vale? O sea que si yo esta

247
00:13:53,960 --> 00:13:54,720
aquí la uso

248
00:13:54,720 --> 00:13:57,360
con reglas

249
00:13:57,360 --> 00:13:59,240
mías, pues puedo hacer que la

250
00:13:59,240 --> 00:14:01,379
linked list pueda funcionar como lista

251
00:14:01,379 --> 00:14:03,120
pila o cola

252
00:14:03,120 --> 00:14:04,460
de hecho

253
00:14:04,460 --> 00:14:08,120
si me voy a linked list

254
00:14:08,120 --> 00:14:16,919
si no me equivoco, veis que

255
00:14:16,919 --> 00:14:19,059
linked list tiene pick

256
00:14:19,059 --> 00:14:21,019
tiene pop

257
00:14:21,019 --> 00:14:22,559
y tiene push

258
00:14:22,559 --> 00:14:24,860
que si os acordáis eran

259
00:14:24,860 --> 00:14:26,980
los mecanismos que yo

260
00:14:26,980 --> 00:14:28,179
usaba para hacer una

261
00:14:28,179 --> 00:14:30,399
una pila

262
00:14:30,399 --> 00:14:32,440
o sea que si yo quiero usar una pila

263
00:14:32,440 --> 00:14:35,539
en vez de stack, que es más lento

264
00:14:35,539 --> 00:14:38,480
porque es sincronizado, pues puedo

265
00:14:38,480 --> 00:14:41,139
simplemente crearme una linked list

266
00:14:41,139 --> 00:14:44,419
y olvidarme que existe la get, que existe

267
00:14:44,419 --> 00:14:47,279
la add, en vez de hacer la add

268
00:14:47,279 --> 00:14:50,019
para añadir cosas, uso solo pop

269
00:14:50,019 --> 00:14:53,279
pick y push, de esta forma

270
00:14:53,279 --> 00:14:56,399
si uso solo estos tres métodos, estoy utilizando esta lista

271
00:14:56,399 --> 00:14:58,919
como si fuera una pila

272
00:14:58,919 --> 00:15:03,679
y así si uso otros

273
00:15:03,679 --> 00:15:04,940
cosas como

274
00:15:04,940 --> 00:15:09,539
si uso la add

275
00:15:09,539 --> 00:15:10,860
y la get first

276
00:15:10,860 --> 00:15:12,600
yo creo que está creando

277
00:15:12,600 --> 00:15:14,360
una cola

278
00:15:14,360 --> 00:15:16,679
add me lo añadirá al final

279
00:15:16,679 --> 00:15:19,179
get first siempre me pilla el primer elemento

280
00:15:19,179 --> 00:15:22,019
entonces usando

281
00:15:22,019 --> 00:15:24,340
los correctos

282
00:15:24,340 --> 00:15:25,620
los objetos correctos

283
00:15:25,620 --> 00:15:27,820
puedo utilizar

284
00:15:27,820 --> 00:15:29,740
una linked list como si fuera

285
00:15:29,740 --> 00:15:41,200
cosa fijaos que en vez del rey list no debería tener si no me acuerdo mal push pop veis esto

286
00:15:41,200 --> 00:15:51,330
no lo puede usar como una como una stack con una una pila si queréis saber algo más pues vais aquí

287
00:15:51,330 --> 00:15:58,950
le es lo que está aquí comparación entre a rey liste linked list vale a rey listos internamente

288
00:15:58,950 --> 00:16:03,309
una red dinámico linked list usa una lista doblemente enlazadas parecida a la que hemos

289
00:16:03,309 --> 00:16:09,809
hecho nosotros pero con dos punteros o sea que el nodo tendrá tres campos tendrá el campo valor

290
00:16:09,809 --> 00:16:19,129
siguiente y anterior siguiente interior son nodos también la manipulación con la relista es lenta

291
00:16:19,129 --> 00:16:24,129
porque internamente susana rey vales es el elemento era rey todos los bits se tendrá que desplazar en

292
00:16:24,129 --> 00:16:31,169
memoria un caos bla bla bla bla la manipulación con linked list es más rápida porque que realista

293
00:16:31,169 --> 00:16:37,409
Porque utiliza una lista doblemente vinculada y cuando elimino algo es simplemente cambiar un puntero y fue a funcionar.

294
00:16:38,029 --> 00:16:43,509
Una clase relist puede actuar como lista porque solo implementa list, ¿vale?

295
00:16:43,649 --> 00:16:48,769
Mientras que una linked list puede actuar como una lista, pero también una cola y también una pila, ¿vale?

296
00:16:48,769 --> 00:17:04,769
Si os fijáis en esta cosa aquí, se ve también que LinkedList, además de implementar list, implementa también deck, que implementa queue, ¿vale?

297
00:17:04,769 --> 00:17:17,250
Entonces, estoy implementando también esta interfaz de aquí, entonces LinkedList me puede funcionar de lista, de cola, de cola doblamente enlazada y de pila.

298
00:17:17,250 --> 00:17:32,170
más versátil y finalmente arrelist es mejor para almacenar y acceder a datos

299
00:17:32,170 --> 00:17:43,160
linked list es mejor para manipular datos dudas vale otro tema interfaz q vale la

300
00:17:43,160 --> 00:17:47,559
interfaz q es una interfaz que ordena solamente de manera fifo vale es la idea

301
00:17:47,559 --> 00:17:51,440
de que en vez de poner una lista y luego hago como le da gana pues la lista tiene

302
00:17:51,440 --> 00:17:53,640
que mantener esta cosa de que el primero

303
00:17:53,640 --> 00:17:55,119
que inserto será el primero

304
00:17:55,119 --> 00:17:56,160
que pillo

305
00:17:56,160 --> 00:17:59,200
o sea siempre extraigo

306
00:17:59,200 --> 00:17:59,940
el

307
00:17:59,940 --> 00:18:02,960
elemento más viejo

308
00:18:02,960 --> 00:18:05,279
de mi lista, y por qué quiero esto

309
00:18:05,279 --> 00:18:07,019
no lo sé, a lo mejor no lo quiero

310
00:18:07,019 --> 00:18:08,220
si no lo quiero uso una list

311
00:18:08,220 --> 00:18:11,140
pero si quisiera utilizar

312
00:18:11,140 --> 00:18:13,079
este mecanismo pues

313
00:18:13,079 --> 00:18:15,519
lo que busco

314
00:18:15,519 --> 00:18:16,960
es una queue o una deck

315
00:18:16,960 --> 00:18:19,160
tened en cuenta que la deck

316
00:18:19,160 --> 00:18:20,980
es doblemente enlazada, puedo

317
00:18:20,980 --> 00:18:25,220
enceder de un lado para el otro pero si yo sólo uso uno de los dos extremos o

318
00:18:25,220 --> 00:18:30,539
estoy haciendo una cola normal corriente. En fin, por el primer elemento se elimina

319
00:18:30,539 --> 00:18:35,079
primero y el último elemento se elimina por último. Vale, los elementos se añaden al

320
00:18:35,079 --> 00:18:39,180
final de la cola, puede contener elementos duplicados, vale, porque sigue

321
00:18:39,180 --> 00:18:44,299
siendo más o menos como una lista. Las principales operaciones son encolar y

322
00:18:44,299 --> 00:18:49,059
obtener siguiente, vale, encolar lo pondrá al final, si quiere obtener siguiente

323
00:18:49,059 --> 00:18:54,940
pillará el primero de la de la cola aparte de esta interfaz también existe

324
00:18:54,940 --> 00:19:00,880
la interfaz de deck lo que permite insertar al final para hacerlo

325
00:19:00,880 --> 00:19:06,240
además de insertar al final puede insertar al principio vale este comando

326
00:19:06,240 --> 00:19:09,960
se llama empujar vale push

327
00:19:09,960 --> 00:19:17,220
por el estilo estará desde que un ejemplo que implementa que es prioritario y desde

328
00:19:17,220 --> 00:19:26,700
deck a rey deck es una implementación de una cola con dos extremos ahora si queréis empezamos de lo

329
00:19:26,700 --> 00:19:46,559
pone esto, doble, vamos a verla, desde aquí me voy a deck, este es deck y desde aquí me voy a

330
00:19:46,559 --> 00:19:55,180
raid deck, esta es una implementación de deck, si os fijáis debería, veis que a añadir, que es el

331
00:19:55,180 --> 00:20:00,220
añadir normal, pero tiene también un método especial de añade primero y añade último,

332
00:20:00,220 --> 00:20:04,140
esto me permite utilizar la cola en un sentido o en otro

333
00:20:04,140 --> 00:20:05,839
si yo uso solo add first

334
00:20:05,839 --> 00:20:08,960
y get last

335
00:20:08,960 --> 00:20:13,839
pues lo que estoy haciendo es una cola correcta

336
00:20:13,839 --> 00:20:17,180
si yo uso solo add last y get first

337
00:20:17,180 --> 00:20:18,759
estoy utilizando una cola al revés

338
00:20:18,759 --> 00:20:21,960
si yo uso las dos estoy utilizando una cola

339
00:20:21,960 --> 00:20:23,480
que puede hacer desde los dos lados

340
00:20:23,480 --> 00:20:26,700
la idea no es para qué usa y por qué

341
00:20:26,700 --> 00:20:29,900
no lo sé, es porque a mí de alguna forma

342
00:20:29,900 --> 00:20:39,559
me interesa eso. Fijaos que también push y pop, o sea que posiblemente se puede utilizar como una

343
00:20:39,559 --> 00:20:49,059
pila. Y luego está PriorityQueue. PriorityQueue es una clase que implementa queue, proporciona

344
00:20:49,059 --> 00:20:57,559
la facilidad de usar la cola, no ordena solamente de manera fifo, literalmente, sino que lo ordena

345
00:20:57,559 --> 00:21:01,019
de una forma de prioridad, ¿vale? O sea que

346
00:21:01,019 --> 00:21:05,519
first in, first out, pero en sentido de prioridad. Quien tiene más prioridad

347
00:21:05,519 --> 00:21:08,599
es el primero que será extraído, ¿vale? Y esto

348
00:21:08,599 --> 00:21:13,519
si vosotros, por ejemplo, a nivel de programación de sistema operativo, que hay varias

349
00:21:13,519 --> 00:21:17,539
tareas que hacer y algunas tareas pueden ser más importantes que otras, pues

350
00:21:17,539 --> 00:21:21,599
tú puedes crearte una Priority Queue para que insertes allí las tareas que tiene que hacer

351
00:21:21,599 --> 00:21:25,640
y cuando el procesador está libre y dice voy a sacar la tarea que voy

352
00:21:25,640 --> 00:21:31,640
hacer va a la cola de prioridad y pilla la cola la tarea con más prioridad da igual que se haya

353
00:21:31,640 --> 00:21:39,200
insertado antes o después pues la parte ahora el cual la cuestión es que como defino la prioridad

354
00:21:39,200 --> 00:21:45,960
o sea los objetos tendrán que tener una prioridad vale para establecer la prioridad se usa con

355
00:21:45,960 --> 00:22:03,380
Comparable, ¿vale? Entonces los objetos que yo uso allí dentro, ¿vale? Tendrán que implementar Comparable y yo simplemente cuando voy a insertarlo en la cola lo pondré en la posición correcta en base a lo que me dice Comparable.

356
00:22:03,380 --> 00:22:05,299
Que no necesariamente es un orden

357
00:22:05,299 --> 00:22:07,019
Es un orden de prioridad

358
00:22:07,019 --> 00:22:08,059
Para este caso

359
00:22:08,059 --> 00:22:11,900
Entonces, esto ya lo hemos hablado

360
00:22:11,900 --> 00:22:12,700
Ya lo hemos visto

361
00:22:12,700 --> 00:22:14,819
La interfaz comparable es una interfaz

362
00:22:14,819 --> 00:22:16,359
Que me permite comparar dos objetos

363
00:22:16,359 --> 00:22:18,559
Fuerza que tú uses compare to

364
00:22:18,559 --> 00:22:19,700
De un objeto

365
00:22:19,700 --> 00:22:22,059
Y en base a esta cosa aquí

366
00:22:22,059 --> 00:22:25,500
Tú lo que puedes hacer es comparar

367
00:22:25,500 --> 00:22:28,019
Devolver un positivo

368
00:22:28,019 --> 00:22:30,180
Si el objeto actual es mayor

369
00:22:30,180 --> 00:22:32,220
Que el objeto especificado

370
00:22:32,220 --> 00:22:38,559
negativo si es menor, cero si son de igual importancia en un cierto sentido. Él utilizará

371
00:22:38,559 --> 00:22:45,099
esta información para ordenar en términos de prioridad. Entonces cuando yo defino el

372
00:22:45,099 --> 00:22:53,859
compareTo para usar un objeto dentro de un priority queue, tendré que definir su comparación

373
00:22:53,859 --> 00:23:00,279
en términos de prioridad, cuál es más importante que otro. Tened en cuenta que esto de comparable

374
00:23:00,279 --> 00:23:10,900
me permite comparar dos elementos, sí, pero como yo decido el criterio con que se comparan, pues lo decido yo, ¿sí?

375
00:23:11,759 --> 00:23:17,220
Y aquí abro también otra paréntesis, que a lo mejor lo veremos en algún ejemplo más adelante.

376
00:23:18,759 --> 00:23:26,160
Imaginaos que yo tenga un string, ¿vale? Un string se puede comparar, implementa string comparable,

377
00:23:26,160 --> 00:23:32,299
¿Cómo puedo saber si implementa string comparable?

378
00:23:34,019 --> 00:23:36,359
Ya, exacto

379
00:23:36,359 --> 00:23:38,420
Me voy a pijaba

380
00:23:38,420 --> 00:23:48,640
Me voy a pijaba

381
00:23:48,640 --> 00:23:52,180
Voy a mirar y veo que efectivamente

382
00:23:52,180 --> 00:23:54,220
Implementa comparable

383
00:23:54,220 --> 00:23:56,339
Entonces por aquí está compare to

384
00:23:56,339 --> 00:23:57,460
Vale, ok

385
00:23:57,460 --> 00:24:02,819
¿Cómo es la definición de compare to?

386
00:24:02,819 --> 00:24:05,000
Pues posiblemente a nivel lexicográfico

387
00:24:05,000 --> 00:24:13,259
¿Vale? Gato es menor que perro, porque gato empieza por G y perro empieza por P.

388
00:24:14,039 --> 00:24:15,259
¿Sí? Vale.

389
00:24:16,160 --> 00:24:23,599
¿Y qué pasa si ahora yo quiero hacer una priority queue, le quiero poner string,

390
00:24:23,599 --> 00:24:26,180
pero la prioridad

391
00:24:26,180 --> 00:24:28,980
de lo que representa

392
00:24:28,980 --> 00:24:29,859
este string

393
00:24:29,859 --> 00:24:32,539
no tiene que ser ordenada por

394
00:24:32,539 --> 00:24:35,859
¿cómo se dice?

395
00:24:38,980 --> 00:24:39,579
alfabéticamente

396
00:24:39,579 --> 00:24:41,460
pero con un orden distinto

397
00:24:41,460 --> 00:24:48,160
entonces debería crear una nueva clase

398
00:24:48,160 --> 00:24:53,420
string no la puede usar

399
00:24:53,420 --> 00:24:54,640
string tiene su comparación

400
00:24:54,640 --> 00:24:56,279
¿cómo sobreescribo string?

401
00:24:56,640 --> 00:24:59,119
¿me pongo dentro del jdk, busco string

402
00:24:59,119 --> 00:25:00,220
y cambio el código? no

403
00:25:00,220 --> 00:25:02,039
no se toca el jdk

404
00:25:02,039 --> 00:25:05,339
Podría heredar string con mi string

405
00:25:05,339 --> 00:25:06,200
Y cambiarlo

406
00:25:06,200 --> 00:25:08,779
Pero, ¿y si tengo que usar las dos cosas?

407
00:25:09,539 --> 00:25:10,559
O sea, que en parte

408
00:25:10,559 --> 00:25:13,019
Cuando lo escribo al usuario

409
00:25:13,019 --> 00:25:15,339
Quiero que se lo escriba ordenado literalmente

410
00:25:15,339 --> 00:25:17,140
Entonces necesito el Compertur

411
00:25:17,140 --> 00:25:18,180
Léxico gráfico

412
00:25:18,180 --> 00:25:20,759
Pero cuando lo usa la Priority Queue

413
00:25:20,759 --> 00:25:22,400
Quiero que lo ordene según

414
00:25:22,400 --> 00:25:24,579
Otra cosa, por ejemplo, el numerito

415
00:25:24,579 --> 00:25:25,960
Que le pondría al final

416
00:25:25,960 --> 00:25:28,980
Tiene que pillar ese número y ordenarlo según ese número

417
00:25:28,980 --> 00:25:30,839
¿Cómo lo hago?

418
00:25:30,839 --> 00:25:36,500
Pues existe una cosa que se llama comparator.

419
00:25:40,009 --> 00:25:53,569
El comparator es una forma de, sustancialmente, crear un objeto y darle una forma distinta de comparar las cosas.

420
00:25:53,769 --> 00:25:58,470
En vez de crear compara y tú, usa este compare que pilla dos objetos.

421
00:25:58,470 --> 00:26:19,990
Entonces, yo lo que puedo hacer es definir una nueva versión del compare y luego utilizarla y mantener el orden natural, o sea, el orden natural de las strings será lo que conocemos todos, el lexico gráfico, pero en casos concretos le voy a añadir un comparator nuevo,

422
00:26:19,990 --> 00:26:22,569
que lo que permite es, oye, mira, pero ahora

423
00:26:22,569 --> 00:26:24,589
no lo uses con

424
00:26:24,589 --> 00:26:27,069
la comparación

425
00:26:27,069 --> 00:26:28,589
normal, más úsala con

426
00:26:28,589 --> 00:26:29,829
esta cosa aquí, ¿vale?

427
00:26:30,750 --> 00:26:32,569
Un poquito más complejo que esto

428
00:26:32,569 --> 00:26:34,789
uno de estos días hacemos una prueba

429
00:26:34,789 --> 00:26:35,970
y vemos como

430
00:26:35,970 --> 00:26:38,589
como sale

431
00:26:38,589 --> 00:26:40,769
¿vale? Por ahora centrámonos en cosas

432
00:26:40,769 --> 00:26:42,630
más útiles. Yo quería

433
00:26:42,630 --> 00:26:44,410
ahora ir a ver

434
00:26:44,410 --> 00:26:45,829
de Q

435
00:26:45,829 --> 00:26:49,000
RQ

436
00:26:49,000 --> 00:26:53,599
de queue

437
00:26:53,599 --> 00:26:55,980
puedo ir a ver

438
00:26:55,980 --> 00:26:57,819
priority queue

439
00:26:57,819 --> 00:27:00,920
y priority queue

440
00:27:00,920 --> 00:27:03,140
lo veis aquí

441
00:27:03,140 --> 00:27:07,839
es que no puedo hacer zoom

442
00:27:07,839 --> 00:27:09,299
lo veis

443
00:27:09,299 --> 00:27:11,930
aquí

444
00:27:11,930 --> 00:27:16,779
o sea una priority queue normal

445
00:27:16,779 --> 00:27:18,279
te hará una colección

446
00:27:18,279 --> 00:27:20,359
con luego uso string

447
00:27:20,359 --> 00:27:21,480
pues usaré

448
00:27:21,480 --> 00:27:24,339
compararé entre ellos los string

449
00:27:24,339 --> 00:27:26,539
para saber como organizar la prioridad

450
00:27:26,539 --> 00:27:30,680
Pero yo puedo crear una Priority Queue y pasarle un Comparator.

451
00:27:31,799 --> 00:27:35,819
Entonces le estoy diciendo, mira, Priority Queue, te voy a pasar a String.

452
00:27:36,920 --> 00:27:43,240
Pero cuidado, cuando las vas a comparar para saber la prioridad, no uses el CompareTo.

453
00:27:43,240 --> 00:27:59,170
Pero usas el método que yo te he definido dentro de la interfaz comparator, que es este método de aquí, que es un orden distinto al orden natural que tienen estos objetos.

454
00:28:07,819 --> 00:28:18,480
Aquí, porque aquí tú le pondrías a string1 y string2 y devolvería 0, 1 o menos 1 en base a cuál de las dos es mayor, si esta o esta otra.

455
00:28:18,480 --> 00:28:24,779
aquí

456
00:28:24,779 --> 00:28:27,880
tú te creas un comparator

457
00:28:27,880 --> 00:28:29,980
que pillará string o1

458
00:28:29,980 --> 00:28:31,819
string o2 y dirás

459
00:28:31,819 --> 00:28:34,180
que esta string, cuando pillas

460
00:28:34,180 --> 00:28:35,940
el numerito al final que hemos dicho antes

461
00:28:35,940 --> 00:28:38,000
y los comparas y ves cuál es mayor o menor

462
00:28:38,000 --> 00:28:39,980
vale, cuando luego crearás

463
00:28:39,980 --> 00:28:41,440
tú priority queue

464
00:28:41,440 --> 00:28:43,920
le pasas este comparator que tú

465
00:28:43,920 --> 00:28:45,859
has creado y entonces él dirá

466
00:28:45,859 --> 00:28:47,640
ah, vale, muy bien, no voy a utilizar

467
00:28:47,640 --> 00:28:49,819
la lexicográfica, me voy a utilizar este

468
00:28:49,819 --> 00:28:53,880
metodito que me has dado, para que

469
00:28:53,880 --> 00:28:55,980
sepáis que existe, luego un

470
00:28:55,980 --> 00:29:04,940
día de estos hacemos un ejemplo un poquito más serio pero vale el proyecto posiblemente nosotros

471
00:29:04,940 --> 00:29:10,220
la parte de que la usaremos pocos son nada vale es para introducir el compañero bol que pero ya

472
00:29:10,220 --> 00:29:20,170
nosotros hemos visto anteriormente por lo tanto está aquí vale pasamos a set vale y nos quedan

473
00:29:20,170 --> 00:29:28,190
pocas transparencias vale estamos en la 23 al 29 acabamos entonces hasta ahora nosotros hemos

474
00:29:28,190 --> 00:29:35,470
trabajado con listas sostancialmente lineales una tras de otro vale cuando entro en el set cambian un

475
00:29:35,470 --> 00:29:45,829
poquito las cartas en tabla en la mesa hasta ahora nosotros nos importaba el orden vale o sea que

476
00:29:45,829 --> 00:29:50,809
puede que el orden sea con prioridad puede que el orden sea invertido puede que el orden sea de

477
00:29:50,809 --> 00:29:56,029
inserción puede ser que el orden pero el orden con que yo meto los elementos se tiene que mantener

478
00:29:56,029 --> 00:29:58,710
si yo he puesto un objeto en segunda

479
00:29:58,710 --> 00:30:00,789
posición, cuando voy a iterar

480
00:30:00,789 --> 00:30:02,650
me lo quiero encontrar en segunda

481
00:30:02,650 --> 00:30:03,329
posición

482
00:30:03,329 --> 00:30:06,849
sin embargo en el set

483
00:30:06,849 --> 00:30:08,710
no, en el set lo que hago

484
00:30:08,710 --> 00:30:10,390
es, mira, voy a

485
00:30:10,390 --> 00:30:12,269
ceder dos cosas

486
00:30:12,269 --> 00:30:14,470
a cambio de que

487
00:30:14,470 --> 00:30:15,329
otras

488
00:30:15,329 --> 00:30:18,549
métodos

489
00:30:18,549 --> 00:30:20,470
otras actividades que puedo hacer

490
00:30:20,470 --> 00:30:21,990
sobre el set, sean

491
00:30:21,990 --> 00:30:24,430
más fáciles, más eficientes

492
00:30:24,430 --> 00:30:31,930
las dos cosas que cedan son que no quiero que los elementos se pueden duplicar y que no quiero

493
00:30:31,930 --> 00:30:37,269
mantener el orden si tú quieres para ser más eficiente mezclar el orden y poner los objetos

494
00:30:37,269 --> 00:30:41,769
como te da la gana ti organizarlos como te da la gana ti para que sean más eficientes hazlo

495
00:30:43,109 --> 00:30:45,930
enorme a mí me interesaba el orden pues no uses un set

496
00:30:48,430 --> 00:30:55,180
la interfaz se definió colección que no puede contener elementos duplicados en automático si

497
00:30:55,180 --> 00:31:01,180
yo inserto un elemento que ya que no está pues él tendrá que hacer algo o sobreescribir el que

498
00:31:01,180 --> 00:31:07,480
ya estaba o no insertarlo vale esto dependerá de la implementación que yo tengo sí y tendré

499
00:31:07,480 --> 00:31:14,940
que leerme la presentación que uso que hace cuando añado un elemento que ya existe esta

500
00:31:14,940 --> 00:31:20,420
interfaz contiene únicamente los métodos heredados de collection añadiendo la restricción de que los

501
00:31:20,420 --> 00:31:36,859
elementos duplicados están prohibidos es decir si yo me busco set estos son los

502
00:31:36,859 --> 00:31:42,880
mismos métodos que tenía en collection vale pero si me leo la descripción vale

503
00:31:42,880 --> 00:31:51,259
me debería decir por ejemplo añade el elemento especificado en este set si no

504
00:31:51,259 --> 00:31:56,980
está ya presente vale ha cambiado la definición si yo me

505
00:31:56,980 --> 00:32:06,589
voy a mirar en collection lo que dice la definición del add es

506
00:32:06,589 --> 00:32:14,839
añade este elemento a la colección y si está duplicado pues lo añade, el set

507
00:32:14,839 --> 00:32:28,960
me añade explícitamente que no se puede duplicar, está bien el equals, ahora esto

508
00:32:28,960 --> 00:32:33,900
quiere decir que el set en automático me lo hace, no, esta es una interfaz que era

509
00:32:33,900 --> 00:32:48,609
interfaz era un contrato no era oye mira yo te voy a decir que tienes que hacer y aquí te lo

510
00:32:48,609 --> 00:32:59,049
estoy explicando vale ahora que tú dices yo implementó un set y luego esto no lo hago y

511
00:32:59,049 --> 00:33:06,849
me hago un set donde se puede poner duplicados pues allá tú lo has hecho y él no se va a dar

512
00:33:06,849 --> 00:33:08,690
cuenta porque la semántica no la va a entender

513
00:33:08,690 --> 00:33:10,910
pero tú te has hecho un error

514
00:33:10,910 --> 00:33:12,710
porque no estás cumpliendo

515
00:33:12,710 --> 00:33:14,029
con lo que tiene que hacer add

516
00:33:14,029 --> 00:33:16,869
tú has creado tu set, mi set

517
00:33:16,869 --> 00:33:18,690
cuando la gente

518
00:33:18,690 --> 00:33:20,569
usará mi set, que hereda

519
00:33:20,569 --> 00:33:22,690
de set, se esperará

520
00:33:22,690 --> 00:33:23,529
esto

521
00:33:23,529 --> 00:33:26,930
si tú lo has implementado de otra forma

522
00:33:26,930 --> 00:33:28,650
que en vez de añadir el elemento

523
00:33:28,650 --> 00:33:30,690
lo que hace, te escribe, me gustan

524
00:33:30,690 --> 00:33:33,150
los gatitos, pues no está funcionando

525
00:33:33,150 --> 00:33:34,849
tal y como te han pedido

526
00:33:34,849 --> 00:33:36,750
que funcione, entonces el error es tuyo

527
00:33:36,750 --> 00:33:43,089
Lo puedes hacer, sí, como puedes hacer todos los programas malos que quieres, ¿sí?

528
00:33:43,230 --> 00:33:56,920
Pero la idea es que cuando tú vas a implementar set, te tienes que ceñir a lo que te pide en cada uno de sus métodos, ¿sí?

529
00:33:57,799 --> 00:33:58,200
¿Se entiende?

530
00:33:58,200 --> 00:34:08,099
Entonces, yo me espero también que cualquiera de estas, no un implementing de clases, cualquiera de estas clases, funcione así.

531
00:34:09,460 --> 00:34:10,840
¿Me explico lo que quiero decir?

532
00:34:11,519 --> 00:34:16,960
Si yo uso un triset, me espero que el triset no admita dos elementos iguales.

533
00:34:18,219 --> 00:34:24,039
Luego me puedo ir a mirar en el triset qué hace literalmente, porque podría pasar dos cosas.

534
00:34:24,039 --> 00:34:26,280
si yo he metido el alumno 1

535
00:34:26,280 --> 00:34:28,539
y ahora vuelvo a poner el alumno 1

536
00:34:28,539 --> 00:34:30,099
hay dos opciones

537
00:34:30,099 --> 00:34:32,199
o lo que se ha insertado

538
00:34:32,199 --> 00:34:33,119
no se inserta

539
00:34:33,119 --> 00:34:36,340
o tiro el que estaba antes

540
00:34:36,340 --> 00:34:37,519
y añado el nuevo

541
00:34:37,519 --> 00:34:40,559
eso dependerá de cómo lo has implementado

542
00:34:40,559 --> 00:34:42,420
y en la implementación

543
00:34:42,420 --> 00:34:43,900
te lo debería decir

544
00:34:43,900 --> 00:34:49,829
add

545
00:34:49,829 --> 00:34:50,429
add the present

546
00:34:50,429 --> 00:34:54,170
vamos a leer si nos explica un poquito más

547
00:34:54,170 --> 00:34:56,989
more form

548
00:34:56,989 --> 00:35:16,030
Si el set lo contiene ya, esta cosa de aquí no cambiará el set y devolverá false, porque te permite poner.

549
00:35:16,030 --> 00:35:24,219
Entonces ya sé que el triset, si yo añado algo que ya existe, no cambia lo que tenía ya y me dice false.

550
00:35:24,219 --> 00:35:26,739
Si me dice true es porque la he insertado

551
00:35:26,739 --> 00:35:28,559
Lo leo y sé cómo funciona

552
00:35:28,559 --> 00:35:29,739
¿Se entiende?

553
00:35:31,079 --> 00:35:31,380
Vale

554
00:35:31,380 --> 00:35:34,199
Más, es importante destacar que

555
00:35:34,199 --> 00:35:36,880
Para comprobar si los elementos son duplicados o no

556
00:35:36,880 --> 00:35:38,920
Es necesario que dichos elementos

557
00:35:38,920 --> 00:35:40,719
Tengan implementadas de forma correcta

558
00:35:40,719 --> 00:35:42,380
Equals y hashCode

559
00:35:42,380 --> 00:35:44,820
¿Vale? En particular equals

560
00:35:44,820 --> 00:35:46,340
¿Sí?

561
00:35:46,639 --> 00:35:48,380
¿Por qué? Porque yo tengo que saber

562
00:35:48,380 --> 00:35:50,400
Si inserto el elemento 1

563
00:35:50,400 --> 00:35:52,219
Vale, ahora inserto el elemento 1 otra vez

564
00:35:52,219 --> 00:35:54,400
tengo que comparar estos dos elementos

565
00:35:54,400 --> 00:35:56,460
para saber que son iguales

566
00:35:56,460 --> 00:35:57,659
si yo no hago nada

567
00:35:57,659 --> 00:36:00,420
la igualdad será la que hemos dicho

568
00:36:00,420 --> 00:36:02,360
ya muchas veces, está basada sobre

569
00:36:02,360 --> 00:36:04,400
el concepto que sea en la misma instancia

570
00:36:04,400 --> 00:36:06,340
que sea en la misma dirección

571
00:36:06,340 --> 00:36:08,340
de memoria, solo en ese caso

572
00:36:08,340 --> 00:36:09,059
son iguales

573
00:36:09,059 --> 00:36:12,119
pero a veces eso no es suficiente

574
00:36:12,119 --> 00:36:14,199
a veces yo tengo que añadir

575
00:36:14,199 --> 00:36:16,179
alumnos y no tengo

576
00:36:16,179 --> 00:36:18,019
el objeto alumnos anterior

577
00:36:18,019 --> 00:36:20,420
estoy añadiendo un alumno que ya tiene el DNI

578
00:36:20,420 --> 00:36:22,119
metido y ya está otro alumno

579
00:36:22,119 --> 00:36:24,039
con el mismo DNI, pues me debería decir

580
00:36:24,039 --> 00:36:25,960
oye, mira, no lo puedo añadir

581
00:36:25,960 --> 00:36:27,260
¿vale? y entonces

582
00:36:27,260 --> 00:36:29,760
el equals tendré que

583
00:36:29,760 --> 00:36:31,699
modificarlo para que

584
00:36:31,699 --> 00:36:33,900
haya una

585
00:36:33,900 --> 00:36:36,099
comparación entre los DNI

586
00:36:36,099 --> 00:36:37,739
de los alumnos y me dé

587
00:36:37,739 --> 00:36:40,260
true si el DNI es el mismo, false si el DNI

588
00:36:40,260 --> 00:36:41,539
son distintos, ¿vale?

589
00:36:41,900 --> 00:36:43,480
si toco equals

590
00:36:43,480 --> 00:36:45,699
tengo que tocar también hashCode

591
00:36:45,699 --> 00:36:48,000
porque hashCode van juntos

592
00:36:48,000 --> 00:36:48,860
¿vale?

593
00:36:49,860 --> 00:36:51,500
¿qué es una función hash?

594
00:36:51,500 --> 00:37:06,769
Ahora hablamos de eso. Para comprobar si dos sets son iguales, son el mismo set, lo que se hace es, se va elemento por elemento y se comprueba, o sea, se mira si está en el otro set.

595
00:37:07,590 --> 00:37:17,730
Si están todos los elementos allí y son grandes iguales, los sets son iguales. O sea, que la equals entre dos sets está pensada así.

596
00:37:17,730 --> 00:37:30,639
¿Y cuál es el H-code? Ambos métodos son importantes cuando necesitamos buscar nuestros objetos en colecciones, como el método equals, o en mapas, como el método hash.

597
00:37:31,139 --> 00:37:42,980
Los mapas los veremos el lunes y los hash-codes principalmente se usan en mapas, aun si ahora veremos el hash-set, que lo usa también el set.

598
00:37:42,980 --> 00:37:45,900
Como sabemos que es un mapa, lo veremos el lunes.

599
00:37:45,900 --> 00:37:49,500
Cuando se realiza una implementación de ambos métodos

600
00:37:49,500 --> 00:37:52,659
Si dos objetos son iguales según el método equals

601
00:37:52,659 --> 00:37:55,679
Se debe cumplir que el resultado del método hashCode

602
00:37:55,679 --> 00:37:58,420
También tiene que ser el mismo

603
00:37:58,420 --> 00:37:59,800
Pero no al revés

604
00:37:59,800 --> 00:38:02,639
O sea, dos objetos iguales

605
00:38:02,639 --> 00:38:04,820
Tienen que dar el mismo hashCode

606
00:38:04,820 --> 00:38:08,420
Pero dos objetos que dan el mismo hashCode

607
00:38:08,420 --> 00:38:10,659
No necesariamente son iguales

608
00:38:11,719 --> 00:38:14,420
¿Qué era una función hash?

609
00:38:15,900 --> 00:38:39,179
Una función hash, o hash, o como sea, es una función que pilla objetos, ¿vale?, o en general números infinitos, ¿vale?, y una vez hecha esta función, devuelve un número más pequeño y finito de valores.

610
00:38:39,179 --> 00:38:46,659
O sea, y aquí tengo infinitos valores, aquí tengo n valores, ¿sí?

611
00:38:47,340 --> 00:38:50,820
Sustancialmente hace un mapeado, por eso luego se usan los maps,

612
00:38:51,360 --> 00:38:56,840
de números infinitos, valores infinitos, posibilidades infinitas,

613
00:38:57,179 --> 00:39:00,679
en un cierto número n de categorías, ¿sí?

614
00:39:00,980 --> 00:39:07,519
Estas categorías son como bolsas, ¿vale?

615
00:39:07,519 --> 00:39:29,920
Es como si yo tuviera un cajón, que son todos los números, y pero dentro de este cajón divido el cajón en secciones para que luego ordene estas cosas aquí dentro y cuando luego voy a buscar, no tengo que buscar en todo el cajón, más solo en la sección correcta.

616
00:39:29,920 --> 00:39:31,400
¿Se entiende lo que quiero decir?

617
00:39:38,619 --> 00:39:43,960
Asumiendo que tú tienes infinitos lápices y los categorizas por color, sí.

618
00:39:43,960 --> 00:39:51,400
Y luego cuando buscas un color rojo, pues no tienes que ir a buscar entre la maraña de lápices,

619
00:39:51,539 --> 00:39:55,400
más vas solo a la caja de los rojos, a la sección de los rojos.

620
00:39:56,519 --> 00:39:56,719
¿Sí?

621
00:39:58,599 --> 00:40:02,559
Un ejemplo fácil de entender.

622
00:40:02,559 --> 00:40:09,219
Me creo un conjunto de categorías que son las letras

623
00:40:09,219 --> 00:40:20,099
Entonces tengo A, tengo B, tengo C, tengo D, etcétera, etcétera, todas las letras

624
00:40:20,099 --> 00:40:30,599
Al final tengo Z y luego tengo una categoría asterisco que es todo lo que nos caiga aquí

625
00:40:30,599 --> 00:40:37,659
vale tendré un cierto número de letras no sé cuántas letras hay 26 pues 27

626
00:40:37,659 --> 00:40:43,260
categorías 26 letras más una categoría comodín

627
00:40:43,260 --> 00:40:49,599
ahora yo aquí tengo todas las string del mundo cuántas string hay

628
00:40:49,599 --> 00:41:02,329
infinitas vale entonces si yo pillo la cadena gato la paso por esta máquina de

629
00:41:02,329 --> 00:41:14,730
aquí que es mi funcionar y él me dice gato va en la categoría g y entonces

630
00:41:14,730 --> 00:41:24,320
desde aquí empiezo por ejemplo una lista donde pongo gato ahora viene el usuario

631
00:41:24,320 --> 00:41:33,079
me dice ponme otra palabra ponme la palabra árbol o no sin acento el perro

632
00:41:33,079 --> 00:41:48,969
perro se pasa por aquí él va a la categoría p y pone aquí perro se entiende

633
00:41:48,969 --> 00:41:51,690
¿Cómo funciona? Más o menos.

634
00:41:53,510 --> 00:42:06,269
Ahora, yo si pongo una palabra que es gusano, esto cuando va en la H, pasará por la G.

635
00:42:06,269 --> 00:42:10,429
Y por lo tanto, se pondrá aquí.

636
00:42:15,159 --> 00:42:18,079
Ahora, gato y gusano son iguales.

637
00:42:19,739 --> 00:42:23,079
¿El hashcode de gato y el hashcode de gusano son iguales?

638
00:42:24,039 --> 00:42:24,280
Sí.

639
00:42:31,550 --> 00:42:39,269
Porque mi funcionage es, pilla la primera letra, en base a la primera letra, ponla en la categoría.

640
00:42:40,769 --> 00:42:43,210
Ese es mi funcionage, el funcionage que yo he definido.

641
00:42:43,329 --> 00:42:45,710
Es una buena funcionage, no nos metemos ahí.

642
00:42:48,409 --> 00:42:56,030
Pero la funcionalidad, la funcionage que yo hago es, pilla la string, mira la primera letra,

643
00:42:56,030 --> 00:42:59,030
en base a la primera letra, lo pones aquí.

644
00:42:59,030 --> 00:43:00,530
Aquí, ¿vale?

645
00:43:00,710 --> 00:43:05,429
Ahora, pongamos que yo ponga otras mil palabras, ¿sí?

646
00:43:05,429 --> 00:43:12,090
Y todas estas mil palabras no tienen la G como primera, ¿vale?

647
00:43:12,150 --> 00:43:16,489
Entonces, aquí pondré varias, aquí pondré varias, aquí pondré varias,

648
00:43:16,650 --> 00:43:20,309
aquí relleno esto, alguna no tiene nada, aquí mogollón.

649
00:43:21,030 --> 00:43:23,250
Ahora tengo mil palabras metidas en mis ojos.

650
00:43:23,250 --> 00:43:29,489
Si ahora busco gato, ¿cuántas comprobaciones tengo que hacer?

651
00:43:29,969 --> 00:43:33,179
Como máximo dos.

652
00:43:34,639 --> 00:43:39,840
O sea, porque si yo estoy buscando gato, hago primero un hash code, me voy a esta G,

653
00:43:40,559 --> 00:43:44,179
y ahora tengo que comprobar si existe gato aquí dentro.

654
00:43:45,079 --> 00:43:50,480
Todas las otras palabras que están en otras categorías no me interesan, seguramente no son.

655
00:43:50,480 --> 00:44:02,519
Entonces el hashcode y el equals se usan juntos para mejorar mucho la búsqueda de este tipo

656
00:44:02,519 --> 00:44:10,559
Yo tengo una colección de un millón de palabras

657
00:44:10,559 --> 00:44:15,940
Pero pon que solo 10.000 son gato, son con g

658
00:44:15,940 --> 00:44:19,039
Por lo tanto cuando voy a buscar una palabra que empieza por g

659
00:44:19,039 --> 00:44:21,199
Para saber si la tengo o no en mi diccionario

660
00:44:21,199 --> 00:44:24,300
Pues no la tengo que buscar sobre un millón de palabras

661
00:44:24,300 --> 00:44:26,619
La busco sobre las 10.000 que empiezan por G.

662
00:44:35,880 --> 00:44:39,920
Tú puedes hacer todos los niveles que quieras, pero un objeto tiene un hash code.

663
00:44:41,619 --> 00:44:47,900
Ahora, tú puedes decir, no, mira, en vez de tener 26 categorías, tengo 1.000 categorías,

664
00:44:48,360 --> 00:44:50,480
basadas sobre las primeras dos letras.

665
00:44:51,099 --> 00:44:55,099
Entonces, gato y gusano no caen en la misma cosa.

666
00:44:58,559 --> 00:45:02,440
Entonces, la clave de la función hash.

667
00:45:02,440 --> 00:45:09,340
Funcionage es buena cuando distribuye bien en sus categorías los elementos.

668
00:45:10,019 --> 00:45:16,639
Si todos los elementos tienden a caer en la misma categoría, la Funcionage es fea.

669
00:45:18,860 --> 00:45:25,920
Pero siempre tiene que valer el hecho que si yo busco gato y tengo la cadena gato,

670
00:45:27,579 --> 00:45:32,260
esta cosa de aquí, asumiendo que sea un objeto distinto de este de aquí,

671
00:45:32,260 --> 00:45:34,360
porque son dos strings creadas distintamente

672
00:45:34,360 --> 00:45:35,659
dos objetos distintos

673
00:45:35,659 --> 00:45:37,840
pues me tienen que dar el mismo hashCode

674
00:45:37,840 --> 00:45:39,500
en este caso me tienen que dar G

675
00:45:39,500 --> 00:45:41,320
me tienen que dar esta categoría aquí

676
00:45:41,320 --> 00:45:43,639
si esto no vale

677
00:45:43,639 --> 00:45:45,579
pues cuando yo lo buscaré

678
00:45:45,579 --> 00:45:48,139
no lo estaré buscando en el sitio correcto

679
00:45:48,139 --> 00:45:50,300
entonces el equals no me servirá

680
00:45:50,300 --> 00:45:51,320
por esta razón

681
00:45:51,320 --> 00:45:52,460
dos

682
00:45:52,460 --> 00:45:55,079
si yo tengo dos elementos

683
00:45:55,079 --> 00:45:56,980
dos objetos que den

684
00:45:56,980 --> 00:45:59,320
equals igual

685
00:45:59,320 --> 00:46:01,920
también su hashCode tiene que ser igual

686
00:46:01,920 --> 00:46:14,139
Si su hashCode es igual, no necesariamente son el mismo objeto. Estarán en la misma categoría, pero no necesariamente son iguales. ¿Queda claro?

687
00:46:14,139 --> 00:46:19,360
Ahora, esto con string es para que lo entendamos nosotros

688
00:46:19,360 --> 00:46:22,099
En la realidad, yo aquí no tengo string

689
00:46:22,099 --> 00:46:26,119
Yo aquí tengo objetos

690
00:46:26,119 --> 00:46:29,800
Por ejemplo, tengo alumnos

691
00:46:29,800 --> 00:46:39,190
Y tengo una función hash que transforma los alumnos en números

692
00:46:39,190 --> 00:46:44,230
La función hash, el hash code, si miráis, devuelve un int

693
00:46:44,230 --> 00:46:57,389
Entonces, si aquí tengo el alumno Estefano con edad 43, con dirección no sé cuánto, no os la digo, con cosas por el estilo, ¿vale?

694
00:46:57,389 --> 00:47:05,849
Y ahora tengo que hacer esto, lo paso por aquí, lo paso en esta máquina mágica y esto vale 3.

695
00:47:07,750 --> 00:47:13,050
Perfecto, este alumno de aquí, que es el alumno A, lo pondré en la categoría 3.

696
00:47:13,050 --> 00:47:18,050
Ahora, ¿cómo he sacado este 3 a partir de mi dirección en mi nombre?

697
00:47:19,050 --> 00:47:19,829
Que no lo sé

698
00:47:19,829 --> 00:47:21,969
No lo sé

699
00:47:21,969 --> 00:47:26,329
Lo que tengo que evitar es que

700
00:47:26,329 --> 00:47:29,510
Ahora tengo un elemento B y también caiga en 3

701
00:47:29,510 --> 00:47:31,889
Ahora tengo un elemento C y también caiga en 3

702
00:47:31,889 --> 00:47:34,610
Porque cuanto más caen en la misma categoría, pues mal

703
00:47:34,610 --> 00:47:38,050
Ahora, ¿yo sé hacer una cosa de ese estilo?

704
00:47:44,760 --> 00:47:47,920
¿Sé hacer una buena funcionage?

705
00:47:47,920 --> 00:48:06,219
En un sistema en el que tiene que estar optimizado, tiene que ir rápido y tiene que funcionar bien

706
00:48:06,219 --> 00:48:13,019
Pues habrá un equipo de matemáticos que se pondrán allí y encontrarán una función hash

707
00:48:13,019 --> 00:48:17,780
Que funcione bien para ese entorno, para organizar esos objetos

708
00:48:17,780 --> 00:48:20,880
nosotros

709
00:48:20,880 --> 00:48:22,900
por ejemplo, yo tengo

710
00:48:22,900 --> 00:48:35,099
más que sé yo, ejercicio básico

711
00:48:35,099 --> 00:48:36,800
sistema de objeto, herencia

712
00:48:36,800 --> 00:48:38,579
en herencia algún objeto lo tengo

713
00:48:38,579 --> 00:48:43,070
cuadrado

714
00:48:43,070 --> 00:48:45,929
por ejemplo, tenía los empleados

715
00:48:45,929 --> 00:48:50,489
empleados era una clase, ¿vale?

716
00:48:50,869 --> 00:48:53,110
esta cosa de aquí, ahora, a partir de aquí

717
00:48:53,110 --> 00:48:55,170
¿cómo saco

718
00:48:55,170 --> 00:48:55,989
una función hash?

719
00:48:57,090 --> 00:48:58,429
por ejemplo, podría pillar

720
00:48:58,429 --> 00:49:00,829
la string y usar

721
00:49:00,829 --> 00:49:01,969
la hash de string

722
00:49:01,969 --> 00:49:04,969
entonces

723
00:49:04,969 --> 00:49:08,960
podría decir yo

724
00:49:08,960 --> 00:49:09,599
que oye mira

725
00:49:09,599 --> 00:49:11,199
no lo sé

726
00:49:11,199 --> 00:49:12,000
porque yo no sé

727
00:49:12,000 --> 00:49:12,860
cómo funciona

728
00:49:12,860 --> 00:49:14,599
la hash de string

729
00:49:14,599 --> 00:49:15,559
pero me fío

730
00:49:15,559 --> 00:49:16,519
que quien ha hecho

731
00:49:16,519 --> 00:49:16,900
string

732
00:49:16,900 --> 00:49:17,960
haya hecho un buen trabajo

733
00:49:17,960 --> 00:49:18,739
entonces digo

734
00:49:18,739 --> 00:49:19,300
voy a utilizar

735
00:49:19,300 --> 00:49:20,039
lo mismo de string

736
00:49:20,039 --> 00:49:21,320
vale

737
00:49:21,320 --> 00:49:22,739
cuidado

738
00:49:22,739 --> 00:49:23,539
vale

739
00:49:23,539 --> 00:49:24,460
porque esto tiene

740
00:49:24,460 --> 00:49:25,019
implicaciones

741
00:49:25,019 --> 00:49:25,739
debería pensar

742
00:49:25,739 --> 00:49:26,099
si más

743
00:49:26,099 --> 00:49:26,539
pero más

744
00:49:26,539 --> 00:49:27,219
si tengo dos

745
00:49:27,219 --> 00:49:28,019
con el mismo nombre

746
00:49:28,019 --> 00:49:29,199
pero salario distinto

747
00:49:29,199 --> 00:49:29,400
¿eh?

748
00:49:29,400 --> 00:49:30,079
¿qué pasaría?

749
00:49:32,440 --> 00:49:32,940
pues entonces

750
00:49:32,940 --> 00:49:34,679
para obviarnos

751
00:49:34,679 --> 00:49:35,300
a estos problemas

752
00:49:35,300 --> 00:49:35,920
que son problemas

753
00:49:35,920 --> 00:49:36,260
más

754
00:49:36,260 --> 00:49:38,820
abstractos y cosas por el estilo

755
00:49:38,820 --> 00:49:41,099
mi amigo personal

756
00:49:41,099 --> 00:49:41,539
el

757
00:49:41,539 --> 00:49:45,099
Eclipse nos da

758
00:49:45,099 --> 00:49:47,159
generate as code and equals

759
00:49:47,159 --> 00:49:49,179
tú pinchas aquí

760
00:49:49,179 --> 00:49:51,340
seleccionas aquí

761
00:49:51,340 --> 00:49:53,440
que quieres que conte

762
00:49:53,440 --> 00:49:54,980
para el

763
00:49:54,980 --> 00:49:56,659
equals, vale

764
00:49:56,659 --> 00:49:59,059
a mí por ejemplo, yo quiero

765
00:49:59,059 --> 00:50:00,340
fecha era fecha de nacimiento

766
00:50:00,340 --> 00:50:03,280
el salario no me interesa

767
00:50:03,280 --> 00:50:04,760
para comparar dos

768
00:50:04,760 --> 00:50:15,719
Para saber si dos empleados son el mismo empleado, me interesa saber el nombre del empleado y la fecha en la que se ha llegado a trabajar.

769
00:50:15,719 --> 00:50:24,539
Si estas dos son iguales, pues nunca contrataré dos personas que se llamen iguales el mismo día.

770
00:50:26,750 --> 00:50:29,190
No lo hago por decisión personal.

771
00:50:29,610 --> 00:50:32,849
Entonces, elijo que fecha y nombre sean los que se han...

772
00:50:32,849 --> 00:50:38,389
Mirad que aquí dice, selecciona los campos para incluir en el hash code y en el equals.

773
00:50:38,969 --> 00:50:42,449
Le doy a Generate y él me ha hecho un equals.

774
00:50:43,510 --> 00:50:45,250
Vale, perfecto, con la cosa así.

775
00:50:45,690 --> 00:50:51,250
Fijaos que mira que si son exactamente la misma instancia es true.

776
00:50:51,670 --> 00:50:54,670
Si object es null, pues entonces no son iguales.

777
00:50:54,809 --> 00:50:56,489
Comprueba que sean de la misma clase.

778
00:50:56,489 --> 00:51:02,690
Si son de la misma clase, pues entonces comprueba campo por campo la fecha y el nombre.

779
00:51:02,849 --> 00:51:06,210
vale, perfecto, esto funciona

780
00:51:06,210 --> 00:51:09,150
y también me hace esta cosa aquí

781
00:51:09,150 --> 00:51:15,699
¿y qué es esto? no lo sé

782
00:51:15,699 --> 00:51:17,280
no lo quiero saber

783
00:51:17,280 --> 00:51:20,179
es una función hash que me da él

784
00:51:20,179 --> 00:51:23,599
basada sobre este valor y este valor

785
00:51:23,599 --> 00:51:27,619
él lo pilla, lo machaca, hace cosas raras

786
00:51:27,619 --> 00:51:30,780
un poco de mojo, jumbo

787
00:51:30,780 --> 00:51:33,019
no sé qué, y me devuelve un entero

788
00:51:33,019 --> 00:51:39,480
Y es él que me garantiza que si dos son iguales, pues este número será igual.

789
00:51:46,760 --> 00:51:51,760
Ahora, lo que yo sí tengo que saber es cuándo tengo que hacer un override de esto.

790
00:51:52,400 --> 00:51:54,300
Y sobre todo, no hacer esto.

791
00:51:55,099 --> 00:51:57,280
Esto es un suspenso en mi examen.

792
00:51:58,739 --> 00:52:07,099
Si estás tocando equals, pero no has tocado el hash code, es un suspenso en mi examen.

793
00:52:07,980 --> 00:52:13,760
Porque ahora estarías usando el equals de esta clase con el hashcode de object.

794
00:52:15,019 --> 00:52:24,820
Y entonces es posible que, como el equals de aquí me puede dar, o sea, el equals y el hashcode de object van juntos sobre la base de que sean la misma instancia,

795
00:52:25,239 --> 00:52:31,199
ahora me lo estás usando con otro criterio de igualdad, y es posible que a veces cosas que sean iguales no den el mismo hashcode.

796
00:52:31,639 --> 00:52:32,400
Y eso no puede ser.

797
00:52:32,400 --> 00:52:47,070
si ahora si tú no lo usas en un asset por ejemplo pues esto no se usa entonces

798
00:52:47,070 --> 00:52:52,489
no te daría problemas ahora otra cosa es que luego llega uno tú has hecho alumno

799
00:52:52,489 --> 00:52:57,150
lo has puesto así has hecho empleado las puestas y un día llega él y usa tu

800
00:52:57,150 --> 00:53:02,670
empleado en un asset y le colapsa el programa porque tú lo has hecho mal

801
00:53:02,670 --> 00:53:04,789
Porque tú deberías haber hecho esto

802
00:53:04,789 --> 00:53:06,530
¿Se entiende?

803
00:53:08,269 --> 00:53:09,750
Ok, luego vosotros

804
00:53:09,750 --> 00:53:11,570
Buscáis más información

805
00:53:11,570 --> 00:53:12,949
Vais más en profundidad

806
00:53:12,949 --> 00:53:15,250
Entendéis bien qué es esto y cómo se hace

807
00:53:15,250 --> 00:53:17,750
Y queráis hacer vuestra versión de la Shcode

808
00:53:17,750 --> 00:53:19,010
Encantado de la vida

809
00:53:19,010 --> 00:53:20,690
¿Sí?

810
00:53:23,980 --> 00:53:24,539
Vale

811
00:53:24,539 --> 00:53:28,320
Técnicamente, ¿os acordáis?

812
00:53:29,579 --> 00:53:30,719
Hago en

813
00:53:30,719 --> 00:53:33,719
En cuadrado

814
00:53:33,719 --> 00:53:35,519
si acordáis

815
00:53:35,519 --> 00:53:36,179
hay un main

816
00:53:36,179 --> 00:53:38,679
para main

817
00:53:38,679 --> 00:53:44,059
si hago cuadrado

818
00:53:44,059 --> 00:53:48,579
cuadrado es igual a

819
00:53:48,579 --> 00:53:49,559
new cuadrado

820
00:53:49,559 --> 00:53:51,199
si no me equivoco

821
00:53:51,199 --> 00:53:53,519
de lado 3

822
00:53:53,519 --> 00:53:55,980
vale, si hago

823
00:53:55,980 --> 00:53:59,460
siso cuadrado

824
00:53:59,460 --> 00:54:02,179
y ejecuto

825
00:54:02,179 --> 00:54:02,659
esto

826
00:54:02,659 --> 00:54:06,219
me sale esta cosa aquí, esto que es

827
00:54:06,219 --> 00:54:12,250
este de aquí

828
00:54:12,250 --> 00:54:13,389
es el tipo

829
00:54:13,389 --> 00:54:15,670
es la clase, la clase cuadrado

830
00:54:15,670 --> 00:54:16,570
del paquete

831
00:54:16,570 --> 00:54:19,710
R figuras, este debería

832
00:54:19,710 --> 00:54:21,230
ser el hashcode

833
00:54:21,230 --> 00:54:22,989
creo, si

834
00:54:22,989 --> 00:54:25,489
pero no estoy seguro

835
00:54:25,489 --> 00:54:27,449
y por lo tanto hacemos eso

836
00:54:27,449 --> 00:54:31,409
cuadrado

837
00:54:31,409 --> 00:54:32,309
punto

838
00:54:32,309 --> 00:54:34,010
hashcode

839
00:54:34,010 --> 00:54:41,940
deberíamos ver si esta cosa de aquí

840
00:54:41,940 --> 00:54:43,519
en hexadecimal es esta cosa aquí

841
00:54:43,519 --> 00:54:44,800
que no tengo ni idea

842
00:54:44,800 --> 00:54:46,880
probablemente no

843
00:54:46,880 --> 00:54:51,460
probablemente no, vale

844
00:54:51,460 --> 00:54:54,780
probablemente esto es más complejo

845
00:54:54,780 --> 00:54:57,000
que solo esta cosa aquí, pero yo tengo entendido

846
00:54:57,000 --> 00:54:58,539
que aquí esto tiene alguna

847
00:54:58,539 --> 00:55:00,380
referencia, vamos a ver si

848
00:55:00,380 --> 00:55:02,820
tengo suerte, me parece

849
00:55:02,820 --> 00:55:04,980
demasiado pequeño para ser este número aquí

850
00:55:04,980 --> 00:55:08,780
científica, no

851
00:55:08,780 --> 00:55:10,159
programador

852
00:55:10,159 --> 00:55:12,460
esto

853
00:55:12,460 --> 00:55:14,860
mira

854
00:55:14,860 --> 00:55:17,380
6F53

855
00:55:17,380 --> 00:55:19,019
9K, exactamente

856
00:55:19,019 --> 00:55:22,719
es

857
00:55:22,719 --> 00:55:24,159
el hash code

858
00:55:24,159 --> 00:55:25,500
en esta decimal

859
00:55:25,500 --> 00:55:38,460
pues ya está, más o menos

860
00:55:38,460 --> 00:55:40,980
algo de hash se ha quedado

861
00:55:40,980 --> 00:55:43,099
si, se os quede

862
00:55:43,099 --> 00:55:43,780
aquí

863
00:55:43,780 --> 00:55:46,519
si queréis os metéis aquí

864
00:55:46,519 --> 00:55:48,960
este de aquí tengo la sospecha que no funcione

865
00:55:48,960 --> 00:55:51,019
¿vale? pero este link de aquí

866
00:55:51,019 --> 00:55:51,699
sí que funciona

867
00:55:51,699 --> 00:55:54,940
y os explico un poquito más, y si no siempre

868
00:55:54,940 --> 00:55:56,659
podéis indagar cuanto queráis más

869
00:55:56,659 --> 00:55:57,880
sobre esta cosa aquí

870
00:55:57,880 --> 00:56:00,780
la interfaz 7, nosotros

871
00:56:00,780 --> 00:56:02,940
veremos 3 o 2

872
00:56:02,940 --> 00:56:04,960
probablemente, clases interesantes

873
00:56:04,960 --> 00:56:06,519
que son hset y triset

874
00:56:06,519 --> 00:56:08,780
¿vale? hset es

875
00:56:08,780 --> 00:56:10,659
un conjunto que usa h

876
00:56:10,659 --> 00:56:12,760
para organizar las cosas, para una

877
00:56:12,760 --> 00:56:14,659
tabla h parecida a lo que hemos visto ahora

878
00:56:14,659 --> 00:56:16,460
mientras que triset

879
00:56:16,460 --> 00:56:18,800
organiza las cosas como un árbol

880
00:56:18,800 --> 00:56:20,460
un árbol

881
00:56:20,460 --> 00:56:22,679
¿vale? lo hemos visto antes

882
00:56:22,679 --> 00:56:24,460
y si os fijáis

883
00:56:24,460 --> 00:56:26,639
está en sorted set, o sea que

884
00:56:26,639 --> 00:56:28,760
los elementos que añade, no los

885
00:56:28,760 --> 00:56:30,679
añade al azar, mas los añade

886
00:56:30,679 --> 00:56:31,960
organizados

887
00:56:31,960 --> 00:56:34,599
Hset

888
00:56:34,599 --> 00:56:38,159
Esta implementación almacena los elementos en una tabla H

889
00:56:38,159 --> 00:56:39,380
¿Una tabla H qué es?

890
00:56:39,500 --> 00:56:39,960
Esto

891
00:56:39,960 --> 00:56:42,079
Esta es una tabla H

892
00:56:42,079 --> 00:56:43,119
¿Vale?

893
00:56:43,239 --> 00:56:44,539
Con mis categorías

894
00:56:44,539 --> 00:56:45,840
Taca, taca, taca, taca

895
00:56:45,840 --> 00:56:47,719
Y cuando yo te doy un elemento

896
00:56:47,719 --> 00:56:49,579
Pues ese elemento va en una zona

897
00:56:49,579 --> 00:56:51,300
Este elemento aquí va en otra cosa

898
00:56:51,300 --> 00:56:52,300
Esta es una tabla H

899
00:56:52,300 --> 00:56:52,980
¿Sí?

900
00:56:54,699 --> 00:56:57,400
No permite tener elementos duplicados

901
00:56:57,400 --> 00:57:00,579
Es la implementación con mejor rendimiento

902
00:57:00,579 --> 00:57:01,320
De todas

903
00:57:01,320 --> 00:57:01,900
¿Vale?

904
00:57:01,960 --> 00:57:05,260
pero no garantiza ningún orden a la hora de realizar iteraciones

905
00:57:05,260 --> 00:57:07,260
o sea que yo he metido

906
00:57:07,260 --> 00:57:11,199
el A y luego el B y luego el C

907
00:57:11,199 --> 00:57:13,960
cuando itero a lo mejor antes me encuentro el B

908
00:57:13,960 --> 00:57:15,059
luego el A y luego el C

909
00:57:15,059 --> 00:57:18,760
no lo sé, los encontré todos

910
00:57:18,760 --> 00:57:22,000
pero si voy a buscar el set

911
00:57:22,000 --> 00:57:23,980
no se ha mantenido ningún tipo de orden

912
00:57:23,980 --> 00:57:26,860
esto es importante

913
00:57:26,860 --> 00:57:31,219
o sea que si yo no quiero el orden y no me interesan los duplicados

914
00:57:31,219 --> 00:57:40,340
uso Hset, es lo más rápido posible. Tiene tiempo constantes en las operaciones básicas, inserción,

915
00:57:40,340 --> 00:57:50,480
búsqueda y remoción, tiempo constante, lo que es muy bueno. Yo puedo aumentar el número n de

916
00:57:53,099 --> 00:57:58,780
elementos y siempre tardaré una constante para llegar allí. La constante será grande,

917
00:57:58,780 --> 00:58:08,280
10 segundos pero no aumenta mucho con el aumentar de los números n si fuera en vez el tiempo que

918
00:58:08,280 --> 00:58:16,300
tarda en función de n o lineal con n o cuadrática en el cuadrado pues cuanto más elemento pongo más

919
00:58:16,300 --> 00:58:24,679
será difícil es lo que pasaba con linked list ayer que yo lo hacía por mil mil elementos y

920
00:58:24,679 --> 00:58:26,860
funcionaba rápido, 10.000 elementos

921
00:58:26,860 --> 00:58:28,739
rápido, en cierto momento llegaba a 100.000

922
00:58:28,739 --> 00:58:30,900
elementos y ya tardaba

923
00:58:30,900 --> 00:58:32,780
un mogollón. Iba tardando siempre

924
00:58:32,780 --> 00:58:33,800
más, siempre más, siempre más.

925
00:58:34,360 --> 00:58:35,739
Si tengo suerte, es lineal.

926
00:58:36,599 --> 00:58:38,320
Cuanto más aumento los elementos,

927
00:58:38,719 --> 00:58:41,019
más aumenta el tiempo en una función lineal.

928
00:58:41,340 --> 00:58:42,980
Si tengo mala suerte, es exponencial.

929
00:58:45,019 --> 00:59:00,619
Sí. Pero

930
00:59:00,619 --> 00:59:03,139
lo que no mantiene es

931
00:59:03,139 --> 00:59:05,400
el orden con que tú insertas

932
00:59:05,400 --> 00:59:07,159
las cosas. Tú insertas

933
00:59:07,159 --> 00:59:09,179
A, B, C y D. Luego pillas el tu

934
00:59:09,179 --> 00:59:11,179
array y no te esperes de encontrar

935
00:59:11,179 --> 00:59:13,280
A, B, C, D dentro de este array.

936
00:59:15,079 --> 00:59:16,460
Lo que te puedes encontrar es

937
00:59:16,460 --> 00:59:19,079
C, D, B, A. O te puedes encontrar

938
00:59:19,079 --> 00:59:21,059
A, B, C, D porque has tenido suerte. Pero no

939
00:59:21,059 --> 00:59:23,159
está garantizado. Una lista, tú

940
00:59:23,159 --> 00:59:25,179
pones A, B, C, D, lo haces

941
00:59:25,179 --> 00:59:27,280
tu array, en el array te encuentras A, B,

942
00:59:27,360 --> 00:59:29,059
C, D. Porque el orden es importante.

943
00:59:30,440 --> 00:59:30,519
¿Sí?

944
00:59:35,050 --> 00:59:36,389
O sea, puede hacer

945
00:59:36,389 --> 00:59:43,889
un set ordenado, si, pongo dentro del objeto que guardo un numerito

946
00:59:43,889 --> 00:59:48,929
secuencial, un serial number y luego que le mezcle lo que da la gana y cuando lo

947
00:59:48,929 --> 00:59:55,530
saco pues se que orden tiene, lo voy a hacer, pero si a mí me interesa el orden no voy a

948
00:59:55,530 --> 00:59:58,050
utilizar set

949
00:59:59,849 --> 01:00:03,989
es la presentación más empleada debido a su rendimiento bla bla bla bla bla bla

950
01:00:03,989 --> 01:00:15,199
Triset es una implementación que almacena los elementos ordenando en función de su valor.

951
01:00:15,519 --> 01:00:23,599
Es bastante más lento que Hset en el proceso de inserción, pero el tiempo de acceso y recuperación es bastante rápido.

952
01:00:23,599 --> 01:00:34,039
Los elementos almacenados deben implementar la interfaz comparable y te da un rendimiento de logaritmo de n,

953
01:00:34,039 --> 01:00:43,099
O sea, con el aumentar de los elementos que pongo, cuanto tardo en pillar las cosas es logarítmica.

954
01:00:43,340 --> 01:00:45,719
El logaritmo, si os acordáis, es una función así.

955
01:00:46,960 --> 01:00:52,159
O sea, que cuanto más aumenta, poco aumenta el tiempo que tardo.

956
01:00:52,320 --> 01:00:55,360
Entonces es muy bueno para grandes colecciones de datos.

957
01:00:56,960 --> 01:00:59,340
Repaso de la matemática que seguramente sabéis.

958
01:00:59,340 --> 01:01:12,199
Si yo tengo la complejidad, o sea, el tiempo que tarda en hacer las operaciones

959
01:01:12,199 --> 01:01:15,739
Y el número de elementos

960
01:01:15,739 --> 01:01:19,079
Yo puedo tener distintas funciones

961
01:01:19,079 --> 01:01:22,199
Puedo tener una complejidad lineal

962
01:01:22,199 --> 01:01:27,159
Esto es que cuanto más aumente n, más será complicado hacerlo

963
01:01:27,159 --> 01:01:28,800
¿Vale? Está bien

964
01:01:28,800 --> 01:01:34,639
Puedo tener una cuadrática

965
01:01:34,639 --> 01:01:39,940
que cuanto más aumentan los n

966
01:01:39,940 --> 01:01:42,460
mucho más aumentan

967
01:01:42,460 --> 01:01:43,699
los cosas

968
01:01:43,699 --> 01:01:46,159
si mi algoritmo funciona así

969
01:01:46,159 --> 01:01:48,219
no me vale para números

970
01:01:48,219 --> 01:01:50,119
grandes, cuanto más

971
01:01:50,119 --> 01:01:51,880
elemento añado

972
01:01:51,880 --> 01:01:54,199
mi programa peor funcionará hasta un momento

973
01:01:54,199 --> 01:01:55,480
en que no colapsará

974
01:01:55,480 --> 01:01:58,159
el logaritmo

975
01:01:58,159 --> 01:02:00,199
sería una cosa así

976
01:02:00,199 --> 01:02:07,340
y entonces no es exactamente

977
01:02:07,340 --> 01:02:07,699
igual

978
01:02:07,699 --> 01:02:10,679
y entonces es bueno

979
01:02:10,679 --> 01:02:13,000
constante

980
01:02:13,000 --> 01:02:21,300
sería así

981
01:02:21,300 --> 01:02:23,980
no lo conseguiré nunca

982
01:02:23,980 --> 01:02:25,000
se entiende

983
01:02:25,000 --> 01:02:28,179
a lo mejor es más alto

984
01:02:28,179 --> 01:02:30,559
pero esto irá creciendo, creciendo, creciendo

985
01:02:30,559 --> 01:02:32,400
técnicamente está a 1 pero bueno

986
01:02:32,400 --> 01:02:33,800
mientras este de aquí

987
01:02:33,800 --> 01:02:35,559
la mejor es que sea constante

988
01:02:35,559 --> 01:02:38,059
luego logarítmica, luego lineal

989
01:02:38,059 --> 01:02:40,079
luego exponencial, cuadrática

990
01:02:40,079 --> 01:02:40,920
y cosas por el estilo

991
01:02:40,920 --> 01:02:42,980
¿sí?

992
01:02:44,619 --> 01:02:45,059
vale

993
01:02:45,760 --> 01:02:48,380
Pues triset trabaja sobre el logaritmo de n.

994
01:02:48,920 --> 01:02:54,820
Bien, es más lenta en inserción con respecto a esta de aquí, a la anterior.

995
01:02:56,380 --> 01:03:00,500
Pero una vez insertado, si esto es que yo inserto, por ejemplo, inserto a los alumnos,

996
01:03:00,639 --> 01:03:04,440
tardará un rato insertar a los alumnos, pero luego manejarlos, buscarles, cosas por el estilo,

997
01:03:04,440 --> 01:03:06,599
es muy rápido, pues me puede valer.

998
01:03:07,880 --> 01:03:12,739
Repito que se tiene que, para usar una triset, los elementos que uso,

999
01:03:12,739 --> 01:03:19,000
los objetos que uso tienen que implementar con comparable. ¿Por qué? Porque el triset funciona así.

1000
01:03:23,139 --> 01:03:31,860
Pongamos que yo tenga que poner tres objetos. El objeto A, el objeto B y el objeto C. ¿Vale?

1001
01:03:32,440 --> 01:03:42,079
¿Qué hace? Pues A lo pone aquí como raíz. Perfecto. A lo he puesto. Ahora tengo que poner B.

1002
01:03:42,079 --> 01:03:44,119
Comparo A con B

1003
01:03:44,119 --> 01:03:47,480
Si B es menor, lo pongo en este lado

1004
01:03:47,480 --> 01:03:50,679
Si B es mayor, lo pongo en este lado

1005
01:03:50,679 --> 01:03:55,320
Entonces, pongamos que B sea mayor

1006
01:03:55,320 --> 01:03:59,719
Para poder hacer la comparación entre A y B que necesito

1007
01:03:59,719 --> 01:04:04,849
El compare to

1008
01:04:04,849 --> 01:04:08,510
Entonces, necesito que los objetos este de aquí

1009
01:04:08,510 --> 01:04:10,429
Implementen compareable

1010
01:04:10,429 --> 01:04:13,070
Porque cuando voy a insertar B, tengo que hacer

1011
01:04:13,070 --> 01:04:15,309
B compare to A

1012
01:04:15,309 --> 01:04:30,110
Y si B es mayor, lo pondré aquí. Si B era menor, lo pondré aquí. Ahora me viene C. Entro aquí. Pongamos que A sea menor que C. Por lo tanto, lo tengo que poner en esta subrama de aquí.

1013
01:04:30,110 --> 01:04:54,670
C, ¿es mayor o menor que B? Menor, pues lo pongo a su izquierda. Ahora pongo D, ¿D es menor que A? Pues lo pongo aquí. Ahora pongo E, ¿E es mayor que A y mayor que B? Pues lo pongo aquí. ¿Entendéis?

1014
01:04:54,670 --> 01:05:00,289
Entonces, la idea es que esto no vaya demasiado en profundidad

1015
01:05:00,289 --> 01:05:03,090
Cuanto menos profundo es

1016
01:05:03,090 --> 01:05:06,329
Si ahora, por ejemplo, tengo que buscar C

1017
01:05:06,329 --> 01:05:10,130
Tardo 1, 2, 3 comprobaciones

1018
01:05:10,130 --> 01:05:14,710
En vez de 1, 2, 3, 4, 5 comprobaciones

1019
01:05:14,710 --> 01:05:17,590
¿Se entiende?

1020
01:05:17,889 --> 01:05:19,670
O si busco E, que es el último que he puesto

1021
01:05:19,670 --> 01:05:22,409
Si esto fuera una lista y lo buscara E

1022
01:05:22,409 --> 01:05:24,429
Debería hacer 5 comprobaciones

1023
01:05:24,429 --> 01:05:28,949
Porque he puesto A, B, C, D y ahora he encontrado

1024
01:05:28,949 --> 01:05:31,449
En vez con el árbol solo tardaría 3

1025
01:05:31,449 --> 01:05:35,170
Cuanto más este árbol crezca

1026
01:05:35,170 --> 01:05:39,289
Mejor veo la diferencia entre lista y cosas así

1027
01:05:39,289 --> 01:05:50,710
No necesariamente porque podría haber un árbol así

1028
01:05:50,710 --> 01:05:59,699
Pero estarías perdiendo uno

1029
01:05:59,699 --> 01:06:05,329
el problema es si tú

1030
01:06:05,329 --> 01:06:07,449
los pones ordenados

1031
01:06:07,449 --> 01:06:09,769
y entonces te sale un árbol así

1032
01:06:09,769 --> 01:06:18,960
pero al fin y al cabo

1033
01:06:18,960 --> 01:06:20,280
si te sale un árbol así

1034
01:06:20,280 --> 01:06:22,199
tiene la misma complejidad de

1035
01:06:22,199 --> 01:06:23,920
de una lista

1036
01:06:23,920 --> 01:06:27,480
o sea que en el caso pésimo

1037
01:06:27,480 --> 01:06:29,400
en el que mira

1038
01:06:29,400 --> 01:06:30,820
has hecho lo peor que podías hacer

1039
01:06:30,820 --> 01:06:32,739
pues es igual a una lista

1040
01:06:32,739 --> 01:06:34,619
por lo tanto

1041
01:06:34,619 --> 01:06:36,840
con que un par de veces

1042
01:06:36,840 --> 01:06:38,760
te haya hecho esto

1043
01:06:38,760 --> 01:06:41,400
y has ganado algo

1044
01:06:41,400 --> 01:06:46,190
porque sustancialmente

1045
01:06:46,190 --> 01:06:47,090
se basa sobre la cosa

1046
01:06:47,090 --> 01:06:47,949
y cuando voy a buscar

1047
01:06:47,949 --> 01:06:48,869
puedo eliminar

1048
01:06:48,869 --> 01:06:49,989
enteros subárboles

1049
01:06:49,989 --> 01:06:52,170
si yo estoy buscando

1050
01:06:52,170 --> 01:06:53,010
un elemento

1051
01:06:53,010 --> 01:06:54,070
que es menor de A

1052
01:06:54,070 --> 01:06:55,349
todo este subárbol

1053
01:06:55,349 --> 01:06:58,070
lo puedo eliminar

1054
01:06:58,070 --> 01:06:58,449
¿sí?

1055
01:07:02,420 --> 01:07:03,119
luego tú tampoco

1056
01:07:03,119 --> 01:07:04,679
o sea tú añades las cosas

1057
01:07:04,679 --> 01:07:05,380
a lo mejor te va a dar

1058
01:07:05,380 --> 01:07:05,960
al usuario

1059
01:07:05,960 --> 01:07:07,360
lo mejor

1060
01:07:07,360 --> 01:07:08,159
es que sea lo más

1061
01:07:08,159 --> 01:07:09,039
distribuido posible

1062
01:07:09,039 --> 01:07:10,099
y eso es

1063
01:07:10,099 --> 01:07:11,579
lo menos profundo posible

1064
01:07:11,579 --> 01:07:13,119
si funciona así

1065
01:07:13,119 --> 01:07:14,079
perfecto

1066
01:07:14,079 --> 01:07:16,780
también existen

1067
01:07:16,780 --> 01:07:20,079
ahora esto lo deberíamos mirar

1068
01:07:20,079 --> 01:07:22,679
pero existen cosas que te permiten

1069
01:07:22,679 --> 01:07:25,719
pillar un árbol así y reestructurarlo

1070
01:07:25,719 --> 01:07:27,880
por ejemplo diciendo ahora la raíz es esta

1071
01:07:27,880 --> 01:07:29,960
y lo reestructura todo

1072
01:07:29,960 --> 01:07:33,619
o tú lo puedes hacer, dices a un cierto momento me creo

1073
01:07:33,619 --> 01:07:37,000
hago una operación de reestructurar

1074
01:07:37,000 --> 01:07:41,139
en el que miro esta cosa de aquí, me doy cuenta que está en esta cosa de aquí

1075
01:07:41,139 --> 01:07:43,340
y digo en vez de insertarlo aquí

1076
01:07:43,340 --> 01:07:44,059
hago una

1077
01:07:44,059 --> 01:07:47,019
una iteración sobre estos, pero

1078
01:07:47,019 --> 01:07:48,780
empiezo insertando esto

1079
01:07:48,780 --> 01:07:51,400
y luego inserto esto

1080
01:07:51,400 --> 01:07:53,179
que irá aquí, y luego

1081
01:07:53,179 --> 01:07:55,079
inserto esto, que irá aquí

1082
01:07:55,079 --> 01:07:57,420
y lo vuelvo a reestructurar en un árbol

1083
01:07:57,420 --> 01:07:59,480
más bonito, a lo mejor esto lo hago una vez

1084
01:07:59,480 --> 01:08:01,420
al mes, añado datos, añado datos

1085
01:08:01,420 --> 01:08:03,599
y una vez al mes hago una operación

1086
01:08:03,599 --> 01:08:05,460
de reestructuración para que mi árbol

1087
01:08:05,460 --> 01:08:06,960
sea más eficiente, porque no

1088
01:08:06,960 --> 01:08:09,280
ahora después miramos si existe

1089
01:08:09,280 --> 01:08:11,340
dejadme un segundo que

1090
01:08:11,340 --> 01:08:12,199
quiero ver que

1091
01:08:12,199 --> 01:08:14,420
Triset

1092
01:08:14,420 --> 01:08:16,359
Y link dash set

1093
01:08:16,359 --> 01:08:17,020
No me interesa

1094
01:08:17,020 --> 01:08:20,520
Estas son las funciones que hace

1095
01:08:20,520 --> 01:08:22,420
El triset

1096
01:08:22,420 --> 01:08:24,420
Que me puede sustancialmente

1097
01:08:24,420 --> 01:08:25,920
Ir a mirar

1098
01:08:25,920 --> 01:08:28,560
Las ramas

1099
01:08:28,560 --> 01:08:29,899
Si la rama mayor o menor

1100
01:08:29,899 --> 01:08:32,420
Y con este de aquí puedo navegar

1101
01:08:32,420 --> 01:08:33,159
Sobre el triset

1102
01:08:33,159 --> 01:08:36,020
Lo miráis después

1103
01:08:36,020 --> 01:08:37,720
Y ya está