20260204 LinkedListArrayList_1 | Mediateca de EducaMadrid

El que nos va a dar hambre, pero bueno, pues venga, modelo, ¿vale? Paquete aparte para nuestro modelo de entidades son las entidades que definen nuestro negocio, de qué se ocupa, ¿vale? Se ocupa de menús, restaurantes, empleados, camareros, ese es nuestro negocio y se traduce en un modelo y en unas entidades, ¿vale? 00:00:00

Y en caso de trabajar con una base de datos también se traducirán unas tablas, lógicamente con unas relaciones, ¿vale? Entonces esas entidades son las entidades con las que vamos a trabajar metiéndolas en colecciones, llevándolas de un sitio a otro, con lo cual los objetos de esas entidades son los que salen al mundo y son los que se exponen al mundo vía sus get y sus set, ¿vale? 00:00:26

el concepto de Get y Set, aplicadlo a entidades de un modelo 00:00:50

de negocio con el que tú trabajas, no a todas las clases por defecto 00:00:54

no, aplicadlo al concepto de entidad, bueno pues ahora nosotros estamos 00:00:58

haciendo nuestro modelo, entonces va nuestro paquete 00:01:02

model por ejemplo 00:01:06

así, ya está, y vamos a hacer 00:01:09

nuestro restaurante 00:01:14

Nuestro restaurante que tiene 00:01:18

Su nombre 00:01:25

Y nuestro restaurante 00:01:28

Tiene un montón de 00:01:34

¿Qué? 00:01:36

De platos 00:01:39

De la carta 00:01:40

Vale 00:01:42

Esto tiene 00:01:44

Entonces ahora ya por fin 00:01:47

Tenemos una propiedad 00:01:49

Que es un montón de algo 00:01:52

Ya por fin vamos a, en lugar de utilizar un array, utilizar una colección, ¿vale? ¿Qué colección? Tengo muchas posibilidades. Tengo listas y tengo conjuntos. Tengo también diccionarios, pero bueno, aunque a veces se le llama colecciones, al no heredar de colección, pues lo estudiamos aparte, después de las listas y conjuntos, ¿vale? 00:01:54

ahora mismo nosotros en mente sabemos que tenemos 00:02:19

listas y conjuntos 00:02:22

vale, pues venga 00:02:24

vamos a seleccionar un objeto lista 00:02:26

para guardar todos esos platos 00:02:29

el usar un objeto lista 00:02:31

implica que esos platos 00:02:35

en el momento de meterlos en la colección 00:02:36

van a tener un orden, van a estar ahí colocaditos 00:02:38

lo cual puede ser útil 00:02:41

por ejemplo para funcionalidades 00:02:42

del tipo 00:02:44

sácame un listado de los platos que tienes 00:02:46

porque van a salir por el orden 00:02:48

por el que tú los has introducido 00:02:50

o vas a poder ordenar 00:02:52

en un conjunto 00:02:53

el concepto de ordenar 00:02:55

no tiene sentido, porque en el conjunto 00:02:57

los elementos están así 00:03:00

los conjuntos no se ordenan 00:03:01

una lista sí, porque la lista 00:03:03

son elementos en filita 00:03:06

entonces en la lista tiene sentido 00:03:07

que tú reordenes, cambies las cosas 00:03:09

ahora la fila quiero que se ordene por 00:03:11

el alfabético, la lista quiero que se ordene 00:03:13

por precio 00:03:15

entonces en general las listas 00:03:17

las asociamos a ideas, a conjuntos de cosas 00:03:19

que por su naturaleza pues admiten orden 00:03:24

o me puede interesar a mí funcionalidades 00:03:27

en las cuales sacarlas por cierto orden tiene su sentido. 00:03:30

Entonces, bueno, es una colección muy habitual. 00:03:35

Pues venga, y aparte es la única que conocemos nosotros hasta ahora, 00:03:39

pues una lista. 00:03:42

Entonces, lista plato, perdón. 00:03:43

Lista plato. 00:03:47

Entonces vamos a hacer la entidad plato y luego ya volvemos a esta. 00:03:49

Entonces vamos a hacer nuestra entidad plato. 00:03:55

Ala, el plato porque se caracteriza tal y como va a aparecer en la carta, 00:04:01

pues el plato se caracteriza por el nombre y se caracteriza por su lista de ingredientes para ser así súper guays. 00:04:06

bueno, primero vamos a poner el precio 00:04:17

para perderle el miedo 00:04:19

a los 00:04:22

grappers 00:04:24

lo voy a declarar a propósito 00:04:24

como grappers, ¿vale? 00:04:28

que da igual, se usa exactamente igual 00:04:29

a la hora de asignar valores y de mostrarlos 00:04:32

y de operar con ellos 00:04:34

se opera igual con los operadores aritméticos 00:04:35

pero 00:04:38

el objeto, perdón, el número va a estar 00:04:39

envuelto en un objeto 00:04:42

lo cual le da 00:04:43

varias prestaciones añadidas 00:04:45

una de ellas, ¿puede ser nul? 00:04:48

¿vale? el precio 00:04:50

va a poder ser nul 00:04:51

si yo pongo un precio de Abel en minúscula 00:04:52

nunca va a poder ser nul, tiene que ser o 0 o 1 00:04:55

o menos 3, nunca va a poder ser nul 00:04:57

entonces hombre, es una prestación 00:04:59

muy buena, porque el concepto 00:05:01

de precio por definir 00:05:03

si yo lo declaro como envolvente 00:05:05

con la idea de precio por definir 00:05:07

la puedo recoger, que es poniendo un nul 00:05:09

pero si yo lo declaro con la D mayúscula 00:05:11

la idea de precio por definir 00:05:13

no podría recogerla, sí 00:05:16

tendría que añadir a lo mejor un boolean 00:05:17

que me ponga precio por definir o no 00:05:20

o acordar que precios 00:05:21

negativos significa que están sin 00:05:24

definir, pero ya son acuerdos 00:05:26

ya son como acuerdos artificiosos 00:05:27

bueno, pues venga 00:05:29

para perderle el miedo a los envolventes lo hacemos como 00:05:31

esto y ya que 00:05:34

estamos, vamos a ponerle aquí 00:05:36

la lista de ingredientes 00:05:37

del plato 00:05:40

entonces 00:05:42

Vale, pues primera cosa 00:05:45

Bueno, me faltan GetSet 00:06:03

Y constructores, que ahora los hacemos 00:06:05

Primera cosa, lógicamente 00:06:06

Me falta importar list 00:06:08

Porque list está en el 00:06:10

Paquete Java útil 00:06:13

Entonces yo, o bien 00:06:14

Llamo a list con su nombre verdadero 00:06:15

Que su nombre verdadero es este 00:06:19

Este es su nombre verdadero 00:06:21

Que no lo vamos a crear 00:06:22

Sí, claro que lo vamos a crear 00:06:25

Pero estoy declarando la propiedad 00:06:26

Ah, no, claro, sí, sí 00:06:28

No, no, no, lo que estamos 00:06:33

No, lo que vamos a hacer ya a partir de ahora es 00:06:35

Usar las colecciones 00:06:37

Claro 00:06:40

Lo otro que habíamos hecho es 00:06:40

Aparte de como ejercicio de programación 00:06:43

Interesante, para que veáis 00:06:46

Cómo están hechas por dentro 00:06:48

¿Vale? Pero luego ya, claro, usamos las colecciones 00:06:49

De Java útil, que es las que vais a usar 00:06:52

Vale 00:06:54

Vale, entonces 00:06:56

Lógicamente no quiero arrastrar el java útil 00:07:01

Porque es un rollo arrastrar 00:07:03

Su prefijo 00:07:05

Pues lo importo y ala, apañado 00:07:06

Vale 00:07:09

Voy a hacer 00:07:12

Constructor con parámetros 00:07:15

No, hombre, tampoco 00:07:17

Si no vamos a complicarlo mucho 00:07:26

Si es solo para ver el uso de las list 00:07:28

Vale 00:07:30

El ingrediente pues pepino y tomate 00:07:32

Ya está 00:07:34

Es que de hecho 00:07:35

En una carta de un restaurante 00:07:38

La lista de ingredientes de una cadena de stream 00:07:40

No tiene sin tomate 00:07:42

Color, cuanta cantidad de tomate 00:07:44

No la sueles tener 00:07:46

No tienes el nombre del ingrediente sin más 00:07:47

Vale 00:07:49

Bueno pues 00:07:52

Vale a ver bueno 00:07:53

olvidados por ahora del constructor, lo voy a meter antes 00:08:00

en otra cosa, vale, pues entonces 00:08:02

ahora es cuando me decís 00:08:04

vosotros 00:08:07

¿no hay algo que os dé un poco de angustia 00:08:07

de esta línea, alguna cosa que queréis 00:08:11

