1
00:00:00,300 --> 00:00:06,240
Voy a grabar esta clase, por lo tanto, si habláis me autorizáis a grabar vuestra voz, ¿vale?

2
00:00:06,240 --> 00:00:16,140
Entonces, en las otras últimas clases hemos visto algo de estructuras dinámicas, ¿vale?

3
00:00:16,140 --> 00:00:23,879
Estructuras que pueden aumentar o disminuir su tamaño sin que yo tenga que pensar en ello, ¿vale?

4
00:00:23,879 --> 00:00:30,239
los pobres arrays que son una cosa que se utilizaba principalmente antes entre comillas

5
00:00:30,239 --> 00:00:35,399
pues tenían este problema que eran siempre estáticos como tamaño entonces cuando tenía

6
00:00:35,399 --> 00:00:40,079
que hacerlo más pequeño más grande tenía que no podía cambiar el array tenía que crear un

7
00:00:40,079 --> 00:00:45,780
nuevo array y luego cambiar las referencias eso nos ha dado también una mano para entender un

8
00:00:45,780 --> 00:00:51,359
poquito cómo funcionan las referencias vale si lo pensáis bien esto de que hay un método que

9
00:00:51,359 --> 00:00:59,520
me hace una red más grande luego añade una cosa al final y luego me cambia el puntero al principio

10
00:00:59,520 --> 00:01:04,500
a otro pues es una cosa interesante porque estoy utilizando las referencias estos elementos que

11
00:01:04,500 --> 00:01:16,739
son fundamentales en la programación orientada a objetos vale en java es que a veces perdemos

12
00:01:16,739 --> 00:01:26,879
de vista en el sentido de que no lo hemos pensado que no nos ha no lo hemos interiorizado pero que

13
00:01:26,879 --> 00:01:32,799
tenéis que entender bien la diferencia entre una variable que contiene un valor y una variable que

14
00:01:32,799 --> 00:01:38,400
contiene una referencia un objeto porque cambia completamente la forma con la que luego se

15
00:01:38,400 --> 00:01:47,819
utilizan estas variantes vale entonces en la nueva ya hablamos pero la que vemos hoy un

16
00:01:47,819 --> 00:01:57,019
poco más en detalle es la que o sea la coda vale la cola la cola es digamos una estructura que

17
00:01:57,019 --> 00:02:04,780
implementa el concepto de fifo first in first out vale entonces en una lista son parecidas

18
00:02:04,780 --> 00:02:12,099
De hecho una linked list hace también de queue, ningún problema. Simplemente lo que cambia son

19
00:02:12,099 --> 00:02:18,759
los métodos que utilizo. Mientras en la lista yo puedo añadir, remover y puedo hasta añadir en el

20
00:02:18,759 --> 00:02:27,099
medio o remover o pillar un elemento del medio, la cola tiene que implementar algunos métodos

21
00:02:27,099 --> 00:02:35,080
que garantizan que el comportamiento es fijo. Entonces, yo por debajo puedo tener una lista,

22
00:02:35,080 --> 00:02:44,740
un ArrayList o un LinkedList, pero lo quiero utilizar de una forma específica. No lo quiero

23
00:02:44,740 --> 00:02:51,280
utilizar con... Sustantemente, me impido de utilizar los métodos como el de pillar un

24
00:02:51,280 --> 00:02:55,599
elemento en el medio, de remover un elemento en el medio o añadir un elemento en el medio. Que

25
00:02:55,599 --> 00:03:03,639
las listas permiten, pero la cura no tiene que permitir. Si yo me voy a la interfaz de Q, los métodos específicos

26
00:03:03,639 --> 00:03:11,740
de la Q son de añadir al final y pillar desde el principio. Si yo hago una lista como la que

27
00:03:11,740 --> 00:03:16,280
hicimos nosotros, porque la implementación que hicimos nosotros al final hacía funcionar la lista

28
00:03:16,280 --> 00:03:24,159
prácticamente como una cola, porque nosotros cuando el get en realidad pillamos la posición,

29
00:03:24,159 --> 00:03:27,180
aquí el getter no debería

30
00:03:27,180 --> 00:03:28,800
tener una posición, es sólo

31
00:03:28,800 --> 00:03:30,979
inserta y pilla

32
00:03:30,979 --> 00:03:33,259
si tú insertas ya sabes

33
00:03:33,259 --> 00:03:34,840
que vas a insertar al final de la cola

34
00:03:34,840 --> 00:03:36,800
y pilla no tienes que especificarle

35
00:03:36,800 --> 00:03:38,919
qué elemento pillar o qué elemento

36
00:03:38,919 --> 00:03:40,819
en qué posición pillarlo

37
00:03:40,819 --> 00:03:42,860
porque sabes que seguramente será el primero

38
00:03:42,860 --> 00:03:43,240
de la cola

39
00:03:43,240 --> 00:03:46,419
para garantizar que haga

40
00:03:46,419 --> 00:03:47,539
¿me seguís?

41
00:03:48,639 --> 00:03:50,039
¿sí? ¿dudas?

42
00:03:53,479 --> 00:03:55,199
en fin, el primer elemento se elimina

43
00:03:55,199 --> 00:04:00,819
primero, el último elemento se elimina por último. Los elementos se añaden a una fila de la coda,

44
00:04:00,819 --> 00:04:06,000
pueden contener elementos duplicados. Otra cosa importante, como la lista, si yo añado dos veces

45
00:04:06,000 --> 00:04:11,960
el mismo elemento, entonces se añade dos veces. El mismo elemento tanto considerado como igual

46
00:04:11,960 --> 00:04:19,819
igual, o sea, si inserto literalmente el mismo objeto, como si inserto dos objetos que si lo

47
00:04:19,819 --> 00:04:26,480
comparara con el equal se me daría true pero igualmente entran los dos

48
00:04:27,420 --> 00:04:32,600
los principales operaciones son en colar o tener siguiente vale añadir a la cola

