Saltar navegación

Queue - Contenido educativo

Ajuste de pantalla

El ajuste de pantalla se aprecia al ver el vídeo en pantalla completa. Elige la presentación que más te guste:

Subido el 11 de febrero de 2026 por Stefano C.

2 visualizaciones

Más información Transcripción

Descargar la transcripción

Voy a grabar esta clase, por lo tanto, si habláis me autorizáis a grabar vuestra voz, ¿vale? 00:00:00
Entonces, en las otras últimas clases hemos visto algo de estructuras dinámicas, ¿vale? 00:00:06
Estructuras que pueden aumentar o disminuir su tamaño sin que yo tenga que pensar en ello, ¿vale? 00:00:16
los pobres arrays que son una cosa que se utilizaba principalmente antes entre comillas 00:00:23
pues tenían este problema que eran siempre estáticos como tamaño entonces cuando tenía 00:00:30
que hacerlo más pequeño más grande tenía que no podía cambiar el array tenía que crear un 00:00:35
nuevo array y luego cambiar las referencias eso nos ha dado también una mano para entender un 00:00:40
poquito cómo funcionan las referencias vale si lo pensáis bien esto de que hay un método que 00:00:45
me hace una red más grande luego añade una cosa al final y luego me cambia el puntero al principio 00:00:51
a otro pues es una cosa interesante porque estoy utilizando las referencias estos elementos que 00:00:59
son fundamentales en la programación orientada a objetos vale en java es que a veces perdemos 00:01:04
de vista en el sentido de que no lo hemos pensado que no nos ha no lo hemos interiorizado pero que 00:01:16
tenéis que entender bien la diferencia entre una variable que contiene un valor y una variable que 00:01:26
contiene una referencia un objeto porque cambia completamente la forma con la que luego se 00:01:32
utilizan estas variantes vale entonces en la nueva ya hablamos pero la que vemos hoy un 00:01:38
poco más en detalle es la que o sea la coda vale la cola la cola es digamos una estructura que 00:01:47
implementa el concepto de fifo first in first out vale entonces en una lista son parecidas 00:01:57
De hecho una linked list hace también de queue, ningún problema. Simplemente lo que cambia son 00:02:04
los métodos que utilizo. Mientras en la lista yo puedo añadir, remover y puedo hasta añadir en el 00:02:12
medio o remover o pillar un elemento del medio, la cola tiene que implementar algunos métodos 00:02:18
que garantizan que el comportamiento es fijo. Entonces, yo por debajo puedo tener una lista, 00:02:27
un ArrayList o un LinkedList, pero lo quiero utilizar de una forma específica. No lo quiero 00:02:35
utilizar con... Sustantemente, me impido de utilizar los métodos como el de pillar un 00:02:44
elemento en el medio, de remover un elemento en el medio o añadir un elemento en el medio. Que 00:02:51
las listas permiten, pero la cura no tiene que permitir. Si yo me voy a la interfaz de Q, los métodos específicos 00:02:55
de la Q son de añadir al final y pillar desde el principio. Si yo hago una lista como la que 00:03:03
hicimos nosotros, porque la implementación que hicimos nosotros al final hacía funcionar la lista 00:03:11
prácticamente como una cola, porque nosotros cuando el get en realidad pillamos la posición, 00:03:16
aquí el getter no debería 00:03:24
tener una posición, es sólo 00:03:27
inserta y pilla 00:03:28
si tú insertas ya sabes 00:03:30
que vas a insertar al final de la cola 00:03:33
y pilla no tienes que especificarle 00:03:34
qué elemento pillar o qué elemento 00:03:36
en qué posición pillarlo 00:03:38
porque sabes que seguramente será el primero 00:03:40
de la cola 00:03:42
para garantizar que haga 00:03:43
¿me seguís? 00:03:46
¿sí? ¿dudas? 00:03:48
en fin, el primer elemento se elimina 00:03:53
primero, el último elemento se elimina por último. Los elementos se añaden a una fila de la coda, 00:03:55
pueden contener elementos duplicados. Otra cosa importante, como la lista, si yo añado dos veces 00:04:00
el mismo elemento, entonces se añade dos veces. El mismo elemento tanto considerado como igual 00:04:06
igual, o sea, si inserto literalmente el mismo objeto, como si inserto dos objetos que si lo 00:04:11
comparara con el equal se me daría true pero igualmente entran los dos 00:04:19
los principales operaciones son en colar o tener siguiente vale añadir a la cola 00:04:27
o pillar el siguiente estas son las dos operaciones que debería utilizar está 00:04:32
claro que si yo tengo una linked list por debajo vale y entonces podría 00:04:37
también funcionar como lista y a mitad de mi programa en vez de utilizar esto 00:04:44
dos métodos, uso el método que me pilla, el tercer elemento, pues entonces no estoy usando una POP. 00:04:49
¿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 00:04:56
tengo son add, element, offer, pick, poll y remove. Son estos. Si os fijáis, los remove, los poll, 00:05:20
los pick, no tienen un parámetro. Tú no puedes remover el primero, el tercero. Tú dices remueve 00:05:31
y él removerá el primero de la columna. Tú puedes decir añade un elemento, pero no puedes decir 00:05:42
en generalmente en tercera posición. Entonces, si yo voy a mirar una linked list, 00:05:49
veo que linked list que implementa Q, pero implementa también otras cosas, 00:06:03
tendrá las dos. Tendrá por un lado la add a secas, que lo añade a la final de la 00:06:17
lista, pero también tendrá el add en esta posición de este elemento. 00:06:24
Entonces, si yo en un código, vale, si yo en colecciones, hay ejemplos en colecciones, 00:06:32
Si yo tengo una clase, una clase red-blue, y aquí tengo un main, si yo hago linked list 00:07:15
de string. Lista. Alt. Es igual a new linked list de string. Así. Pues cuando yo hago 00:07:31
algo, punto, pues aquí me da la posibilidad de utilizar esto, el add de string, que sostancialmente 00:07:55
me añadiría una string al final de la lista, pero me da la posibilidad también de añadirlo 00:08:04
a nivel de segunda posición o tercera posición. Esto me daría como un marco de peligrosidad, 00:08:09
porque si me equivoco a usar el método, pues no lo estaría usando como una queue. 00:08:18
Entonces, ¿cómo podría evitar esto? Pues forzando que este señor sea una queue. Por debajo sigue 00:08:24
siendo una linked list y como linked list implementa queue, pues puedo usarlo como queue. 00:08:38
Pero ahora, si yo hago algo punto, solo me aparecen los métodos relacionados con la queue, 00:08:43
no con una linked list que estarán implementados en linked list pero ahora yo no tengo no tengo 00:08:52
el add de string en una cierta posición porque que uno lo tiene y su referencia no obstante su 00:09:01
instancia sea una linked list que es una queue y es también una list y es también otras cosas pues 00:09:07
yo les estoy diciendo sí pero tú considéramela como si fuera una call por lo tanto ahora no 00:09:13
tengo problemas de utilizarlo mal. Ahora no puedo insertar algo en posición 3 porque no tengo ese 00:09:18
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? 00:09:26
No existe el constructor de cola porque Q es una interfaz. 00:09:47
No puede hacer un new queue, porque no existe queue. 00:09:55
Es una interfaz, no se puede hacer una, como si fuera una clase abstracta. 00:09:59
No puede hacer una new de queue. 00:10:04
O sea, hay que construir una interfaz, pero el intervicio sería una implementada. 00:10:05
Esta es una clase que implementa esta interfaz. 00:10:12
Por lo tanto, yo no puedo hacer new queue, porque no puede hacer una new de una interfaz. 00:10:17
pero así puede hacer una new linked list 00:10:22
ahora esto como objeto es una linked list 00:10:25
va a usar los métodos de linked list 00:10:28
pero si yo aquí le pongo linked list 00:10:29
él utilizará esta referencia 00:10:32
como un objeto de tipo 00:10:34
linked list, entonces me dará todos los métodos 00:10:36
posibles de linked list 00:10:38
si yo lo quería usar como una queue 00:10:39
me expongo al problema de que pueda 00:10:41
utilizar algún método que una cola 00:10:43
no podría 00:10:46
entonces con esto 00:10:46
en un cierto sentido protejo 00:10:49
voy a proteger esta cosa 00:10:51
diciendo, no, mira, cuando uso algo 00:10:54
voy a utilizar solo métodos de queue 00:10:56
¿podría utilizarlo en LinkedList? 00:10:58
sí, yo aquí puedo hacer un 00:11:00
downcasting a LinkedList tranquilamente 00:11:02
porque es un objeto de LinkedList y utilizar 00:11:04
su cosa, pero me estoy ayudando a mí 00:11:06
como programador, para evitar 00:11:08
de usar métodos que no debería 00:11:10
porque si los uso ya no es una cola 00:11:12
pues entonces digo, no, no 00:11:14
la llamo como una cola, sé que esto lo implementa 00:11:16
por lo tanto 00:11:18
todo lo que hace una cola lo puede hacer linked list podrá hacer también otras cosas más esas 00:11:20
cosas no la quiero usar para estar seguro que estoy utilizando algo pasado mañana además si 00:11:25
yo esto hago todas las cosas con el gato tranquilamente si mañana esto lo cambio con 00:11:31
una implementación distinta de cola pues me va a funcionar el resto del programa igualmente 00:11:42
porque no he hecho nunca referencia 00:11:48
a métodos específicos de linked list 00:11:51
siempre he hecho métodos específicos de queue 00:11:53
entonces cualquier clase 00:11:55
que implemente queue, incluida la 00:11:57
mía, o sea, si yo me hago una mía 00:11:59
clase, que se llama mi 00:12:01
no, se llama 00:12:02
my queue 00:12:04
entonces 00:12:05
la puedo poner aquí 00:12:10
si implementa queue 00:12:12
dudas 00:12:14
y el linked list 00:12:16
implementa queue y implementa list. Y si implementaría list, el add sería de list, no de list. 00:12:17
El add te daría igual porque queue lo tiene el add y también list tiene el add. 00:12:26
Pero no se guardaría de la forma, no se añadiría de la forma en que se añade un add. 00:12:37
Vamos a verlo. List ¿qué me dice? Cuando yo implemento el add de list me dice 00:12:41
appends the specified element to the end of the list. Entonces, en este caso tengo suerte porque 00:12:46
tanto lo que me dice la interfaz list como lo que me dice la interfaz queue coinciden. Es añadirla al final. 00:12:54
Tiene sentido, cuando tú añades una lista no la añades al principio, la añades al final. Luego, la lista te incluye 00:13:01
otras cosas que tú dices, no, yo lo puedo insertar al principio. Lo pones aquí. Si tú haces add 0 de un 00:13:07
elemento, pues lo añado al principio en vez que al final. Vale, fenomenal, pues hazlo como quieras. Pero el 00:13:16
add normal coincide con el otro. Entonces, yo implemento un add, en realidad lo estoy tirando de 00:13:22
dos lados, porque list me obliga a implementar add y también queue me obliga a implementar add. 00:13:28
Pero si te fijas, son el mismo idéntico método. Pillan los mismos variables, pillan las mismas 00:13:39
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. 00:13:46
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? 00:13:57
Depende. Esa es una refactorización del código. 00:14:11
¿Por qué no quieres que sea una cola y que sea una lista? 00:14:15
Claro que puedes. O sea, tú mañana entras aquí, aquí en vez de Q pones list y ahora 00:14:20
pregas, rezas, que no haya problemas. 00:14:31
Porque a lo mejor ahora has usado algunos métodos que en Q si existían, entonces lo 00:14:36
podías usar y que ahora en list ya no existen y por lo tanto ya no puedes usar. Por ejemplo el 00:14:43
pick. Si tú has usado pick por algún lado, pues ahora te explota porque te dice una lista no tiene pick. 00:14:48
Pero si tú tenías una juegue, tampoco. No la hemos visto antes. Ah, pero con esto. Lista. Porque esto de mirar 00:14:56
el primer elemento de la lista 00:15:15
es típico de una cola 00:15:19
¿vale? porque tú dices, oye mira 00:15:21
quiero ver cuál es el siguiente elemento 00:15:22
en base a eso hacer una cosa u otra 00:15:25
pero en una lista no 00:15:26
¿vale? no está pensado la lista 00:15:28
si tú quieres habrá otro método 00:15:31
para hacer eso ¿vale? 00:15:33
entonces, claro, si tú de repente 00:15:34
cambias, tienes un problema serio 00:15:37
de diseño, porque tú habías diseñado 00:15:39
para que fuera una queue 00:15:41
y ahora de repente es una list 00:15:43
por qué 00:15:45
no porque te ha dado la gana 00:15:46
porque has hecho un error en el diseño 00:15:49
has visto que las funcionalidades 00:15:51
que te daba la queue no eran 00:15:53
suficientes o no eran adaptas para 00:15:55
todo tu tipo de programa, pero has hecho un problema 00:15:57
tuyo, entonces ahora tienes que 00:15:59
dedicar tiempo en 00:16:00
pillar todo lo que has hecho 00:16:02
y transformarlo en una queue, se puede hacer 00:16:05
si yo quiero hacerlo todavía más 00:16:06
amplio, pues pongo collection 00:16:08
ahora por ejemplo, el collection pick no está 00:16:10
pero si yo uso los métodos 00:16:17
de collection, luego a mí me da 00:16:19
igual que tú uses aquí 00:16:22
una linked list, una queue, una list 00:16:23
lo que te da la gana 00:16:26
va a funcionar porque collection está por arriba de todos 00:16:27
y solo en los métodos 00:16:30
que he utilizado por collection lo voy a encontrar 00:16:34
en toda la lista, en todos los 00:16:35
pero no los propios 00:16:37
de list, no los propios de queue 00:16:39
de hecho collection 00:16:41
tiene un add, remove 00:16:43
y poco más 00:16:46
¿Sí? ¿Entiendes? 00:16:46
O sea, que esto es un poco jugar 00:16:50
con entender lo que yo 00:16:52
quiero y, no obstante, 00:16:54
yo tenga una implementación por debajo 00:16:56
que sea específica 00:16:58
de una cosa, pues luego aquí 00:17:00
la enmascaro en lo que yo 00:17:02
quiero de verdad para que funcione como yo quiero. 00:17:04
¿Vale? Podría dejarme 00:17:07
libertad. 00:17:08
Sí, yo podría poner aquí esto 00:17:10
y ahora 00:17:12
está a mi programador 00:17:14
Utilizar los métodos correctos 00:17:16
Para que sea una cola 00:17:18
O los métodos correctos para que sea una lista 00:17:19
Pero puedo usar los dos 00:17:22
¿Por qué? 00:17:25
LinkedIn List implementa las dos cosas 00:17:26
¿Vale? 00:17:28
Es como si hubiese perdido en un cierto sentido 00:17:29
La ayuda que me da él 00:17:32
A decir, oye mira me has dicho que tienes que ser FIFO 00:17:34
Vale, te garantizo yo que seas FIFO 00:17:36
Porque los métodos que te ponga a disposición 00:17:38
Solo funcionan FIFO 00:17:40
Ahora no, ahora tienes todos los métodos 00:17:41
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. 00:17:44
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. 00:17:54
Pero es peligroso, es un pequeño problema de diseño. No se programa sin saber que se tiene que hacer. 00:18:10
Es un mecanismo que hacemos nosotros porque estamos a un nivel muy bajo de pruebas, pero tú 00:18:33
normalmente la primera parte de un problema de un proyecto es el diseño tú piensas en lo que tiene 00:18:39
que hacer entonces mientras estás pensando sin haberlo implementado porque el cómo se hace es 00:18:44
distinto del que sea tú sabes que tienes un método que te hace esto un método que te hace y allí 00:18:50
piensa se dice soy mira estos datos de aquí viene en este orden tengo que mantener el orden por si 00:18:54
me viene bien el cifro pues entonces implementas esa por aquí a nivel de diseño que luego te das 00:19:00
cuenta que no que no que necesitabas otra cosa vale pero tiene que ser a nivel de diseño en el 00:19:06
momento en que quien ha hecho el diseño ya lo pasa a los programadores para que lo hagan pues 00:19:10
vosotros tenéis que hacer lo que ve allí tú lo que no puedes hacer es si tu jefe de comillas 00:19:15
el diseñador el design ha dicho esto tiene que ser un club pues le pongo linked list porque así 00:19:21
ve pues tienen que seguir las indicaciones que está o si tú eres el design te esperas que la 00:19:26
gente siga las indicaciones que te he prestado. Tú das poquitopi. Vale. También, vale, existe la 00:19:32
DEC. Creo que se pronuncia DEC. Vale, que es una Double Ended Queue. Una queue con dos finales. 00:19:44
Si me voy a ver DEC, es otra interfaz donde hay métodos, pero además de la ADD a secas, 00:19:53
que es la ADD de la cuba normalmente, tengo un ADD first y un ADD last. O sea que puedo acceder a 00:20:10
los dos extremos de la cola. Puedo añadir delante, añadir detrás, remover delante, remover detrás. 00:20:16
Puedo, es sustantivamente que fuera una cola que puedo recorrerla en los dos sentidos. 00:20:23
En determinados contextos, pues esto puede ser útil. Entonces, si os fijáis, es lo mismo que 00:20:28
antes, tiene la misma cosa, solo que añade un first y un last por cada cosa. Antes tenía pick, 00:20:42
ahora tengo pick first y pick last. Antes tenía poll, ahora tengo poll first y poll last. Pick 00:20:48
que es para mirar pero no lo quita paul lo mira el primer objeto y lo quita de la lista de la 00:20:55
pica mira el primer elemento en que a lo mejor se entiende mejor o sea este aquí añade un 00:21:11
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. 00:21:19
Offer, me dice, pick retrieves but does not remove the head of the cue. Sostancialmente igual a esto. 00:21:33
Ahora devuelve nulo si la Q es empty. Si la Q está vacía me devuelve nulo. 00:21:48
Este de aquí no lo sé qué hace. Por nulo es de QM. Es igual. No, este es por. Remove. 00:21:54
Si la cola está vacía, pues lanzo una infección. No sacio elemento externo. 00:22:06
¿Vale? La diferencia entre... No, perdón. Estoy mirando. ¿Dónde está el elemento? El elemento. Sí. 00:22:11
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. 00:22:18
lo mismo, idéntico, peak, la diferencia es cuando es null. Si tú llamas element y la queue es empty, 00:22:41
o sea, no tiene elemento, te lanza una excepción. Entonces la puedes pillar con un try-catch. 00:22:53
Mientras que la peak te devuelve null. Siempre te devuelve algo, nunca explota, pero te devuelve null 00:22:57
si no hay una cabeza de la palabra. ¿Se entiende? 00:23:05
O sea, en el momento, si lo usas cuando hay algo dentro de ti. 00:23:10
No, puedes usar los dos cuando te dé la gana. Solo que reaccionas distinto cuando está vacío. 00:23:16
Este de aquí, si yo uso pic, yo haría ring primero. 00:23:24
Es igual a algo.pic, no lo he quitado de la pila. Y aquí debería hacer, si primero es null, haz algo. 00:23:37
Si no, haz otra cosa. Esta como se te dice a pic. Si uso element, nunca será null. 00:23:51
Porque no me devuelve nunca null. Lo que puede ser, pero hay que explote. Por lo tanto, lo uso así. 00:24:03
Trae la cosa aquí, captcha, no such element exception, aquí, no such element Q, vacía, 00:24:09
y aquí hago algo, si yo intento pillar el primero y lo que hace es explotar porque está 00:24:32
vacía y entonces no lo puede hacer, pues entrará aquí y haré lo que antes hacía 00:24:43
hay en el si es no dos formas son dos hacen lo mismo pero hay un comportamiento ligeramente 00:24:47
distinto que tú tú eliges cuál usar y vale de cara a una una una chica 00:24:55
vale la de que existe la situación esta es la que vale que hereda de 00:25:04
colección si es una interfaz vale la deck hereda de que vale y añade con las de esta cosa aquí vale 00:25:20
y hay varias implementaciones y yo quiero saber cuáles son las implementaciones de que aquí viene 00:25:33
todas las las implementaciones conocidas de esta clase o sea todas las clases que implementan esto 00:25:40
Esto es AbstractQueue, ArrayBlockingQueue, ArrayDeck, DaylightDeck, LinkedTransferQueue... 00:25:48
Todo eso son implementaciones de esta interfaz. 00:25:58
En particular nosotros usamos esta porque es la más fácil. 00:26:01
Sabemos que, por ejemplo, ArrayList no implementa Queue. 00:26:04
¿Hay una Queue basada sobre Arrays en vez que sobre objetos del linkador? 00:26:09
pues probablemente esta, la ArrayDec. La ArrayDec es una cola de doble fin, como Array. 00:26:16
Entonces si uso esta de aquí, por debajo estoy usando Arrays, y si uso esta de aquí, por debajo estoy usando 00:26:30
Enlazar, con las ventajas y desventajas que hemos visto de utilizar Array y utilizar objetos 00:26:34
en la sala. 00:26:39
Sí, también está Priority Queue, 00:26:41
por ejemplo, ¿vale? 00:26:43
Como ejemplos que vemos nosotros, están 00:26:44
por un lado una Priority Queue y por otro 00:26:47
lado la Raydeck, ¿vale? 00:26:49
La Raydeck es una implementación 00:26:50
de la DEC, también la Linked 00:26:53
List es una implementación de DEC, 00:26:55
entonces si tenéis que usar una DEC, podéis 00:26:57
usar estas dos cosas, ¿vale? 00:26:59
Y la Priority Queue es una implementación 00:27:01
de Queue con prioridad, una cola 00:27:03
con prioridad, que vosotros habéis visto, por ejemplo, 00:27:05
sistemas, ¿vale? 00:27:07
Los de procesos, de 00:27:11
gestionar 00:27:13
cuál proceso se ejecuta. 00:27:14
Pues probablemente esa es una cola 00:27:18
con prioridad, porque 00:27:19
tienen procesos con más prioridad que otros 00:27:21
y antes se ejecutan los que 00:27:23
tienen más prioridad. Cuando los de 00:27:25
más prioridad no hay ninguno, pues 00:27:27
se pasa a prioridad más baja. Si los de 00:27:29
bajos por mucho tiempo no 00:27:31
son ejecutados, pues 00:27:33
se le aumenta la prioridad para que antes o 00:27:35
Entonces, pues, esto es una forma de hacer el scheduling o no sé qué hacer, ¿sí? 00:27:37
Entonces, podemos ir a ver, ¿no? 00:27:45
Preview. 00:27:49
Esto molaría que vosotros, cuando hablamos de estas cosas, queue, Preview, ArrayList, 00:27:50
os vayáis aquí y os leáis estas cosas, ¿vale? 00:28:02
estas son informaciones técnicas que os describen qué es cada cosa, para que luego vosotros en un 00:28:06
futuro sepáis qué es cada cosa y sepáis dónde buscar la información que os suene. De esto una 00:28:12
vez lo he leído, estaba... Probablemente habrá una versión en castellano. Si no copiáis esto, 00:28:17
lo pegáis a ChatGPT o Gemini o whatever y le decís no traduces y ya está. Entonces, 00:28:23
Pues aquí tenéis los constructores, añadir, contains, iterator, es muy parecido, por algún 00:28:33
lado debería haber una prioridad, habría que leerlo bien. 00:28:43
Insert priority queue, es prácticamente como una queue, debería haber algo por algún 00:28:55
lado. 00:29:12
esto luego se basará sobre un orden, la Priority Queue asume que los objetos que tú le estás 00:29:13
poniendo dentro sean comparables entre ellos y entonces lo va a añadir pero no necesariamente 00:29:24
al principio, más lo va a añadir en la correcta prioridad. 00:29:39
Sí, es que sustancialmente es como si me ordenara esta bola en base a una prioridad que 00:29:45
le doy yo. ¿Cómo le doy la prioridad? 00:29:51
O por Natural Ordering, o sea, esto implementa Comparable y por lo tanto yo sé 00:29:53
cómo ordenarlos, o con un Comparator. 00:29:59
Ese Comparator pues lo veremos dentro de poco. 00:30:04
Si? dudas hasta aquí. 00:30:07
Trash and prevent queue no ordena los elementos de manera FIFO, vale? 00:30:12
Es un FIFO por orden, en este caso Fast In Fast Out va del más ordenado, del más importante, 00:30:21
del que tenga más prioridad. 00:30:32
Como se define la prioridad? 00:30:34
Con comparable. 00:30:36
Y entonces aquí vamos a ver lo que es la interfaz comparable. 00:30:37
La interfaz comparable, en realidad, ya la hemos visto, hemos jugado un poquito con ellos. 00:30:44
Es, sustancialmente, tú implementas comparable cuando quieres definir un orden natural de los objetos que estás creando. 00:30:50
Por ejemplo, los strings implementan comparable y su orden natural es alfabético, léxico-gráfico. 00:31:00
O sea que A viene antes de BBB y AB viene después de A, pero antes de BBB, ¿sí? 00:31:11
La orden natural de la cosa. 00:31:22
Los números, integer, ¿tienen una orden natural integer? 00:31:25
Ahora menor, A mayor, ¿vale? 00:31:32
Ahora, gato, ¿tienen una orden natural gato? 00:31:34
En principio no, ¿vale? 00:31:41
Pero yo puedo hacer que mi gato implemente un compareable, entonces estoy forzado a poner compare to, 00:31:44
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. 00:31:52
Yo podría decir, los gatos se ordenan por tamaño, y si dos tienen el mismo tamaño, pues por nombre. 00:32:04
y lo codifico yo 00:32:11
implementando este método aquí 00:32:14
¿sí? recordáis 00:32:16
este método aquí da un positivo 00:32:18
si el objeto actual 00:32:19
es mayor que el especificado 00:32:21
o sea que he pasado por parámetros 00:32:24
negativo si el objeto this 00:32:25
es menor que el otro 00:32:28
y el mismo es igual 00:32:29
tened en cuenta también que con per tu 00:32:31
tiene que ir de la manita con equals 00:32:33
¿sí? 00:32:36
en el sentido que 00:32:38
si dos 00:32:39
objetos dan 00:32:41
equals true, tienen 00:32:43
que dar con per tu 00:32:45
cero. 00:32:47
¿Vale? 00:32:51
Ahora, si 00:32:52
con per tu das 00:32:53
cero, no necesariamente 00:32:55
el equals tiene que ser 00:32:58
true. 00:32:59
Es una implicación en un sentido 00:33:01
solo. O sea, 00:33:03
equals 00:33:09
igual a true. 00:33:10
implica que COMPAR TÚ tenga que ser cero, pero COMPAR TÚ a cero no necesariamente implica que sea TRUE, ¿se entiende? 00:33:13
Yo tengo dos gatos, si me dices, estos dos gatos son iguales, claramente cuando los comparo me tiene que dar cero. 00:33:34
Pero si yo tengo dos gatos, que hemos dicho que lo mencionamos por la tamaña, y son dos gatos completamente distintos, 00:33:40
pero este gato aquí son tres kilos, este gato aquí son tres kilos también, 00:33:46
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, 00:33:50
pero no son el mismo elemento, entonces igual me daría falso. 00:33:58
Lo que yo tengo que comprobar es esta cosa de aquí, estar seguro de esto. 00:34:04
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í? 00:34:09
Estas cosas van siempre, van un poquito de la manita. 00:34:23
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. 00:34:26
Cuando toco estas cosas, estaría bien que tocaran todas las cosas, ¿sí? 00:34:34
ejemplo de comparable, aquí tenemos persona 00:34:38
pues entonces tenemos un compareTo 00:34:43
a personaO 00:34:45
fijaos que comparable tiene un tipo genérico 00:34:46
si uso comparable a secca 00:34:48
pues esto sería un object 00:34:50
¿vale? sería esto 00:34:52
object 00:34:53
si pero yo digo que implementas 00:34:55
comparable y le pongo el específico 00:34:58
tipo genérico string o gato 00:35:00
o lo que sea, pues entonces 00:35:02
este object se me transforma en el objeto 00:35:04
de esta persona 00:35:06
Por ejemplo, aquí implemento comparable con tipo genérico persona, ¿lo veis? 00:35:07
Pues entonces aquí es compare to de persona. 00:35:13
Me evita de pillar un object y preguntarme, ¿es una persona? 00:35:16
Sí, si es una persona, haz un downcasting a persona. 00:35:19
Ya lo he hecho. 00:35:23
Entonces aquí, por ejemplo, es el resultado de cero. 00:35:25
Si this.edad es mayor que o.edad, el resultado es uno. 00:35:28
Si this.edad es mayor que o.edad es lo mismo. Esto debería ser al revés. Esto es un typo. Si 00:35:32
es mayor, dale 1. Si es menor, dale menos 1. Y si no retorna, que es a 0, entonces son la misma. 00:35:54
Esto, por ejemplo, está asumiendo que las personas se ordenan por edad. 00:36:01
Una vez que yo he definido que se puede ordenar por edad, por ejemplo, si uso una Priority 00:36:11
Queue, pues pondrá primero los niños y el último los viejos, a menos que no inverta 00:36:15
aquí uno y menos uno, y entonces me pondrá antes los viejos y luego los niños. 00:36:22
Dejamos los set para el siguiente. 00:36:33
Materias:
Programación
Niveles educativos:
▼ Mostrar / ocultar niveles
  • Formación Profesional
    • Ciclo formativo de grado superior
      • Primer Curso
Autor/es:
Stefano Chiesa
Subido por:
Stefano C.
Licencia:
Reconocimiento - No comercial
Visualizaciones:
2
Fecha:
11 de febrero de 2026 - 11:48
Visibilidad:
Clave
Centro:
IES ROSA CHACEL
Duración:
36′ 37″
Relación de aspecto:
1.78:1
Resolución:
1920x1080 píxeles
Tamaño:
307.24 MBytes

Del mismo autor…

Ver más del mismo autor

EducaMadrid, Plataforma Educativa de la Comunidad de Madrid

Plataforma Educativa EducaMadrid