comentar, algún comentario 00:08:13

vale, va por ahí la cosa 00:08:14

ahora es cuando me hacéis el comentario de, pero 00:08:25

a ver, según lo que nos contaste 00:08:27

ayer, de lo cual nos 00:08:30

acordamos perfectamente 00:08:32

list es una interfaz 00:08:33

¿verdad? 00:08:36

list es una interfaz 00:08:37

y de la interfaz list 00:08:40

ya tengo dos implementaciones 00:08:47

ArrayList y LinkedList 00:08:51

entonces yo podría efectivamente 00:08:53

haber puesto aquí ArrayList o LinkedList 00:08:59

pero recordad que en el momento de declarar una variable 00:09:03

tú la puedes declarar como la superclase 00:09:08

luego ya otro asunto es cuando la instancias 00:09:10

cuando la instancias, la tienes que 00:09:13

instanciar ya sí o sí 00:09:15

como un objeto 00:09:17

concreto, no una interfaz 00:09:18

como una clase que exista, no una clase 00:09:21

abstracta, ¿vale? pero en el momento de 00:09:23

declararla, yo la puedo declarar 00:09:25

como la superclase 00:09:27

entonces, ¿qué puedo haber ganado declarándola 00:09:28

así? hombre, es más cómodo 00:09:31

es más cómodo ya solo por escritura 00:09:33

es más cómodo, transmito ahí la idea de que 00:09:35

esto va a ser una lista 00:09:37

en el momento de instanciarla ya decidiré cuál va a ser 00:09:38

pero ahora mismo la puedo declarar 00:09:41

como una super clase 00:09:43

pero no pasa nada, si yo aquí directamente 00:09:44

pongo linked list o la otra 00:09:47

pues ya está 00:09:49

¿vale? 00:09:51

¿qué otra cosa podría ganar 00:09:53

si yo la declaro como list? 00:09:55

pues que no me estoy comprometiendo 00:09:58

desde ahí, no me estoy comprometiendo 00:10:00

a qué tipo de lista usar 00:10:02

¿vale? en el momento de instanciarla 00:10:03

pues ya decido, ¿vale? ya decido 00:10:05

pero sobre todo es por una cuestión de comodidad 00:10:08

de hábito, ¿vale? 00:10:10

eso por un lado 00:10:11

vale, ahora 00:10:12

por otro lado, esto es como el array 00:10:16

el plato tiene un listo de ingredientes 00:10:17

siempre viene bien y es útil 00:10:20

aquí ya directamente 00:10:22

instanciar 00:10:24

es relativamente habitual 00:10:25

porque así cuando el objeto, plato 00:10:27

se instancie 00:10:30

en lugar de instanciarse con un objeto 00:10:31

ingrediente es null, que es feo y peligroso 00:10:34

como bien sabemos por el null pointer exception, 00:10:36

pues se va a instanciar con un objeto de ingredientes 00:10:38

que es una lista que no es null, pero que está vacía. 00:10:41

Ya se le meterán ingredientes más adelante, 00:10:44

pero que está vacía. 00:10:46

Entonces, es relativamente habitual 00:10:48

que hagamos esto nosotros para evitar los null pointer exception. 00:10:49

Y aquí ya sí que sí tengo que comprometer 00:10:53

o ArrayList o LinkedList. 00:10:56

¿Cuál? 00:11:01

En realidad da un poco igual, 00:11:02

pero los criterios de decisión 00:11:03

son más o menos los que hemos 00:11:05

apuntado, que es 00:11:08

el array obviamente es la estructura más eficiente 00:11:09

del mundo, que es la que está 00:11:12

directamente en memoria Java 00:11:14

por naturaleza 00:11:15

pero el array cuando empieza a ser 00:11:16

ya muy grande, es decir 00:11:20

si prevemos que en la carta 00:11:21

va a haber un montón de platos 00:11:24

pues a la hora de meter 00:11:25

platos nuevos y sacar platos 00:11:28

ya eso se puede hacer 00:11:29

menos manejable 00:11:31

entonces, si en general 00:11:32

no trabajamos con una, prevemos que esto 00:11:35

es una cantidad de datos manejable 00:11:37

y una carta lo es, esto no es como 00:11:39

hacer una aplicación que sea 00:11:41

lista de usuarios de Google 00:11:43

pues la lista de usuarios de Google puede ser 00:11:45

dos mil millones 00:11:47

aquí, platos de un restaurante 00:11:48

pues una array list, no pasa nada 00:11:51

porque la array es eficiente 00:11:53

pero si es cierto 00:11:54

que si la aplicación, las funciones 00:11:56

que va a tener sobre todo 00:11:59

Van a ser 00:12:00

Insertar y sacar, insertar y sacar 00:12:01

Pues el array es costoso 00:12:04

Pues bueno, puedo poner un link 00:12:05

Que ya hemos visto que insertar y sacar 00:12:07

Es tan fácil como 00:12:10

Mover enlaces 00:12:10

Entonces, criterio en general 00:12:13

Conjunto de datos manejable 00:12:16

Pequeñito 00:12:18

10, 15 datos, array list sin duda 00:12:19

Conjunto de datos 00:12:22

Imprevisible 00:12:24

No lo puedo calibrar por ahora 00:12:25

Ya veremos 00:12:28

Vale, pues entonces siguiente pregunta. ¿Qué va a hacer mi aplicación sobre todo? ¿Consultas o va a hacer inserciones y borrados? Si va a hacer consultas, sobre todo, sin duda, ArrayList. Si sobre todo lo que va a hacer va a ser inserciones y borrados, pues LinkedList. 00:12:29

¿Vale? 00:12:48

en este caso 00:12:49

pues se supone 00:12:53

podríamos decidir, vale esta aplicación 00:12:54

va a crear mi carta con los 00:12:57

platos y luego sobre todo se va 00:12:59

a usar pues para 00:13:01

consultar, en lugar de 00:13:03

la carta que tú repartes en cartón 00:13:05

pues le repartes una tablet a cada 00:13:07

comensal y cada comensal pues 00:13:09

cada vez que pinche 00:13:11

en plato 00:13:12

pues le saldrá 00:13:15

Tendrá la lista de ingredientes que va a servir. 00:13:17

Él no va a meter ingredientes nuevos. 00:13:21

Bueno, sí, le va a servir para consultar. 00:13:23

Pues bueno, vamos a decidir una linked list. 00:13:26

Pero el uso es igual que si dijéramos una array list. 00:13:32

¿Vale? 00:13:36

Ahora lo vemos. 00:13:36

Bueno, pues ya está. 00:13:39

Este es mi plato, que se caracteriza por estas cosas. 00:13:40

Lo normal es un constructor, claro, con parámetros. 00:13:44

Aquí también, esto no es que esto se hace así o no se hace así, no, no hay un se hace así o no se hace así, no, es relativamente habitual y tiene sentido, cuando una entidad tiene propiedades que son colecciones de cosas, pues ofrecer un constructor con su estado básico, nombre, precio, y que lo que sea colección, no inicializarlo, y que luego tú le puedas a través de otro método añadir cosas o quitárselas, es lo habitual. 00:13:47

Que tengas la posibilidad de iniciar el plato 00:14:17

Sin ningún ingrediente 00:14:20

Luego tú agregas y quitas ingredientes 00:14:21

Entonces, bueno, sería relativamente habitual 00:14:23

No es que sea lo que hay que hacer 00:14:28

Como de costumbre 00:14:30

Depende del contexto 00:14:31

De qué me pide hacer la aplicación, etc. 00:14:32

Puedes hacer un constructor con estos dos 00:14:35

¿Vale? 00:14:38

Y vamos a hacer los get y set 00:14:39

De todo, eso sí, claro 00:14:44

De todas las propiedades 00:14:45

Sus get y set 00:14:48

Y aquí 00:14:49

tendría mucho sentido poner un método 00:14:56

que fuera añadir 00:14:59

ingrediente al plato 00:15:00

aquí sí que sí, vamos a añadir un ingrediente 00:15:02

porque el plato cuando se crea 00:15:06

por primera vez, se crea sin ingredientes 00:15:08

vamos a hacer 00:15:10

que la aplicación 00:15:12

te permita ir añadiendo los ingredientes 00:15:13

claro, pues aquí 00:15:19

¿qué haríamos? public void 00:15:20

add ingrediente 00:15:23

el ingrediente 00:15:25

es un string 00:15:28

Y añadir ingrediente 00:15:30

Ahora ya sí es usar la lista 00:15:39

¿La lista cómo se llamaba? 00:15:41

La lista se llama ingredientes 00:15:44

¿Verdad? 00:15:45

Se llama ingredientes 00:15:47

Vale, pues si fuera un array 00:15:48

Si fuera un array 00:15:51

Ahora es cuando tendríamos el rollo 00:15:52

De hacer un array auxiliar 00:15:55