49
00:04:32,600 --> 00:04:37,899
o pillar el siguiente estas son las dos operaciones que debería utilizar está

50
00:04:37,899 --> 00:04:44,959
claro que si yo tengo una linked list por debajo vale y entonces podría

51
00:04:44,959 --> 00:04:49,800
también funcionar como lista y a mitad de mi programa en vez de utilizar esto

52
00:04:49,800 --> 00:04:56,639
dos métodos, uso el método que me pilla, el tercer elemento, pues entonces no estoy usando una POP.

53
00:04:56,639 --> 00:05:20,620
¿Se entiende? ¿Cómo evito eso? Yo me voy a ver la API Java de QW. Si os fijáis, aquí los métodos que

54
00:05:20,620 --> 00:05:31,240
tengo son add, element, offer, pick, poll y remove. Son estos. Si os fijáis, los remove, los poll,

55
00:05:31,240 --> 00:05:42,100
los pick, no tienen un parámetro. Tú no puedes remover el primero, el tercero. Tú dices remueve

56
00:05:42,100 --> 00:05:49,360
y él removerá el primero de la columna. Tú puedes decir añade un elemento, pero no puedes decir

57
00:05:49,360 --> 00:06:03,490
en generalmente en tercera posición. Entonces, si yo voy a mirar una linked list,

58
00:06:03,490 --> 00:06:17,310
veo que linked list que implementa Q, pero implementa también otras cosas,

59
00:06:17,310 --> 00:06:24,689
tendrá las dos. Tendrá por un lado la add a secas, que lo añade a la final de la

60
00:06:24,689 --> 00:06:32,889
lista, pero también tendrá el add en esta posición de este elemento.

61
00:06:32,889 --> 00:07:15,110
Entonces, si yo en un código, vale, si yo en colecciones, hay ejemplos en colecciones,

62
00:07:15,110 --> 00:07:31,600
Si yo tengo una clase, una clase red-blue, y aquí tengo un main, si yo hago linked list

63
00:07:31,600 --> 00:07:55,839
de string. Lista. Alt. Es igual a new linked list de string. Así. Pues cuando yo hago

64
00:07:55,839 --> 00:08:04,600
algo, punto, pues aquí me da la posibilidad de utilizar esto, el add de string, que sostancialmente

65
00:08:04,600 --> 00:08:09,660
me añadiría una string al final de la lista, pero me da la posibilidad también de añadirlo

66
00:08:09,660 --> 00:08:18,519
a nivel de segunda posición o tercera posición. Esto me daría como un marco de peligrosidad,

67
00:08:18,519 --> 00:08:24,519
porque si me equivoco a usar el método, pues no lo estaría usando como una queue.

68
00:08:24,519 --> 00:08:38,740
Entonces, ¿cómo podría evitar esto? Pues forzando que este señor sea una queue. Por debajo sigue

69
00:08:38,740 --> 00:08:43,759
siendo una linked list y como linked list implementa queue, pues puedo usarlo como queue.

70
00:08:43,759 --> 00:08:52,879
Pero ahora, si yo hago algo punto, solo me aparecen los métodos relacionados con la queue,

71
00:08:52,879 --> 00:09:01,080
no con una linked list que estarán implementados en linked list pero ahora yo no tengo no tengo

72
00:09:01,080 --> 00:09:07,620
el add de string en una cierta posición porque que uno lo tiene y su referencia no obstante su

73
00:09:07,620 --> 00:09:13,759
instancia sea una linked list que es una queue y es también una list y es también otras cosas pues

74
00:09:13,759 --> 00:09:18,860
yo les estoy diciendo sí pero tú considéramela como si fuera una call por lo tanto ahora no

75
00:09:18,860 --> 00:09:26,039
tengo problemas de utilizarlo mal. Ahora no puedo insertar algo en posición 3 porque no tengo ese

76
00:09:26,039 --> 00:09:44,809
método, no me lo permite. ¿Y cuando hagas un objeto dentro de esa lista, por ejemplo, ¿se va a crear con el constructor de cola o con el constructor de linterna?

77
00:09:47,009 --> 00:09:50,909
No existe el constructor de cola porque Q es una interfaz.

78
00:09:55,100 --> 00:09:58,559
No puede hacer un new queue, porque no existe queue.

79
00:09:59,460 --> 00:10:03,240
Es una interfaz, no se puede hacer una, como si fuera una clase abstracta.

80
00:10:04,000 --> 00:10:05,440
No puede hacer una new de queue.

81
00:10:05,840 --> 00:10:11,259
O sea, hay que construir una interfaz, pero el intervicio sería una implementada.

82
00:10:12,840 --> 00:10:16,360
Esta es una clase que implementa esta interfaz.

83
00:10:17,019 --> 00:10:22,240
Por lo tanto, yo no puedo hacer new queue, porque no puede hacer una new de una interfaz.

84
00:10:22,240 --> 00:10:25,600
pero así puede hacer una new linked list

85
00:10:25,600 --> 00:10:28,039
ahora esto como objeto es una linked list

86
00:10:28,039 --> 00:10:29,779
va a usar los métodos de linked list

87
00:10:29,779 --> 00:10:32,179
pero si yo aquí le pongo linked list

88
00:10:32,179 --> 00:10:34,179
él utilizará esta referencia

89
00:10:34,179 --> 00:10:36,019
como un objeto de tipo

90
00:10:36,019 --> 00:10:38,179
linked list, entonces me dará todos los métodos

91
00:10:38,179 --> 00:10:39,299
posibles de linked list

92
00:10:39,299 --> 00:10:41,279
si yo lo quería usar como una queue

93
00:10:41,279 --> 00:10:43,960
me expongo al problema de que pueda

94
00:10:43,960 --> 00:10:46,000
utilizar algún método que una cola

95
00:10:46,000 --> 00:10:46,740
no podría

96
00:10:46,740 --> 00:10:49,960
entonces con esto

