Saltar navegación

20260303 Examen24feb_ejer2_2 - 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 3 de marzo de 2026 por Raquel G.

1 visualizaciones

Más información Transcripción

Descargar la transcripción

Vale, el planificador se llama plan, pues venga, vamos a ejecutar uno, otro y otro, vamos a ejecutar tres. 00:00:01
Se supone que hemos ejecutado tres, vamos a mirar los que quedan pendientes y los que hay ahora en ejecución, a ver si este ejecutar se ha hecho bien. 00:00:20
Venga, pues vamos a volver a mirar los pendientes, vamos a volver a copiar, la verdad es que esto es tan feo que si luego lo vamos a subir para que quede bonito. 00:00:29
voy a agregar un método que sea 00:00:34
listar procesos pendientes y otro listar 00:00:37
procesos en ejecución y ya está 00:00:39
entonces voy a agregar 00:00:40
aquí un método que sea 00:00:43
listar 00:00:45
pendientes, no sé si 00:00:47
el ejercicio lo pedía 00:00:49
si, había uno listar ejecución 00:00:50
si, pero listar ejecución 00:00:53
ordenando, no, voy a 00:00:55
hacer uno listar ejecución tal cual, ese lo hacemos luego 00:00:57
voy a hacerme un 00:00:59
auxiliar listar pendientes 00:01:01
y este auxiliar, listar pendientes, es este código de aquí, este código, que corto y meto aquí, listar pendientes, listar pendientes, le tengo que pasar de este planificador, de este, claro, listar pendientes de este planificador, vale, este método mío auxiliar, 00:01:03
Me lista todos los procesos pendientes 00:01:33
Del planificador este que yo le pasé aquí 00:01:36
Y ahora vamos a hacer uno de lista en ejecución 00:01:38
Sin orden y sin nada 00:01:41
Para hacer comprobaciones 00:01:42
Qué aburrida estás, ¿verdad? 00:01:44
Es que me miras con una cara de aburrimiento 00:01:47
Pero forma parte de la vida, ¿eh? Aburrirse 00:01:49
Vale, vamos a lista en ejecución 00:01:52
Procesos 00:01:57
Ejecu 00:01:59
Oye 00:02:01
No, no, era que no te metieras con él 00:02:03
Claro, efectivamente 00:02:10
Perdona que soy hija de Madero 00:02:11
Hace el favor 00:02:13
¿Sí? 00:02:16
A todos, alguien, a ver 00:02:18
Tienes que ser hija de alguien 00:02:19
Siempre, ¿no? 00:02:22
Pues a mí me ha tocado eso 00:02:23
Procesos en ejecución 00:02:25
Plan punto ejecución 00:02:29
ejecución 00:02:32
vale, pues venga 00:02:35
ya tengo estos dos métodos que lo único que 00:02:37
hacen es listar los pendientes 00:02:39
y listar en ejecución 00:02:41
de este planificador, voy a llamarlo 00:02:42
aquí antes de la ejecución y 00:02:44
después voy a llamar a los 00:02:46
pendientes 00:02:48
pendientes 00:02:50
de este planificador 00:02:57
si no le pongo un static 00:02:59
pues voy mal 00:03:02
Vale 00:03:03
Vale 00:03:06
Y ahora después de haber ejecutado 3 00:03:11
Voy a volver a listar 00:03:13
Los pendientes que me han quedado 00:03:15
Y los que están en ejecución 00:03:16
También 00:03:20
A ver si hay 3 en ejecución y en pendientes 00:03:21
3 menos 00:03:24
Venga, vamos a por este main 00:03:25
Después de ejecutar 3 00:03:31
A ver 00:03:32
Vale, primero hemos añadido 00:03:34
Los 10, aquí están, ordenados 00:03:40
Que feo esto 00:03:42
Ah, es que debo tener 00:03:57
En ejecutar 00:04:02
Debo tener dentro de ejecutar 00:04:05
Debo tener algún 00:04:06
Ah, claro, es que en ejecutar tenía este for dentro 00:04:07
Perdón, entonces claro, me sale mil veces 00:04:10
Fuera 00:04:12
Vale, ahora 00:04:13
Siguiente intento 00:04:16
Venga, los 10 primeros añadidos 00:04:18
Muy bien, muy ordenaditos 00:04:21
Como tenía que ser 00:04:22
Por prioridad y duración 00:04:23
Vale, ahora he ejecutado tres, se supone que son estos, porque los va sacando por orden de prioridad, con lo cual, ¿cuáles me han quedado como pendientes? Los de abajo, todos menos estos, esos son los pendientes que me han quedado. 00:04:25
¿Y cuáles tengo como ejecución? 00:04:42
Pues tengo estos 00:04:44
El 8, el 3 y el 7 00:04:45
Que bendita casualidad 00:04:50
Que el listado de procesos en ejecución 00:04:51
Está en orden de prioridad 00:04:54
También 00:04:56
¿Por qué? 00:04:56
¿Por qué me han salido 00:05:01
En ese orden tan bonito? 00:05:02
Claro, porque he hecho un 00:05:05
Treeset 00:05:06
Si yo lo cambio a esto y lo hago a 00:05:07
haset, pues me van a salir 00:05:10
de cualquier manera 00:05:14
vale 00:05:15
vamos a ver a ejecutarlo 00:05:17
ahora cambiándolos a un haset 00:05:19
yo no tengo que cambiar nada en mi aplicación 00:05:21
si es que da igual, funcionan igual 00:05:23
de puertas para afuera 00:05:24
ahora 00:05:27
procesos pendientes, aquí magníficos 00:05:29
ahora me han quedado 00:05:32
después de ejecutar 00:05:35
tres 00:05:37
Estos son los que me han quedado pendientes 00:05:38
Estos son en ejecución 00:05:44
Que como veis, no me los ha mostrado por orden 00:05:46
Porque este 00:05:50
Ah bueno, o si 00:05:51
Están por orden 00:05:53
Yo creo que ha sido 00:05:57
De puñetera casualidad 00:05:59
Porque los pide 00:06:01
Pero ha sido de casualidad 00:06:02
En ejecución 00:06:04
Yo estoy mandando a ejecutar 00:06:07
Añadiendo a un hashet 00:06:08
Estoy añadiendo un headset 00:06:10
Y se van añadiendo de cualquier manera 00:06:12
¿Vale? 00:06:14
No, es que lo he cambiado 00:06:16
Ahora, para ver que ahora ya me saca de cualquier manera 00:06:17
Entonces 00:06:20
No, al headset tú vas añadiendo 00:06:21
Y van cayendo en el conjunto en cualquier lado 00:06:27
Y cuando twitteres 00:06:29
Van saliendo de cualquier manera 00:06:30
Imaginaos que voy a 00:06:32
Añadirlos todos 00:06:36
A ver si 00:06:38
Que no me respete el orden 00:06:40
Voy a añadir 9, he añadido 9 ahora 00:06:43
Venga, he añadido 9 00:06:45
En prioridad se me ha quedado solo 1 00:06:48
Y efectivamente 00:06:53
Estos en ejecución 00:06:55
Están mostrados de cualquier manera 00:06:57
¿Vale? No van por orden de prioridad 00:06:59
Van de cualquier manera 00:07:01
¿Vale? De hecho me ha mostrado el del 4 00:07:02
Antes que el 9, que no debería 00:07:05
¿Vale? Entendida, ¿no? 00:07:07
La diferencia en realidad crítica 00:07:08
Entre el HACET y el otro 00:07:11
Vale 00:07:13
Ay, jolines 00:07:16
¿Qué método nos falta ahora? 00:07:18
Ahora ya sí 00:07:26
Nos vamos al comparador 00:07:27
Listar ejecución 00:07:29
Lista de procesos que se están ejecutando ordenados 00:07:31
Entonces 00:07:34
Método listar ejecución 00:07:36
Ejecución, ejecutar ya lo tenemos aquí, vamos a listar ejecución, listar ejecución, este método tiene que listar todos los que están en ejecución ordenados por pip. 00:07:39
si nos dijeran 00:08:05
ordenados por su orden natural 00:08:07
lo único que habría que hacer 00:08:10
es lo que hemos hecho antes, cambiar esto 00:08:13
a triset 00:08:15
e iterar, ya está 00:08:16
está claro, ¿no? 00:08:19
si este enunciado habría sido 00:08:20
mostrar los procesos que están ejecutando 00:08:22
ordenados por su orden de prioridad 00:08:25
el del comparable 00:08:27
pues listar ejecución sería este mismo 00:08:28
que hemos hecho, este 00:08:31
iterar sin más 00:08:33
cambiando este a triset 00:08:34
Ya lo tendríamos 00:08:36
Ya lo tendríamos 00:08:37
Pero en este caso ya sabemos que 00:08:39
Iteramos 00:08:45
Por el conjunto 00:08:47
De procesos en ejecución 00:08:50
El orden que me va a salir es el de comparable 00:08:51
Entonces, soluciones 00:08:54
Podemos hacer 00:08:56
Un montón de cosas, en realidad 00:08:58
Tenemos millones de maneras de abordar esto 00:08:59
A ver, una manera que se nos ocurre 00:09:01
Hombre, como el trip set tiene 00:09:06
La maravillosa ventaja 00:09:08
que me los mete ordenados 00:09:09
por el orden que yo le diga 00:09:12
pues los procesos en ejecución 00:09:14
que sea un triset 00:09:16
¿vale? 00:09:18
esto es lo más cómodo de hacer 00:09:23
oye, voy a meterlos en ejecución 00:09:24
ya que me pides un listado ordenado 00:09:26
maravilloso, triset 00:09:28
me va ordenando 00:09:30
pues un triset, magnífico 00:09:31
pero ojo, ya hemos visto 00:09:34
lo acabamos de ver 00:09:36
que si yo hago un triset 00:09:38
el orden con el que me los va a sacar 00:09:40
cuando itere es este. 00:09:42
¿Vale? 00:09:45
Pero yo quiero otro. 00:09:46
Pues entonces, vamos a hacer un triset 00:09:48
pero le vamos a decir, oye, 00:09:50
para ti, triset, cuando tú insertes, 00:09:52
inserta en este otro 00:09:55
orden que yo te doy. 00:09:56
No en el propio de los procesos, inserta en otro. 00:09:57
Entonces, si tú insertas en otro, 00:10:01
cuando yo recorra los procesos en ejecución, 00:10:02
te van a seguir con ese orden. 00:10:05
Esa sería la opción más sencilla. 00:10:07
¿Vale? 00:10:09
repito, como lo que yo tengo que 00:10:10
listar ordenado 00:10:12
es este set de aquí 00:10:13
pues me hago un triset y así 00:10:16
ya al iterar me sale ordenado 00:10:18
¿qué problema tengo aquí si me hago un triset sin nada? 00:10:20
que me va a salir ordenado 00:10:23
cuando itere, está claro, pero me va 00:10:24
a salir ordenado según este 00:10:26
comparable, y ese no lo 00:10:28
puedo cambiar, porque ese es el que usa 00:10:30
el agregar proceso para que estén todos 00:10:32
ordenados, no lo puedo cambiar 00:10:34
¿cómo soluciono este pequeñito 00:10:36
problema? Pues al triset 00:10:38
le digo, oye tú, no uses el 00:10:40
orden que tiene ese por defecto, 00:10:42
sino usa un criterio 00:10:45
que yo te doy aquí. 00:10:46
Y aquí es donde entra el comparator. 00:10:48
¿Vale? Aquí es donde entra. 00:10:51
¿Qué era el comparator? 00:10:53
El comparator era un criterio 00:10:54
de ordenación. No era 00:10:57
un rol, un papel que tiene 00:10:58
que jugar una entidad. Es un criterio 00:11:00
de ordenación. Pues en este 00:11:02
caso vamos a hacer un criterio de ordenación 00:11:05
para asignárselo a triset 00:11:07
y que ordene según ese criterio. 00:11:09
Vale, pues podría hacer yo aquí una clase 00:11:12
anónima de una serie de historias que no 00:11:13
hemos visto y nos hemos metido. 00:11:15
Vamos a hacerlo más fácil. 00:11:17
¿Qué es un criterio de ordenación? 00:11:19
Pues un criterio de ordenación es una clase 00:11:21
aparte, completamente aparte. 00:11:23
Eso es un criterio de ordenación. 00:11:25
Pues venga, 00:11:28
vamos a hacernos una clase. 00:11:29
Criterio de orden... 00:11:31
¿Qué? 00:11:32
A ver, pero en el contexto 00:11:37
que tú me estabas preguntando 00:11:44
que era para hacer métodos auxiliares 00:11:45
cosas 00:11:48
Si me lo preguntaste 00:11:48
en relación a esto 00:11:54
es que yo te veo 00:11:55
No, no, no, no, no pasa nada 00:11:56
y de hecho lo ideal sería hacerlo aquí 00:12:06
como una clase anónima 00:12:08
que no sabemos todavía lo que es 00:12:10
es que como este criterio de aquí 00:12:11
solo vale 00:12:13
para meterlo aquí dentro 00:12:14
solo vale para meterlo aquí dentro, es que 00:12:16
en realidad en Java no haría ni falta 00:12:19
hacer una clase para él, yo a la vez 00:12:21
que lo instancio, lo 00:12:23
declaro, y eso es hacer una clase anónima 00:12:25
pero bueno, eso lo dejamos ahí 00:12:27
flotando 00:12:28
si, tú lo harías como una clase 00:12:32
dentro del mismo fichero, supongo 00:12:35
no pasa nada, lo que pasa es que no podrían ser las dos 00:12:37
public, pero no pasa nada cuando sean las dos public 00:12:39
que en el mismo fichero 00:12:41
no puede haber dos clases 00:12:44
públicas, porque como el fichero 00:12:45
tiene que llamar como la clase pública 00:12:48
Yo lo que hice fue implementar 00:12:50
el proceso comparable y comparado 00:12:55
Ah, vale 00:12:57
que la propia clase 00:12:59
proceso además era criterio de 00:13:01
comparación, raro pero sí 00:13:03
A ver, raro 00:13:05
porque proceso se supone que 00:13:07
tiene su uso, que es yo soy un proceso 00:13:08
me describo patatín, no soy un 00:13:10
criterio, pero bueno, que también 00:13:13
puede funcionar como criterio si presenta comparator 00:13:14
también funciona como criterio, vale, es una solución 00:13:16
es una forma de sobrevivir muy digna 00:13:19
y muy elegante 00:13:21
vale, pues 00:13:22
venga, para que esto sea 00:13:25
un criterio 00:13:27
sea un criterio, tiene que 00:13:28
implementar 00:13:30
comparator 00:13:32
porque comparator es la interfaz 00:13:34
que tienen que implementar todos aquellos que quieran 00:13:38
ser criterio de 00:13:41
ordenación 00:13:42
vale, este criterio de ordenación 00:13:43
que va a ordenar entre sí 00:13:47
va a ordenar procesos 00:13:48
pues venga 00:13:50
si va a ordenar procesos 00:13:52
el comparator que sea de proceso 00:13:54
y ahora 00:13:57
si esto es un criterio de ordenación 00:13:59
que va a ordenar procesos 00:14:02
necesita implementar 00:14:04
el método de comparator 00:14:07
que es este 00:14:09
entonces este es un método 00:14:11
Que te compara este proceso 00:14:13
Con este otro 00:14:16
Este con este 00:14:17
Y te dice cual va antes 00:14:19
Pues aquí si queremos que vayan ordenados por pit 00:14:21
Pues esto sería 00:14:24
O uno punto get pit 00:14:26
Menos 00:14:28
O dos punto get pit 00:14:29
Vale, esto es un criterio de ordenación 00:14:34
Es un criterio 00:14:37
Que va por libre 00:14:38
Esto no es un papel 00:14:40
De ser comparable 00:14:43
que lo juega un proceso 00:14:44
que él es comparable con otro 00:14:47
y que por tanto 00:14:49
tienes que compare tú 00:14:50
esto es un criterio de prioridad 00:14:52
un criterio de ordenación entre procesos 00:14:54
¿ese criterio para qué me vale? 00:14:56
pues para entregárselo a gente 00:14:58
para que ordene según ese criterio 00:14:59
para entregárselo a gente 00:15:01
¿vale? pues ¿a qué gente se lo puede entregar? 00:15:02
pues por ejemplo al triset 00:15:06
por ejemplo al triset 00:15:07
se lo puede entregar y decir 00:15:09
oye tú 00:15:11
ordena 00:15:11
según este criterio 00:15:14
ala, ya está 00:15:18
ahora mi triset es un conjunto 00:15:22
que cuando yo le meta los procesos 00:15:24
los va a ordenar según este 00:15:26
criterio que yo lo estoy pasando 00:15:28
¿vale? ignorando por tanto 00:15:29
el papel de comparable 00:15:36
que tiene este, ignorando 00:15:38
lo va a ordenar según este 00:15:39
el triset 00:15:42
lo va a ordenar según ese 00:15:44
con lo cual ahora mi listar ejecución 00:15:45
este de aquí, este que yo he hecho aquí 00:15:49
Listar ejecución 00:15:51
Ya está, me los va a sacar por ese orden 00:15:53
Vamos a verlo 00:15:56
Entonces este que he dejado aquí vacío 00:16:01
Es que no tengo ni que hacerlo porque ya lo tenía hecho 00:16:02
Este ya lo tengo hecho, es el que he hecho antes 00:16:04
Vamos a ver 00:16:07
Estos son los procesos pendientes 00:16:11
Inicialmente 00:16:16
Ordenados por prioridad, muy bien 00:16:17
Ejecutado 9 00:16:20
Me ha quedado esto 00:16:23
Y ahora, los de ejecución 00:16:24
Efectivamente me salen 00:16:27
ordenados por pit 00:16:28
me salen ordenados por pit 00:16:30
los de ejecución 00:16:33
me salen ordenados por pit 00:16:34
porque los he ido metiendo 00:16:37
cada vez que los ejecutaba 00:16:38
cada vez que los ejecutaba 00:16:40
los he ido metiendo 00:16:43
a un triset 00:16:44
los he ido metiendo a un triset 00:16:45
cuyo criterio de ordenación 00:16:49
es ese 00:16:51
pues entonces si yo 00:16:52
ya me salen ordenados por ahí 00:16:54
Es que es otra idea distinta 00:16:56
Vale 00:17:10
A ver, tú puedes decir 00:17:12
Oye, este además de comparable 00:17:15
Que además simplemente 00:17:16
Comparator 00:17:18
Lo que hizo él para no hacer una clase aparte 00:17:20
Vale 00:17:23
Entonces 00:17:24
Entonces tendrías que implementar el compare aquí 00:17:26
Tendrías que implementar el compare 00:17:29
Y luego aquí le pasarías el, le pasarías el new planificador, te va a funcionar igual, lo que pasa es que tu diseño del proyecto, de la aplicación es muy fea y muy chunga, porque proceso es un proceso, proceso no es un criterio de comparación, es un proceso, ¿vale? 00:17:31
es un proceso 00:17:54
y tiene su uso 00:17:58
y no es un criterio de comparación 00:18:00
entonces proceso es un proceso 00:18:01
que puede ser comparable con otros 00:18:04
etcétera 00:18:06
pero no es un criterio de comparación 00:18:07
entonces estás como mezclando ideas 00:18:09
que lo hace todo como más complejo de entender 00:18:12
pero entiendes que en realidad 00:18:14
funcionaría igual porque 00:18:16
este proceso ahora aparte de ser un proceso 00:18:17
también es un criterio 00:18:20
de comparación por libre 00:18:22
vale 00:18:24
entonces bueno, podrías, pero es más 00:18:26
como más feo 00:18:28
entonces 00:18:29
entonces, mejor que quede 00:18:32
aparte, esto, su objetivo, ser 00:18:47
criterio de comparación, pues se queda aparte 00:18:49
claro, es cierto que 00:18:51
estamos haciendo una clase 00:18:53
solo para esto 00:18:54
que es muy poquito, entonces una clase 00:18:56
solo para esto, es muy poquito 00:18:59
pero por eso existe 00:19:01
el concepto de clase 00:19:03
anónima 00:19:05
que se llama 00:19:06
¿vale? 00:19:08
que eso está una buena oportunidad para mencionarlo 00:19:10
porque ahora 00:19:12
la ventaja de la IA es que vosotros 00:19:13
le preguntáis cosas y él los resuelve 00:19:16
cosas muy estupendamente 00:19:18
o pseudo estupendamente 00:19:20
pero claro, os va sacando muchas cosas 00:19:21
pues que no conocéis, que tenéis que averiguar 00:19:24
hay millones de cosas 00:19:26
entonces pues muchas cosas 00:19:28
las hará con clases anónimas 00:19:30
¿vale? ¿qué es una clase anónima en realidad? 00:19:31
¿en qué situación nos pide el cuerpo 00:19:34
con una clase anónima? 00:19:36
Pues cuando tienes que usar un objeto 00:19:38
¿vale? para pasárselo a otro 00:19:39
pero es que solo lo usas ahí 00:19:42
solo lo vas a usar ahí 00:19:44
ese objeto. Entonces solo lo usas 00:19:45
para hacer news de ese objeto, para hacer news 00:19:48
luego ese objeto nunca vuelves a acceder 00:19:50
para cambiarle propiedades ni para hacer 00:19:52
nada. Con ese objeto solo quieres 00:19:54
hacer un new para pasárselo a otro 00:19:56
y ya está, y de ese objeto 00:19:58
ya no vale para nada más. Luego ese objeto 00:20:00
no es como alumno, tú creas un alumno 00:20:02
alumno a new alumno 00:20:04
y luego con ese alumno a le pones la edad 00:20:05
le haces no se cuantos 00:20:07
pero en este ejemplo 00:20:09
este objeto comparador 00:20:11
solo lo queremos 00:20:14
solo lo queremos 00:20:16
para instanciarlo y pasárselo 00:20:17
a este 00:20:20
y nunca jamás vamos a 00:20:20
acceder a ese objeto para nada 00:20:23
ni hacer nada más con él ni nada 00:20:25
entonces estamos aquí 00:20:27
declarando una clase 00:20:29
que aparece ahí en la aplicación 00:20:30
que en estos proyectos 00:20:33
que tienen 10 clases no pasa nada 00:20:35
pero un proyecto normal que tiene 00:20:36
10.000, pues hombre 00:20:39
hacer una más, pues que 00:20:40
pereza, ¿no? Entonces ahí podría 00:20:43
entrar el concepto de clase anónima 00:20:45
que es 00:20:47
en el momento en el que yo 00:20:49
instancio un objeto, que en este 00:20:51
caso sería aquí 00:20:53
sería aquí 00:20:54
en el momento en el que yo lo instancio 00:20:58
en ese momento 00:21:01
voy además a declarar la clase 00:21:02
voy a declararla porque es cortita y pequeñita 00:21:04
voy a declararla aquí a la vez que la instancia 00:21:07
y no la pongo ni nombre 00:21:09
me limito a declararla 00:21:11
es decir, meto aquí 00:21:13
este código 00:21:14
que es un código pequeñito 00:21:16
meto ahí ese código 00:21:19
y ya está, con lo cual 00:21:21
no necesito una clase aparte 00:21:22
lo meto ahí ese código 00:21:25
y no le doy ni nombre 00:21:26
por eso se llama anónimo 00:21:28
¿Vale? Entonces 00:21:31
Estos países se me hacen más grandes 00:21:33
Quedaría una cosa 00:21:35
Como esta 00:21:37
Quedaría una cosa como esta 00:21:39
New 00:21:50
Comparator 00:21:54
De proceso 00:21:59
Y aquí 00:22:01
Me haría 00:22:04
Yo proceso 00:22:10
Y aquí me hago 00:22:14
el método este 00:22:17
vale 00:22:19
y aquí 00:22:28
triset new comparator 00:22:30
proceso 00:22:35
aquí 00:22:36
me faltará un punticom algo en algún sitio 00:22:38
donde me sale el 00:22:41
el rojo este 00:22:43
tokens 00:22:45
comparator procesos 00:22:46
o será esto que me falta, ah, estos paréntesis me faltaban 00:22:49
vale 00:22:51
esto es una clase anónima 00:22:52
no asusta, no tiene que asustaros 00:22:54
no pasa nada 00:22:57
entonces, fijaos 00:22:57
yo tengo que pasarle a triset 00:23:01
algo que implemente esto 00:23:03
puedo hacerme 00:23:05
una clase que implementa eso 00:23:07
hacer su código 00:23:09
y luego aquí instanciarlo 00:23:11
vale 00:23:13
pero hombre, ya es otra clase aparte 00:23:14
si total 00:23:18
solo la uso 00:23:19
es muy pequeñita 00:23:21
solo la uso aquí, no es una entidad de mi aplicación 00:23:23
no es una entidad de mi aplicación 00:23:26
que entre mi jerarquía de clases 00:23:28
ni nada, solo la uso 00:23:30
aquí, para instanciarla y pasárselo 00:23:32
ya está, pues en el momento de 00:23:34
instanciarla, en el momento de instanciarla voy a declararla 00:23:36
vale, en el momento de instanciarla 00:23:38
la declaro, entonces yo pongo 00:23:40
oye tú, que voy a instanciar, vale 00:23:42
¿qué vas a instanciar? vas a instanciar 00:23:43
una instancia que implementa esto 00:23:46
que implementa 00:23:48
esto, no le das ni nombre 00:23:50
no le das ni nombre 00:23:52
y aquí entre llaves 00:23:53
pones el código de esa clase 00:23:55
ya está, pones el código 00:23:58
bueno, pues si lo hacemos así, nos ahorramos 00:23:59
la otra clase 00:24:04
entonces las clases anónimas se usan un montón 00:24:04
en realidad, cuando tienes que pasar 00:24:09
una instancia de un objeto a alguien 00:24:11
ese objeto 00:24:13
pertenece a una clase cortita 00:24:15
pequeñita 00:24:17
pues la declaras en el momento de pasársela 00:24:19
y no tienes que tener esa clase aparte todo el rato 00:24:22
eso sí, si lo estás haciendo 00:24:24
todo el rato, pues repetir 00:24:26
esto mil veces, es un poco 00:24:28
tonto repetirlo mil veces 00:24:30
pues entonces ya te la haces aparte y ya está 00:24:31
pero aquí, que solo 00:24:34
la vamos a usar aquí, pues la declaro aquí 00:24:36
a la vez que la instancia y se acabó 00:24:38
¿vale? bueno, pues 00:24:43
¿en dónde? 00:24:44
sí, efectivamente 00:24:54
claro, sí, cada vez 00:24:56
que tú tienes que pasar una instancia 00:24:58
de algo a alguien 00:25:00
una instancia de un objeto, pues 00:25:01
lo puedes pasar como new 00:25:04
eso que he implementado y declaro en ese 00:25:05
momento, ¿vale? Siempre 00:25:07
lo que pasa es que si la clase es muy larga 00:25:09
no lo haces, porque entonces te queda 00:25:11
entre paréntesis una declaración 00:25:13
muy larga, porque si la clase tiene muchas cosas 00:25:15
no lo haces, ¿vale? Pero para cosas como 00:25:17
esta, sí que lo haces 00:25:19
esto sería con 00:25:21
clase 00:25:28
anónima 00:25:29
bueno, para que 00:25:32
ya no os asuste cuando lo veáis, ¿vale? 00:25:34
Que lo veréis mucho si le pedís cosas a las IAS. 00:25:37
Vale. 00:25:42
Y prácticamente 00:25:44
se ha acabado el ejercicio, ¿no? Ah, bueno, nos falta 00:25:45
este. 00:25:47
Bueno, este otro. Si no lo habéis hecho 00:25:48
con un triset dándole 00:25:50
criterio de ordenación, 00:25:53
pues se puede hacer de muchas maneras. 00:25:55
También se puede hacer, pues 00:25:57
eso, paso 00:25:58
mi conjunto, yo no puedo 00:26:00
ordenar un conjunto, no puedo hacer de ese conjunto 00:26:02
hacer un sort, no puedo 00:26:05
porque los conjuntos no pueden ordenarse 00:26:07
pero puedo hacerme 00:26:09
una lista, una lista 00:26:11
nueva limpia, añadir 00:26:13
con add all todos los 00:26:15
de ese conjunto, añadirlo y ordenar 00:26:17
esa lista con ese criterio y ya está 00:26:19
esa sería otra forma sencilla 00:26:20
de hacer ese método 00:26:23
de hacer el método de volver lista 00:26:24
ordenada, añadirlos 00:26:27
todos a una lista nueva, todos 00:26:29
los del conjunto de ejecución 00:26:31
y ahora ya esa lista llamarla 00:26:32
ordenarla con sort, con el criterio 00:26:35
nuevo. Y 00:26:37
si no habéis hecho un triset, pues esa sería 00:26:40
la manera. Y ahora ya el último que nos 00:26:42
queda. El abortar proceso 00:26:47
este de aquí. Y aquí me falta 00:26:49
esto. 00:26:57
Y me sobra esto. 00:27:00
No, algo me falta aquí. 00:27:03
Este de donde está cerrando. 00:27:05
New triset. 00:27:09
Como que no está 00:27:10
Ah vale, me falta 00:27:17
No, no, no 00:27:18
La clase anónima esta 00:27:25
Que hay aquí algo que 00:27:27
No estoy haciendo bien 00:27:28
Este, no, no es este 00:27:30
Es este de aquí 00:27:38
No sé que me falta aquí 00:27:40
Ah, me faltaba importar el comparator este. Vale, vale, me faltaba importar... Vale, ya está. Vale, estaba bien. Bueno, pues el otro método que nos faltaba, el de abortar proceso. Aquí. Voy... Eliminar por PID. 00:27:46
Vale, pues este es 00:28:20
Eliminar 00:28:29
De la lista de ejecución 00:28:33
De procesos, es decir 00:28:39
Esto idealmente sería 00:28:40
Ejecución 00:28:42
Remove 00:28:44
Vale, aquí 00:28:49
Cuidado 00:29:01
Para eliminar por 00:29:04
PID 00:29:06
A ver, ¿qué os ocurre? 00:29:06
Como vamos a acabar ahora 00:29:11
Luego ya que haga las preguntas que sean 00:29:16
¿Vale? Pero vamos a intentar acabar 00:29:18
Porque esto que viene aquí también es importante 00:29:19
Si tú haz como que haces caso 00:29:22
Vale, a ver, cuidado 00:29:25
Aquí esto es eliminar por pit 00:29:28
Entonces aquí nos llama, nos pide un remove 00:29:30
Cuidado, depende de si yo he hecho 00:29:32
Triset o haset 00:29:35
Si este fuera 00:29:36
Un haset 00:29:39
Ningún problema 00:29:40
Porque yo tengo un hash set de equal 00:29:43
Por 00:29:45
Pit 00:29:47
¿Vale? 00:29:48
Luego si la estructura fuera un hash set 00:29:50
¿Dónde está el? 00:29:53
Aquí 00:29:55
Si ejecución 00:29:55
Si ejecución 00:30:00
Fuera hash set 00:30:02
Esto me vale 00:30:05
Me hago un proceso con ese pit 00:30:07
Y listo 00:30:09
Y lo mando a borrar 00:30:10
Proceso 00:30:12
p.setPid 00:30:18
newProceso 00:30:21
con cualquier valor 00:30:29
me da lo mismo, vale 00:30:31
vale, es decir 00:30:33
si los métodos en ejecución 00:30:35
estuvieran en un hashSet 00:30:37
esto es suficiente 00:30:38
porque remove me va a borrar 00:30:41
uno igual a este 00:30:43
e igual a ese significa 00:30:46
igual en pid, porque el hashSet 00:30:47
mira el hasco de equals que está hecho por pid 00:30:49
vale, ningún problema 00:30:51
si yo quiero borrar un proceso con ese pit 00:30:53
y lo he hecho con un haset 00:30:56
y he puesto el hasco de equals por pit 00:30:58
ya estaría 00:31:01
pero si yo lo he hecho con triset 00:31:02
para hacer esto de la ordenación 00:31:05
pasarle un criterio de ordenación 00:31:08
y que me lo saque yo ordenado 00:31:10
o lo he hecho un triset porque me ha dado la gana 00:31:11
lo que sea 00:31:13
si los procesos en ejecución 00:31:13
ejecución 00:31:22
fuera 00:31:27
Triset 00:31:31
Lo de arriba 00:31:34
No vale 00:31:36
¿Verdad que lo de arriba no vale? 00:31:38
¿Por qué? Porque si yo he hecho un triset 00:31:48
Ah bueno 00:31:49
Vale si le he dado, depende 00:31:51
Vale 00:31:53
En función del criterio que yo le haya puesto 00:31:54
De comparación 00:31:57
Como le he puesto por pi 00:31:58
Para el triset 00:32:01
La igualdad es por pi 00:32:03
Luego valdría también 00:32:04
¿Vale? 00:32:06
Valdría también 00:32:08
Si el criterio que usara el triset 00:32:09
Si el criterio que usara el triset 00:32:12
Fuera este 00:32:14
Fuera este, el de 00:32:15
Prioridad y duración, no valdría 00:32:20
Luego esto que he puesto aquí 00:32:22
A ver 00:32:23
¿Dónde está aquí? 00:32:25
Aquí, esto de aquí 00:32:29
Fuera triset 00:32:33
Funcionaría 00:32:34
Solo si el criterio 00:32:37
De ordenación del triset fuera por pit 00:32:42
Si no, no. Luego, si el criterio de ordenación del triset de ejecución, si el criterio fuera pit, lo de arriba también funciona. Lo de arriba también funciona porque el triset mira la igualdad por el criterio de ordenación. 00:32:44
que yo he hecho un triset con un criterio de ordenación 00:33:09
no por pip 00:33:15
es decir, si yo he hecho un triset sin esto 00:33:16
con lo cual el criterio de ordenación 00:33:21
es este de aquí, el del comparable 00:33:24
que es esto otro 00:33:27
no puedo borrar así 00:33:29
no puedo borrar de esta manera 00:33:30
Entonces 00:33:36
Si no es el caso 00:33:40
Pues como borro 00:33:42
Pues borro con el iterador y ya está 00:33:43
Siempre podré borrar así 00:33:46
Me hago un iterator 00:33:49
De proceso 00:33:51
Ejecución 00:33:52
Punto 00:34:01
Iterator 00:34:02
Vale, y ahora ya sí 00:34:07
Mientras haya un siguiente sobre el que 00:34:10
Iterar 00:34:17
Si ese en el que estoy posicionada 00:34:18
su pit 00:34:23
es igual 00:34:25
que el que me han dicho 00:34:27
este 00:34:29
es igual que el que me han dicho 00:34:31
pues lo puedo borrar 00:34:33
a través del iterador sin problema 00:34:34
y ya está 00:34:37
esto me va a funcionar siempre 00:34:39
para borrar por pit 00:34:41
al margen de si tengo un haset 00:34:43
un triset, un list, da igual 00:34:45
me va a funcionar siempre 00:34:47
bueno y con esto habría terminado el ejercicio 00:34:48
a ver hemos 00:35:03
sacado muchas pequeñas cosas, 00:35:06
pero una versión básica se podría hacer 00:35:08
con muy poca cosa. 00:35:10
A pesar que hemos aprovechado, pues bueno, 00:35:16
para comentar muchas cosas en paralelo 00:35:19
y todo eso. Pero 00:35:20
hasta aquí 00:35:22
todo esto tiene que estar muy suelto y muy fluido. 00:35:24
¿Vale? 00:35:28
Tiene que estar suelto y fluido. 00:35:29
Para que podamos seguir 00:35:31
incorporando 00:35:34
Materias:
Programación
Niveles educativos:
▼ Mostrar / ocultar niveles
  • Formación Profesional
    • Ciclo formativo de grado superior
      • Primer Curso
Subido por:
Raquel G.
Licencia:
Todos los derechos reservados
Visualizaciones:
1
Fecha:
3 de marzo de 2026 - 17:16
Visibilidad:
Clave
Centro:
IES ROSA CHACEL
Duración:
35′ 39″
Relación de aspecto:
1.78:1
Resolución:
1920x1080 píxeles
Tamaño:
157.21 MBytes

Del mismo autor…

Ver más del mismo autor

EducaMadrid, Plataforma Educativa de la Comunidad de Madrid

Plataforma Educativa EducaMadrid