Con una más, copiando en el otro 00:15:58

Añadir, si fuera un array 00:15:59

Pero como no es un array 00:16:00

Sino que es un objeto lista 00:16:02

El objeto lista 00:16:04

Me ofrece métodos 00:16:06

Para hacerlo él 00:16:07

¿Vale? 00:16:09

¿Pues qué métodos me ofrece? 00:16:10

Pues me ofrece un objeto add 00:16:12

¿Vale? 00:16:13

Y con este objeto add 00:16:16

Yo ya meto el elemento 00:16:18

¿Vale? 00:16:19

Pues ya está 00:16:22

Es mucho más fácil 00:16:23

Lógicamente que un array 00:16:24

Llamo al método add 00:16:25

De la interfaz list 00:16:27

Que linked list 00:16:29

Lo tiene implementado por dentro 00:16:31

para hacer lo que ya sabemos que hace 00:16:32

todo lo de los enlaces, la recorrer, etc 00:16:34

y ya está 00:16:36

vale, este método 00:16:38

puede fallar por algún lado, puede petar 00:16:42

en algún sitio 00:16:45

su único petamiento posible 00:16:45

es que 00:16:51

el ingrediente sea null, ¿verdad? 00:16:53

porque entonces sería un null pointer exception 00:16:55

pero bueno, claro 00:16:57

pero tal y como hemos hecho 00:16:59

la aplicación, como está inicializada 00:17:01

¿vale? 00:17:03

Bueno, hay manera, a menos que alguien desde la aplicación 00:17:05

le haga un set a nul. 00:17:07

Pero ¿por qué va a hacer eso, no? 00:17:09

Claro. 00:17:11

Tenemos que confiar que la gente no 00:17:13

va haciendo esas cosas por la vida. 00:17:14

Vale, pues nuestra 00:17:18

entidad plato podría... 00:17:19

Ah, podríamos... Vale, vamos a hacerle un 00:17:21

elimina ingrediente. Porque el que 00:17:22

hace la aplicación, pues que está 00:17:25

configurando los platos para la carta, que está 00:17:27

creando la carta, pues 00:17:29

tendrá que poder eliminar ingredientes. 00:17:31

Pues venga. 00:17:33

Ingrediente 00:17:33

Vale 00:17:44

Claro, vale, entonces 00:17:45

Ingredientes 00:17:53

Vale, esto ya no es tan 00:17:55

Trivial, aunque uno lo use como si fuera 00:18:01

Trivial, no, hay que conocer los detalles 00:18:02

De nuevo, si ingredientes 00:18:05

Fuera un array, menudo rollo 00:18:08

Tendríamos que hacer array auxiliar, copiar uno en otro 00:18:10

Saltándote el que quieres borrar, etc 00:18:12

Vale, pues menos mal que no es 00:18:14

Un array, sino que es un objeto 00:18:16

list, en concreto 00:18:18

linked list, que tiene 00:18:20

un remove, de hecho 00:18:22

tiene dos, porque es un método sobrecargado 00:18:24

pero vámonos al segundo que ofrece 00:18:26

a este de aquí, tiene un 00:18:28

remove 00:18:30

que funciona de la siguiente manera 00:18:31

¿vale? 00:18:34

¿qué hace el remove? 00:18:37

coge esta lista 00:18:41

va elemento 00:18:42

por elemento desde el principio 00:18:44

desde el principio, recordad que la lista está 00:18:46

ordenada. Luego va pum, pum, pum. En cuanto encuentra un elemento igual a este, ¿y qué 00:18:48

significa ser igual? Que el método equals me devuelve true. Cuando encuentro uno que 00:18:57

es igual a este, lo saca de la lista. Todos los demás, por tanto, se desplazan una posición 00:19:02

hacia arriba. Y además me devuelve boolean, si yo quiero utilizarlo, para true se eliminó. 00:19:07

Porque podría ocurrir que después de recorrer la lista, pum, pum, pum, pum, pum, no haya 00:19:14

encontrado ninguno igual a este 00:19:17

entonces no pasa nada, no da error 00:19:19

lo que pasa es que me devuelve falso 00:19:21

entonces yo el valor de retorno true o false 00:19:22

lo puedo usar si quiero como validación 00:19:25

¿vale? 00:19:27

por ejemplo 00:19:30

yo puedo, dime 00:19:31

¿por efecto se añade último 00:19:32

casaño? 00:19:35

al final 00:19:36

el add a palo seco es al final 00:19:38

si quieres al principio es 00:19:41

add first 00:19:43

vale, entonces 00:19:43

Yo puedo usar si quiero 00:19:46

Ese boolean 00:19:49

Como valor de retorno aquí 00:19:50

Si me da la gana 00:19:54

Este método 00:19:59

¿Qué haría? 00:20:02

Vamos a documentarlo 00:20:04

Param ingrediente 00:20:06

Entonces ¿Qué hace este método? 00:20:07

Pues aquí explicaríamos 00:20:11

Este método 00:20:12

Borra 00:20:16

El primer 00:20:18

Ingrediente 00:20:19

De la 00:20:22

Lista 00:20:23

De ingredientes 00:20:25

Que sea 00:20:28

Igual 00:20:33

A el parámetro 00:20:35

¿Vale? 00:20:37

Y ahora 00:20:43

¿Qué devuelve? Pues devuelve 00:20:44

True si 00:20:47

Borró 00:20:48

False si no encontró ninguno y por tanto 00:20:49

No borró, claro 00:20:58

Vale, esto es un comentario ya bien hecho 00:20:59

Javadoc 00:21:11

entonces hacer un comentario bien hecho 00:21:12

javadoc implica 00:21:14

que el que luego use mi método 00:21:16

esta documentación la va a tener 00:21:18

como ahora veremos en el main o donde sea 00:21:22

y se le va a desplegar si está en un entorno de desarrollo 00:21:23

incompatible 00:21:26

como inteligeo, eclipse, el que sea 00:21:27

pues se le va a desplegar esa ayuda 00:21:30

entonces estupendo 00:21:31

vale, aquí 00:21:32

este boolean 00:21:37

luego el que llame a este método lo puede utilizar 00:21:39

para verificar si se borró o no 00:21:42

y decir, oye, porque si te da falso y dices 00:21:44

el ingrediente que me has dado, pues no 00:21:46

lo he podido borrar, pues tú lo puedes 00:21:48

ignorar o no, pero hombre, no deberíamos 00:21:50

pero cuando tú en una aplicación 00:21:52

mandas a hacer algo, que es una 00:21:54

realimentación del tipo, sí, se eliminó 00:21:56

o no, no pudo eliminarlo porque no 00:21:58

existe, que es una realimentación 00:22:00

pues si este método no te devolviera 00:22:01

ese valor de control 00:22:04

pues no tendrías ninguna realimentación, tú harías 00:22:06

borrar, ya está 00:22:08

ha funcionado perfectamente 00:22:10

pero no sabes si realmente lo borró 00:22:12

o te equivocaste y pusiste azúcar 00:22:14

con ese. 00:22:16

Azúcar, sí. 00:22:20

¿Tú lo pondrías en el método? 00:22:20

Lo pondrías en el que 00:22:22

llama el método, no aquí. 00:22:24

Porque si lo pones aquí lo vas a hacer con un system.println 00:22:26

y eso ya te 00:22:28

condena a que este método solo informa 00:22:30

por consola. Si luego tú 00:22:32

en el futuro quieres migrar esto a una interfaz gráfica 00:22:34

pues esta clase ya no te vale. 00:22:36

La tienes que retocar. 00:22:38

¿Vale? 00:22:40

Vale. 00:22:43

Bueno, pues primer detalle importante del remove 00:22:44

Del add 00:22:47

No hay nada que decir 00:22:48

Porque no es 00:22:50

No hay nada raro que tenga, ya sabemos lo que hace 00:22:51

Detalle importante 00:22:55

Del remove, que esto sí que tenemos 00:22:57

Que no olvidarlo 00:22:59

El remove 00:23:00

Te borra el primero que encuentra 00:23:02

Igual, solo el primero 00:23:05

Y ya está, y deja de buscar 00:23:07

Imaginaos que en la lista de ingredientes 00:23:08

Estuviera azúcar 00:23:10

dos veces, que puede estar 00:23:12

porque esto es una lista 00:23:14

luego como en la lista los elementos tienen 00:23:15

su posición, pueden estar repetidos 00:23:18

porque se distinguen perfectamente 00:23:20

por la posición en la que están 00:23:22

pues si tú pones 00:23:24

en la lista está azúcar en la quinta y en la octava 00:23:26

y tú le dices remufa azúcar 00:23:28

este método remufa 00:23:30

está programado para que te borre 00:23:32

solo el primero de todos 00:23:34

¿vale? la primera ocurrencia 00:23:36

si tú quieres 00:23:38