97
00:10:49,960 --> 00:10:51,759
en un cierto sentido protejo

98
00:10:51,759 --> 00:10:54,399
voy a proteger esta cosa

99
00:10:54,399 --> 00:10:56,480
diciendo, no, mira, cuando uso algo

100
00:10:56,480 --> 00:10:58,620
voy a utilizar solo métodos de queue

101
00:10:58,620 --> 00:11:00,139
¿podría utilizarlo en LinkedList?

102
00:11:00,279 --> 00:11:02,059
sí, yo aquí puedo hacer un

103
00:11:02,059 --> 00:11:04,240
downcasting a LinkedList tranquilamente

104
00:11:04,240 --> 00:11:06,019
porque es un objeto de LinkedList y utilizar

105
00:11:06,019 --> 00:11:08,379
su cosa, pero me estoy ayudando a mí

106
00:11:08,379 --> 00:11:10,220
como programador, para evitar

107
00:11:10,220 --> 00:11:12,100
de usar métodos que no debería

108
00:11:12,100 --> 00:11:14,259
porque si los uso ya no es una cola

109
00:11:14,259 --> 00:11:16,200
pues entonces digo, no, no

110
00:11:16,200 --> 00:11:18,700
la llamo como una cola, sé que esto lo implementa

111
00:11:18,700 --> 00:11:20,039
por lo tanto

112
00:11:20,039 --> 00:11:25,320
todo lo que hace una cola lo puede hacer linked list podrá hacer también otras cosas más esas

113
00:11:25,320 --> 00:11:31,840
cosas no la quiero usar para estar seguro que estoy utilizando algo pasado mañana además si

114
00:11:31,840 --> 00:11:42,279
yo esto hago todas las cosas con el gato tranquilamente si mañana esto lo cambio con

115
00:11:42,279 --> 00:11:48,120
una implementación distinta de cola pues me va a funcionar el resto del programa igualmente

116
00:11:48,120 --> 00:11:51,240
porque no he hecho nunca referencia

117
00:11:51,240 --> 00:11:53,059
a métodos específicos de linked list

118
00:11:53,059 --> 00:11:55,240
siempre he hecho métodos específicos de queue

119
00:11:55,240 --> 00:11:57,620
entonces cualquier clase

120
00:11:57,620 --> 00:11:59,500
que implemente queue, incluida la

121
00:11:59,500 --> 00:12:01,399
mía, o sea, si yo me hago una mía

122
00:12:01,399 --> 00:12:02,879
clase, que se llama mi

123
00:12:02,879 --> 00:12:04,679
no, se llama

124
00:12:04,679 --> 00:12:05,779
my queue

125
00:12:05,779 --> 00:12:10,289
entonces

126
00:12:10,289 --> 00:12:12,549
la puedo poner aquí

127
00:12:12,549 --> 00:12:14,269
si implementa queue

128
00:12:14,269 --> 00:12:16,070
dudas

129
00:12:16,070 --> 00:12:17,590
y el linked list

130
00:12:17,590 --> 00:12:26,590
implementa queue y implementa list. Y si implementaría list, el add sería de list, no de list.

131
00:12:26,590 --> 00:12:37,929
El add te daría igual porque queue lo tiene el add y también list tiene el add.

132
00:12:37,929 --> 00:12:41,929
Pero no se guardaría de la forma, no se añadiría de la forma en que se añade un add.

133
00:12:41,929 --> 00:12:46,929
Vamos a verlo. List ¿qué me dice? Cuando yo implemento el add de list me dice

134
00:12:46,929 --> 00:12:54,970
appends the specified element to the end of the list. Entonces, en este caso tengo suerte porque

135
00:12:54,970 --> 00:13:01,509
tanto lo que me dice la interfaz list como lo que me dice la interfaz queue coinciden. Es añadirla al final.

136
00:13:01,509 --> 00:13:07,870
Tiene sentido, cuando tú añades una lista no la añades al principio, la añades al final. Luego, la lista te incluye

137
00:13:07,870 --> 00:13:16,429
otras cosas que tú dices, no, yo lo puedo insertar al principio. Lo pones aquí. Si tú haces add 0 de un

138
00:13:16,429 --> 00:13:22,049
elemento, pues lo añado al principio en vez que al final. Vale, fenomenal, pues hazlo como quieras. Pero el

139
00:13:22,049 --> 00:13:28,549
add normal coincide con el otro. Entonces, yo implemento un add, en realidad lo estoy tirando de

140
00:13:28,549 --> 00:13:39,230
dos lados, porque list me obliga a implementar add y también queue me obliga a implementar add.

141
00:13:39,230 --> 00:13:44,909
Pero si te fijas, son el mismo idéntico método. Pillan los mismos variables, pillan las mismas

142
00:13:46,429 --> 00:13:57,429
devuelven la misma variable, entonces, si tú lo implementas para list, lo estás implementando también para queue, y como hacen lo mismo, se añaden al final, todo es fin.

143
00:13:57,429 --> 00:14:11,470
Pero si yo hago una cola con todos los elementos que implemento así, y el día de mañana yo ya no quiero que sea una cola, quiero que sea una lista, ¿es posible?

144
00:14:11,470 --> 00:14:15,669
Depende. Esa es una refactorización del código.

145
00:14:15,750 --> 00:14:19,450
¿Por qué no quieres que sea una cola y que sea una lista?

146
00:14:20,169 --> 00:14:31,700
Claro que puedes. O sea, tú mañana entras aquí, aquí en vez de Q pones list y ahora

147
00:14:31,700 --> 00:14:35,240
pregas, rezas, que no haya problemas.

148
00:14:36,679 --> 00:14:43,399
Porque a lo mejor ahora has usado algunos métodos que en Q si existían, entonces lo

149
00:14:43,399 --> 00:14:48,220
podías usar y que ahora en list ya no existen y por lo tanto ya no puedes usar. Por ejemplo el

