Saltar navegación

20250206 Ejercicio Simple LinkedList - 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 6 de febrero de 2025 por Stefano C.

16 visualizaciones

Más información Transcripción

Descargar la transcripción

Entonces voy a grabar este ejercicio, si por si acaso habláis, me autorizáis a grabar vuestra voz. 00:00:00
Entonces vamos a hacer un pequeño ejercicio sobre uso de listas y cosas por el estilo. 00:00:07
El ejercicio va sobre un cine, en el que se hace una lista de personas que quieren entrar en el cine. 00:00:13
Entonces luego miraremos esta lista y veremos qué hacemos con ella. 00:00:22
y vamos calculando para cada persona que está en la cola para entrar en el cine 00:00:28
el precio de su billete en base a la edad que tiene, ¿vale? 00:00:34
Un cine en un pueblo pequeño nos propone hacer una aplicación 00:00:42
para controlar las personas de una cola de un cine en los grandes estrenos de la película. 00:00:46
Usa una implementación de lista enlazada creada por ti. 00:00:52
Esto aquí no lo hacemos creado por nosotros, ya lo hemos creado, el otro día usamos una lista enlazada normal y así lo probamos. 00:00:55
Un conjunto de personas esperan la cola para sacar una entrada. 00:01:06
Tendremos que calcular el coste de la entrada según la edad de las personas, que sea mínimo 5 años. 00:01:10
La edad de las personas se genera naturalmente entre 5 y 60 años. 00:01:18
Os recomiendo utilizar un método del main 00:01:22
Al final, deberemos mostrar la cantidad total recaudada 00:01:24
El número de personas de la cola se elige al azar entre 0 y 50 00:01:29
Recuerda que al final la lista debe quedar vacía 00:01:33
Una vez que una persona paga, su entrada ya no está en la cola 00:01:37
Esto simula la cola de un cine 00:01:41
Aquí están los precios que son aleatorios y cosas por el estilo 00:01:43
Vamos a intentar hacerlo 00:01:48
Entonces, como aquí son personas, pues la primera cosa que hacemos es crear personas. 00:01:49
A ver, aquí podríamos jugar con algo en plan que haya personas, adolescentes y niños 00:01:59
y hacer que los adolescentes se reten de persona o qué sé yo 00:02:08
y que lo que cambien es el valor del precio que pagan o cosas por el estilo. 00:02:14
Pero como el ejercicio no va tanto de herencia y cosas por el estilo, 00:02:19
sino que va de lista enlazada, pues lo dejo fuera. 00:02:25
Entonces hago persona normal y corriente. 00:02:30
Una persona, lo que me interesa es la edad, principalmente. 00:02:33
Fijaos que en este contexto, el nombre de una persona, el NIF de una persona, no me interesa. 00:02:39
O sea, lo que me interesa es su edad para que sepa el precio que le tengo que cobrar. 00:02:47
Pero en mi programa, pues la clase Persona, sostancialmente, lo que me interesa de verdad es solo la edad. 00:02:53
¿Podría hacerla más compleja? Sí. 00:03:01
Pero mantenemosla lo más sencillo posible para hacer un ejercicio de utilizo de LinkedList básico. 00:03:03
entonces tendrá un 00:03:09
constructor 00:03:12
creo una persona, le pongo su edad 00:03:21
y si quiero 00:03:27
hacerla privada le pongo un get 00:03:29
vale 00:03:31
y esto es public 00:03:32
int 00:03:37
get edad 00:03:38
return edad 00:03:41
para que en cualquier momento 00:03:45
pueda saber 00:03:50
la edad de una persona 00:03:51
entonces 00:03:53
prácticamente todo va en un main 00:03:55
este ejercicio es muy sencillito 00:03:57
como ejemplo inicial 00:03:59
pues me hago mi 00:04:01
clase 00:04:03
cinema 00:04:05
entonces 00:04:08
un cinema lo que tiene 00:04:10
cinema es italiano 00:04:14
español 00:04:16
entonces 00:04:17
lo que podemos hacer 00:04:25
o crear una clase cine y luego crear un objeto cine trabajar con él o directamente hacerlo en 00:04:27
el main vale como aquí vamos a utilizar la linked list pues hagamos el main directamente luego si 00:04:33
necesitamos algún método lo haremos estático entonces la idea es que ahora yo me cree una 00:04:38
cola de personas vale entonces el primer paso sería crear una cola de persona me han dicho 00:04:44
de utilizar una lista enlazada en teoría la parte difícil entre comillas de este ejercicio sería que 00:04:50
nosotros definiremos nuestra propia lista enlazada que pero ya hemos hecho 00:04:56
entonces uso una linked list normal linked list 00:05:00
de persona o la es igual al año linked list de persona así 00:05:07
heredo esta cosa aquí 00:05:25
y ya está, perdón, importo esta cosa aquí y ya está 00:05:27
también podría hacer que como esta cola 00:05:32
la quiero llenar con números aleatorios de personas aleatorias 00:05:37
podría en vez de crearla aquí directamente, pues hacer un 00:05:41
metodito que me crea la cola nueva y me devuelva directamente 00:05:45
la cola, ¿vale? entonces esto me lo copio y simplemente 00:05:49
aquí pongo un crea 00:05:53
cola 00:05:55
este de aquí entiende 00:05:55
que tiene que devolver un linked list persona 00:06:01
por ahora devuelve null 00:06:03
pero nosotros lo que 00:06:05
haremos es 00:06:07
linked 00:06:08
list 00:06:11
de persona 00:06:12
c, vale, de cola, es igual 00:06:14
a esta cosa aquí, se la creo aquí dentro 00:06:20
y luego la devuelvo 00:06:22
así 00:06:23
Entonces lo que pasará aquí es que llamo este método, este método es el que ha encargado de crearme un cierto número de personas con un cierto número de edad cada persona, ¿vale? 00:06:25
Y luego después me devuelve este enlace aquí y aquí desde el main lo usaré. 00:06:36
¿Dudas hasta aquí? 00:06:44
Porque estoy en un entorno estático, entonces no hay un objeto. 00:06:56
Y cuando llamo un método, no puedo llamar un método sobre un objeto. 00:07:00
si yo este de aquí le quito 00:07:05
ahora Creacola lo tengo que crear sobre un objeto 00:07:07
sobre un objeto de tipo cine 00:07:10
pero como no tengo un objeto cine 00:07:11
no hay atributos en un objeto cine 00:07:14
no hay métodos propios de cine 00:07:16
yo esto lo podría hacer con cine 00:07:17
c es igual a newCine 00:07:20
y ahora aquí llamar 00:07:22
c.Creacola 00:07:26
esto es admisible porque estoy creando un cine 00:07:28
pero yo no estoy haciendo 00:07:30
una cadena de cines 00:07:32
donde creo distintos 00:07:35
cines, una rey liste de cine 00:07:37
una rey de cines 00:07:39
y luego digo, en el cine 1 00:07:40
pasa esto, en el cine 2 pasa esto, en el cine 3 00:07:42
pasa esto, ¿que lo puedo hacer? Sí 00:07:45
a lo mejor después, mejor 00:07:46
modificamos esto para que haya varios cines 00:07:48
pues lo podría hacer 00:07:51
pero por ahora, como esto es un 00:07:52
cine, es el único cine que tengo, es el cine 00:07:55
del pueblo, y gestiono 00:07:56
así, pues entonces no estoy 00:07:59
creando objetos cine 00:08:00
entonces si estoy en un entorno estático 00:08:02
pues no puede hacer el método no estático porque si no aquí no sabría sobre qué llamar 00:08:04
entonces aquí necesito una variable aleatoria vale que aquí el enunciado me decía que hay 00:08:12
entre 0 y 50 personas vale entonces int en una persona es igual a por ejemplo hago un 00:08:21
Un random o mathint de math.random multiplicado 50, 51. 00:08:34
Como es desde 0 a 50, si esto me da 0, 0 por 50 dará 0. 00:08:49
Si esto me da 0,999999, dará 50,999999. 00:09:01
Y por lo tanto, casteado a int, me lo transforma en 50. 00:09:06
Por lo tanto, esta cosa aquí me da de 0 a 50. 00:09:12
Y ahora voy a hacer este número de personas veces 1, añádeme una persona. 00:09:15
Por lo tanto, lo que haré es for int y es igual a 0 y menor que num personas. 00:09:22
Num personas y más más. 00:09:29
Esto es por 00:09:33
Nun personas veces 00:09:35
Lo que hago es 00:09:37
Añadir 00:09:39
Pues no sé dónde estaba 00:09:41
Pero bueno, sigo 00:09:44
Entonces 00:09:45
Estamos haciendo por 00:09:46
Nun personas veces, ahora tengo que crear 00:09:50
Personas y añadirlas a la cola, ¿vale? 00:09:51
Entonces por este número de veces creo una nueva 00:09:53
Persona, lo que hago es 00:09:56
Ac.add 00:09:57
New 00:09:59
Persona 00:10:01
de una cierta edad 00:10:03
ahora tengo que darle la edad 00:10:05
la edad tiene que ser un número aleatorio 00:10:07
desde 5 hasta 60 00:10:09
si no me equivoco 00:10:11
por lo tanto es 00:10:12
int 00:10:14
de math 00:10:18
punto random 00:10:21
multiplicado 00:10:23
y a esto 00:10:29
le sumo 00:10:33
random es un método 00:10:38
esto debería 00:10:41
a ver 00:10:44
esta es la paréntesis 00:10:45
esta es la paréntesis 00:10:47
de esta cosa 00:10:49
esto debería funcionar 00:10:52
entonces 00:10:53
por no sé cuantas veces 00:10:54
me añade una persona con no sé cuantos años 00:10:57
así que cada vez 00:10:59
es una cosa distinta 00:11:01
si quiero 00:11:03
al final aquí para que tenga una idea de lo que has hecho escribo en pantalla algunas cosas cola 00:11:05
hay en cola puntos como sé cuántas personas hay en cola exactos de puntos 6 personas y si quiero 00:11:14
ver la edad de las personas cómo podría hacer para para lo hacemos después porque así utilizamos un 00:11:39
poquito las listas esto me dice simplemente que hay un cierto número de personas en cola 00:11:59
vale aquí para ver la cosa puede hacer un siso de cola veo que hay 26 personas y estas son las 00:12:05
26 personas, si lo lanzo otra vez 00:12:19
ahora hay 42 personas y estas son las personas, está claro que las personas 00:12:23
no las veo, entonces para poderlas 00:12:27
ver, ¿qué hago? para que vea algo interesante de persona 00:12:31
¿qué hago? me voy a persona y hago 00:12:39
public string to string 00:12:47
return persona 00:12:52
de edad 00:13:00
años 00:13:05
entonces ahora 00:13:08
si lo lanzo veo que hay una persona de 32 años 00:13:14
una persona de 6 años 00:13:17
una persona de 60, 26 00:13:19
hay todas las personas 00:13:22
vale 00:13:25
entonces tengo mi 00:13:30
cola de personas 00:13:33
este de aquí 00:13:36
a lo mejor lo dejo allí pero 00:13:37
ahora tengo 00:13:39
lo que tengo que hacer es empezar 00:13:43
a seguir esta 00:13:45
lista, ¿vale? 00:13:47
para sustancialmente intentar 00:13:49
hacerles pagar, ¿vale? 00:13:52
en base a la edad que tienen 00:13:55
quiero que paguen más 00:13:57
o menos, ¿vale? 00:13:59
entonces tendré un int 00:14:00
recaudación 00:14:01
es igual a 0 00:14:07
al principio, y ahora por cada 00:14:10
elemento de la lista, lo que tengo que hacer es sumar el precio 00:14:13
correcto, ¿sí? Entonces, puedo hacer 00:14:17
de varias formas para hacer 00:14:21
esta cosa, ¿vale? Teniendo en cuenta también que yo quiero que al final 00:14:25
pues esta cola aquí sea vacía, ¿vale? 00:14:29
Esto representa la cola real, han venido la gente y ahora cada vez 00:14:33
que yo cobro un billete, pues esto se va de la cola, ¿sí? 00:14:37
y desaparece 00:14:40
entonces, una opción 00:14:41
sería algo como 00:14:43
we before 00:14:46
persona 00:14:51
p dos puntos cola 00:14:54
p punto 00:14:56
recaudación 00:15:02
más igual 00:15:05
vamos a verlo 00:15:09
recaudación más igual 00:15:18
p.get 00:15:20
edad, no, bueno, no, esto 00:15:25
esto debería ser el precio 00:15:27
de p.get 00:15:31
edad, ¿esto qué es? es un método que me calcula en base a la edad 00:15:36
el precio, ¿vale? entonces vamos a ver 00:15:43
este método aquí, y aquí recibo 00:15:46
un entero y devuelvo un precio vale entonces interprecio es igual a cero y 00:15:51
yo hago ahí tres franjas de edad de 5 a 10 11 17 o mayor que 18 vale entonces o 00:16:03
con un if o con switch si edad menor que 00:16:13
8, ¿cuánto era? 00:16:24
menor o igual que 10 00:16:28
precio 00:16:30
es igual 00:16:33
a un euro 00:16:35
lo que ponga aquí, ¿vale? 00:16:37
el save 00:16:40
edad mayor o igual 00:16:41
a 18 00:16:44
entonces 00:16:45
precio es igual a 00:16:48
3,5 00:16:50
era un double 00:16:53
Sí, pues este es un doble, esto será un doble, esto será 3.5, else precio es igual a 2.5. 00:16:54
vale, ahora 00:17:17
esta es una forma de hacerlo, a lo mejor es fea 00:17:20
no es muy, estaría más 00:17:23
interesante a lo mejor definir 00:17:25
franjas en una array 00:17:27
y en base a la array 00:17:29
que yo tenga, pues haga pagar 00:17:31
una cosa u otra, o hacer una estructura 00:17:33
que me diga 00:17:35
de alguna forma cuánto costa, porque esta es 00:17:36
muy hardcoded, o que 00:17:39
esto lo saque por algún lado 00:17:41
y en los precios los ponga 00:17:42
en constantes arriba 00:17:45
para que si luego lo modifico, solo tengo que modificarlo allí, 00:17:47
pues todas estas consideraciones derivan de lo que sabemos de antes de programación 00:17:49
y se pueden hacer, ¿vale? 00:17:53
Pero ahora para dejarlo muy sencillo, pues esto, ¿sí? 00:17:55
Entonces, esto me devuelve el precio en base a la edad que tiene, ¿vale? 00:17:59
Si es menor o igual que 10.1, si es mayor o igual que 18.1, 00:18:02
y si no es ni esto ni esto, quiere decir que es entre 11 y 17, 00:18:05
y por lo tanto cae aquí, ¿sí? 00:18:09
Entonces, aquí me da la recaudación. 00:18:14
Siso, cola, vamos a ver qué pasa. Lanzo, bueno, Siso, el cine gana, más recaudación, más euros. Muy sencillo, ¿sí? 00:18:17
entonces había 37 personas 00:18:46
pa pa pa, 28 euros 00:18:48
¿vale? ahora habría que comprobar si esto 00:18:50
es verdad 00:18:52
¿vale? para hacer una comprobación 00:18:52
fácil, por ejemplo, puedo 00:18:56
disminuir el 00:18:58
puedo hacer que crea cola 00:19:00
int 00:19:02
max 00:19:05
¿vale? y lo que haga 00:19:06
aquí es un int max 00:19:09
y entonces 00:19:11
aquí ponga max más 1 00:19:14
vale, de esta forma me crea 00:19:15
el número max de personas 00:19:19
cuando yo llamo aquí 00:19:21
bueno, a cola 00:19:22
en vez de int max le pongo 3 00:19:24
entonces con esto me hace una cola de 3 personas 00:19:27
de esta forma si que puedo 00:19:29
más o menos ver, bueno de 2 personas 00:19:31
porque menos 00:19:33
entonces max, que ha pasado 00:19:34
tititititititit 00:19:37
ah bueno si 00:19:40
porque no me lo hace 00:19:49
de esas personas, es un número de 1 a 3 00:19:51
Y ha elegido 2, ¿vale? 00:19:53
Ok, perfecto 00:19:55
Es aleatorio 00:19:56
Pero, de todas formas, pocas personas 00:19:57
Tengo una de 32 años y una de 10 00:19:59
Por lo tanto, esto debería pagar 3,50 euros 00:20:01
Y este de aquí, que es 10, 1 euro 00:20:05
Y esto sale 4 euros 00:20:08
Ha hecho algo raro 00:20:10
Vamos a comprobar el precio 00:20:11
Mayor o igual de 10 es 1 euro 00:20:15
Y mayor de 32 es 3,5 00:20:19
Ah, claro, porque esto he usado enteros 00:20:25
y entonces el .5 es desaparecido 00:20:26
entonces 00:20:29
la declaración tiene que ser un doble 00:20:32
vamos a ver ahora 00:20:34
ahora ya me pone 00:20:38
el .5 00:20:40
tenemos 3 personas 00:20:41
mayores de 18, 3, 6, 9 00:20:44
más 1 de 50, pues 10 y 50 00:20:46
parece que sí, después de hacer las pruebas 00:20:48
estos 9 años debería pagar 1 00:20:50
justo, más 7 00:20:54
8 euros 00:20:56
parece funcionar 00:20:57
vuelvo a poner que 00:20:59
esta aquí son 50 personas 00:21:01
y ya está 00:21:04
¿vale? pero el problema 00:21:05
es que después de la cola 00:21:08
o sea, de aquí 00:21:10
mi cola sigue con gente 00:21:13
¿vale? 00:21:15
y yo podría hacer 00:21:18
aquí ahora, vale, perfecto 00:21:20
hago, después de haberlo hecho todo 00:21:21
cola.clear 00:21:23
ya está 00:21:26
cola vacía 00:21:31
pero esto es feo 00:21:32
porque no está simulando 00:21:37
que una persona paga y se va de la cola 00:21:39
una persona paga y se va de la cola 00:21:41
¿sí? estoy más bien diciendo 00:21:42
que antes pago todos y luego se van todos 00:21:45
que es una cosa que no simula 00:21:47
lo que estamos haciendo, por lo tanto 00:21:49
hagámoslo de otra forma, que cuando uno ha pagado 00:21:50
pues se vaya 00:21:53
¿cómo hago aquí 00:21:54
para quitarle la cola? podría hacer 00:21:56
cola.remove 00:21:59
remove 00:22:02
el cola.remove 00:22:03
puede hacer dos cosas 00:22:05
o sea, tres en concreto 00:22:08
no sé si habéis visto 00:22:11
tiene un remove sin nada 00:22:12
un remove con int 00:22:17
un remove con object 00:22:19
si yo hago remove a secas 00:22:20
quita el primer 00:22:23
elemento de la lista 00:22:25
si yo hago int index 00:22:26
la persona en el índice este de aquí 00:22:30
si yo hago int object 00:22:33
pues entonces me busca este object y me lo remueve vale vamos a probar con el primero 00:22:35
pero si te fijas removeFist y remove hace lo mismo 00:22:51
porque por defecto si yo hago como el add nosotros hemos usado el add 00:22:57
sin embargo hay un addFirst y un addLast pero con add si yo uso addRemove estoy haciendo 00:23:04
ADD LAST y REMOVE FIRST 00:23:15
otra cosa interesante que podría mirar es que devuelve remove, devuelve a una persona 00:23:22
ahora vamos a ver qué pasa 00:23:35
¿Qué es esto? 00:23:46
Concurrent Modification Exception 00:23:52
El problema de esto es que nosotros estamos viajando sobre una lista 00:23:59
y mientras estamos mirando esta lista, estamos machacando la lista misma, quitando objetos. 00:24:06
Entonces, esta cosa que estaba visionando la lista, de repente se encuentra en una lista que no es el objeto original. 00:24:16
Y como no es el objeto original, pues hay como si hubiese dos cosas que están trabajando sobre un mismo objeto, sobre la misma lista, pero están cambiando, o sea, lo están cambiando los dos a la vez. 00:24:24
Y eso, como están cambiando los dos a la vez, es un concurrent modification, modificación concurrente. 00:24:38
No es exactamente concurrente porque hay un hilo solo de ejecución 00:24:44
Pero sí que él se encuentra a volver a pillar el siguiente elemento de una cola 00:24:48
Pero este objeto ha sido modificado 00:24:54
Y entonces se lía 00:24:56
Y este problema sale con el forEach 00:24:58
O sea, el forEach se usa y es útil 00:25:02
Mientras que tú quieras hacer algo por cada uno de los elementos de la vista 00:25:05
perfecto pero si lo que quieres hacer es además removerlo pues forEach causa este problema vamos 00:25:10
a probar con iterato, forEach debe utilizar un método forEach si vamos a ver debería ahora ya 00:25:22
me pierdo a este nivel de profundidad de java pero si vas a ver java api iterable creo que 00:25:31
foreach pic usa más esta cosa aquí pero no lo sé es una suposición aún así vamos a ver con 00:25:50
iterator si lo hace o no entonces como con esto me da problemas lo marco un momento luego vemos 00:26:02
tengo otra forma de hacerla 00:26:09
y digo for 00:26:11
no, for no 00:26:13
iterator 00:26:15
iterator 00:26:16
de persona 00:26:18
es igual a new 00:26:24
no, es igual a cola.iterator 00:26:26
me importo 00:26:31
la clase iterator 00:26:33
y ahora digo 00:26:35
will 00:26:37
it.asNext 00:26:37
y hago lo mismo 00:26:40
solo que ahora mi persona 00:26:46
p es igual a 00:26:54
este punto next 00:26:55
y luego hago esto, esto funcionará 00:26:56
pum 00:27:05
tampoco 00:27:06
vale, o sea que aquí 00:27:08
tengo un problema de 00:27:11
modificar la 00:27:12
la lista 00:27:15
la estructura 00:27:19
mientras la estoy utilizando 00:27:22
Esto puede crear problemas. Entonces tenemos que encontrar otra forma de hacerlo, o borrarla por entero como hemos hecho, o encontrar un modo distinto de hacerlo. 00:27:24
Vamos a pensar otro modo. ¿Cómo podemos hacer esta cosa? 00:27:46
cuidado porque ahora estamos utilizando objetos entrelazado entre ellos entonces hay que ver 00:27:51
porque cuando copias la cola hay que ver si te copias o la cola o te copia también los objetos 00:28:24
que tiene dentro porque probablemente no te los copia el objeto que tiene yo creo que son 00:28:29
referencias a los mismos objetos pero no lo sé hay que ver cómo se hace o cómo la implementa 00:28:39
tu copia vale depende de qué estás usando diga por qué es igual literalmente es igual es la 00:28:45
potencia de las añadas o los quitarás promete así yo en vez que un linked list aquí en vez de un 00:29:03
linked list creo un list vale entonces me permite aquí en vez de un linked list puedo crear una 00:29:18
realista no me cambia nada pero esto funciona pero no gana por qué no porque porque he comentado los 00:29:33
dos iteradores por eso claro no hace nada si pillo un iterador o lo que sea ahora cola punto remove 00:30:01
no existe 00:30:11
porque Oracle es una lista 00:30:12
y lista 00:30:17
tiene 00:30:19
remove 00:30:20
index o remove object 00:30:21
o remove all 00:30:25
o remove first 00:30:27
vamos a ver 00:30:28
sigue habiendo 00:30:34
este error 00:30:37
ahora el problema que nosotros tenemos con esto 00:30:39
es que 00:30:42
la cola yo quiero que se vaya cambiando paso por paso porque y quiero hacerlo por todos los 00:30:46
elementos entonces a lo mejor no es tan absurdo a nivel de programación decir lo hago con todos 00:30:56
y luego la vacío no está simulando exactamente lo que está pasando pero a nivel de programación 00:31:02
estaría bien tengo estos para usar lo hago todo y luego lo quito está si yo esto lo meto en un 00:31:08
método, pues simulo que es 00:31:14
procesa cola, pues ha procesado 00:31:15
todos los elementos de la cola, perfecto 00:31:18
pero como yo quiero que funcione 00:31:19
de esta forma, tenemos que 00:31:21
encontrar un método 00:31:23
distinto a esto 00:31:25
lo que yo haría es 00:31:27
intentar utilizar 00:31:29
no tanto 00:31:31
algo que vaya 00:31:33
creando 00:31:35
un mecanismo 00:31:39
un, como se dice 00:31:42
un objeto que vaya iterando sobre la cola 00:31:43
sin utilizando los métodos propios de la cola 00:31:48
o de la linked list en este caso 00:31:51
vuelvo a linked list porque habíamos dicho hacerlo en linked list 00:31:52
esta era una prueba 00:31:55
fijaos pero que ahora he hecho que 00:31:56
aquí sea una list 00:32:04
y por lo tanto me he extraído 00:32:06
de lo que es la implementación interna 00:32:08
entonces lo que podríamos hacer 00:32:13
aquí, es decir 00:32:18
huile 00:32:19
cola.sitze 00:32:20
es mayor que 0 00:32:24
¿qué me estoy preguntando? 00:32:27
¿me entrae alguien en cola? 00:32:33
pues lo que hago 00:32:35
es que la recaudación 00:32:36
en más precio 00:32:38
esta cosa aquí 00:32:39
donde p, ¿quién es? 00:32:41
zona p es igual a 00:32:44
¿quién? 00:32:46
cola.remove 00:32:48
first 00:32:50
entonces, técnicamente 00:32:51
yo aquí no me he creado 00:33:03
un conjunto, un objeto 00:33:05
un algo que me permite 00:33:07
recoleccionar, o sea, seguir 00:33:09
la colección 00:33:11
elemento por elemento 00:33:13
y que cuando me modificas la colección 00:33:15
ya no se corresponde a esta cosa que me había 00:33:17
creado y por lo tanto 00:33:19
se enfada, y aquí simplemente estoy 00:33:21
preguntando, oye, ahora mismo 00:33:23
en la cola, la cola que existe 00:33:25
ahora, hay al menos una persona 00:33:27
si la hay, píllame la primera 00:33:29
y cálculame su precio 00:33:31
si no la hay 00:33:33
he acabado la cola 00:33:35
y como 00:33:36
remove lo que me hace es 00:33:39
quitar el primero pero 00:33:42
devolverme un puntero a este objeto 00:33:43
que he quitado, pues la cola 00:33:45
se va reduciendo, reduciendo, reduciendo hasta que se accede 00:33:47
y este de aquí 00:33:50
si quiero ver que está funcionando 00:33:51
pasito a pasito 00:33:59
esto lo puedo poner 00:34:00
aquí y entonces veré como esta cola se va reduciendo, reduciendo, reduciendo, reduciendo 00:34:03
hasta que queda una sola persona. Además, si os estáis fijando, siempre desaparece 00:34:12
la primera. O sea que estoy haciendo bien la cola de la que antes procesó la primera 00:34:17
persona, luego la segunda, luego la tercera. Entonces, este ejercicio para que tengáis 00:34:21
en mente que si vosotros modifica jce una una colección mientras la estáis recorriendo eso 00:34:29
puede dar un problema vale en situaciones en el que tengo que hacer todos los elementos pues o 00:34:42
no lo remuevo hago todos los elementos y luego al final de nuevo toda la cola o toda la colección 00:34:50
vale esa es una opción o si no puede buscarme una vía alternativa para hacer lo mismo si ten en 00:34:57
cuenta que las herramientas sabéis varias pues esto es otra forma de recorrer una cosa removiendo 00:35:05
pero esto funciona porque en cada en cada ciclo yo estoy acortando un poquito la cola si yo no 00:35:11
hiciera esto pues esto no cambiaría nunca y entonces esto sería un ciclo infinito 00:35:19
teniendo en cuenta también otra cosa que si en vez imaginaos que yo digo vale quiero recorrer 00:35:28
esta esta cola pero quiero eliminar solo los mayores de edad no todos entonces una opción 00:35:36
que podría hacer es crearme otra cola 00:35:45
otra linked list 00:35:48
o una relist que sean los mayores 00:35:50
de edad, voy haciendo una iteración 00:35:54
sin remover nada 00:35:57
y cada vez que encuentro un mayor de edad 00:35:59
lo guardo en esta nueva cola 00:36:03
una vez que he guardado en esta nueva cola y tengo una cola 00:36:04
con solo los mayores de edad 00:36:09
puedo hacer, acabado todo, sobre la cola original 00:36:11
removal de esta colección para que se entienda imaginaos que yo quiera ahora hago hago una copia 00:36:14
para que se entienda lo que estoy haciendo imaginaos que en vez de esto yo diga vale 00:36:28
quiero quedarme solo quiero procesar los mayores de edad dejando fuera los los pequeños dejando en 00:36:39
cola los pequeños y nada más entonces lo que haría yo es 00:36:48
linked list por ejemplo de persona borrar 00:36:54
o mayores es igual año linked list de persona a 00:37:04
A este punto diría, for persona p dos puntos cola, los pequeños se quedan en cola y no pagan por ahora. 00:37:18
Diría, si p punto get edad es mayor o igual que 18, entonces que paguen. 00:37:32
Recaudación más o igual a precio de p.edad. 00:37:53
Y luego me marco que esta persona ahora la tengo que eliminar. 00:38:04
Entonces la añado a mayores. 00:38:20
Mayores.add p. 00:38:22
entonces cuando he acabado 00:38:25
todo esto, yo he hecho 00:38:31
pagar a los mayores 00:38:32
y todavía no los he eliminado 00:38:34
es decir, que aquí yo si escribo 00:38:37
lista 00:38:39
más lista 00:38:41
cola 00:38:44
veré que siguen todos allí 00:38:46
¿vale? 00:38:50
es que en lista siguen todas las personas 00:38:54
también los mayores de edad 00:38:56
pero una vez que he acabado esto, yo puedo decirle 00:38:57
vale ok cola punto remove all y ahora le puedo poner una colección y le pongo mayores este de 00:39:00
aquí lo que debería hacerme es pillar los mayores y removerlo y está filtrada es verdad es que aquí 00:39:14
hay mayores de edad y en la lista filtrada sólo hay menores de edad si esta es una opción pregunta 00:39:35
para vosotros porque esto funciona no es exactamente la pregunta pero imaginamos 00:39:46
a ver si se pillan vale perfecto ahora yo lo que quiero hacer es después de haber hecho esto 00:40:18
filtrar todas las personas que tienen siete años entonces yo lo que hago es persona 7 es igual a 00:40:24
persona de 7 años, y ahora le digo cola.remove, 7, filtrada 2, ahora vamos a ver si me hace 00:40:38
persona de 7 años, aquí en lista filtrada 5, 5, 8, 16, 17, 7 años, pero sigue también 00:41:06
de la lista filtrada 2. Pero yo le había dicho de borrarlo el que tiene 00:41:19
7 años. ¿Qué ha pasado aquí? 00:41:27
Entonces, ¿por qué esto funciona? 00:41:35
Porque aquí yo estoy añadiendo en esta 00:41:47
cola, en esta get list 00:41:51
una referencia a exactamente la misma 00:41:55
persona que está en cola. Entonces, cuando yo voy 00:41:59
hacer esto aquí dentro dentro mayores hay enlaces a instancias concretas que son las mismas que usen 00:42:03
cola entonces cuando voy a ver si lo tengo que borrar o no diciendo este le va a borrar esta 00:42:11
persona borra esta instancia él me lo está buscando en cola me la encuentra y hace un 00:42:17
igual igual entre estos dos objetos y como son igual igual estos dos objetos porque son en la 00:42:24
misma instancia pues entonces me lo puede borrar y solo este objeto si hay dos que tienen 18 años 00:42:30
pues son dos personas distintas como debería ser sin embargo aquí yo estoy creando una instancia 00:42:36
distinta cuando va a comparar esta persona de 7 años con una persona de 7 años que está en la en 00:42:44
la cola no es la misma instancia y como yo he definido que sea igual igual no me lo va a 00:42:51
alcance a borrar se entiende para que esto funcione que debería hacer para que 00:42:56
esto me borre la persona de 7 años que debería hacer eso es una opción vale 00:43:14
entendido que la opción que buscaba yo podría ir a personas decir vale entonces 00:43:28
defino nuevamente el equals para que dos personas que tengan la misma edad sea la 00:43:33
misma persona se corresponden como iguales a lo mejor no es lo que quiero 00:43:38
yo porque en lista puede haber dos niños de siete años y si yo pongo así pues parece que sean la 00:43:43
misma persona pero la verdad no lo son son objetos equivalentes son niños de siete años pero no son 00:43:49
la misma persona y cuidado que una cola admite repeticiones entonces no cambiaría mucho vale 00:43:55
cambiaría a nivel de que cuando luego creo una persona de siete años así la puede usar para 00:44:02
a remover personas de 7 años. Ahora, la remove posiblemente me remueve 00:44:07
uno solo. Y luego me devuelve 00:44:11
el link a lo que ha removido probablemente. Pues eso sería hacer 00:44:15
un while que remueva siempre esta persona de aquí 00:44:19
hasta que me devuelva null, que entonces no ha removido nada. 00:44:23
Estas cosas hay que trabajar 00:44:29
un poquito con las listas 00:44:31
cosas por estilo para que surjan 00:44:35
varios y distintos 00:44:38
situaciones y también 00:44:39
os invito a que seáis vosotros que 00:44:41
frente a una situación como esta penséis 00:44:43
y si quiero hacer esto y si quiero hacer esto para 00:44:45
explorar las posibilidades de hacer cosas 00:44:47
distintas 00:44:49
vuelvo aquí 00:44:52
entonces esto es una 00:44:55
posible solución, repito, al problema 00:44:57
que surge aquí, la otra 00:44:59
solución posible sería 00:45:01
hacer esto pero sin 00:45:03
remove y luego 00:45:05
devolver, o sea, remover todo después 00:45:06
¿vale? o sea que 00:45:09
hacer aquí un cola punto 00:45:10
esto sí que 00:45:12
funcionaría 00:45:22
pero nos está simulando 00:45:23
que se vayan de uno en uno 00:45:26
¿sí? 00:45:27
y más o menos 00:45:32
vamos a ver si tengo que hacer algo más 00:45:35
dudas 00:45:38
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:
16
Fecha:
6 de febrero de 2025 - 12:59
Visibilidad:
Clave
Centro:
IES ROSA CHACEL
Duración:
45′ 52″
Relación de aspecto:
16:10 El estándar usado por los portátiles de 15,4" y algunos otros, es ancho como el 16:9.
Resolución:
1152x720 píxeles
Tamaño:
177.18 MBytes

Del mismo autor…

Ver más del mismo autor

EducaMadrid, Plataforma Educativa de la Comunidad de Madrid

Plataforma Educativa EducaMadrid