que te borre todos, tienes que 00:23:40

hacer remove muchas veces 00:23:42

entonces 00:23:44

vamos a hacer por ejemplo 00:23:47

aquí 00:23:48

la versión 00:23:49

en la que te 00:23:54

borra no solo el primer 00:23:56

ingrediente que encuentre igual a este 00:23:58

sino todos 00:24:00

vamos a copiar y 00:24:01

pegar esto abajo 00:24:06

borra todos los ingredientes 00:24:07

de la lista 00:24:14

entonces aquí cambiaríamos, no borra el primer ingrediente 00:24:15

todos los 00:24:18

ingredientes 00:24:20

de la lista de ingredientes 00:24:22

que sean igual al parámetro 00:24:24

vamos a hacer esta versión ahora 00:24:26

te borra todos los que sean igual al parámetro 00:24:28

no solo el primero, ese te borra el primero 00:24:30

y ya está 00:24:32

todas las listas 00:24:32

claro, todas 00:24:36

porque cada elemento tiene una posición distinta 00:24:38

entonces tú haces un add azúcar 00:24:40

ese azúcar se queda en la cera 00:24:42

Ahora haces por segunda vez 00:24:43

Haz azúcar 00:24:45

Pues azúcar ahí está, en la posición 1 00:24:46

Y puedes hacer haz azúcar 00:24:48

Pues otro azúcar en la posición 2 00:24:50

Voy a ver 3 azúcar que son 3 elementos 00:24:52

Iguales, según el equals 00:24:55

Vale, pues remove ingrediente 00:24:57

Versión 2, por ejemplo 00:24:59

O la vamos a llamar versión todos 00:25:00

Porque ingredientes 00:25:02

Todos 00:25:05

No todos los ingredientes, sino todos los que sean igual 00:25:08

Todos los que sean igual 00:25:11

Nombre un poco feo, pero bueno 00:25:13

vale 00:25:14

pues aquí tenemos un 00:25:16

voy a dejar por ahora el void para que no moleste 00:25:19

el compilador 00:25:21

vale, aquí 00:25:24

ingredientes remove, ya hemos dicho 00:25:27

que te borra el primero 00:25:29

que sea igual 00:25:31

y como lo he encontrado te devuelve true 00:25:33

si no he encontrado ninguno 00:25:36

es decir, la lista se la ha pulido entera 00:25:37

y no he encontrado ninguno, te devolvería false 00:25:39

entonces si te devuelve true 00:25:41

queremos que se ejecute otra vez 00:25:43

porque habrá otro más 00:25:46

o queremos que se ejecute otra vez porque borró uno 00:25:47

y puede haber más, no habrá otro, puede haber más 00:25:50

si te vuelve a devolver true 00:25:52

querríamos que se ejecutara una tercera vez 00:25:54

o sea 00:25:56

queremos que el ingredientes remove 00:25:58

se ejecute mientras 00:26:00

él mismo no te devuelva false 00:26:01

cuando él te devuelva false es que no encontró ninguno 00:26:03

con lo cual no queremos que se ejecute más 00:26:05

entonces 00:26:08

¿cómo pondríamos esto? 00:26:09

para que se ejecutara 00:26:11

todas las veces necesarias 00:26:13

hasta que te devolviera falso 00:26:15

¿dónde lo podríamos meter? 00:26:18

porque decís un for 00:26:25

de buenas a primeras 00:26:26

un bucle por condición de toda la vida es un while 00:26:27

un for lo asociamos más 00:26:29

a un bucle, que no es saliamente 00:26:32

porque son intercambiables, pero un for 00:26:33

lo asociamos a bucles que se ejecutan 00:26:35

un número de veces que ya a priori conoces 00:26:38

el while es el while por condición 00:26:40

que esto se ejecute 00:26:42

mientras me dé 00:26:45

true 00:26:47

siempre que sea true, con lo cual eso es un wild 00:26:48

podrías hacerlo con un for 00:26:51

pero te quedaría con un for 00:26:53

en los tres campos de los puntos y comas 00:26:55

el primero y el último vacíos 00:26:57

y solo el del medio 00:26:59

ya, pero 00:27:00

significa que 00:27:05

quiero que siga comprobando 00:27:06

entonces si ya no hay más 00:27:09

te devolverá false 00:27:11

O sea, si me devuelve true 00:27:12

Yo quiero volverlo a ejecutar 00:27:14

Esa siguiente ejecución puede que ya no encuentre ninguno 00:27:16

Entonces ya sé, ya me devolverá falsa 00:27:18

¿Vale? 00:27:21

Ya está, ya hemos terminado 00:27:30

Lo metemos efectivamente en un while 00:27:31

En un while que no necesita cuerpo 00:27:35

Fijaos que while tan raro 00:27:38

Ah, es que lo enchufa donde no es 00:27:39

Vale, este while que he puesto yo 00:27:44

Sería igual que este 00:27:56

¿Vale? 00:27:58

sería igual que hacer este while de aquí 00:28:00

en realidad este es el while que quiero hacer 00:28:04

¿verdad? un while 00:28:08

que lo único que hace 00:28:10

ya está en la propia condición, recordad 00:28:12

que en una condición 00:28:14

lo que importa es que el resultado 00:28:15

de evaluar esa condición tiene un boolean 00:28:18

pero en el propio proceso 00:28:20

de evaluar la condición se harán cosas 00:28:22

¿no? es como cuando hacíamos 00:28:24

pues mientras 00:28:26

n 00:28:30

igual a 3 00:28:32

distinto de 7 00:28:33

esta es una condición 00:28:35

perfectamente válida 00:28:38

porque esto distinto 00:28:39

de esto es un boolean 00:28:41

lo que pasa es que dentro de una condición 00:28:43

puede haber sentencias 00:28:45

que sean necesarias ser ejecutadas 00:28:47

para ya evaluar la condición 00:28:50

pues aquí estamos en las mismas 00:28:51

esto se va a ejecutar 00:28:53

cada vez que evaluemos la condición 00:28:55

es decir, el propio remove 00:28:57

se va a ejecutar cuando evaluamos la condición 00:28:58

el propio remove 00:29:01

Y a su vez te va a dar el true o el false 00:29:02

Luego es una condición 00:29:04

Entonces este while va a estar todo el rato 00:29:05

Haz el primer remove 00:29:07

Que me ha dado false, ya está 00:29:09

Ya no hace más remove, porque ya me ha dado false 00:29:11

Vale, haz el primer remove 00:29:13

Que me ha dado true 00:29:15

Pues haz un siguiente 00:29:16

Que me sigues dando true, es decir, has borrado un segundo 00:29:18

Pues hazme un siguiente 00:29:21

Que ahora ya me das false, es porque no había un tercero 00:29:23

Con lo cual el while termina 00:29:26

Entonces 00:29:27

Como un while 00:29:29

con cuerpo vacío 00:29:32

o un for con cuerpo vacío 00:29:34

es un poco feo 00:29:36

pues esto lo podemos hacer 00:29:36

cerrando aquí con un punto y coma 00:29:39

¿vale? lo podemos cerrar ahí con un punto y coma 00:29:41

si uno cierra un while 00:29:44

o un for con un punto y coma 00:29:45

significa que ese bucle 00:29:47

tiene un cuerpo vacío 00:29:49

no tiene nada de otro 00:29:51

¿significa eso que no hace nada? 00:29:52

claro que hace 00:29:54

cada vez que evaluamos la condición 00:29:55

están pasando cosas 00:29:57

cada vez que evaluamos la condición 00:29:58

no siempre 00:30:00

pasan cosas cada vez que evaluamos una condición 00:30:01

si la condición 00:30:04

es esta 00:30:06

este bucle sí que no hace nada de nada 00:30:07

porque evaluar esta condición no implica que pase nada 00:30:12

no implica que pase nada 00:30:15

entonces este bucle pues efectivamente no hace nada 00:30:16

pero este sí 00:30:18

porque evaluar la condición 00:30:20

implica que se hagan cosas 00:30:22

¿qué era la pregunta? 00:30:24

dígame 00:30:30

¿hay alguna vez 00:30:30

Claro, aquí ahora vamos a pensar, vamos a pensar cómo lo podríamos hacer, ¿vale? 00:30:34

Porque aquí el tema, ahora ya sí que tendríamos, si queremos dar un feedback, no podemos dejarlo así, 00:30:39

porque esto, si yo pongo aquí el, ¿vale? El retun, el false, el true, aquí sí que tendríamos que avisar 00:30:45

con algún indicador si encontró o no encontró, es decir, si alguna vez entró en el bucle o no. 00:30:53

Entonces, si queremos dar ese feedback, tenemos que avisar mediante una variable que luego devuelvo. Y esa variable me tiene que avisar si yo he entrado alguna vez en el bucle o no. 00:30:58