150
00:14:48,220 --> 00:14:56,779
pick. Si tú has usado pick por algún lado, pues ahora te explota porque te dice una lista no tiene pick.

151
00:14:56,779 --> 00:15:15,899
Pero si tú tenías una juegue, tampoco. No la hemos visto antes. Ah, pero con esto. Lista. Porque esto de mirar

152
00:15:15,899 --> 00:15:19,220
el primer elemento de la lista

153
00:15:19,220 --> 00:15:21,080
es típico de una cola

154
00:15:21,080 --> 00:15:22,899
¿vale? porque tú dices, oye mira

155
00:15:22,899 --> 00:15:25,279
quiero ver cuál es el siguiente elemento

156
00:15:25,279 --> 00:15:26,940
en base a eso hacer una cosa u otra

157
00:15:26,940 --> 00:15:28,320
pero en una lista no

158
00:15:28,320 --> 00:15:31,480
¿vale? no está pensado la lista

159
00:15:31,480 --> 00:15:33,139
si tú quieres habrá otro método

160
00:15:33,139 --> 00:15:34,360
para hacer eso ¿vale?

161
00:15:34,779 --> 00:15:37,159
entonces, claro, si tú de repente

162
00:15:37,159 --> 00:15:39,419
cambias, tienes un problema serio

163
00:15:39,419 --> 00:15:41,340
de diseño, porque tú habías diseñado

164
00:15:41,340 --> 00:15:43,080
para que fuera una queue

165
00:15:43,080 --> 00:15:45,039
y ahora de repente es una list

166
00:15:45,039 --> 00:15:46,700
por qué

167
00:15:46,700 --> 00:15:49,600
no porque te ha dado la gana

168
00:15:49,600 --> 00:15:51,480
porque has hecho un error en el diseño

169
00:15:51,480 --> 00:15:53,460
has visto que las funcionalidades

170
00:15:53,460 --> 00:15:55,200
que te daba la queue no eran

171
00:15:55,200 --> 00:15:57,019
suficientes o no eran adaptas para

172
00:15:57,019 --> 00:15:59,200
todo tu tipo de programa, pero has hecho un problema

173
00:15:59,200 --> 00:16:00,500
tuyo, entonces ahora tienes que

174
00:16:00,500 --> 00:16:02,840
dedicar tiempo en

175
00:16:02,840 --> 00:16:05,019
pillar todo lo que has hecho

176
00:16:05,019 --> 00:16:06,940
y transformarlo en una queue, se puede hacer

177
00:16:06,940 --> 00:16:08,840
si yo quiero hacerlo todavía más

178
00:16:08,840 --> 00:16:10,460
amplio, pues pongo collection

179
00:16:10,460 --> 00:16:17,120
ahora por ejemplo, el collection pick no está

180
00:16:17,120 --> 00:16:19,980
pero si yo uso los métodos

181
00:16:19,980 --> 00:16:22,039
de collection, luego a mí me da

182
00:16:22,039 --> 00:16:23,720
igual que tú uses aquí

183
00:16:23,720 --> 00:16:26,100
una linked list, una queue, una list

184
00:16:26,100 --> 00:16:27,419
lo que te da la gana

185
00:16:27,419 --> 00:16:30,039
va a funcionar porque collection está por arriba de todos

186
00:16:30,039 --> 00:16:34,070
y solo en los métodos

187
00:16:34,070 --> 00:16:35,950
que he utilizado por collection lo voy a encontrar

188
00:16:35,950 --> 00:16:37,509
en toda la lista, en todos los

189
00:16:37,509 --> 00:16:39,970
pero no los propios

190
00:16:39,970 --> 00:16:41,549
de list, no los propios de queue

191
00:16:41,549 --> 00:16:43,669
de hecho collection

192
00:16:43,669 --> 00:16:46,330
tiene un add, remove

193
00:16:46,330 --> 00:16:46,889
y poco más

194
00:16:46,889 --> 00:16:50,549
¿Sí? ¿Entiendes?

195
00:16:50,990 --> 00:16:52,509
O sea, que esto es un poco jugar

196
00:16:52,509 --> 00:16:54,470
con entender lo que yo

197
00:16:54,470 --> 00:16:56,549
quiero y, no obstante,

198
00:16:56,610 --> 00:16:58,389
yo tenga una implementación por debajo

199
00:16:58,389 --> 00:17:00,549
que sea específica

200
00:17:00,549 --> 00:17:02,529
de una cosa, pues luego aquí

201
00:17:02,529 --> 00:17:04,470
la enmascaro en lo que yo

202
00:17:04,470 --> 00:17:06,450
quiero de verdad para que funcione como yo quiero.

203
00:17:07,109 --> 00:17:08,750
¿Vale? Podría dejarme

204
00:17:08,750 --> 00:17:10,470
libertad.

205
00:17:10,710 --> 00:17:12,630
Sí, yo podría poner aquí esto

206
00:17:12,630 --> 00:17:14,390
y ahora

207
00:17:14,390 --> 00:17:16,430
está a mi programador

208
00:17:16,430 --> 00:17:18,329
Utilizar los métodos correctos

209
00:17:18,329 --> 00:17:19,690
Para que sea una cola

210
00:17:19,690 --> 00:17:22,650
O los métodos correctos para que sea una lista

211
00:17:22,650 --> 00:17:25,210
Pero puedo usar los dos

212
00:17:25,210 --> 00:17:26,509
¿Por qué?

213
00:17:26,910 --> 00:17:28,670
LinkedIn List implementa las dos cosas

214
00:17:28,670 --> 00:17:29,490
¿Vale?

215
00:17:29,890 --> 00:17:32,650
Es como si hubiese perdido en un cierto sentido

216
00:17:32,650 --> 00:17:34,509
La ayuda que me da él

217
00:17:34,509 --> 00:17:36,730
A decir, oye mira me has dicho que tienes que ser FIFO

