Saltar navegación

20260204 LinkedListArrayList_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 7 de febrero de 2026 por Raquel G.

1 visualizaciones

Más información Transcripción

Descargar la transcripción

Ven a nuestro restaurante, los métodos que empezaban aquí. 00:00:00
Este nada, no tiene ninguna duda ni nada que comentar, ¿verdad? 00:00:07
Añadir un plato a la carta, escoger la colección y añadírselo, ya está. 00:00:13
Aquí no hay nada raro que pueda salir, en principio nada. 00:00:19
Ver carta 00:00:21
Ver carta tampoco tiene nada raro 00:00:25
Es recorrer la colección 00:00:28
Ya sabemos recorrer una colección 00:00:30
Tanto con un for de índice 00:00:34
Como con un for each 00:00:36
Cualquiera de las dos nos vale para recorrer una colección 00:00:37
Aquí por comodidad 00:00:40
A la hora de escribirlo 00:00:42
Con un for each normal 00:00:43
Para cada plato 00:00:46
Con catenamen el resultado 00:00:47
Su nombre 00:00:49
tabulación para que quede más bonito 00:00:50
y el precio, ¿vale? Así me queda más bonita 00:00:52
la carta 00:00:54
no me he complicado, podría aquí también 00:00:55
añadir la lista de ingredientes, pero bueno 00:00:58
ver carta que sea plato y precio 00:01:00
si luego uno quiere detalles del plato, ya que pulse 00:01:02
a ver ingredientes de un plato 00:01:04
vale 00:01:07
aquí 00:01:09
cuando he puesto hacerlo, he visto que yo 00:01:11
aquí había puesto stream, ¿verdad? 00:01:14
y para devolver 00:01:16
los platos que tiene un ingrediente 00:01:18
son muchos en principio 00:01:20
con lo cual este método sería un list 00:01:22
lo que debería devolver, ¿verdad? 00:01:24
imagino que os habréis dado cuenta al hacerlo 00:01:25
¿vale? 00:01:26
entonces, este método 00:01:28
devuelve en principio los nombres 00:01:31
de los platos que contiene el ingrediente 00:01:34
también muy fácil de hacer 00:01:36
porque tenemos el método 00:01:37
adecuado para eso 00:01:40
tenemos que recorrer nuestra carta 00:01:41
el resultado 00:01:44
del método, ¿cuál va a ser? 00:01:45
una lista de cosas 00:01:48
Pues yo aquí preparo mi lista vacía 00:01:49
Esta como veis 00:01:51
Es una lista pensada 00:01:54
Solo para añadir 00:01:55
Con lo cual bueno 00:01:58
Me hago un linked list 00:01:59
Que es mucho más cómodo 00:02:00
Hacer los ads en un linked list 00:02:03
Vale pues recorro mi carta 00:02:04
Para cada plato 00:02:06
Si contiene el ingrediente que me han dicho 00:02:08
Si lo contiene 00:02:11
Añado el nombre de ese plato 00:02:12
Al list y ya está 00:02:15
¿vale? podría devolver 00:02:16
una lista de platos directamente 00:02:18
con lo cual aquí añadiría el plato 00:02:20
tal cual, pero bueno lo hemos 00:02:22
hecho para que te devuelvan los 00:02:24
nombres solamente, oye dime 00:02:26
¿qué es lo que tiene aceite? 00:02:28
pues tú 00:02:31
pinchas aceite y te sale 00:02:32
aceite tiene sopa, carne, macarrones 00:02:34
los nombres 00:02:36
¿vale? este 00:02:38
no tiene nada, raro tampoco ¿verdad? 00:02:40
no tiene nada 00:02:43
extraño 00:02:44
vale, siguiente 00:02:49
eliminar plato 00:03:07
que es 00:03:13
eliminar un plato que se llama 00:03:15
como me han dicho 00:03:17
elimina los macarrones 00:03:18
elimina las lentejas de la carta 00:03:20
elimina el plato que se llame carne 00:03:22
nos hemos hecho vegetarianos 00:03:25
elimina un plato con un nombre 00:03:26
bueno, pues este es el que más me interesa 00:03:28
¿qué es lo que uno haría 00:03:31
con lo que nosotros en principio sabemos? 00:03:33
bueno, sabemos que tenemos 00:03:36
un método remove 00:03:37
que nos permite eliminar un plato 00:03:38
si yo le doy un plato 00:03:41
lógicamente 00:03:43
bueno, pues entonces 00:03:43
pero tengo que encontrar qué plato eliminar 00:03:47
si a mí me dicen directamente 00:03:49
elimina el objeto plato y me pasan aquí 00:03:50
el plato tal cual 00:03:53
pues entonces 00:03:54
yo puedo directamente hacer 00:03:56
carta.remove, le paso el plato 00:03:58
y me elimina de la colección 00:04:00
el primer plato que encuentra igual 00:04:02
aquí no me han pasado 00:04:04
el objeto plato entero, sino me han pasado 00:04:06
uno de sus 00:04:08
campos, su clave primaria 00:04:10
bueno, pues entonces 00:04:12
nos plantearíamos 00:04:15
una búsqueda 00:04:16
vamos a buscar en la carta 00:04:18
hasta que encontremos el que 00:04:20
cumple la condición de llamarse 00:04:22
igual que esto, vamos a buscar en la carta 00:04:24
pues venga 00:04:27
recorremos la carta 00:04:28
y uno podría hacer 00:04:29
con lo que hemos visto 00:04:31
vale 00:04:32
cuando ya hemos encontrado 00:04:34
el plato 00:04:35
que cumple 00:04:37
llamarse como este 00:04:38
ese objeto 00:04:39
plato 00:04:40
remove carta 00:04:41
ya sabemos 00:04:42
que entonces 00:04:43
ese plato 00:04:44
se eliminará 00:04:44
y aquí ya avisamos 00:04:45
de que lo hemos encontrado 00:04:47
de que result true 00:04:49
para 00:04:50
para 00:04:51
devolver 00:04:53
un valor de control 00:04:54
al que nos llama 00:04:55
que el que nos llama 00:04:56
sepa 00:04:57
si realmente ese plato existía 00:04:58
o no se eliminó ninguno 00:05:00
¿vale? al menos tienen un 00:05:02
valor de rock control, una realimentación 00:05:04
porque igual escribió mal el nombre 00:05:06
y no está borrando el plato 00:05:07
correspondiente, o sea, eso sí que es importante 00:05:09
tú pones, elimina macarrones 00:05:12
y has puesto macarrones con una R 00:05:14
si la aplicación no te dice 00:05:16
nada y el método no te dice nada, te vas tan 00:05:18
tranquilo pensando que ha quitado 00:05:20
los macarrones de la carta, pero no, los macarrones 00:05:22
siguen ahí, porque tú le has 00:05:24
pasado macarrones con una R solo 00:05:26
con lo cual él no ha borrado nada 00:05:28
eso 00:05:30
es una situación típica que induce un montón 00:05:32
de errores, si uno no realimenta hacia arriba 00:05:34
la parte 00:05:36
de la aplicación que ya no es el método 00:05:38
pues se cree que realmente has eliminado los macarrones 00:05:40
y no, no has eliminado nada 00:05:42
entonces este boolean aquí sí que es interesante 00:05:43
porque el que llama al método 00:05:46
tiene manera de saber si ha eliminado realmente 00:05:48
no se ha eliminado 00:05:50
no se ha eliminado porque es que lo he escrito mal 00:05:51
o que pasa, o la carta 00:05:54
es que esta no es la carta 00:05:55
que yo quiero. Bueno, ya te permite 00:05:57
indagar un poco más de lo que ha pasado. 00:05:59
Bueno, pues en principio uno 00:06:02
podría plantearse que lo que sabemos hacer es esto, ¿verdad? 00:06:03
Entonces, 00:06:06
si vosotros habéis hecho esto 00:06:07
sin más, y luego 00:06:09
vamos a hacer un main para probar esto. 00:06:12
¿Vale? Porque estos dos métodos ahora mismo 00:06:14
están así. Vamos a hacer un main. 00:06:15
Entonces, aquí efectivamente... 00:06:17
Sí, por estos dos. 00:06:20
Estamos probando este. 00:06:21
Sí, podrías hacer un retun, el retun remove, ¿vale? 00:06:29
Sí, lo único es que no lo he hecho así, pues yo que sé, 00:06:33
para que quede el código un poco más estructurado, ¿vale? 00:06:35
No poner un retun aquí mismo, ¿vale? 00:06:38
No sé si te refieres a eso, ¿vale? 00:06:41
Entonces, si pongo yo aquí el retun, ya está, retun true. 00:06:43
Y si no sale por aquí, es por que no aparezca en retun, 00:06:46
por lo que hablábamos de un código estructurado, 00:06:50
que no tenga varios puntos de salida, 00:06:52
que un código salga siempre por el mismo punto. 00:06:54
Es decir, cuando proliferan los return 00:06:57
En un código 00:07:00
Pues ya empieza a escamar un poco 00:07:01
Pero bueno, tampoco hay que ser demasiado estrictos 00:07:05
Con eso, ¿vale? 00:07:07
Vale, entonces 00:07:10
Ahora en un main, pues yo me he creado aquí 00:07:11
Un restaurante y lógicamente 00:07:13
Idiota no soy, entonces le he dicho a esa GPT 00:07:14
Dame una línea para rellenar 00:07:17
Un restaurante 00:07:18
Y me ha dado esto 00:07:19
¿Vale? Bueno, pues ahora ya sí que podemos 00:07:22
Probar nuestros métodos 00:07:24
vale, entonces voy a asegurarme 00:07:26
de que sí 00:07:28
entonces 00:07:28
pedís el hgpt 00:07:31
a ver 00:07:34
lo que yo le he hecho es 00:07:36
le he copiado y pegado solamente 00:07:37
estas líneas de aquí 00:07:40
no la clase entera, esto para que vea la estructura 00:07:41
le he copiado esto 00:07:44
para que vea la estructura y le he copiado 00:07:46
esto y esto 00:07:48
y le he dicho dame unas líneas 00:07:51
para rellenar un restaurante con datos 00:07:53
cualesquiera al azar 00:07:55
Vale, esto es lo que le he dicho 00:07:57
Le he pegado estas dos cositas 00:08:00
O sea, es que él se enrolla 00:08:02
Y le he dicho 00:08:05
Quiero líneas de código para crear un restaurante 00:08:07
Con platos e ingredientes 00:08:09
Vale, solo quiero eso, no te enrolles tanto 00:08:11
Y ya está, y me ha dado eso 00:08:13
Vale 00:08:15
Nuestro mail 00:08:16
Bueno, los tenéis ya, la pizza 00:08:26
Imagino que os habrá dado otros nombres 00:08:28
¿Verdad? Y otros ingredientes 00:08:31
Y otros platos 00:08:32
¿Cómo se llama el tuyo? 00:08:34
Tú no se lo has pedido 00:08:37
Lo has hecho a mano 00:08:38
Muy bien 00:08:40
Bueno 00:08:41
Pues nada, ya tenemos nuestro restaurante 00:08:49
La buena mesa 00:08:52
El vuestro, pues el que sea 00:08:54
Nuestro super restaurante 00:08:55
Ahora 00:08:57
Voy a ver la carta que tiene 00:09:01
Vale 00:09:05
Espera, primero voy a 00:09:06
probar a ver si está todo bien, voy a ver la carta que tiene 00:09:08
ahora mismo solamente vamos a probar 00:09:12
por ejemplo, ver carta 00:09:16
vale, porque añadir plato ya me lo ha hecho 00:09:17
y añadir ingredientes al plato ya me ha hecho todo eso 00:09:21
vale, a ver, como no le he dado los nombres 00:09:24
de los métodos, él me puso en origen agregar 00:09:27
pero yo lo he cambiado a add y ya está 00:09:30
bueno, estamos situados 00:09:32
venga, vamos a ver la carta de este restaurante 00:09:43
Pues ya está 00:09:49
Pizza, ensalada 00:09:51
Uy, que carta más fea, le voy a poner un barra N 00:09:53
Un salto de línea 00:09:55
Para que quede más bonito 00:09:57
Vale, pues aquí 00:10:01
Este editor va a necesitar 00:10:06
Barra R, será 00:10:09
Vamos a ver 00:10:10
Ah, no, perdón, que el ver carta irá en 00:10:14
Vale 00:10:19
A ver, el método ver carta 00:10:24
No me está haciendo el salto de línea 00:10:29
¿Dónde está ver carta? 00:10:31
Ah, claro, me falta el salto de línea que al final 00:10:32
Vale 00:10:34
Vamos a ver ahora la carta 00:10:37
Vale, ya queda más bonita 00:10:40
Venga 00:10:42
¡Hala! Pues venga 00:10:44
Tenemos más métodos para probar por aquí 00:10:48
Vamos a ver los platos que tienen un ingrediente 00:10:51
A ver 00:10:55
Venga 00:10:57
Entonces 00:10:58
De mi restaurante tiene 00:11:04
Un método que era 00:11:07
platos que tienen un ingrediente 00:11:11
que es una lista directamente 00:11:13
¿qué ingrediente? voy a ver los platos 00:11:15
que tienen 00:11:17
queso 00:11:18
¿vale? entonces como 00:11:19
veis le estoy pasando 00:11:23
al system out directamente 00:11:25
una lista, un list 00:11:27
porque platos con ingrediente 00:11:28
me devuelve un list de string 00:11:31
entonces system out 00:11:33
ya sabemos lo que hace por dentro, le pasas algo 00:11:35
que no sea una cadena y te llama 00:11:37
el método toString de ese algo 00:11:39
para convertirlo a cadena 00:11:41
¿cómo es el método toStringDeList? 00:11:42
ni idea, vamos a probar a ver si es bonito 00:11:45
o me saca ahí una caca 00:11:47
porque si es bonito, pues ya está 00:11:48
no tenemos que modificar nosotros 00:11:50
el método platos con ingredientes 00:11:53
vale, entonces 00:11:55
vamos a ver los platos que tienen 00:11:57
que eso, pues el 00:11:58
toStringDeList 00:12:03
este es bonito 00:12:05
vale, me saca 00:12:06
todos los elementos así 00:12:09
pero a ver 00:12:11
este es 00:12:13
bonito 00:12:17
de casualidad 00:12:20
o sea, no es que sea bonito de casualidad, perdón 00:12:22
este es bonito porque lo que me devuelve 00:12:24
platos con ingrediente 00:12:27
es un list de string 00:12:29
entonces, ¿qué me 00:12:31
devuelve tu 00:12:33
string de list? 00:12:35
pues me devuelve entre corchetes 00:12:36
me devuelve entre corchetes 00:12:38
los objetos 00:12:41
de la lista, en este caso eran string 00:12:43
pues el toString 00:12:45
de pizza, que es un 00:12:47
string de pizza, pero si yo le hubiera pasado 00:12:49
platos, es decir 00:12:51
si mi método platos con ingredientes 00:12:53
si mi método platos 00:12:55
con ingredientes de aquí me hubiera devuelto 00:12:57
el objeto plato enterito 00:12:59
eso 00:13:01
me habría salido un list muy feo 00:13:03
y muy horrible, porque me habría mostrado 00:13:05
el toString 00:13:07
de cada plato, si yo no lo 00:13:09
tengo implementado, pues vete a saber lo que 00:13:11
sale. ¿Vale? 00:13:13
¿Lo tenemos claro a lo que nos referimos? 00:13:15
Bueno, pues entonces 00:13:18
plato... Vale, ahora vamos a 00:13:19
eliminar 00:13:23
un plato por su nombre 00:13:27
con el método que hemos 00:13:28
hecho. R punto 00:13:35
eliminar plato. Vale. 00:13:37
Voy a eliminar la hamburguesa. 00:13:40
Tengo tres platos. 00:13:41
Y me sale este error. 00:13:52
Un error que no nos había salido en la vida. 00:13:54
Y esto, a ver, voy a probar otra vez. 00:13:57
No la hayamos liado 00:13:58
Voy a eliminar la ensalada 00:13:59
Y luego voy a ver la carta otra vez 00:14:02
Porque tendría que haber puesto aquí 00:14:08
Ver carta después para 00:14:11
Venga, vamos a eliminar 00:14:12
Uy, eliminar plato ensalada 00:14:17
Venga, aquí ya lo tenéis puesto 00:14:20
Pues este sí 00:14:22
Y es un elemento más 00:14:25
Ensalada 00:14:28
Voy a eliminar a la pizza 00:14:29
Pues aquí me vuelve a salir el error raro 00:14:31
¿Vale? 00:14:41
Vamos a meter otro ingrediente más 00:14:43
Otro plato más 00:14:46
A ver 00:14:47
Vamos a meter, por ejemplo 00:14:48
Hamburguesa, pizza, ensalada 00:14:51
Vamos a meter, yo que sé, cocido 00:14:53
Que el cocido tiene 00:14:56
Pues morcilla, garbanzos y patatas 00:15:00
Y ahora, sí, ahora lo cambio de nombre 00:15:04
Patatas 00:15:12
Y este es P4 00:15:15
Y P4 00:15:24
Vale, y ahora me falta añadir a mi restaurante 00:15:26
Add plato 00:15:29
Vale, tengo un nuevo plato 00:15:32
Que es el último 00:15:34
Venga 00:15:37
Voy a intentar eliminar ahora 00:15:38
La hamburguesa 00:15:41
Voy a ver si consigo eliminar la hamburguesa 00:15:42
De esta carta de cuatro platos 00:15:45
Que tengo ahora 00:15:47
eliminar plato 00:15:48
pues ahora sí que me la he eliminado 00:15:51
antes no me eliminaba la hamburguesa 00:15:54
y ahora sí, o sea, esto 00:15:57
es absolutamente caótico 00:15:58
¿vale? pero ¿qué patrón estamos encontrando? 00:16:00
que me da 00:16:04
ese error extraño 00:16:05
cuando intento eliminar el primero y el último 00:16:06
voy a intentar eliminar 00:16:08
ahora el cocido, a ver 00:16:11
vamos a eliminar ahora el cocido 00:16:12
pues aquí ya la hemos liado 00:16:19
entonces 00:16:21
es la primera vez que nos sale 00:16:26
esta excepción, que es muy extraña 00:16:29
que se llama concurrent modification exception 00:16:31
vale, ¿de dónde viene 00:16:33
esta excepción? vámonos al método 00:16:35
viene de que aquí 00:16:37
era 00:16:39
eliminar plato, este 00:16:41
de que aquí 00:16:43
estamos anidando for 00:16:44
que están accediendo 00:16:47
a la vez al mismo sitio 00:16:49
que esa carta 00:16:51
es decir 00:16:52
este for 00:16:54
ya ha cogido ahí 00:16:56
internamente, ya ha cogido 00:16:58
esta colección carta, ya la ha cogido 00:17:00
y la tiene ahí reservada para pipipi y terar 00:17:02
y ahora cuando 00:17:04
encontramos el elemento 00:17:06
que yo quiero borrar 00:17:08
llamo a remove como si no pasara nada 00:17:09
pero remove es un método muy complejo 00:17:11
por dentro, remove que hace 00:17:14
pues remove abre otro for 00:17:15
abre otro for 00:17:17
en el cual 00:17:19
se pone a buscar 00:17:20
el que sea igual a este, cuando lo encuentra 00:17:24
lo borra, pues esto ya no suena raro 00:17:25
o sea, estamos haciendo aquí un for para recoger 00:17:27
la colección, para encontrar un plato 00:17:29
que le volvemos a pasar 00:17:31
para que 00:17:33
ahora ya lo borre 00:17:35
que a su vez va a iterar dentro 00:17:38
entonces esas dos iteraciones son dos iteraciones 00:17:39
concurrentes, dos iteraciones 00:17:42
dos for que cogen internamente 00:17:44
el mismo recurso, bueno pues 00:17:46
de ahí viene 00:17:48
que me salga esto de aquí 00:17:49
oye, pero que me estás haciendo 00:17:51
esto de aquí que es 00:17:53
vamos a ver 00:17:55
hay una comodificación 00:17:57
es decir, estás modificando 00:17:59
desde dos sitios 00:18:01
esto no lo puedes hacer 00:18:02
vale, aquí el tema 00:18:04
es que esto 00:18:08
no lo hacemos nunca, no deberíamos hacerlo nunca 00:18:11
porque hay mil formas de hacer esto 00:18:13
pero sería la más natural 00:18:14
con la filosofía que tenemos ahora 00:18:16
la más natural es, quiero probar un elemento de la colección 00:18:18
voy a recorrer la colección 00:18:21
hasta que lo encuentre 00:18:23
que es lo que hacemos aquí, reconozco la colección hasta que lo encuentre 00:18:24
y cuando lo he encontrado 00:18:26
ahora voy a hacer lo que sea con él 00:18:28
si lo que fuera con él fuera 00:18:30
un system out, ningún problema 00:18:32
pero lo que vamos a hacer 00:18:34
con él a su vez 00:18:36
es meternos otra vez en la colección 00:18:37
carta para iterarla otra vez 00:18:40
a través del interior de remove, no lo hemos hecho nosotros 00:18:42
pero podemos deducir que hace eso 00:18:44
reconozco hasta que encuentre una igual 00:18:46
pues mucha 00:18:48
iteración concurrente, aunque no la veamos 00:18:49
Claro, es que nos hemos complicado la vida un montón 00:18:52
Porque ya el remove 00:18:54
Ya sabemos que el remove 00:18:56
Lo que hace es 00:18:58
Tú le pasas un objeto 00:19:00
Y te borra el que sea igual a ese 00:19:01
Ya está 00:19:05
¿Por qué vas a tener que recorrer? 00:19:05
No hay ninguna razón para recorrer 00:19:07
Claro, pero me diríais 00:19:08
Pero perdona, es que no me has pasado el plato 00:19:10
Me has pasado el nombre 00:19:13
¿Vale? ¿Por qué? 00:19:16
Si hubiéramos pasado el plato 00:19:17
Vamos a hacer la versión eliminar 2 00:19:19
De eliminar plato 00:19:20
Bueno, con este va a borrar el primero que encuentra 00:19:21
Igual a este p 00:19:31
Vale, entonces 00:19:32
Vamos a suponer que tenemos aquí 00:19:36
La versión 2 de eliminar plato 00:19:38
Que esta no nos habría causado ningún problema 00:19:41
Porque 00:19:43
La versión 2 de eliminar plato 00:19:44
Si hubiera sido pasado el objeto 00:19:47
Aquí sí que 00:19:50
Habríamos hecho directamente esto 00:19:52
retum 00:19:54
carta punto 00:19:57
remove 00:19:59
plato 00:20:01
¿vale? 00:20:03
entonces, aquí no habríamos 00:20:08
tenido ningún problema de modificación 00:20:10
concurrente porque solo llegamos a la 00:20:11
carta desde el remove 00:20:14
el remove ya abre su for 00:20:15
se pone a recorrer la colección 00:20:18
y en cuanto encuentra uno igual 00:20:19
que este, lo borra 00:20:21
¿vale? y me devuelve true 00:20:23
por eso lo he puesto aquí en el return 00:20:26
si el remove después de recorrer 00:20:28
toda la colección no hubiera encontrado 00:20:31
ninguno igual a este, me devuelve false 00:20:32
pues por eso yo lo pongo directamente en el return 00:20:34
y listo 00:20:37
bueno, pues si estuviéramos borrando 00:20:37
por directamente 00:20:41
el elemento plato 00:20:43
no tendría ningún problema 00:20:44
pero hombre, realmente es que 00:20:45
este método, normalmente 00:20:48
cuando tú eliminas 00:20:50
o consultas, lo haces por clave primaria 00:20:52
siempre, ¿no? 00:20:55
No tiene sentido que cuando tú le dices a un usuario de la aplicación, el usuario quiere eliminar un plato de la carta, quiere eliminarlo. Pues tú no le dices, pásame el nombre, su precio y todos los ingredientes. No le dices todo eso para eliminar el plato. Le dices, pásame el nombre y ya se ocupará él de eliminar el plato con ese nombre. 00:20:56
Luego este método así 00:21:17
Pues no es muy operativo 00:21:20
Obligamos al que lo llama 00:21:22
A tener todos los datos enteros 00:21:23
El nombre, el precio, la lista de ingredientes 00:21:25
Pues no, nos gusta más el de arriba 00:21:28
Nos gusta más el de arriba 00:21:30
Cuando yo borro un plato 00:21:32
Quiero darte el nombre 00:21:34
No quiero darte el resto de cosas 00:21:35
Yo te doy el nombre y tú lo borras 00:21:37
Nos gusta más este 00:21:38
Pero este tiene este problema 00:21:39
Claro, pero es que 00:21:41
aquí nos vamos al asunto 00:21:44
del criterio de igualdad 00:21:48
¿qué hace el remove? borrar un plato 00:21:49
igual a este que 00:21:52
esté aquí, vale 00:21:54
pero igual según que criterio 00:21:55
ostras pues no he puesto 00:21:58
un criterio de igualdad en plato 00:22:00
entonces puedo tener un problema 00:22:01
vamos 00:22:05
por ejemplo a 00:22:07
a probarlo 00:22:09
aquí en el main 00:22:11
vamos a probar aquí en el main 00:22:12
Estoy en mi mail 00:22:15
Voy a quitar esta prueba 00:22:19
Que he hecho antes, que me daba ese error 00:22:21
Que estoy en proceso de arreglarlo 00:22:22
Vale, vamos a 00:22:25
Eliminar 00:22:26
Este tiene 00:22:28
Mi restaurante tiene P1, P2, P3 y P4 00:22:30
Vale 00:22:34
Voy a 00:22:35
Eliminar del restaurante 00:22:38
Eliminar plato 00:22:41
El P1, el primero de todos 00:22:42
que he añadido 00:22:45
eliminar plato versión 2, era 00:22:45
voy a eliminar 00:22:48
el p1 y ahora voy a 00:22:51
ver la carta otra vez, a ver 00:22:52
si lo he eliminado, vale, entonces 00:22:54
debería eliminarlo, si nos vamos 00:23:01
al método eliminar plato 00:23:03
remove, le pasas el objeto plato 00:23:04
remove, ya está, vale 00:23:07
vámonos aquí a hacer el main 00:23:09
a ver la carta antes y ver la carta después 00:23:11
del restaurante, a ver si 00:23:13
lo he eliminado, pues venga 00:23:15
ejecutamos esto 00:23:17
Espera, ¿qué? 00:23:19
Ah, vale, vale, vale 00:23:35
Vale 00:23:36
Lo ha eliminado en normal, pero no quería hacer yo esta prueba 00:23:37
Yo quiero hacer la prueba 00:23:43
Vamos a suponer 00:23:45
Que 00:23:49
Nos hacemos un plato 00:23:50
Plato 00:23:53
Y este plato 00:24:00
¿Os parece que 00:24:03
Sigamos 00:24:08
Con las paradillas que a lo mejor toquen para que 00:24:09
Es algo y nos vayamos antes? 00:24:12
En lugar de hacer una parada ahora que siempre se estira 5 o 10 minutos 00:24:14
Vale, pues vamos a hacernos un 00:24:16
Vamos a imaginar que este código de arriba 00:24:20
De rellenar los ingredientes 00:24:22
Este código, yo no tengo acceso a él 00:24:23
Porque este código se ha hecho en un mail y ahora yo estoy en otra parte 00:24:25
De mi 00:24:28
Y voy a eliminar un plato 00:24:28
Igual que 00:24:30
Este de aquí, ¿vale? Me voy a hacer un nuevo plato 00:24:32
Me voy a hacer un nuevo plato pizza 00:24:35
Vale 00:24:40
Igualito que este de aquí 00:24:44
Que el P1 00:24:47
Me lo voy a hacer igualito 00:24:48
Vale, igualito, con todos sus datos 00:24:49
Venga 00:24:53
Ahora 00:24:55
P5 y P5, vale 00:24:59
Entonces yo quiero eliminar 00:25:03
Este plato que me acabo de hacer 00:25:05
Este, oye, elimina 00:25:06
La pizza, elimina la pizza 00:25:08
que valía 9,5 y tenía esto, elimínala, pues uno podría decir 00:25:10
venga, tengo el plato al completo, lo tengo al completo, lo acabo de construir 00:25:15
lo tengo al completo, con todos sus datos 00:25:18
pues aquí va, al completito está, con todos sus datos 00:25:21
como el método de eliminar plato me pide el plato al completo 00:25:26
no pasa nada, yo te he construido el plato al completo, te lo he construido 00:25:30
enterito, tú me lo pides para borrarlo, te lo construyo entero 00:25:34
Vamos a tratar de eliminarlo 00:25:38
Viendo la carta antes 00:25:42
Y viendo la carta después 00:25:43
Vale, pues efectivamente 00:25:45
No he eliminado nada 00:25:49
Uno podría pensar 00:25:52
Pero si he construido un plato 00:25:53
Tal cual, como este de aquí 00:25:55
Con sus ingredientes, porque tú quieres que yo te pase 00:25:58
Un plato para borrarlo 00:25:59
Lo he construido, te lo he pasado 00:26:01
Y tú no has borrado nada 00:26:03
No lo has borrado 00:26:07
Vale 00:26:09
¿por qué no lo ha borrado? 00:26:11
¿podríais intuir por qué no me lo ha borrado 00:26:14
según lo que hemos dicho que hace Remus 00:26:16
que es que recorre la colección 00:26:18
hasta que encuentra uno igual 00:26:20
al que le has pasado y cuando lo ha encontrado 00:26:22
te lo elimina y ya está 00:26:24
¿por qué no lo ha borrado? 00:26:26
¿por qué no lo ha borrado? 00:26:28
¿por qué no? ¿sólo había uno en el pizza? 00:26:29
¿cómo que le han salido dos? 00:26:32
a ver, es que tenía 00:26:34
ver carta antes y ver carta después 00:26:34
a ver, tenía 00:26:36
espera, voy a ponerle aquí un separador 00:26:38
primero, ver carta, antes de hacer ningún borrado 00:26:40
le voy a poner aquí y ahora 00:26:45
pues esto 00:26:48
ahora 00:26:49
ahora vamos a eliminar 00:26:51
este P5 que es clavado al otro 00:26:54
eliminamos 00:26:56
pizza 00:27:03
y ahora vamos a ver la carta después de haber eliminado pizza 00:27:04
pues esta era la carta 00:27:07
antes 00:27:11
y ahora que ocurre 00:27:11
Que la carta después 00:27:14
Es idéntica, es la misma 00:27:16
No ha hecho nada 00:27:18
¿Eh? 00:27:20
¿Pero por qué no lo ha borrado? 00:27:26
Pregunto 00:27:28
¿Sí? ¿O no? 00:27:29
Es que si no habría salido en la carta 00:27:33
A ver 00:27:34
Mira, a ver 00:27:35
Ah, vale, vale, vale, si tenéis toda la razón 00:27:39
Vale 00:27:44
Restaurante.getcarta.com 00:27:45
Add 00:27:51
Este plato pizza 00:27:53
No, pero es que no lo quiero incluir en el restaurante 00:27:56
Pero no me liéis 00:27:58
¿Por qué lo voy a incluir en el restaurante? 00:28:00
A ver, yo tengo mi carta 00:28:02
Con los cuatro 00:28:04
Estos 00:28:05
Tengo mi carta 00:28:08
Y ahora lo que yo quiero es la funcionalidad 00:28:09
De eliminar uno 00:28:12
Para eliminar uno 00:28:13
Tengo el método 00:28:15
Este de aquí 00:28:17
tengo el método eliminar plato 00:28:19
al que le pasas un plato 00:28:22
bueno, pues es lo que estoy haciendo 00:28:23
yo tengo mi carta hecha 00:28:26
con mis platos, y ahora 00:28:28
quiero eliminar un plato 00:28:29
pues si lo tienes que pasar 00:28:32
pues lo estoy construyendo 00:28:33
un plato igual al que quiero eliminar 00:28:35
para que lo elimines 00:28:37
por fin, decís algo 00:28:39
que sí, claro 00:28:43
vale, es decir, remove 00:28:45
repito, remove lo que hace es 00:28:48
buscar un objeto 00:28:50
igual al que tú le pasas 00:28:53
el que le pasas da igual de donde venga 00:28:54
busca uno igual 00:28:56
claro, la pregunta es 00:28:57
igual según qué criterio 00:29:00
cuando hacíamos un remove de una lista 00:29:02
de cadenas 00:29:04
no hay ningún problema, la cadena tenía hola, adiós, no sé qué 00:29:05
y ahora tú le pasabas un string 00:29:09
que venía de donde fuera 00:29:10
era hola y encuentra uno igual 00:29:11
y lo elimina, ¿por qué? 00:29:14
Porque el equals de string está implementado 00:29:16
y el equals de string te dice que una cadena es igual a otra 00:29:19
y todos sus caracteres son iguales, ¿vale? 00:29:22
Pero aquí necesita la igualdad entre platos. 00:29:25
¿Cuál es la igualdad entre platos? 00:29:29
No la hay implementada. 00:29:31
Yo no he implementado el equals en plato. 00:29:32
Entonces, si yo no he implementado el equals en plato, 00:29:35
el criterio de igualdad para el remove 00:29:38
es el de la superclase, que es object. 00:29:40
y el criterio 00:29:43
y el equals de la superclase 00:29:45
es dos objetos 00:29:47
son iguales si su dirección 00:29:49
de memoria es la misma 00:29:51
eso es lo que hemos dicho siempre, ¿no? 00:29:52
el equals de object es 00:29:54
este objeto es igual a este 00:29:57
solo si están exactamente 00:29:59
en la misma dirección de memoria 00:30:01
ese es el equals de object 00:30:03
con lo cual 00:30:05
cualquier otra clase que yo haga 00:30:07
si yo no sobre escribo 00:30:09
el equals, su criterio de igualdad 00:30:11
es el mismo, pero en la vida real 00:30:13
no funcionamos así, en las aplicaciones no funcionamos 00:30:15
así, si yo estoy haciendo una matrícula 00:30:17
y me das la 00:30:19
misma matrícula, me la das dos veces 00:30:21
porque te has equivocado 00:30:23
porque has hecho la solicitud dos veces 00:30:25
la misma con el mismo DNI 00:30:27
y dices, no, perdona, es que esta es la misma 00:30:28
no voy a tramitar dos veces 00:30:31
lo mismo con el mismo DNI 00:30:33
entonces, el criterio de 00:30:34
igualdad en el mundo real 00:30:37
no es por dirección de memoria 00:30:39
dos objetos pueden estar en diferentes líneas de memoria 00:30:41
pero la aplicación son el mismo 00:30:43
¿vale? pues entonces 00:30:44
¿por qué no elimina aquí la pizza? 00:30:46
no porque este código esté mal, el main está estupendo 00:30:48
lo elimina porque la clase 00:30:51
plato no tiene criterio de igualdad 00:30:53
con lo cual usa el de object 00:30:55
¿vale? pues nuestro problema no está en el main 00:30:56
nuestro problema está aquí 00:30:58
bueno, pues entonces aquí 00:31:00
es cuando 00:31:02
en la clase plato es cuando decimos 00:31:04
vamos a ver 00:31:07
para la aplicación 00:31:07
que le hace ver que un objeto 00:31:10
que un plato sea igual a otro 00:31:14
tengo que irme de los campos a cuáles son clave primaria 00:31:16
pues en este caso el nombre 00:31:19
dos platos que se llaman igual son el mismo 00:31:21
y dos platos que se llaman diferente son diferente 00:31:24
el nombre es su clave primaria 00:31:27
pues me tendré que hacer un equals por nombre 00:31:30
que lo puedo sobre escribir tal cual a mano 00:31:34
porque me acuerdo yo de la cabecera 00:31:37
O lo genero 00:31:38
Con el entorno de desarrollo que estoy usando 00:31:41
Me da igual el que estéis usando 00:31:43
El eclipse ya sabemos que lo generamos de esta manera 00:31:44
Ala 00:31:50
Ya tenemos un equals 00:31:51
El me hace el hascode también, el hascode no lo estamos usando 00:31:53
Lo borramos 00:31:55
Me hace un equals por nombre 00:31:56
Entonces ahora ya si 00:31:58
Mi main ya si que va a funcionar 00:32:01
¿Vale? Porque ahora ya el remove 00:32:05
Si va a partir de igualdad de nombres 00:32:07
Entonces ahora ya 00:32:09
El problema no era mi main 00:32:11
El problema era que el plato no tenía el criterio de igualdad 00:32:12
Pues ahora yo ejecuto mi main 00:32:15
Y trato de eliminar la pizza 00:32:16
Y efectivamente 00:32:19
Ahora sí 00:32:21
Ahora sí que la ha eliminado 00:32:21
Botón derecho 00:32:23
Source 00:32:30
Generar hashcode 00:32:31
Unequals 00:32:33
Y aquí seleccionas cuál de los campos 00:32:34
Es el que fija la igualdad 00:32:38
Que puede ser uno o más de uno 00:32:39
¿Vale? 00:32:40
entonces cualquier entidad 00:32:42
que maneja una aplicación 00:32:45
pues habrá que ponerle 00:32:46
un equals, porque es que si no 00:32:49
le falta información a la aplicación 00:32:51
le falta información respecto a qué hace 00:32:53
que dos objetos sean iguales 00:32:55
porque puede haber objetos 00:32:56
que se refieren a la misma cosa 00:32:59
aunque estén en direcciones de memoria 00:33:01
distintas y eso lo tenemos que saber 00:33:03
bueno, pues aquí entonces ahora ya 00:33:05
en este mail 00:33:12
hago la siguiente pregunta 00:33:13
este main de aquí 00:33:16
en el que hemos creado un objeto 00:33:17
plato igual al que queríamos 00:33:21
borrar, idéntico en todos sus campos 00:33:24
nombre, ingredientes 00:33:26
y se lo he pasado 00:33:28
al remove, al remove que está aquí dentro 00:33:30
y ese remove no ha tenido ningún problema 00:33:32
ha encontrado uno igual a este nuevo 00:33:34
que acabo de hacer 00:33:36
ha encontrado uno igual, aunque este está en otra 00:33:36
y es de mi memoria porque es uno nuevo 00:33:39
pero ha encontrado uno igual y lo ha borrado 00:33:41
vale, y ahora mi pregunta 00:33:43
para eliminar este plato que se llama 00:33:46
pizza, para eliminar el plato que se llama 00:33:49
pizza, podríamos 00:33:51
haber simplificado un poquito 00:33:54
este código, alguna de estas seis 00:33:56
líneas, siete líneas que tenemos aquí 00:33:58
claro, solo 00:33:59
necesito para el 00:34:04
P5, el que le paso como parámetro 00:34:06
con que tenga el nombre 00:34:08
es suficiente, porque el remove, el único 00:34:10
que va a mirar, el remove solo va a mirar el nombre 00:34:12
el remove no va a mirar más, solo va a mirar el nombre 00:34:13
entonces 00:34:16
Esto me está sobrando 00:34:17
Y me está sobrando hasta esto 00:34:20
Pero como no tengo un constructor solo de nombre 00:34:23
Pues bueno, le pongo cualquier cosa 00:34:25
Como si le pusiera 100 00:34:27
Es que da igual lo que le ponga ahí 00:34:28
Ah, vale, vale 00:34:30
Pero no lo puede 00:34:43
Vale 00:34:48
Como es un double con envolvente 00:34:51
Pues no lo promociona automáticamente 00:34:53
Desde lint 00:34:55
Porque 100 a palo seco 00:34:57
100 a palo seco 00:34:59
Sería un int 00:35:00
Un int en primitivo 00:35:02
Y un int en primitivo a dabble primitivo 00:35:03
Si lo sabe promocionar 00:35:06
Pero un int primitivo a dabble envolvente 00:35:07
Como tengo aquí 00:35:10
Dabble 00:35:11
No lo sabe promocionar 00:35:13
Pero un dabble primitivo 00:35:14
Que este sería un dabble primitivo 00:35:17
A un dabble envolvente si lo sabe promocionar 00:35:18
Venga pues ya está 00:35:21
Pues este me va a borrar la pizza sin ningún problema 00:35:24
Si es que el remove que hay aquí dentro 00:35:27
Eliminar plato 00:35:29
El remove que hay aquí en eliminar plato 00:35:30
Solamente mira el nombre 00:35:32
Solo mira el nombre 00:35:34
Porque ese es el equals 00:35:34
Solo mira el nombre 00:35:35
Luego 00:35:36
Con poner aquí pizza 00:35:38
Ya está 00:35:41
¿Vale? 00:35:42
Efectivamente me borra la pizza 00:35:44
¿Que quiero borrar ensalada? 00:35:46
Pues ya está 00:35:49
Pongo aquí ensalada 00:35:50
Y ese es el que elimina 00:35:52
La ensalada 00:35:56
¿Vale? 00:35:57
Luego 00:36:07
Cuando usemos un remove 00:36:07
para eliminar 00:36:10
elementos de una colección 00:36:12
tenemos que tener muy claro que la clase 00:36:13
a la que pertenecen 00:36:15
los elementos de la colección tiene que tener 00:36:17
el equals, porque si no lo 00:36:19
tiene va a tirar del de object y eso no va a 00:36:21
funcionar bien, va a eliminar 00:36:23
solamente si son el mismo 00:36:25
sobre la misma dirección de memoria y eso no ocurre nunca 00:36:27
¿vale? 00:36:29
Bueno, pues estando esto claro 00:36:36
clarísimo 00:36:38
vamos al método 00:36:39
a la otra versión de eliminar plato 00:36:41
Que no recibía el objeto entero 00:36:45
Con lo cual recibiendo el entero 00:36:47
El remove es muy sencillo 00:36:48
Sino que recibe el nombre 00:36:50
Y que este nos daba el error 00:36:51
Porque 00:36:55
Porque dentro del remove 00:36:56
Accedía a 00:37:00
Con un for y ya teníamos un for fuera 00:37:03
Con lo cual esto que hemos hecho aquí 00:37:05
Error 00:37:07
De concurrencia 00:37:11
Vale 00:37:13
con lo cual esto de aquí no nos gusta 00:37:15
vale, pues con lo que sabemos 00:37:17
ahora, que código 00:37:22
podríamos poner aquí, para eliminar plato 00:37:24
dado su nombre, exclusivamente 00:37:26
solo el nombre, que es como querremos enviar un plato 00:37:28
a partir del nombre, claro, creamos 00:37:30
aquí un plato, con ese 00:37:34
nombre, cualquier precio 00:37:37
o lo ideal sería este, un constructor 00:37:43
solo por nombre, mejor, o uno vacío 00:37:45
y le hago el set 00:37:47
como sea, vale 00:37:48
y llamo al remove 00:37:50
y ya está 00:37:53
retuncarta.removep 00:37:54
y ya está 00:38:01
y me va a borrar 00:38:03
el primer plato 00:38:06
que encuentre exactamente igual 00:38:08
a este 00:38:10
y exactamente igual a este significa que su nombre 00:38:11
sea igual, ya está 00:38:14
porque la igualdad no mira más 00:38:15
cosas 00:38:17
vamos a probarlo en el main 00:38:19
vamos a eliminar 00:38:33
esto lo dejamos comentado 00:38:38
Y ahora vamos a eliminarla por nombre 00:38:41
No por plato, ahora ya es mucho más sencillo 00:38:56
El main 00:38:58
Porque en el main 00:38:58
El que usa el main quiere eliminar por nombre 00:39:01
No quiere tener que construir un plato 00:39:04
Quiere eliminar por nombre 00:39:05
Pues venga, vamos a eliminar la ensalada 00:39:07
Bueno, el que nos daba problemas de modificación concurrente 00:39:10
Que era el que era primero o último 00:39:14
La pizza 00:39:16
Vamos a eliminar la pizza 00:39:17
Y ahora vamos a mostrar la carta 00:39:18
Vale, llamando ahora ya el método 00:39:20
Que recibe solo el nombre 00:39:30
Que es lo natural 00:39:31
Ahora este ya no debería darnos 00:39:32
Ninguna excepción 00:39:36
¿Vale? 00:39:37
Que quiero borrar el último 00:39:39
Que el último nos daba problemas 00:39:40
Cuando hacíamos lo del for y todo eso 00:39:41
Pues ala, borro el último 00:39:43
¿Vale? Sin problema 00:39:51
Vale, vamos a poner más métodos aquí 00:39:54
Para que hagáis 00:40:19
Se supone que estos dos 00:40:21
O los habéis hecho o estáis en 00:40:23
Proceso de 00:40:24
Y vamos a poner 00:40:26
No tenemos por ejemplo 00:40:29
Eliminar todos los platos que contengan un ingrediente 00:40:30
Ese no lo teníamos 00:40:33
Tenemos eliminar un plato 00:40:36
Por nombre 00:40:38
Eliminar 00:40:40
Platos que contienen 00:40:47
El resultado final 00:40:50
De este método es que en la carta hayan desaparecido 00:41:03
Todos los platos que contengan 00:41:06
Esto de aquí 00:41:08
Pues venga 00:41:08
Haced este y los que no hayan 00:41:10
Hecho los anteriores 00:41:13
Pues los hacéis también 00:41:14
Gracias. 00:41:16
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:
7 de febrero de 2026 - 18:54
Visibilidad:
Clave
Centro:
IES ROSA CHACEL
Duración:
41′ 18″
Relación de aspecto:
1.78:1
Resolución:
1920x1080 píxeles
Tamaño:
166.48 MBytes

Del mismo autor…

Ver más del mismo autor

EducaMadrid, Plataforma Educativa de la Comunidad de Madrid

Plataforma Educativa EducaMadrid