Entonces, si yo quiero hacer un feedback, sí vamos a tener que abrir este while para detectar si yo he entrado al menos una vez. Y si he entrado al menos una vez, devuelvo, ¿vale? 00:31:12

pero bueno, esto que nos asuste 00:31:22

entonces vamos a dejar esto en comentario 00:31:27

para que nadie se le olvide 00:31:29

que esto es lo que yo haría 00:31:30

si quiero borrar todos los que sean 00:31:32

igual a este, todos los que sean igual 00:31:35

vale 00:31:37

pero si queremos hacer un boolean, un feedback 00:31:38

pues venga 00:31:41

boolean ahí 00:31:42

inicialmente a falso 00:31:44

y ahora me hago 00:31:47

mi while, ahora ya con 00:31:48

su cuerpo 00:31:52

Y ya está 00:31:54

Y lo devuelvo 00:32:01

Y aquí boolean 00:32:09

¿Vale? Entonces con que entre solo una vez 00:32:11

Pues ya está 00:32:18

Ha borrado alguno 00:32:20

True si borró 00:32:21

Entonces podríamos aquí añadir en la condición 00:32:23

Si borró alguno 00:32:25

Si borró alguno devuelve true 00:32:27

Si no, nada 00:32:29

¿Vale? Pues la clase plato 00:32:31

Igual la podemos dejar así ya 00:32:35

Añadir ingredientes 00:32:36

Borrar ingredientes 00:32:39

bueno, tendría sentido mostrar la lista 00:32:41

de ingredientes, ¿verdad? 00:32:43

Vamos a hacer una cosa. 00:32:47

De nuevo, para no comprometernos con que la salida 00:32:52

sea por consola. Que el listado 00:32:54

me lo construya en un string 00:32:57

que me devuelva. Listado 00:32:58

ingredientes del plato. 00:33:03

Para listado 00:33:06

ingredientes del plato 00:33:07

no necesitamos 00:33:08

nada, porque 00:33:11

la información está en la lista de ingredientes de arriba. 00:33:13

Entonces, esto sería 00:33:18

una concatenación 00:33:19

acumulativa donde yo tengo que recorrer 00:33:22

la lista, recorrer 00:33:24

toda la lista con el for 00:33:28

hasta que 00:33:30

no acabe su tamaño, que será seguramente 00:33:32

el método size 00:33:34

y para recorrer 00:33:35

cada uno de ellos en el get 00:33:38

pues venga, para que no os aburráis demasiado 00:33:39

acceden 00:33:42

vale, pues a ver 00:33:43

hasta aquí, hasta aquí 00:33:48

más o menos fácil, ¿no? 00:33:51

¿Qué habéis hecho aquí? 00:33:52

Pues bueno, esto es una concatenación acumulativa 00:33:54

Esta es una concatenación acumulativa 00:33:56

Una concatenación acumulativa 00:34:02

La empezamos así 00:34:07

Como si fuera una suma acumulativa 00:34:09

Que la empezamos con un cero 00:34:12

Uy, cero, perdón 00:34:13

A cadena vacía 00:34:15

Vale 00:34:16

Y ahora ya vamos a recorrer 00:34:18

Todos los elementos que queremos concatenar 00:34:21

Que son todos y cada uno de los elementos de la lista. 00:34:24

¿Cómo recorremos una lista? 00:34:27

Pues con un for, ¿vale? 00:34:30

La primera, el listado de ingredientes, ¿vale? 00:34:35

¿Vale? 00:35:02

Voy, voy, voy, tranquilos. 00:35:05

Un espacio no quiero meterle, ¿qué pasa? 00:35:08

Le voy a meter un salto de línea. 00:35:10

Para que me aparezcan en, ¿vale? 00:35:12

Vale. 00:35:16

Entonces, pues este está claro, ¿no? 00:35:18

El método Ogued me permite recorrer por posición. 00:35:20

Entonces, me va a mostrar los ingredientes en el orden en el que yo los inserté. 00:35:24

¿Vale? 00:35:31

En el orden en el que yo los inserté. 00:35:32

Pero uno, dos. 00:35:34

¿Vale? 00:35:36

puedo recorrer una lista 00:35:36

también, ¿recordáis el for each que lo hemos usado 00:35:46

en Arrays? 00:35:48

pues también lo podemos usar 00:35:49

bueno, a ver que no he hecho el retun, lo podemos usar 00:35:51

en colecciones 00:35:54

un result 00:35:54

vale 00:35:59

es decir, podríamos también 00:36:00

recorrer la lista con un for each 00:36:03

de esta manera 00:36:06

Para cada string 00:36:06

En ingredientes 00:36:12

Pues result 00:36:16

Más igual y 00:36:24

¿Vale? 00:36:26

Es decir, exactamente igual 00:36:30

Que lo usábamos en Arrays 00:36:32

Pues también se puede usar para cualquier colección 00:36:34

Para recorrer una colección 00:36:36

La puedo recorrer 00:36:39

Con esta sintaxis también 00:36:40

Tiene muchos matices 00:36:42

tiene muchos matices 00:36:46

que 00:36:49

ya veremos 00:36:50

porque hay situaciones en las que puede fallar 00:36:53

pero bueno, ahora no estamos en esa situación 00:36:55

yo puedo usar un forit 00:36:57

siempre que quiera recorrer 00:36:59

cuando vamos a consultar 00:37:01

a mostrar, simplemente no tenemos que tenerle 00:37:03

ningún miedo, así podemos 00:37:05

mostrar sin ningún problema 00:37:07

si lo que queremos es 00:37:09

además modificar la colección 00:37:11

ya veremos que no es tan fácil 00:37:13

porque si luego aquí vamos a modificar 00:37:16

la colección, se va a producir un error 00:37:19

de concurrencia y es 00:37:21

el for se ha apoderado de la colección 00:37:22

ahora tú llamas a un método 00:37:25

que a su vez también 00:37:27

trata de hacer cosas con la colección 00:37:29

Java no te deja, pero bueno, eso ya surgirá 00:37:30

más adelante, pero en principio 00:37:33

un for each, para recorrer una colección 00:37:35

y mostrarla, magnífico 00:37:37

¿vale? 00:37:39

ningún problema 00:37:40

el único matiz es exactamente 00:37:41

igual que con los arrays 00:37:45

que el for each 00:37:46

recorre la colección 00:37:49

entera. 00:37:50

De principio a fin. 00:37:52

Con el for tengo más control 00:37:54

sobre cuántas iteraciones hago 00:37:56

en función de lo que ponga aquí. 00:37:59

Yo puedo quedarme en 6 menos 7 00:38:00

donde quiera. 00:38:02

Entonces este recorre la colección 00:38:05

entera. Luego para 00:38:07

mostrar, en este caso 00:38:08

mostrar lo que estamos haciendo es concatenar, pues ya está. 00:38:10

realmente podríamos optimizar 00:38:18

optimizar, lo que pasa es que no es fácil de entender 00:38:20

y ya lo dejaremos 00:38:22

para principios de segundo 00:38:25

pero bueno, como lo veréis por ahí 00:38:26

podríamos hacer una cosa 00:38:28

con las colecciones 00:38:30

que se llama serializarlas 00:38:32

y cuando las serializas 00:38:35

puedes trabajar 00:38:38

como a mogollón con ellas 00:38:39

pero eso tiene que ver con la programación 00:38:40

funcional 00:38:42

que incorporaremos más adelante 00:38:43

veremos a ver cuando podemos 00:38:46

pero lo voy a poner aquí porque 00:38:48

si lo, porque chargpt 00:38:50

lógicamente va a hacer las cosas serializando 00:38:52

porque es mucho más cómodo, pero no es fácil 00:38:54

de entender, hay que explicar bien antes lo que es la programación 00:38:56

funcional, pero solo lo pongo aquí 00:38:58

a efectos de ver o no de examinar 00:39:00

es decir, vosotros si tenéis una colección cualquiera 00:39:01

una colección cualquiera, como en este 00:39:06

caso ingredientes 00:39:08

podéis hacer una cosa que se llama 00:39:09

voy a serializarla, es decir 00:39:11

poner todos los elementos como si fuera 00:39:13

en fila para Java 00:39:16

voy a serializarla, ¿cómo se serializa? 00:39:17

pues poniendo 00:39:20

stream 00:39:22

vale, con esto 00:39:23

hemos serializado la colección 00:39:28

ya veremos un poco qué significa 00:39:30

si tú la serializas 00:39:32

puedes trabajar con ella a mogollón 00:39:33

de golpe, sin tener que ir 00:39:35

elemento por elemento recorriéndolo en un for 00:39:38

o sea, con la serialización 00:39:40

de stream, lo que desaparecen 00:39:42

son los for 00:39:44

desaparecen los for, lo puedes hacer 00:39:45

todo en una sola línea 00:39:48

entonces 00:39:49