218
00:17:36,730 --> 00:17:38,769
Vale, te garantizo yo que seas FIFO

219
00:17:38,769 --> 00:17:40,630
Porque los métodos que te ponga a disposición

220
00:17:40,630 --> 00:17:41,930
Solo funcionan FIFO

221
00:17:41,930 --> 00:17:44,609
Ahora no, ahora tienes todos los métodos

222
00:17:44,609 --> 00:17:53,609
Si te equivocas, problema tuyo. Has asumido tú la responsabilidad, pero muchas veces si yo he llegado aquí y he dicho, no, esto tiene que ser una cola, pues vale.

223
00:17:54,049 --> 00:18:10,410
Entonces me evito problemas haciendo esto. Me ayuda a mí mismo. Ahora le he dicho al ordenador, oye, ayúdame que si intento yo hacer una cosa que no es buena para una Q, pues tú me avisarás diciendo, no, esto no lo puedes hacer.

224
00:18:10,410 --> 00:18:33,339
Pero es peligroso, es un pequeño problema de diseño. No se programa sin saber que se tiene que hacer.

225
00:18:33,339 --> 00:18:39,160
Es un mecanismo que hacemos nosotros porque estamos a un nivel muy bajo de pruebas, pero tú

226
00:18:39,160 --> 00:18:44,799
normalmente la primera parte de un problema de un proyecto es el diseño tú piensas en lo que tiene

227
00:18:44,799 --> 00:18:50,079
que hacer entonces mientras estás pensando sin haberlo implementado porque el cómo se hace es

228
00:18:50,079 --> 00:18:54,980
distinto del que sea tú sabes que tienes un método que te hace esto un método que te hace y allí

229
00:18:54,980 --> 00:19:00,099
piensa se dice soy mira estos datos de aquí viene en este orden tengo que mantener el orden por si

230
00:19:00,099 --> 00:19:06,099
me viene bien el cifro pues entonces implementas esa por aquí a nivel de diseño que luego te das

231
00:19:06,099 --> 00:19:10,960
cuenta que no que no que necesitabas otra cosa vale pero tiene que ser a nivel de diseño en el

232
00:19:10,960 --> 00:19:15,519
momento en que quien ha hecho el diseño ya lo pasa a los programadores para que lo hagan pues

233
00:19:15,519 --> 00:19:21,220
vosotros tenéis que hacer lo que ve allí tú lo que no puedes hacer es si tu jefe de comillas

234
00:19:21,220 --> 00:19:26,099
el diseñador el design ha dicho esto tiene que ser un club pues le pongo linked list porque así

235
00:19:26,099 --> 00:19:32,700
ve pues tienen que seguir las indicaciones que está o si tú eres el design te esperas que la

236
00:19:32,700 --> 00:19:44,359
gente siga las indicaciones que te he prestado. Tú das poquitopi. Vale. También, vale, existe la

237
00:19:44,359 --> 00:19:53,059
DEC. Creo que se pronuncia DEC. Vale, que es una Double Ended Queue. Una queue con dos finales.

238
00:19:53,059 --> 00:20:10,089
Si me voy a ver DEC, es otra interfaz donde hay métodos, pero además de la ADD a secas,

239
00:20:10,089 --> 00:20:16,569
que es la ADD de la cuba normalmente, tengo un ADD first y un ADD last. O sea que puedo acceder a

240
00:20:16,569 --> 00:20:23,990
los dos extremos de la cola. Puedo añadir delante, añadir detrás, remover delante, remover detrás.

241
00:20:23,990 --> 00:20:28,910
Puedo, es sustantivamente que fuera una cola que puedo recorrerla en los dos sentidos.

242
00:20:28,910 --> 00:20:42,829
En determinados contextos, pues esto puede ser útil. Entonces, si os fijáis, es lo mismo que

243
00:20:42,829 --> 00:20:48,730
antes, tiene la misma cosa, solo que añade un first y un last por cada cosa. Antes tenía pick,

244
00:20:48,730 --> 00:20:55,730
ahora tengo pick first y pick last. Antes tenía poll, ahora tengo poll first y poll last. Pick

245
00:20:55,730 --> 00:21:05,410
que es para mirar pero no lo quita paul lo mira el primer objeto y lo quita de la lista de la

246
00:21:11,170 --> 00:21:19,230
pica mira el primer elemento en que a lo mejor se entiende mejor o sea este aquí añade un

247
00:21:19,230 --> 00:21:33,230
elemento al final. Element retrieves but not removed. Vale? The head of the cue. O sea, me da un puntero al principio de la cola, pero sin quitarlo de la cola.

248
00:21:33,230 --> 00:21:48,230
Offer, me dice, pick retrieves but does not remove the head of the cue. Sostancialmente igual a esto.

249
00:21:48,230 --> 00:21:54,549
Ahora devuelve nulo si la Q es empty. Si la Q está vacía me devuelve nulo.

250
00:21:54,549 --> 00:22:02,150
Este de aquí no lo sé qué hace. Por nulo es de QM. Es igual. No, este es por. Remove.

251
00:22:06,150 --> 00:22:11,750
Si la cola está vacía, pues lanzo una infección. No sacio elemento externo.

252
00:22:11,750 --> 00:22:17,589
¿Vale? La diferencia entre... No, perdón. Estoy mirando. ¿Dónde está el elemento? El elemento. Sí.

253
00:22:18,230 --> 00:22:41,950
La diferencia entre Paul y Element es que Paul te da el primero y lo remueve, perdón, estamos viendo el pic, el elemento te recupera pero no lo remueve de la cola, la cabeza de la cola.

254
00:22:41,950 --> 00:22:53,009
lo mismo, idéntico, peak, la diferencia es cuando es null. Si tú llamas element y la queue es empty,

255
00:22:53,009 --> 00:22:57,970
o sea, no tiene elemento, te lanza una excepción. Entonces la puedes pillar con un try-catch.