lo pongo escrito para que veáis 00:39:50

el aspecto, pues ahora yo trabajo 00:39:53

a mogollón con toda, ¿qué es lo que quiero hacer? 00:39:55

pues quiero para cada 00:39:58

elemento 00:39:59

quiero mostrarlo 00:40:00

vale, pues hago esto 00:40:03

que es lo que me muestra 00:40:05

vale, ni quiero que entendáis 00:40:07

lo que 00:40:11

significa esto 00:40:13

nada más que por encima 00:40:14

ni lo vamos a ver ahora 00:40:17

en detalle porque es imposible, porque es programación funcional 00:40:19

lambda si es complicado 00:40:21

pero como 00:40:23

cada vez que alguien, como le preguntáis 00:40:25

cosas a HGPT todo el rato y él lógicamente 00:40:27

las colecciones las va a serializar 00:40:29

pues vais a ver 00:40:31

esto es una versión mínima 00:40:33

cosas de estas, entonces cuando 00:40:35

le pidáis ayuda con ejercicios 00:40:37

le deberíais decir 00:40:39

no me utilices lambdas 00:40:40

vale, ni 00:40:42

programación funcional, vosotros 00:40:45

le decís 00:40:47

no me utilices lambdas 00:40:48

para que no haga esas cosas raras 00:40:50

¿vale? que no son raras 00:40:55

es una forma de programar más natural del mundo 00:40:56

pero bueno 00:40:59

¿vale? 00:40:59

entonces 00:41:03

repito solo 00:41:04

para que no suene a chino 00:41:06

una colección se puede serializar 00:41:08

con stream y desde el momento 00:41:11

que la serializas se te abre un mundo de 00:41:12

posibilidades para hacer a mogollón con la colección 00:41:14

sin necesidad de ir tirando 00:41:17

con un for, una de ellas por ejemplo 00:41:18

es llamando a for each que es 00:41:21

oye a cada uno de ellos, haz lo que yo te diga 00:41:22

pues con cada uno de ellos, ven muéstramelo 00:41:24

por ejemplo 00:41:27

en este caso más que mostrarlo 00:41:27

lo que le pondríamos sería esto 00:41:30

para cada uno elemento 00:41:32

pues bueno, es que sería complicado 00:41:33

para cada elemento x 00:41:36

pues haríamos 00:41:38

result más igual 00:41:40

x 00:41:42

esto es lo que le diríamos pero que 00:41:43

vale 00:41:46

tendríamos que hacerlo con un stream builder 00:41:47

bueno 00:41:50

lo quito 00:41:51

¿vale? nada, nada, nada 00:41:53

o sea que 00:41:55

lo que yo había puesto antes era para mostrar 00:41:56

para concatenar, ahí tendría que poner otra cosa 00:41:59

tendría que poner una función lambda, pero olvidaros 00:42:01

vale, entonces lo que pasa es que no quería dejar 00:42:03

de decirlo porque es la otra forma 00:42:05

natural de recorrer una colección 00:42:07

pues serializándola, pero como 00:42:09

os olvidáis, solo que sepáis 00:42:11

que eso existe 00:42:13

y que ya lo veremos 00:42:15

Pero que ahora no 00:42:16

Vale, pues entonces 00:42:18

El Foris le voy a dejar aquí comentado 00:42:21

¿Qué os ocurre? 00:42:23

¿Qué pasa? ¿Que la huelga se hizo oficial por fin? 00:42:29

No, no sé 00:42:31

Pues 00:42:32

Vale, pues entonces 00:42:33

Listado de ingredientes 00:42:38

Ya está 00:42:40

Concatenamos y se acabó 00:42:41

Y aquí no hay mucho en lo que rascar 00:42:43

no hay mucho en lo que rascar 00:42:46

a ver, pero el tuestrin de string 00:42:47

es que tu obsesión de los métodos 00:42:54

le vas a hacer un tuestrin a string 00:42:57

tu obsesión de los métodos viene 00:42:59

porque crees que programar es llamar 00:43:01

a métodos que te hagan cosas 00:43:03

y es que no tiene nada que ver 00:43:05

programar es pienso 00:43:06

ya está, ahí lo tienes bien claro 00:43:08

el programador es el que tiene 00:43:10

un papel con un boli delante 00:43:13

todo lo demás son sucedáneos 00:43:14

No, pero creo que le refería a la lista entera 00:43:15

Sí, o sea, la lista entera 00:43:18

Sí, vale 00:43:20

Pero 00:43:24

Pues sí 00:43:25

Es que ni siquiera te hace falta, si lo pasas a un sistema 00:43:28

Que ya te llama tu stream 00:43:30

Pero no quiero que hagas eso 00:43:31

Lo que yo quiero es que me recorras la lista 00:43:33

Estamos aprendiendo a trabajar con listas 00:43:35

Porque habrá veces que no será 00:43:37

Tú el tu stream 00:43:39

Te va a servir para mostrarla 00:43:40

Pero es que aquí el tu stream no te vale 00:43:42

Porque estamos concatenando 00:43:44

Claro, aquí no te vale 00:43:46

Te vale si tú quieres hacer un 00:43:48

System.out.println 00:43:50

Vale 00:43:52

Pero es que aquí 00:43:54

No hay ninguna llamada al system.out.println 00:43:56

Vale, entonces aquí no 00:43:59

Venga, seguimos 00:44:00

A ver 00:44:02

Esta, aquí ya si hay un pelininín 00:44:04

Un pelininín más 00:44:07

Donde rascar, vale 00:44:09

Entonces, uno aquí podría pensar 00:44:10

Y hacerlo en plan a lo 00:44:13

De repente pipipipipi 00:44:14

Y decir si contiene ingrediente 00:44:16

Pues venga voy a recorrerla así un poco a lo loco 00:44:18

La recorro 00:44:21

Para cada string 00:44:23

Y 00:44:25

En ingredientes 00:44:26

O sea yo asumo de partida 00:44:29

Asumo de partida 00:44:32

Que no hay 00:44:35

Está igual a false 00:44:36

Y ahora 00:44:40

Para cada uno en ingredientes 00:44:41

Si i.equals 00:44:46

El que me han pasado 00:44:50

Entonces está igual a 00:44:51

Falso 00:44:54

Si puedes 00:44:55

Digo true 00:44:57

¿Os queréis relajar un poco? 00:44:58

¿Vale? 00:45:03

Puedes en algunos casos, no en otros 00:45:04

Por eso hay que entender 00:45:06

Al dedillo lo que estamos haciendo 00:45:07

Puedes lo que creo que me vas a decir 00:45:09

Vale, y ahora 00:45:11

return 00:45:13

esta 00:45:14

vale 00:45:16

ah, vale 00:45:18

bueno, pues podríamos hacer esto 00:45:23

y tiene sentido, ¿verdad? 00:45:25

vamos a recorrer la lista partiendo 00:45:27

inicialmente, mi supuesto es que no está 00:45:29

recorro, si encuentro un 00:45:32

contraejemplo, que este 00:45:33

es igual a ingrediente 00:45:35

lo cambio y lo devuelvo 00:45:37

¿vale? 00:45:40

vale, ¿qué ocurre aquí? 00:45:40

ocurre aquí 00:45:44

que mi criterio 00:45:44

para ver si el elemento 00:45:46

si hay algún elemento en la lista que cumpla 00:45:49

lo que yo digo, es el de 00:45:51

igualdad, es el de igualdad 00:45:53

porque podría ser 00:45:55

¿existe algún ingrediente en la lista 00:45:57

que empiece por A? 00:45:59

entonces, si es eso 00:46:01

yo aquí no pondría 00:46:03

equals, pondría así 00:46:05

charat, no sé qué 00:46:07

igual al char que yo he pasado 00:46:08

entonces ahí no sería 00:46:11

por equals, pero en este caso en particular 00:46:13

el criterio por el que 00:46:15

yo estoy viendo si el elemento 00:46:17

está o no está es porque sea 00:46:19

igual al que yo he pasado 00:46:21

vale, pues cuando el criterio 00:46:23

es ese, efectivamente tengo un método 00:46:25

estupendo que es el contains 00:46:27

¿no me vas a decir eso? 00:46:29

¿caches? que poco previsible 00:46:31

claro 00:46:33

si que puedes, vale 00:46:38

Es un código poco estructurado, feo, propio de jóvenes, no, propio de jóvenes y de Python, que es un lenguaje hecho para generación Z, ¿vale? Pero al final no se le pueden poner puertas al campo y si hay que desestructurar los códigos, pues se desestructuran. 00:46:40

¿qué significa desestructurar 00:47:05

un código? que ya no saben ni por dónde 00:47:07

sales, o sea que hay retun por todos lados 00:47:09

entonces tú tienes un código así 00:47:11

y en un código estructurado 00:47:13

sales al final 00:47:15

¿vale? en un código no estructurado 00:47:17

pues tienes if con 00:47:19

retun por todos lados o while con retun 00:47:21

entonces tu código pues 00:47:23

si tú haces eso en un diagrama 00:47:24

de flujo, pues el diagrama 00:47:27

de flujo te queda más feo que nada 00:47:29

¿vale? la idea de código 00:47:30

estructurado y código no estructurado va por ahí 00:47:33

es cierto 00:47:35

que es mucho más cómodo 00:47:36

hacer un código, efectivamente escribir 00:47:39

un código en el cual tú plantes el retorno 00:47:41

o te quieres ir y ya tienes el resultado y ya está 00:47:43

pero un código poco 00:47:45

estructurado es más ilegible 00:47:47

esa es la idea, es más ilegible 00:47:48

pero al final, pues mira 00:47:51

ya no se puede luchar contra los elementos 00:47:53

y el código no estructurado pues está 00:47:54

en todas partes, esta sería la 00:47:57

versión bonita de este método 00:47:59

¿vale? 00:48:01

vale, bueno pues entonces 00:48:06

a lo que íbamos 00:48:08

aquí efectivamente 00:48:09

el criterio que yo estoy usando para ver 00:48:11

si hay algún elemento 00:48:15

que cumpla lo que yo le he dicho 00:48:16

en la lista es el de igualdad 00:48:18

pues efectivamente tenemos un método 00:48:20

que es el contains que ya me lo hace 00:48:23

entonces todo este código 00:48:24

lo podría yo 00:48:26

haber resumido de la siguiente manera 00:48:28

ingredientes 00:48:31

punto 00:48:34

contains 00:48:34

ingrediente 00:48:36

y esto ya me devuelve un true o un 00:48:37

false, en función 00:48:41

de si hay algún elemento 00:48:43

en la lista igual a ingrediente 00:48:44

o no lo hay, esto ya 00:48:47

me lo devuelve 00:48:49

while no, o sea esto ya te dice 00:48:49

esto en un while para que 00:48:56

contains ya tiene 00:48:57

su propio bucle dentro 00:49:00

que se pone a recorrer la lista 00:49:01

en cuanto encuentra 00:49:03

un ingrediente igual 00:49:06

a este, te devuelve true. 00:49:08

Y si no encuentra ninguno, 00:49:10

te devuelve falsa. 00:49:12

Luego el 00:49:15

contains, para que funcione y tenga 00:49:16

sentido, tiene que haber un criterio 00:49:18

de igualdad definido 00:49:20

en la entidad 00:49:21

de la que forman parte 00:49:23

los elementos de la lista. Si no, no tiene 00:49:26

ningún sentido. En este caso 00:49:28

lo hay, que es string. String 00:49:30

tiene su criterio de igualdad. Y es que todos los caracteres 00:49:32

sean iguales. Luego aquí el contains 00:49:34

Funciona perfectamente 00:49:36

¿Vale? Pero luego 00:49:37

Como ya vamos a ver en plato 00:49:39

No nos va a funcionar el contains 00:49:40

Porque plato no tiene un criterio de igualdad 00:49:42

A menos que se lo pongamos 00:49:45

Pero aquí ingredientes tiene string 00:49:46

String tiene su criterio de igualdad 00:49:49

Que es equals 00:49:51

Con lo cual contains me va a mirar 00:49:51

Si existe alguno en toda la lista 00:49:54

Equals a este 00:49:57

Es decir, contains por dentro 00:49:59

Está haciendo esto 00:50:01

Si nos vamos a contains 00:50:03

Esto es lo que está haciendo. 00:50:05

Ya está. 00:50:06

Está haciendo exactamente eso. 00:50:07

¿Vale? 00:50:10

¿Pero qué ocurre si ahora me piden un método que me dice... 00:50:13

Contiene ingrediente... 00:50:22

Pues a lo mejor alguien le tiene alergia a todos los ingredientes de más de 10 letras. 00:50:27

Entonces puede tomar cordero, pero no puede tomar corderito. 00:50:34

Entonces, pues uno se le hace un método que es, contiene ingrediente largo. 00:50:37

Claro, imagínate que tú tienes alergia a todos los alimentos de más de un número de letras. 00:50:47

Entonces, necesitas que esa aplicación tenga esa funcionalidad. 00:50:54

Contiene ingrediente mayor que esto. 00:51:02

Pues aquí no hay contains que valga. 00:51:04

Aquí no hay contains que valga. 00:51:06

aquí lógicamente tendríamos que hacer 00:51:07

ya este código de aquí 00:51:09

aquí no hay 00:51:10

contains que valga, aquí 00:51:19

si length 00:51:20

y punto length 00:51:25

porque es un string 00:51:28

y punto length 00:51:29

resulta que es mayor 00:51:31

que numletras 00:51:33

pues sí, hay uno 00:51:35

mayor que el número 00:51:37

de letras, entonces esto 00:51:39

jamás lo podríamos hacer con contains 00:51:41

lógicamente, porque el contains lo que mira 00:51:43

es si existe algún elemento exactamente 00:51:45

igual al que 00:51:47

le estamos pasando. 00:51:49

¿Vale? 00:52:05

Vale, en cuanto al remove, 00:52:19

nos subimos un momentito al remove de arriba. 00:52:21

A este remove. 00:52:27

El remove y el contains 00:52:29

los dos tiran de equal. 00:52:30

Recordad, por eso es necesario que el 00:52:32

equals esté implementado en la entidad que sea. 00:52:34

Aquí es string, 00:52:37

no hay problema. 00:52:38

Equals está en string. 00:52:39

vale, remove 00:52:40

cuando hemos desplegado antes lo que había 00:52:43

hemos visto que hay dos versiones 00:52:45

de remove, borrar 00:52:47

pasamos un elemento y que te 00:52:49

borre el elemento, el primero que encuentre 00:52:51

igual a ese 00:52:53

pero también hay una versión de remove que es 00:52:54

bórrame por posición, te pasas la 0, la 1, la 2 00:52:57

depende de lo que queramos usar 00:52:59

¿vale? aquí en este 00:53:01

queremos borrar el que 00:53:03

sea igual a este, pero 00:53:05

podríamos querer borrar por posición 00:53:07

por ejemplo, una forma muy retorcida 00:53:09

de hacer esto, aquí no tendría sentido 00:53:11

hay un método que es el método 00:53:13

indexOf 00:53:15

y el método indexOf 00:53:16

si tú le pasas un elemento 00:53:25

te devuelve 00:53:28

la primera posición 00:53:30

de la lista en la que 00:53:32

encuentra que hay un elemento 00:53:34

igual según equals a esto 00:53:36

a veces es útil 00:53:37

entonces en este caso 00:53:40

una forma muy retorcida de hacer este remove 00:53:41

Podría haber sido esta 00:53:44

Ingredientes 00:53:45

Punto remove 00:53:48

Y le pasamos eso 00:53:50

Le voy a poner una variable aparte 00:53:52

Para que no quede el código tan largo 00:53:56

Int posición 00:53:58

Igual a 00:54:01

Ingredientes 00:54:02

Punto index 00:54:06

Of 00:54:09

Ingredientes 00:54:09

Y ahora borramos 00:54:11

Por la posición 00:54:14

vale, pues 00:54:15

estas dos líneas 00:54:21

y esta 00:54:23

en este caso te hacen exactamente 00:54:24

lo mismo, vale 00:54:27

index of 00:54:29

te devuelve 00:54:35

la primera posición de la lista en la que encuentro 00:54:36

un elemento igual a S 00:54:40

si hubiera varios iguales a S 00:54:41

te devuelve el primero de todos 00:54:44

solamente, el primer índice 00:54:45

en el que encuentra que hay un elemento igual 00:54:47

Entonces tú borras 00:54:49

Y ya está 00:54:51

Otra pregunta 00:54:52

Todas estas cosas no ignoran 00:54:54

Los uppercase, no ignoran las mayúsculas 00:54:57

No, a ver 00:54:59

No, a ver, es que aquí estamos 00:55:01

No, porque aquí estamos hablando 00:55:02

Del criterio equals que tenga cada cosa 00:55:04

El criterio equals de string 00:55:07

No ignora mayúsculas y minúsculas 00:55:08

O sea, tenéis que 00:55:11

Si quieres 00:55:12

Claro 00:55:13

Si tú no puedes hacer un 00:55:14

si tú quieres ignorándolo 00:55:18

no podrías hacer un contains 00:55:19

porque el contains 00:55:21

es el equals tal cual 00:55:23

entonces tú quieres el equals ignore case 00:55:25

si el equals ignore case 00:55:28

no es el equals que incorpora el contains 00:55:30

entonces 00:55:32

pues nada, recorres y ya está 00:55:33

o hay una cosa que puedes hacer 00:55:35

pasas toda 00:55:38