256
00:22:57,970 --> 00:23:05,069
Mientras que la peak te devuelve null. Siempre te devuelve algo, nunca explota, pero te devuelve null

257
00:23:05,069 --> 00:23:10,069
si no hay una cabeza de la palabra. ¿Se entiende?

258
00:23:10,069 --> 00:23:16,069
O sea, en el momento, si lo usas cuando hay algo dentro de ti.

259
00:23:16,069 --> 00:23:24,069
No, puedes usar los dos cuando te dé la gana. Solo que reaccionas distinto cuando está vacío.

260
00:23:24,069 --> 00:23:37,009
Este de aquí, si yo uso pic, yo haría ring primero.

261
00:23:37,009 --> 00:23:51,160
Es igual a algo.pic, no lo he quitado de la pila. Y aquí debería hacer, si primero es null, haz algo.

262
00:23:51,160 --> 00:24:02,609
Si no, haz otra cosa. Esta como se te dice a pic. Si uso element, nunca será null.

263
00:24:03,869 --> 00:24:09,029
Porque no me devuelve nunca null. Lo que puede ser, pero hay que explote. Por lo tanto, lo uso así.

264
00:24:09,950 --> 00:24:32,980
Trae la cosa aquí, captcha, no such element exception, aquí, no such element Q, vacía,

265
00:24:32,980 --> 00:24:43,299
y aquí hago algo, si yo intento pillar el primero y lo que hace es explotar porque está

266
00:24:43,299 --> 00:24:47,440
vacía y entonces no lo puede hacer, pues entrará aquí y haré lo que antes hacía

267
00:24:47,440 --> 00:24:55,599
hay en el si es no dos formas son dos hacen lo mismo pero hay un comportamiento ligeramente

268
00:24:55,599 --> 00:25:02,480
distinto que tú tú eliges cuál usar y vale de cara a una una una chica

269
00:25:04,940 --> 00:25:20,259
vale la de que existe la situación esta es la que vale que hereda de

270
00:25:20,259 --> 00:25:33,019
colección si es una interfaz vale la deck hereda de que vale y añade con las de esta cosa aquí vale

271
00:25:33,019 --> 00:25:40,420
y hay varias implementaciones y yo quiero saber cuáles son las implementaciones de que aquí viene

272
00:25:40,420 --> 00:25:48,579
todas las las implementaciones conocidas de esta clase o sea todas las clases que implementan esto

273
00:25:48,579 --> 00:25:58,079
Esto es AbstractQueue, ArrayBlockingQueue, ArrayDeck, DaylightDeck, LinkedTransferQueue...

274
00:25:58,079 --> 00:26:01,579
Todo eso son implementaciones de esta interfaz.

275
00:26:01,579 --> 00:26:04,579
En particular nosotros usamos esta porque es la más fácil.

276
00:26:04,579 --> 00:26:09,579
Sabemos que, por ejemplo, ArrayList no implementa Queue.

277
00:26:09,579 --> 00:26:16,579
¿Hay una Queue basada sobre Arrays en vez que sobre objetos del linkador?

278
00:26:16,579 --> 00:26:30,079
pues probablemente esta, la ArrayDec. La ArrayDec es una cola de doble fin, como Array.

279
00:26:30,079 --> 00:26:34,339
Entonces si uso esta de aquí, por debajo estoy usando Arrays, y si uso esta de aquí, por debajo estoy usando

280
00:26:34,339 --> 00:26:39,240
Enlazar, con las ventajas y desventajas que hemos visto de utilizar Array y utilizar objetos

281
00:26:39,240 --> 00:26:39,720
en la sala.

282
00:26:41,160 --> 00:26:43,180
Sí, también está Priority Queue,

283
00:26:43,359 --> 00:26:44,200
por ejemplo, ¿vale?

284
00:26:44,920 --> 00:26:47,039
Como ejemplos que vemos nosotros, están

285
00:26:47,039 --> 00:26:49,160
por un lado una Priority Queue y por otro

286
00:26:49,160 --> 00:26:50,539
lado la Raydeck, ¿vale?

287
00:26:50,960 --> 00:26:53,240
La Raydeck es una implementación

288
00:26:53,240 --> 00:26:55,019
de la DEC, también la Linked

289
00:26:55,019 --> 00:26:57,039
List es una implementación de DEC,

290
00:26:57,160 --> 00:26:59,019
entonces si tenéis que usar una DEC, podéis

291
00:26:59,019 --> 00:27:00,680
usar estas dos cosas, ¿vale?

292
00:27:01,019 --> 00:27:03,119
Y la Priority Queue es una implementación

293
00:27:03,119 --> 00:27:05,140
de Queue con prioridad, una cola

294
00:27:05,140 --> 00:27:07,259
con prioridad, que vosotros habéis visto, por ejemplo,

295
00:27:07,420 --> 00:27:07,579
en

296
00:27:07,579 --> 00:27:10,880
sistemas, ¿vale?

297
00:27:11,180 --> 00:27:13,039
Los de procesos, de

298
00:27:13,039 --> 00:27:14,240
gestionar

299
00:27:14,240 --> 00:27:17,799
cuál proceso se ejecuta.

300
00:27:18,200 --> 00:27:19,720
Pues probablemente esa es una cola

301
00:27:19,720 --> 00:27:21,440
con prioridad, porque

302
00:27:21,440 --> 00:27:23,859
tienen procesos con más prioridad que otros

303
00:27:23,859 --> 00:27:25,579
y antes se ejecutan los que

304
00:27:25,579 --> 00:27:27,359
tienen más prioridad. Cuando los de

305
00:27:27,359 --> 00:27:29,579
más prioridad no hay ninguno, pues

306
00:27:29,579 --> 00:27:31,579
se pasa a prioridad más baja. Si los de

307
00:27:31,579 --> 00:27:33,319
bajos por mucho tiempo no

308
00:27:33,319 --> 00:27:35,579
son ejecutados, pues

309
00:27:35,579 --> 00:27:37,380
se le aumenta la prioridad para que antes o

310
00:27:37,380 --> 00:27:45,480
Entonces, pues, esto es una forma de hacer el scheduling o no sé qué hacer, ¿sí?

311
00:27:45,480 --> 00:27:49,980
Entonces, podemos ir a ver, ¿no?

312
00:27:49,980 --> 00:27:50,980
Preview.

313
00:27:50,980 --> 00:28:02,039
Esto molaría que vosotros, cuando hablamos de estas cosas, queue, Preview, ArrayList,

314
00:28:02,039 --> 00:28:06,099
os vayáis aquí y os leáis estas cosas, ¿vale?

315
00:28:06,099 --> 00:28:12,079
estas son informaciones técnicas que os describen qué es cada cosa, para que luego vosotros en un

316
00:28:12,079 --> 00:28:17,619
futuro sepáis qué es cada cosa y sepáis dónde buscar la información que os suene. De esto una

317
00:28:17,619 --> 00:28:23,480
vez lo he leído, estaba... Probablemente habrá una versión en castellano. Si no copiáis esto,

318
00:28:23,480 --> 00:28:33,420
lo pegáis a ChatGPT o Gemini o whatever y le decís no traduces y ya está. Entonces,

319
00:28:33,420 --> 00:28:43,099
Pues aquí tenéis los constructores, añadir, contains, iterator, es muy parecido, por algún

320
00:28:43,099 --> 00:28:55,529
lado debería haber una prioridad, habría que leerlo bien.

321
00:28:55,529 --> 00:29:12,640
Insert priority queue, es prácticamente como una queue, debería haber algo por algún

322
00:29:12,640 --> 00:29:13,640
lado.

323
00:29:13,640 --> 00:29:24,289
esto luego se basará sobre un orden, la Priority Queue asume que los objetos que tú le estás

324
00:29:24,289 --> 00:29:39,400
poniendo dentro sean comparables entre ellos y entonces lo va a añadir pero no necesariamente

325
00:29:39,400 --> 00:29:44,619
al principio, más lo va a añadir en la correcta prioridad.

326
00:29:45,519 --> 00:29:51,220
Sí, es que sustancialmente es como si me ordenara esta bola en base a una prioridad que

327
00:29:51,220 --> 00:29:53,019
le doy yo. ¿Cómo le doy la prioridad?

328
00:29:53,319 --> 00:29:59,779
O por Natural Ordering, o sea, esto implementa Comparable y por lo tanto yo sé

329
00:29:59,779 --> 00:30:04,400
cómo ordenarlos, o con un Comparator.

330
00:30:04,400 --> 00:30:07,400
Ese Comparator pues lo veremos dentro de poco.

331
00:30:07,400 --> 00:30:12,779
Si? dudas hasta aquí.

332
00:30:12,779 --> 00:30:21,640
Trash and prevent queue no ordena los elementos de manera FIFO, vale?

333
00:30:21,640 --> 00:30:32,700
Es un FIFO por orden, en este caso Fast In Fast Out va del más ordenado, del más importante,

334
00:30:32,700 --> 00:30:34,200
del que tenga más prioridad.

335
00:30:34,200 --> 00:30:36,500
Como se define la prioridad?

336
00:30:36,500 --> 00:30:37,500
Con comparable.

337
00:30:37,500 --> 00:30:44,569
Y entonces aquí vamos a ver lo que es la interfaz comparable.

338
00:30:44,569 --> 00:30:50,569
La interfaz comparable, en realidad, ya la hemos visto, hemos jugado un poquito con ellos.

339
00:30:50,569 --> 00:31:00,369
Es, sustancialmente, tú implementas comparable cuando quieres definir un orden natural de los objetos que estás creando.

340
00:31:00,369 --> 00:31:11,730
Por ejemplo, los strings implementan comparable y su orden natural es alfabético, léxico-gráfico.

341
00:31:11,730 --> 00:31:21,869
O sea que A viene antes de BBB y AB viene después de A, pero antes de BBB, ¿sí?

342
00:31:22,349 --> 00:31:24,730
La orden natural de la cosa.

343
00:31:25,210 --> 00:31:29,049
Los números, integer, ¿tienen una orden natural integer?

344
00:31:32,579 --> 00:31:34,140
Ahora menor, A mayor, ¿vale?

345
00:31:34,759 --> 00:31:37,039
Ahora, gato, ¿tienen una orden natural gato?

346
00:31:41,680 --> 00:31:43,859
En principio no, ¿vale?

347
00:31:44,259 --> 00:31:52,819
Pero yo puedo hacer que mi gato implemente un compareable, entonces estoy forzado a poner compare to,

348
00:31:52,819 --> 00:32:03,819
y en este compare to definir cómo se ordenan los gatos, por tamaño, por nombre, por lo que sea, hasta con varios parámetros.

349
00:32:04,960 --> 00:32:11,519
Yo podría decir, los gatos se ordenan por tamaño, y si dos tienen el mismo tamaño, pues por nombre.

350
00:32:11,519 --> 00:32:14,299
y lo codifico yo

351
00:32:14,299 --> 00:32:16,519
implementando este método aquí

352
00:32:16,519 --> 00:32:18,200
¿sí? recordáis

353
00:32:18,200 --> 00:32:19,980
este método aquí da un positivo

354
00:32:19,980 --> 00:32:21,759
si el objeto actual

355
00:32:21,759 --> 00:32:24,539
es mayor que el especificado

356
00:32:24,539 --> 00:32:25,859
o sea que he pasado por parámetros

357
00:32:25,859 --> 00:32:28,039
negativo si el objeto this

358
00:32:28,039 --> 00:32:29,900
es menor que el otro

359
00:32:29,900 --> 00:32:31,759
y el mismo es igual

360
00:32:31,759 --> 00:32:33,619
tened en cuenta también que con per tu