tu lista de ingredientes a minúscula 00:55:40

con lower, la pasas toda a minúscula 00:55:42

el ingrediente que te han dado 00:55:44

lo pasas a minúscula 00:55:45

Y ahora ya sí llamas al remove 00:55:46

A ver, pasas 00:55:48

La lista de ingredientes la pasas toda a minúscula 00:55:52

Pasas el ingrediente que te han dado a minúscula 00:55:55

Y llamas al remove 00:55:58

Ya sin más 00:55:59

Tu uppercase te pasa el string que tú le des a mayúscula 00:56:00

Bueno, a ver, no 00:56:11

A ver, lo que yo estoy diciendo es 00:56:12

que el equals de string es 00:56:16

equals, no es equals ignore case 00:56:19

entonces si tú quieres borrar un ingrediente de la lista 00:56:21

ignorando mayúsculas y minúsculas 00:56:23

entonces no puedes hacerlo 00:56:25

con remove, tendrías que 00:56:27

recorrer la lista 00:56:29

y con cada uno 00:56:30

si equals ignore case, pues entonces 00:56:32

lo que sea, que queremos hacerlo 00:56:35

con remove, pues entonces 00:56:37

llevamos toda la lista a minúscula y el 00:56:39

ingrediente a minúscula o al revés, toda la lista 00:56:41

a mayúscula y el ingrediente a mayúscula, lo que quieras 00:56:43

¿vale? 00:56:45

vale, pues entonces esto es una forma 00:56:46

esto de aquí es una forma muy retorcida 00:56:49

de hacer esto mismo, aquí lo único 00:56:51

es la validación 00:56:53

el index 00:56:55

of te devuelve la 00:56:57

posición del elemento que ha encontrado 00:56:59

igual, si no ha encontrado ninguno 00:57:01

te devuelve menos uno 00:57:03

entonces se lo meteríamos en un bucle que sería 00:57:04

while pos igual a esto 00:57:07

diferente de menos uno 00:57:09

mientras sea diferente de menos uno 00:57:10

vale, es decir 00:57:12

tendríamos que hacer 00:57:17

por ejemplo 00:57:18

y ahora 00:57:24

mientras la posición 00:57:26

siendo la posición igual 00:57:32

el índice de ese ingrediente 00:57:34

sea 00:57:36

diferente de menos 00:57:37

uno, sea diferente 00:57:40

de menos uno, pues mientras 00:57:42

sea diferente de menos uno es porque sigue habiendo 00:57:44

un ingrediente así, lo borro 00:57:46

por posición y además 00:57:48

aviso de que está para 00:57:50

boolean 00:57:52

Está igual a false 00:57:54

Y avisaría de que he borrado uno 00:57:56

Está igual a true 00:58:00

Es decir, todo este código 00:58:02

Es equivalente al de abajo 00:58:05

¿No? 00:58:06

Es una tontería, vamos, que hemos hecho 00:58:08

Para que veamos el index of 00:58:09

Return está 00:58:11

Todo este código de arriba 00:58:12

Hace exactamente lo mismo que el de abajo 00:58:15

Exactamente lo mismo 00:58:18

Luego efectivamente un poco tonto 00:58:19

Pero bueno 00:58:24

Ya sabemos lo que es el index of 00:58:26

lo voy a dejar comentado 00:58:27

vale, pues plato ya tiene aquí 00:58:40

un montón de funcionalidades, de cosas 00:58:49

¿qué le pasa 00:58:51

al restaurante? 00:58:53

bueno, pues el restaurante lo que tiene ahora es una lista 00:58:55

de platos, ahora esto ya no es tan 00:58:57

trivial, porque la colección 00:58:59

tiene platos que puede no tener equals 00:59:01

tendríamos que hacérselo 00:59:03

etcétera 00:59:04

vale, pero vamos a seguir el mismo criterio 00:59:06

que es, vamos a 00:59:08

crear platos 00:59:11

Pues venga, railis para variar 00:59:13

Y ahora un constructor 00:59:14

Con el nombre del plato 00:59:24

Solamente, ya se van añadiendo platos 00:59:30

A la carta 00:59:31

Sus getter y sus setter 00:59:32

Sus getter y sus setter 00:59:36

Y ahora, ¿qué métodos 00:59:45

Nos interesa hacer? 00:59:51

Los dejamos aquí escritos y planteados 00:59:53

Para que los hagáis 00:59:55

Pues bueno, con el restaurante nos va a interesar 00:59:57

Añadirle un plato a la carta 00:59:59

Claro, ese nos va a interesar 01:00:01

¿Qué más nos va a interesar? 01:00:03

Pues 01:00:12

Del restaurante 01:00:12

Pues ver la carta 01:00:15

Que me lo devuelva como stream también 01:00:16

Ver la carta del restaurante 01:00:20

¿Vale? 01:00:26

Por ejemplo 01:00:33

¿Qué otra funcionalidad? 01:00:34

Ver los platos que contienen un ingrediente 01:00:36

Para así 01:00:38

Eliminarlos 01:00:40

De nuestras opciones 01:00:42

Public stream 01:00:44

Platos con 01:00:48

Ingrediente 01:00:51

Pasamos el ingrediente 01:00:53

Y me devuelve un listado 01:00:58

De los platos que lo tengan 01:00:59

Para decir esto, no 01:01:00

De los platos que contengan ese ingrediente 01:01:02

Bueno, eliminar un plato de la lista 01:01:09

Claro 01:01:20

Boolean, eliminar un plato 01:01:20

De la carta, que no lo queremos 01:01:28

Eliminar un plato 01:01:30

Dando el nombre de ese plato 01:01:36

Estoy poniendo los retun 01:01:39

Para que el compilador no falle 01:01:41

Damos el nombre del plato 01:01:43

Y eliminar el plato 01:01:46

De esa carta 01:01:47

¿Qué más cosas 01:01:49

Nos puede interesar hacer con la carta del restaurante? 01:01:51

Buscar un plato con un nombre 01:01:59

Para ver qué ingredientes tiene 01:02:01

Por ejemplo, mostrar ingredientes 01:02:02

Efectivamente 01:02:04

Pero que te devuelva el plato 01:02:05

Dices, buscar un plato y que te lo devuelva 01:02:12

Si, lo que pasa es que el plato solamente tiene 01:02:14

Nombre y 01:02:15

Claro, y como plato solamente tiene 01:02:17

Nombre e ingredientes 01:02:25

O sea, le das el nombre del plato 01:02:26

Te devuelve el plato entero que a su vez 01:02:27

Tiene el mismo nombre e ingredientes 01:02:30

Por eso decía que te devuelvan los ingredientes directamente 01:02:31

¿No? 01:02:33

De hecho, vamos a hacerlo así para cambiar 01:02:35

Es que así no 01:02:37

Vamos a hacer un método que te devuelve 01:02:38

Este es el que es más interesante 01:02:40

Bueno, que es una 01:02:44

Listar 01:02:46

No, get ingredientes 01:02:47

De un plato 01:02:53

Y que vamos a pasar el nombre 01:02:54

De ese plato 01:02:57

Y que te de los ingredientes de ese plato 01:02:57

Si lo hubiéramos puesto precio 01:03:03

Tendría un poco más de interés 01:03:06

Vamos a ponerle al 01:03:08

Ah, que claro que tiene precio 01:03:12

Y estamos pasando el precio completamente 01:03:14

pero que no lo hemos usado 01:03:15

para nada, entonces ahora ya en restaurante 01:03:20

sí, vamos a usar 01:03:23

por ejemplo 01:03:24

mostrar 01:03:27

cuenta no porque no hay 01:03:29

un objeto que sea pedido 01:03:31

que se podría añadir el pedido 01:03:32

una comanda concreta, vale 01:03:34

pues vamos a 01:03:36

ahora ya sí 01:03:38

que me devuelva el nombre 01:03:40

del plato 01:03:42

más caro de todos 01:03:44

Porque ya que vengo 01:03:46

Pues me voy a dejar la pasta 01:03:47

Exacto 01:03:49

El que recomiendas a tus clientes 01:03:56

Devuélveme pues te recomiendo 01:03:58

Las gambas fritas 01:04:00

Por ejemplo 01:04:02

Venga y vamos a dejar estos métodos así por ahora 01:04:05

¿Vale? 01:04:20

Pues ala, os ponéis con ellos de aquí al viernes 01:04:23

Y el viernes nos vemos 01:04:26

20260204 LinkedListArrayList_1 - Contenido educativo

Del mismo autor…

BUDDIES 2026

Halloween en el Ies el Olivo

Navidades Geométricas

DÍA DE LA PAZ Y LA NO VIOLENCIA

20260205 JPA-DTO-SPRINGBOOT_3

20260205 JPA-DTO-SPRINGBOOT_2

20260205 JPA-DTO-SPRINGBOOT_1