361
00:32:33,619 --> 00:32:36,119
tiene que ir de la manita con equals

362
00:32:36,119 --> 00:32:37,480
¿sí?

363
00:32:38,279 --> 00:32:39,940
en el sentido que

364
00:32:39,940 --> 00:32:41,859
si dos

365
00:32:41,859 --> 00:32:43,579
objetos dan

366
00:32:43,579 --> 00:32:45,740
equals true, tienen

367
00:32:45,740 --> 00:32:47,619
que dar con per tu

368
00:32:47,619 --> 00:32:50,160
cero.

369
00:32:51,319 --> 00:32:51,440
¿Vale?

370
00:32:52,000 --> 00:32:53,339
Ahora, si

371
00:32:53,339 --> 00:32:55,559
con per tu das

372
00:32:55,559 --> 00:32:58,079
cero, no necesariamente

373
00:32:58,079 --> 00:32:59,779
el equals tiene que ser

374
00:32:59,779 --> 00:33:00,920
true.

375
00:33:01,920 --> 00:33:03,980
Es una implicación en un sentido

376
00:33:03,980 --> 00:33:09,220
solo. O sea,

377
00:33:09,640 --> 00:33:10,420
equals

378
00:33:10,420 --> 00:33:13,119
igual a true.

379
00:33:13,619 --> 00:33:32,059
implica que COMPAR TÚ tenga que ser cero, pero COMPAR TÚ a cero no necesariamente implica que sea TRUE, ¿se entiende?

380
00:33:34,059 --> 00:33:40,059
Yo tengo dos gatos, si me dices, estos dos gatos son iguales, claramente cuando los comparo me tiene que dar cero.

381
00:33:40,059 --> 00:33:46,059
Pero si yo tengo dos gatos, que hemos dicho que lo mencionamos por la tamaña, y son dos gatos completamente distintos,

382
00:33:46,059 --> 00:33:50,059
pero este gato aquí son tres kilos, este gato aquí son tres kilos también,

383
00:33:50,059 --> 00:33:58,059
pues el Compertú me daría cero, porque no hay uno antes que el otro, porque en la Orden Natural me dirían que están igual,

384
00:33:58,059 --> 00:34:04,069
pero no son el mismo elemento, entonces igual me daría falso.

385
00:34:04,069 --> 00:34:09,070
Lo que yo tengo que comprobar es esta cosa de aquí, estar seguro de esto.

386
00:34:09,070 --> 00:34:22,190
Cuando toco el COMPARE TO, tengo que estar seguro que esto valga, esto no, esto no lo tengo que comprobar porque puede ser o puede no ser, ¿sí?

387
00:34:23,610 --> 00:34:25,969
Estas cosas van siempre, van un poquito de la manita.

388
00:34:26,110 --> 00:34:34,210
Cuando yo toco COMPARE TO, voy a mirar también el EQUALS, cuando voy al EQUALS voy a mirar también el LASH CODE, van un poco todos en el mismo saco.

389
00:34:34,409 --> 00:34:38,690
Cuando toco estas cosas, estaría bien que tocaran todas las cosas, ¿sí?

390
00:34:38,690 --> 00:34:43,030
ejemplo de comparable, aquí tenemos persona

391
00:34:43,030 --> 00:34:45,110
pues entonces tenemos un compareTo

392
00:34:45,110 --> 00:34:46,289
a personaO

393
00:34:46,289 --> 00:34:48,949
fijaos que comparable tiene un tipo genérico

394
00:34:48,949 --> 00:34:50,489
si uso comparable a secca

395
00:34:50,489 --> 00:34:52,510
pues esto sería un object

396
00:34:52,510 --> 00:34:53,489
¿vale? sería esto

397
00:34:53,489 --> 00:34:55,670
object

398
00:34:55,670 --> 00:34:58,429
si pero yo digo que implementas

399
00:34:58,429 --> 00:35:00,570
comparable y le pongo el específico

400
00:35:00,570 --> 00:35:02,590
tipo genérico string o gato

401
00:35:02,590 --> 00:35:04,269
o lo que sea, pues entonces

402
00:35:04,269 --> 00:35:06,489
este object se me transforma en el objeto

403
00:35:06,489 --> 00:35:07,250
de esta persona

404
00:35:07,250 --> 00:35:13,130
Por ejemplo, aquí implemento comparable con tipo genérico persona, ¿lo veis?

405
00:35:13,730 --> 00:35:16,289
Pues entonces aquí es compare to de persona.

406
00:35:16,590 --> 00:35:19,769
Me evita de pillar un object y preguntarme, ¿es una persona?

407
00:35:19,929 --> 00:35:23,150
Sí, si es una persona, haz un downcasting a persona.

408
00:35:23,409 --> 00:35:24,150
Ya lo he hecho.

409
00:35:25,510 --> 00:35:28,630
Entonces aquí, por ejemplo, es el resultado de cero.

410
00:35:28,929 --> 00:35:32,369
Si this.edad es mayor que o.edad, el resultado es uno.

411
00:35:32,369 --> 00:35:54,960
Si this.edad es mayor que o.edad es lo mismo. Esto debería ser al revés. Esto es un typo. Si

412
00:35:54,960 --> 00:36:01,159
es mayor, dale 1. Si es menor, dale menos 1. Y si no retorna, que es a 0, entonces son la misma.

413
00:36:01,159 --> 00:36:11,690
Esto, por ejemplo, está asumiendo que las personas se ordenan por edad.

414
00:36:11,690 --> 00:36:15,929
Una vez que yo he definido que se puede ordenar por edad, por ejemplo, si uso una Priority

415
00:36:15,929 --> 00:36:22,719
Queue, pues pondrá primero los niños y el último los viejos, a menos que no inverta

416
00:36:22,719 --> 00:36:33,960
aquí uno y menos uno, y entonces me pondrá antes los viejos y luego los niños.

417
00:36:33,960 --> 00:36:37,340
Dejamos los set para el siguiente.