20250211 RepasoColecciones_2 | Mediateca de EducaMadrid

vale 00:00:00

por último 00:00:02

en cuanto a las listas 00:00:04

precisamente en relación a la posición 00:00:06

tenemos este método 00:00:08

que es estupendo 00:00:11

que es el método short 00:00:12

vale 00:00:14

claro, el método short 00:00:15

como bien sabéis 00:00:18

los que habláis inglés 00:00:20

porque ya del resto ya pasamos 00:00:21

del método short 00:00:23

silencio 00:00:27

que hace el método 00:00:31

Jesús 00:00:34

eso mire 00:00:35

que hace el método short 00:00:38

pues como bien dice su nombre 00:00:39

David se te ha tirado una vez 00:00:41

como bien dice su nombre 00:00:43

ordena 00:00:45

pero repito 00:00:46

Juanjo cállate, callaos todos 00:00:48

hablad por señas, whatsappearos 00:00:50

algo que no haga ruido 00:00:52

cualquier cosa 00:00:54

pues los ruidos cuando hablo, sí 00:00:55

el sonido de fondo hablando 00:00:58

os oigo a todos 00:01:03

bla bla bla bla bla 00:01:06

también oigo a Gonzalo 00:01:07

bla bla bla bla bla 00:01:11

con Pablo 00:01:12

silencio 00:01:14

pues los oigo a todos 00:01:19

vale, a ver, ordenar 00:01:21

ordenar implica 00:01:23

un criterio de ordenación, ¿no? 00:01:24

Oye, ¿y según qué criterio de ordenación 00:01:27

me quieres ordenar? Este huequito 00:01:29

está para darles 00:01:31

criterios de ordenación. 00:01:32

Pero no lo vamos a meter ahora todavía 00:01:34

a darle criterio de ordenación, porque 00:01:36

vamos a 00:01:38

aligerar un poco de cara al examen. 00:01:40

Entonces, no le voy a dar un criterio de ordenación, 00:01:43

con lo cual le pongo null. 00:01:44

Tranquilo, que te puede la ansiedad. 00:01:47

Relájate. 00:01:49

cuando tiene sentido que yo meta aquí un criterio de ordenación 00:01:49

cuando los objetos que están en la colección 00:01:55

no lo tienen ellos mismos 00:01:58

porque si el objeto de la colección 00:02:01

que pide ser ordenada 00:02:05

tiene ya dentro de él su criterio de ordenación 00:02:06

yo no se lo tengo que dar al método 00:02:09

si no lo tuviera dentro de él se lo tengo que dar 00:02:11

vale, pedidos uno 00:02:16

puede tenerlo dentro de él 00:02:18

y cuando digo dentro de él digo aquí si yo se lo doy 00:02:20

hay un método 00:02:22

que puedas crear dentro de pedidos 00:02:23

a ver 00:02:26

para que sea un criterio de ordenación 00:02:27

claro, a ver 00:02:29

hay dos cosas distintas 00:02:31

pedido, pedido tiene criterio de igualdad 00:02:34

eso está claro 00:02:36

tiene criterio para saber si yo soy igual a otro 00:02:37

pero no tiene criterio 00:02:41

para saber si yo voy antes 00:02:42

que otro o después que otro 00:02:44

ese no, el criterio de ordenación no lo tiene 00:02:46

si yo se lo quiero dar 00:02:48

se lo tendré que meter aquí dentro 00:02:50

igual que le he metido el criterio de igualdad 00:02:52

ahí dentro, en la clase pedido 00:02:54

igual que le he metido el criterio para que un objeto 00:02:55

pedido sepa si es igual a otro 00:02:58

pues si quiero meter el criterio para que un objeto 00:02:59

pedido sepa si es 00:03:02

si va antes que otro o después que otro 00:03:03

se lo tengo que pedir aquí, que meter aquí 00:03:06

vale, eso ya lo hicimos 00:03:07

meter un criterio de ordenación 00:03:09

dentro de una clase 00:03:12

¿Y cómo lo decíamos? Vale, pues si tú quieres saber si vas antes que otro o vas después, significa que lo que tú quieres es ser comparable con otros. ¿Quieres ser comparable con otros? Pues si quieres ser comparable con otros, tienes que implementar la interfaz comparable. 00:03:13

eso ya viene de base 00:03:30

esto ya lo vimos, claro, esto ya está hecho 00:03:32

la interfaz comparable 00:03:34

al menos mal que el criterio de ser 00:03:35

igual a otro lo han aligerado 00:03:39

y con implementar el método ya está 00:03:41

no te obligan a implementar la interfaz 00:03:42

igualable, podría haber sido así 00:03:45

pero ahí no hace falta 00:03:47

entonces 00:03:48

pues comparable 00:03:49

antes de, si tú implementas una interfaz 00:03:52

tienes que implementar todos los métodos que la 00:03:54

implementan, que están 00:03:56

decididos en ella. Pero antes que nada, 00:03:58

comparable es una clase genérica. 00:04:00

Tú puedes, si yo implemento 00:04:03

comparable a palo seco, 00:04:04

me convierto en comparable con 00:04:07

cualquiera del universo. 00:04:08

Yo he pedido, me puedo comparar 00:04:11

con una silla o con un gato. 00:04:12

No tiene sentido. En mi aplicación 00:04:14

no suele tener sentido quién va antes, 00:04:16

este gato o esta silla. No. 00:04:18

Normalmente en mi aplicación yo quiero ordenar 00:04:20

sillas entre sí, gatos entre sí o pedidos 00:04:22

entre sí. Luego, como eso es lo que 00:04:24

yo suelo querer hacer, vamos 00:04:26

a parametrizar la interfaz comparable y decir 00:04:28

oye tú, pedido que estás 00:04:30

aquí, quiero que seas comparable 00:04:32

pero con otros pedidos 00:04:35

no con cualquier bicho del universo 00:04:36

solo con otros pedidos 00:04:38

vale, pues entonces yo ya 00:04:40

parametrizo comparable 00:04:43

con pedido, y ahora ya 00:04:44

vale, muy bien, como implemento comparable 00:04:47

¿qué método tengo que implementar? 00:04:48

pues el entorno de desarrollo 00:04:51

la bolsita de comida 00:04:52

No sé cómo se implementa una música de su vida. 00:04:58

Vale, entonces, 00:05:02

como tengo un entorno de desarrollo 00:05:03

que son patontos, 00:05:05

entornos de desarrollo, pues no tengo que buscar qué método es, 00:05:06

me lo dice. Oye, 00:05:09

¿qué es compare tú? Ojo, ¿qué es compare tú? 00:05:11

Venga, méteme el código. 00:05:13

Pin, pin, Adam Implemented Methods. 00:05:15

Y ya el entorno de desarrollo 00:05:17

que es patontos, te dice, 00:05:19

ese es el que tienes que implementar. 00:05:20

¿Qué pones aquí? Yo qué sé, 00:05:22

lo que tú quieras. 00:05:24

¿vale? esto estoy repitiendo 00:05:25

esto ya lo contamos para ordenar a raíz 00:05:27

¿vale? ¿cómo funciona este método? 00:05:29

lo que la humanidad 00:05:32

sobreentiende 00:05:33

es que el objeto que llama al método 00:05:34

irá antes que este 00:05:37

objeto pedido si el valor 00:05:39

entero devuelto es negativo 00:05:41

será el mismo 00:05:42

si el valor es cero y el que llama 00:05:44

al método irá después 00:05:47

que el parámetro si el valor devuelto 00:05:49

es positivo, luego 00:05:51

sabiendo eso, que eso lo tenemos que respetar 00:05:53

sí o sí, para que no se caiga toda la coherencia 00:05:55

del edificio, pues 00:05:57

ahora ya pensamos, vale, ¿cómo quiero 00:05:59

yo ordenar mis pedidos? ¿Cómo 00:06:01

queréis? ¿Por ID? ¿Por 00:06:03

orden alfabetico de descripción? ¿Por de 00:06:05

baratos a caros? Vamos a ordenarlos por precio. 00:06:07

¿Por ID? No, pues por 00:06:09

precio, que quiero yo por precio. 00:06:11

Pero yo quiero con ID. Ya, pero yo 00:06:12

mando. Entonces, lo vamos a ordenar 00:06:15

por precio. Te lo podría ordenar por 00:06:17

las dos cosas. Y si me 00:06:19

picas, te meto el comparator. 00:06:21

Pero mejor. 00:06:23

Vale, el comparator es el dárselo aparte de este, pero espera, no he dicho nada, ahora lo incorporamos pero no lo decimos, si lo puedo mencionar, lo puedo mencionar sin explicarlo para que tu ansiedad tenga su, vale, vamos a ordenar por precio, vale, pues hombre, pues ahora ya pensamos, como somos muy listos, pensamos, 00:06:25

yo quiero que el que llama al método 00:06:51

cuando el precio sea menor que este 00:06:53

me devuelva un negativo 00:06:56

cuando el precio sea el mismo me devuelva 00:06:57

cero y cuando el precio del que llama al método 00:07:00

sea mayor que este me devuelva 00:07:02

el positivo, hombre pues jolín me han puesto a huevo 00:07:04

pues devuelvo 00:07:06

retún precio 00:07:08

menos o punto 00:07:10

precio y ya está 00:07:12

esto evidentemente, si el precio 00:07:13

del que llama al método 00:07:16

es menor 00:07:17

esta resta va a ser negativa 00:07:18

lógicamente, luego me va a devolver un negativo 00:07:21

si el precio es el mismo 00:07:23

me va a devolver cero 00:07:25

y si el precio del que llama el método es mayor 00:07:26

que el parámetro, me va a dar 00:07:29

esa resta es positiva, luego me va a dar un número positivo 00:07:30

pues hombre 00:07:33

lo que pasa es que como precio es double 00:07:34

pues por eso me dicen, eh, casting 00:07:36

pues venga, no pasa nada, casting 00:07:38

hago un casting de la resta 00:07:40

ahí 00:07:45

tú puedes ordenar como tú quieras 00:07:45

o más que nada como te haya pedido el jefe. 00:07:49

Si te dice que ordenes 00:07:52

por orden alfabético, pues 00:07:53

tendrías que usar el 00:07:55

compare tú de la clase string, que es el 00:07:57

que te devuelve menos uno en función de 00:07:59

qué string. Por ejemplo, que queremos 00:08:01

ordenar por orden alfabético. Vamos a ponernos un comentario. 00:08:03

Eso, 00:08:07

retune. 00:08:07

Descripción. 00:08:10

El string ya tiene el compare tú incluido. 00:08:11

Claro, descripción punto compare 00:08:13

tú 00:08:15

o punto descripción. 00:08:16

vale, pues 00:08:18

si pusiéramos el código de abajo 00:08:22

estaríamos ordenando por orden alfabético 00:08:24

este por orden de precio 00:08:26

vale, pues entonces 00:08:28

esta clase precio ya tiene 00:08:30

el comparable, que esto nos interesa 00:08:32

que lo entendamos bien porque en el triset 00:08:34

lo vamos a usar ahora 00:08:36

vale 00:08:37

vale, entonces ahora 00:08:39

yo puedo llamar a sort 00:08:45

y decirle ordena 00:08:47

y aquí no hace falta que le dé ningún criterio de ordenación 00:08:48

no hace falta, porque ya pedidos uno 00:08:51

ya lo tiene, él ya implementa comparabil y lo tiene 00:08:53

entonces si yo le pido que ordene 00:08:55

y ahora lo vuelvo a recorrer 00:08:57

me lo va a ordenar 00:08:58

por orden de precio 00:09:01

entonces se lo voy a 00:09:02

por orden de precio 00:09:05

en este caso, entonces le voy a poner 00:09:07

le voy a poner 3 00:09:09

1 00:09:13

y 2 00:09:15

para ver 00:09:18

si me los ordena bien por orden de precio 00:09:19

y este remove lo voy a quitar 00:09:21

para que 00:09:22

tenga los tres que he metido 00:09:24

entonces voy a tener estos tres que están desordenados por precio 00:09:26

y ahora 00:09:29

a ver si me los muestra ordenados 00:09:30

eso justo iba a hacer 00:09:33

que me muestre también el precio 00:09:36

mejor si hubiéramos hecho un to string en pedido 00:09:38

más práctico, pero bueno 00:09:46

vale, ejecutamos esto 00:09:47

y efectivamente el sort 00:09:50

me lo ha ordenado por precio 00:09:52

vale 00:09:53

vale, podría ocurrir 00:09:55

que esto es lo que no vamos a concretar 00:09:58

ahora con código, pero para inquietudes 00:10:00

varias, podría ocurrir 00:10:02

que yo quiera ordenar en mi aplicación 00:10:04

esta de aquí, yo quiero ordenar 00:10:06

por precio, y quiero ordenar por precio 00:10:08

pero la clase pedido no la he hecho yo 00:10:10

la tiene Pepito, y o bien 00:10:12

no puedo implementar 00:10:14

comparable, o bien tiene ella un comparable 00:10:16

por orden alfabético 00:10:18

entonces, si tiene un comparable por orden alfabético 00:10:19

y yo quiero ordenar por precio 00:10:22

esto no lo puedo usar 00:10:23

claro, entonces ¿qué hago? 00:10:25

hago un objeto, no, pero es muy sencillo 00:10:28

ya lo incorporamos enseguida 00:10:30

hago un objeto 00:10:31

que es simplemente un objeto 00:10:34

criterio de comparación, no asociado a nada 00:10:36

suelto 00:10:38

que es un objeto comparator, que se llama 00:10:38

se lo meto aquí, y entonces sort 00:10:41

ordenará según el criterio 00:10:43

que yo le meta aquí, no el que tenga 00:10:46

la clase pedido, no ese 00:10:48

entonces yo me hago un objeto 00:10:49

comparator que digo tú, comparator 00:10:52

compara en función del precio 00:10:54

de esta clase pedido que te estoy diciendo 00:10:56

le paso eso ahí justo 00:10:57

y ya está, pero eso 00:11:00

ahora mismo lo olvidamos, vamos a pensar 00:11:01

que short yo le puedo decir 00:11:04

no te pasó nada 00:11:05

porque los objetos pedido 00:11:08

de pedidos uno ya tienen el criterio dentro 00:11:10

pues ordename por ese que tienen dentro 00:11:12

que es el que yo quiero y es el que me vale 00:11:14

y como vemos ordena, ¿vale? 00:11:15

luego 00:11:18

todos los verifuetos y 00:11:19

vicisitudes de ArrayList 00:11:22

están todas 00:11:24

expresadas. 00:11:26

¿Vale? 00:11:28

Si 00:11:30

miráramos los de LinkedList 00:11:30

por curiosidad, 00:11:34

veríamos que son los mismos 00:11:36

más unos añadidos, pero que nos dan 00:11:37

igual. 00:11:40

Pasamos. 00:11:43

Si miramos los de LinkedList, 00:11:47

Vemos que prácticamente son todos igualitos. 00:11:54

Pero hay algunos extra que no estaban en... 00:11:58

Que son estos del pollo, estos de aquí. 00:12:01

El pick, el pick, el poll, el poll first, el poll, el pop, el push. 00:12:03

Estos que empiezan con la P. 00:12:08

Estos resultados solo están en linked list. 00:12:10

¿Por qué? 00:12:12

Porque linked list, por sus características de que son nodos dados de la manita, 00:12:14

es muy flexible 00:12:18

para simular 00:12:20

más que flexible, justo 00:12:21

se adapta muy bien computacionalmente 00:12:24

en cuanto a carga computacional 00:12:26

a simular las pilas y las colas 00:12:27

entonces 00:12:30

te dicen, oye, si tú 00:12:32

tienes una aplicación en la cual 00:12:33

tu estructura de todo es una pila, es decir, tú quieres meter 00:12:36

en la pila y luego desapilar y siempre 00:12:38

cuando metas quieres que caiga arriba 00:12:40

y siempre cuando sacas quieres que salga el de arriba 00:12:41

que es una pila por definición 00:12:43

si tú tienes una aplicación en la que ese es el funcionamiento que tú quieres 00:12:45

usa una linked list y usa 00:12:48

los métodos push y pop 00:12:50

y tan ricamente 00:12:52

y ya está, entonces esto 00:12:54

que existan aquí 00:12:56

te induce a que tú 00:12:58

uses la linked list y quieres usar 00:13:00

pilas y colas 00:13:02

y ya está, nada más 00:13:03

entonces aquí uno 00:13:06

puede ver cada método de estos lo que significan 00:13:08

pues push te pone 00:13:10

en la primera posición de la, push es 00:13:12

at first, es lo mismo, te lo dice 00:13:14

aquí, push es añade el 00:13:17

primero, lo que pasa es que se llama 00:13:18

push para que tu código quede más bonito y se vea 00:13:20

claro que es una pila, etcétera, pero es lo mismo 00:13:23

¿vale? pop 00:13:24

es, elimina el 00:13:26

primero, es lo mismo, elimina el primero 00:13:28

¿vale? 00:13:30

con la diferencia de que te lo devuelve 00:13:32

¿vale? te lo devuelve 00:13:34

pero remove first 00:13:37

no te devuelve, ah si remove first 00:13:39

te devuelve true o false 00:13:41

entonces estos métodos 00:13:42

son métodos que están 00:13:44

en realidad redundantes porque se pueden hacer 00:13:46

con métodos de arriba, se pueden hacer con métodos de arriba 00:13:48

pero les cambian el nombre 00:13:50

para inducirte a ti a que si 00:13:53

usas estructuras que funcionan como 00:13:54

pilas y colas, lo hagas con una linked list y usas esos 00:13:56

métodos y el que lee el código 00:13:58

lo ve más claro, lo ve más bonito 00:14:01

ah mira si es una pila patatina 00:14:02

ya está, vale, es la única diferencia 00:14:04

entre linked list y array list 00:14:07

vale, normal 00:14:08

si aparte 00:14:12

de implementación, en cuanto a uso me refiero 00:14:14

en cuanto a uso. Vale, de listas 00:14:16

¿alguna duda? No, ¿verdad? 00:14:18

Bueno. 00:14:23

Claro, la clave es 00:14:26

que ese método te devuelva 00:14:31

menos 1, 0, 1 y tú ya lo programas 00:14:32

por dentro, como Dios te dé a entender, para que eso ocurra. 00:14:35

Y ya está. Vale. 00:14:37

Conjuntos. 00:14:40

Implementaciones de set. 00:14:45

Pues ya la sabemos. 00:14:50

haset 00:14:52

linked haset que es lo mismito 00:14:54

ahora vemos la única diferencia que tienen 00:14:57

y triset que es 00:14:59

casi lo mismito 00:15:01

ahora lo vemos rápidamente 00:15:02

¿en cuánto nivel de detalle 00:15:04

estamos hablando exactamente? 00:15:08

pues depende 00:15:10

no pidas no vaya a ser 00:15:10

que se te conceda 00:15:14

y luego te arrepientas 00:15:15

vale, a ver 00:15:18

conjuntos, pues venga 00:15:20

es como la mano de mono 00:15:22

yo nunca diré de este agua 00:15:23

nunca digas de este agua no me veré 00:15:24

ni este cura no soy mi padre 00:15:29

sí, porque un cura acogido al azar 00:15:30

tiene muchas probabilidades de ser el padre de cualquiera 00:15:33

a ver, prueba listas 00:15:35

prueba conjuntos 00:15:37

de verdad, ¿no? 00:15:38

prueba conjuntos 00:15:46

Prueba conjuntos 00:15:48

Pues ya con todo lo que hemos visto 00:16:00

Es que esto ya lo revisamos en un pipas 00:16:05

Vale, ahora yo quiero 00:16:07

Que 00:16:12

Mis pedidos ya no los quiero en listas 00:16:13

Como aquí, los quiero en un conjunto 00:16:16

Pues venga, vamos a centrarnos en un hash set 00:16:18

De nuevo 00:16:20

Lo parametrizo, pues ya sabemos por qué 00:16:24

Importo de java útil 00:16:26

Que es el paquete de colecciones 00:16:37

Vale 00:16:38

Y es que ahora ya los métodos 00:16:40

Son prácticamente idénticos 00:16:43

También depende de colección 00:16:45

Sí, sí, sí, set depende de colección 00:16:46

Y hash, y todas las que 00:16:49

Claro, de colección implementan 00:16:50

Estaba aquí, colección list 00:16:53

y set 00:16:55

vale 00:16:57

entonces ahora ya si vemos los métodos 00:16:58

pues es que son 00:17:02

prácticamente iguales que los de array list 00:17:03

eliminando todo lo que 00:17:05

hace referencia a las posiciones 00:17:07

lo que pasa 00:17:09

es que claro, ahora simplemente tenemos que entender 00:17:12

cómo van a 00:17:13

funcionar 00:17:16

entonces, pedidos 00:17:16

añadir a un set 00:17:19

está claro, añadir 00:17:22

muchos de golpe 00:17:23

vaciar el set entero, hacer un clon que da igual 00:17:24

ver si hay un objeto 00:17:27

igual a otro en el set 00:17:29

exactamente igual 00:17:30

que funciona con el list 00:17:33

diferencia 00:17:35

el hash set 00:17:37

justo 00:17:39

para saber si 00:17:41

uno es igual a otro 00:17:43

tiene que tener los dos 00:17:44

entonces si usáis 00:17:47

un hash set de objetos de una clase 00:17:49

En esa clase tienen que estar los dos, el Haskell de Equals. 00:17:51

Pero en un Haskell no se podían meter los idénticos. 00:17:56

No, pero, claro. 00:17:59

Porque tiene un... 00:18:01

Precisamente por eso. 00:18:02

Claro, entonces aquí, por ejemplo, ¿vale? 00:18:04

Vamos a añadir a pedidos estas tres cositas. 00:18:06

Ahora lo añadimos a nuestro conjunto. 00:18:10

Sí, lo voy diciendo y me doy cuenta mientras lo digo. 00:18:12

No pasa nada. 00:18:14

Vale, entonces, aquí. 00:18:15

Aquí está claro. 00:18:21

¿cuántos elementos va a haber en la colección 00:18:23

pedidos una vez hechos estos 00:18:25

tres inserts? 00:18:27

si yo hago ahora esto 00:18:31

siso 00:18:33

pedidos.size 00:18:35

¿qué me va a mostrar? 00:18:37

dos 00:18:40

porque el criterio de igualdad es el id 00:18:41

el id recordad que es este primer 00:18:43

campo, entonces este 00:18:45

y este es igual, aunque el nombre sea 00:18:47

distinto, este 00:18:49

y este es igual, entonces si yo ejecuto 00:18:51

esto. ¿Qué ha pasado? 00:18:53

Vale. 00:19:03

Si yo ejecuto esto, pues me sale dos. 00:19:05

¿Vale? Me sale dos. ¿Está claro, no? 00:19:08

Sí, sí, sí. Yo sé 00:19:10

que sí, que está claro. 00:19:11

Sí, sí, está claro. 00:19:13

Vale. 00:19:15

Entonces, 00:19:18

el contains, ¿qué hemos dicho? 00:19:19

pues el contains 00:19:21

el remove, es que funcionan igual 00:19:24

la única diferencia es eso 00:19:26

que ahora, si yo quiero 00:19:28

hacer, pues pedidos 00:19:30

punto contains, voy a copiar 00:19:32

el p este de aquí que 00:19:34

pues lógicamente 00:19:35

este me devolvería 00:19:46

true, porque hay uno 00:19:48

igual a este, que lo he añadido 00:19:50

remove 00:19:52

vale, me borra 00:19:53

pero aquí lo que 00:19:55

estábamos viendo es que los métodos que hay son los mismos 00:19:56

que list y funcionan igual 00:19:59

salvo que los de 00:20:00

posición son los que no están 00:20:03

¿no? añadir 00:20:04

limpiar, contains 00:20:07

si lo contiene 00:20:09

siguiendo el criterio de igualdad 00:20:11

si está vacía 00:20:12

remove 00:20:15

tiene muy pocos métodos como veis 00:20:17

remove no hay un get 00:20:18

por índice, no hay un get index 00:20:21

porque yo no puedo recorrer con índice 00:20:22

no hay un remove por índice 00:20:24

no hay un index of 00:20:27

todos los métodos que trabajan con posiciones 00:20:28

devuélveme la posición en la que hay un objeto igual a este 00:20:31

recupérame el de esta posición 00:20:33

bórrame el de esta posición 00:20:35

todo lo haciendo con posiciones aquí no existe 00:20:36

aquí se lo puedo borrar 00:20:37

por un objeto 00:20:39

bórrame un objeto igual a este 00:20:42

el tamaño 00:20:45

convertir en un array 00:20:48

convertiría en un array en el orden que le pete 00:20:51

porque él los ha ido metiendo 00:20:54

así a mogollón 00:20:56

¿vale? entonces los métodos 00:20:57

que hay son pocos 00:21:00

y sirven pues para lo básico 00:21:01

¿vale? entonces para recorrer 00:21:03

el set, para recorrer 00:21:06

es que el for each 00:21:08

el for each deliterador que no lo voy a mencionar todavía 00:21:09

para que no andamos muy 00:21:12

sobrados de tiempo 00:21:14

si yo recorro ahora mis pedidos 00:21:14

ahora sí que vamos a poner un toString en pedido 00:21:17

porque es que ya 00:21:20

Ya nos cansamos 00:21:21

Vamos a poner un toString aquí impedido 00:21:22

Vale 00:21:25

Vale, pues si yo ahora recorro 00:21:31

Aquí, insisto 00:21:36

Aquí no puedo recorrer 00:21:40

Con for de índice, imposible 00:21:42

Porque no hay un get y 00:21:44

Tengo que recorrer con un for each 00:21:45

Luego recorro todos de principio a fin 00:21:48

A menos que haga un break 00:21:50

En algún momento porque me dé la gana 00:21:51

este for va de principio a fin 00:21:53

que sueño tenemos 00:21:56

vale, entonces si yo recorro esto 00:21:57

pedido bolis gomas 00:22:02

voy a no borrar 00:22:06

este no le voy a borrar 00:22:08

voy a meter 00:22:11

este con otro id 00:22:14

para que me meta los tres 00:22:16

el bolis gomas 00:22:17

bolis 00:22:20

el 1, 2 y 3 00:22:21

ahora me va a meter los 3 00:22:23

bolis, gomas, bolis 00:22:24

a ver, es que estoy buscando 00:22:28

yo una, a ver 00:22:31

ahora voy a cambiarles, que me meta aquí 3 00:22:32

voy a meter primero 00:22:35

el 3, luego voy a meter el 1 00:22:37

y luego voy a meter el 2, por ejemplo 00:22:38

vale, ¿qué quería yo ilustrar? 00:22:40

que cuando yo itero 00:22:46

el orden en el que él me los va sacando 00:22:48

de la caja para mostrármelos 00:22:50

no es el orden en el que yo los metí 00:22:52

¿es el orden del comparito? 00:22:54

no, no es el orden del compare tú 00:22:56

es 00:23:04

el orden 00:23:05

que encuentra en un campo 00:23:08

él los ordena siempre por orden de un campo 00:23:09

a la hora de iterar 00:23:11

pero no sé exactamente 00:23:12

porque estaba buscando a ver si era el alfabético 00:23:14

que 00:23:18

que orden 00:23:19

que orden usa 00:23:21

pero en cualquier caso lo que se caracteriza 00:23:22

de Hachette es 00:23:25

que el orden 00:23:26

de iteración no va a ser nunca el de inserción. 00:23:29

Cual sea. Depende. 00:23:31

Depende de mil cuestiones varias. Nunca 00:23:33

penséis que el Hachette os va 00:23:35

a ayudar y nunca lo uséis 00:23:37

si el orden es algo interesante para vosotros. 00:23:39

Orden en la iteración. Porque vete 00:23:41

a saber. No hay un criterio establecido. 00:23:43

Depende en el orden en el que tú pongas las propiedades. 00:23:45

Pero siempre que ejecutes el programa 00:23:47

si ha salido un orden es el mismo. 00:23:49

Que yo sepa, sí. Yo siempre lo he visto 00:23:50

igual. 00:23:53

Pero no va a ser el orden de inserción 00:23:55

y no es fácil controlar 00:23:57

con qué orden te va a iterar. 00:23:59

Entonces, cuando uno usa HashSet, es que el orden 00:24:00

realmente le da igual. Y aquí, lógicamente, 00:24:02

Claro. 00:24:05

Claro. Si no habría escogido otra... 00:24:09

Vale, y aquí el sort, por ejemplo, no existe. 00:24:11

Yo aquí en... 00:24:13

Claro. Si yo trato 00:24:15

de hacer 00:24:16

pet.sort, ordenar, 00:24:17

pedidos, perdón, 00:24:21

me dice, perdona, que el método sort 00:24:24

no existe 00:24:26

para haset 00:24:28

claro, no hay otra cosa que tú quieras 00:24:30

vale, no existe 00:24:33

entonces, nada relacionado con posiciones 00:24:34

ni orden existe aquí 00:24:37

y lo más crítico es eso 00:24:38

que el orden en el que tú iteras 00:24:41

no va a ser el orden en el que has insertado 00:24:42

si a ti te interesa que lo sea 00:24:45

te interesa cambiar órdenes, lo que sea 00:24:47

nunca usarías un haset 00:24:49

vale 00:24:50

aquí viene la 00:24:51

única diferencia entre el hashed 00:24:55

y el linked hashed 00:24:57

que el linked hashed 00:24:58

en la iteración 00:25:00

cuando tú iteras, sí te va a conservar 00:25:02

el orden en que insertaste 00:25:05

a cambio es más 00:25:06

complejo computacionalmente 00:25:09

pero es la única diferencia 00:25:10

de hecho si esto lo cambiamos 00:25:11

se supone que sí 00:25:14

porque el linked hashed está doblemente 00:25:19

enlazada a la lista que 00:25:21

si cambiamos 00:25:22

a linked hash set 00:25:24

aquí veríamos 00:25:25

que ahora ya el recorrido 00:25:33

veis, si itera siguiendo 00:25:34

el orden en que yo inserté 00:25:37

itera siguiendo el orden 00:25:38

que a uno le interesa 00:25:40

usar un set, un hash set porque es muy bueno 00:25:42

y está muy bien, pero la particularidad 00:25:45

de que según tú vas 00:25:48

insertando, se recupere 00:25:49

ese orden se mantenga cuando 00:25:52

tú iteras 00:25:53

si te interesa eso por algo 00:25:54

usas un LinkedHashet 00:25:56

si no te interesa eso te da igual 00:25:57

pues un Hashet que es 00:26:00

más eficiente 00:26:01

vale 00:26:03

bueno porque 00:26:04

los Arrays 00:26:10

vale 00:26:13

porque no te interesa llevar un registro 00:26:16

de la posición porque no vas a borrar por posición 00:26:18

no vas a borrar pero a lo mejor es una aplicación 00:26:20

en la que tú tienes una funcionalidad 00:26:22

es que sacar listados, listados de lo que hay. 00:26:24

Y te interesa que el listado salga 00:26:26

en el mismo orden en el que llegaron. 00:26:28

Pues, por ejemplo, entonces, sacar el listado es iterar. 00:26:30

Pues, bueno, en eso en particular, 00:26:33

tú vas a iterar y te van a salir 00:26:34

en el mismo orden en el que llegaron. 00:26:35

Pues, ahí sí. 00:26:36

Pero todas las funcionalidades de 00:26:38

recupérame el de posición 7, 00:26:39

bórrame el de posición 8, no las tendrías, 00:26:41

con lo cual te ahorras, es más eficiente. 00:26:43

¿Vale? 00:26:46

Entonces, bueno, el link de headset 00:26:48

tampoco es que tenga mayor interés, en realidad. 00:26:49

solo aporta eso 00:26:51

entonces 00:26:53

vale 00:26:54

entonces lo ponemos aquí 00:26:55

simplemente en un comentario 00:26:59

que 00:27:01

el 00:27:02

orden 00:27:03

de iteración 00:27:06

el orden 00:27:09

de iteración 00:27:12

no es 00:27:15

el de inserción 00:27:22

en un 00:27:25

linked 00:27:27

hash set, sí, esa es la única diferencia 00:27:29

vale, pues entonces el hash set es muy cómodo 00:27:31

pero es para meter a 00:27:35

ahí hago el picorrazo, un rollo 00:27:37

claro, si queremos hacer cosas 00:27:39

con cualquier elemento, siempre hay que 00:27:41

iterar, quiero recuperar 00:27:43

el elemento de id 5 00:27:46

tienes que iterar 00:27:48

pedido es el pedido de id 5 00:27:49

hago con él lo que sea, quiero recuperar 00:27:51

el pedido de descripción 00:27:53

bolis. Tienes que iterar. 00:27:55

Vas iterando. Este es el 00:27:58

de descripción bolis, patatín. Entonces, 00:27:59

en un haset tienes que iterar 00:28:01

para cualquier cosa que quieras que haga un elemento. 00:28:03

Porque como no tiene en orden, no puedes decir 00:28:05

ah, sácame el tercero, pues tienes que 00:28:07

iterar hasta que encuentras el que buscas. 00:28:09

¿Vale? 00:28:12

Vale. 00:28:14

Vamos a 00:28:19

dejar ahora mismo 00:28:20

para terminar 00:28:22

con el triset, porque eso ya lo vamos 00:28:24

a ver en un ejercicio el jueves 00:28:26

¿qué pasa cuando 00:28:27

quieres borrar de un haset 00:28:30

por algo que no 00:28:32

sea la clave primaria? 00:28:34

¿vale? a ver 00:28:36

sí, o sea cuando 00:28:37

tú, yo quiero borrar 00:28:40

el pedido de índice 1, pues ya sabemos 00:28:41

que en el haset haríamos esto 00:28:44

lo mismo que en la lista 00:28:45

haríamos esto, pedidos punto 00:28:47

remove p 00:28:50

esto es lo mismo que hemos hecho en la 00:28:52

lista. Pues te borraría 00:28:54

del mi set de pedidos, 00:28:56

te borraría el único que encuentra, 00:28:58

en este caso el único, porque no puede haber más de uno, 00:29:00

igual a este. 00:29:03

Igual. 00:29:04

Igual significa el que tenga ID 1. 00:29:06

El único que te encuentre, si es que hay uno, 00:29:08

podría no haber ninguno. Con ID igual a 1 te lo borra. 00:29:10

El problema 00:29:13

es si tú quieres eliminar de la lista 00:29:14

los elementos 00:29:16

cuya descripción sea 00:29:20

bolis, por ejemplo. 00:29:22

no lo puedes hacer con remove 00:29:23

porque remove te borra solo los iguales 00:29:25

en clave primaria 00:29:27

tendríamos que recorrer 00:29:29

cuando encontramos uno igual 00:29:31

cuya descripción sea bolis 00:29:32

entonces le paso al remove 00:29:35

y eso da problemas 00:29:37

entonces eso en particular 00:29:38

a ver 00:29:40

vamos a suponer que quisiéramos hacer esto 00:29:44

por ejemplo vamos a hacer ahora 00:29:46

vamos a borrar 00:29:48

todos los pedidos 00:29:50

con 00:29:56

descripción 00:29:57

bolis 00:30:00

vale, entonces esto está claro 00:30:01

que no lo podemos hacer con el remove 00:30:04

a secas, porque el remove a secas 00:30:06

yo le tengo que pasar un objeto y me borrará 00:30:08

el igual a ese y el igual implica 00:30:10

el igual en id, luego 00:30:12

borrar todos los pedidos con descripción bolis 00:30:14

me toca iterar 00:30:16

y cada uno que encuentre mandarle a borrar 00:30:18

entonces uno con lo que sabemos hasta ahora haría esto 00:30:20

vale 00:30:23

para cada pedido 00:30:25

p en pedidos 00:30:26

empezamos 00:30:28

sin llaves 00:30:31

cada pedido 00:30:32

este pedido 00:30:34

p 00:30:37

resulta que 00:30:37

su descripción 00:30:40

es igual 00:30:42

que 00:30:44

bolis 00:30:46

que es la descripción que me ha dicho que tengo que borrar 00:30:47

es igual, vale 00:30:50

entonces 00:30:53

me toca borrarlo 00:30:55

pues entonces yo 00:30:57

uno se plantearía, de pedidos 00:30:58

punto remove 00:31:01

pet 00:31:02

porque me va a borrar uno 00:31:04

igual a este, que es justo 00:31:07

el que quiero borrar, el que tiene esta descripción 00:31:09

vale, entonces uno 00:31:11

se plantearía hacer esto 00:31:13

¿verdad? 00:31:15

vamos a hacerlo 00:31:17

vamos a hacerlo 00:31:18

No, a ver, es que vamos a forzar 00:31:20

No, no, no, es que lo que yo quiero provocar 00:31:29

es otra cosa, es que se provoca a veces 00:31:33

y a veces no en función de dónde está la posición a borrar 00:31:35

Eso es lo que no quería contar hasta el jueves 00:31:37

Pero ya que preguntáis tanto, vamos a borrar el GOMAS 00:31:39

El GOMAS 00:31:42

El GOMAS 00:31:43

Ay, que jodido 00:31:47

Ahora no me sale la excepción 00:31:51

Me tiene que salir 00:31:52

No es tan fácil provocarla 00:31:54

Vamos a borrar este 00:31:56

Espérate, voy a quitar este 00:31:58

Ah, vale, vale, vale 00:32:02

Es que antes no me iba a salir porque ya lo tenía borrado 00:32:03

Vale, entonces, espérate 00:32:05

Yo creo que con bolis ahora me va a salir 00:32:07

Porque es que antes lo tenía eliminado ya, me parece 00:32:09

Igual yo creo que ahora con bolis 00:32:11

Sí que me va a salir, creo, creo 00:32:14

Solo lo creo 00:32:15

Que jodido 00:32:16

A ver 00:32:19

Por fin 00:32:20

Vale 00:32:29

Aquí sale una excepción 00:32:30

Que sale a veces y a veces no 00:32:32

Como veis depende 00:32:35

Donde haya caído del conjunto 00:32:36

Donde haya caído el que toca borrar 00:32:38

Si en la iteración es el primero 00:32:41

O es el último o es el segundo 00:32:42

Si es el último de la iteración 00:32:44

No del orden de inserción 00:32:46

Pero si es uno de los que no es el último 00:32:47

último del orden de iteración, te sale 00:32:50

esto. ¿Quién lo dice? 00:32:52

¿Eh? 00:32:54

Claro. ¿Cómo que 00:32:56

error de modificación concurrente? 00:32:58

¿Qué me estás contando? ¿Concurrencia 00:33:00

de hay varios hilos haciendo 00:33:02

el mismo recurso? ¿Pero qué me estás contando? 00:33:04

Si aquí no tengo yo hilos, solo tengo un programa. 00:33:06

¿Qué me estás contando? 00:33:09

Claro, es que esto de fondo, 00:33:10

de fondo este main, 00:33:12

nosotros no lo veamos, 00:33:13

resulta que este pedidos 00:33:15

se está recorriendo dos veces. 00:33:17

una en este for 00:33:19

y el remove 00:33:21

de nuevo te hace otro for dentro 00:33:23

hasta que encuentra uno igual a este 00:33:25

y te lo borra 00:33:27

luego, el for each es muy puñetero 00:33:28

este for de aquí 00:33:31

y te bloquea la colección, te bloquea el recurso 00:33:32

al bloqueártela 00:33:35

cuando el remove trata de 00:33:37

volver a iterar sobre ella 00:33:39

hasta que encuentre uno igual a pet en pedidos 00:33:41

que me la han bloqueado 00:33:43

error de concurrencia 00:33:45

por eso cuando es el último 00:33:47

la iteración no te sale, porque el foro ya lo ha soltado. 00:33:49

Ya lo ha soltado. 00:33:52

Conclusión, cuando queremos 00:33:53

eliminar elementos 00:33:55

de un set, 00:33:57

de un set, 00:33:59

no por clave primaria, porque si fuera por clave 00:34:01

primaria, por criterio de igualdad, lo haríamos así. 00:34:03

Ningún problema, lo haríamos así. 00:34:06

Remove 00:34:08

y te paso el que es igual al que quiero borrar. 00:34:08

Cuando quiero borrar por otros criterios 00:34:11

y eso me obliga a iterar, 00:34:13

nunca jamás lo haríamos así. 00:34:16

lo haríamos con iterador 00:34:17

que mencionamos el jueves 00:34:19

pero con un objeto iterador 00:34:20

que usamos solo para eso 00:34:24

y para nada más 00:34:26

para esta situación 00:34:26

si, eliminar de un set 00:34:27

un conjunto de elementos 00:34:33

que ocupen la condición 00:34:36

pues si, y eso lo tienes que hacer con iterador 00:34:36

¿vale? 00:34:39

dime 00:34:40

no, no, no, porque vamos a acabar el triset 00:34:41

si no estáis cansados 00:34:44

Respira fondo 00:34:46

A ver, ¿hace falta un descanso? 00:34:50

Nadie está cansado 00:34:58

A ver, ¿acabo cuando acabo? 00:34:59

Es que no te puedo decir cuando acabo 00:35:04

A ver, yo sé lo que quiero contar 00:35:06

Y no me voy a ir de aquí hasta que no lo contemos 00:35:08

Entonces 00:35:10

Espero que no, que la soledad es muy dura 00:35:11

Claro 00:35:18

Bueno, venga 00:35:21

Respira hondo 00:35:22

Y seguimos, ¿os parece? 00:35:24

Venga, tira, dale, venga 00:35:26

Como las cabras 00:35:28

Vamos 00:35:31

¿Has quedado? 00:35:32

Ay, qué bonito, di que sí 00:35:35

Venga 00:35:37

Ay, qué bien los colegas 00:35:38

Vale, pues a ver 00:35:41

De Hachette 00:35:42

De Link de Hachette 00:35:45

Todo lo que quitamos lo sabemos 00:35:46

A falta de ver cómo solucionamos este problemita. 00:35:48

Esto ya lo arreglaremos con el objeto iterator. 00:36:00

Una cosa muy facilita y muy sencilla. 00:36:07

Vale. 00:36:10

Por último, por ultimito. 00:36:12

Hay una... 00:36:17

Bueno, no por penúltimo. 00:36:18

nos falta el repasito rápido 00:36:19

de los map 00:36:21

por último 00:36:21

hay una implementación 00:36:25

de set que no hemos mencionado todavía 00:36:27

que es el triset 00:36:29

pero es un conjunto sin más 00:36:29

vale 00:36:32

¿qué diferencia usar un set 00:36:34

un hash set y un triset? 00:36:36

ahora lo vemos 00:36:38

eso 00:36:39

un triset y un hash set 00:36:42

por dentro no tienen nada 00:36:45

que ver, son completamente distintos 00:36:47

Eso está claro, ¿vale? 00:36:48

Entonces, que por dentro sean distintos implica precisamente 00:36:51

por qué en algunas situaciones elegirías uno y otro. 00:36:56

Un triset, un triset es un arbolito. 00:36:59

Claro que sí, hombre, toda mi vida, todas horas. 00:37:09

La comida, la cena, la merienda, todo el rato. 00:37:13

No 00:37:18

Vale, esto es un triset 00:37:20

Mira 00:37:23

Eso digo yo 00:37:48

Te estarías aquí como un tonto dos horas 00:37:50

Para hacer una patata 00:37:52

venga, a ver, esto es 00:37:53

un árbol binario 00:37:55

es una estructura básica en programación 00:37:57

como las listas enlazadas que ya hemos 00:38:00

visto, vale 00:38:02

pues el triset guarda 00:38:03

los elementos en un árbol binario 00:38:05

a ver 00:38:07

silencio 00:38:09

Rodrigo 00:38:11

venga, respiramos 00:38:18

tú lo bajas en la tapa todavía 00:38:19

que te veo 00:38:21

Pedro 00:38:23

prueba el autocontrol 00:38:27

venga 00:38:32

¿dónde guarda el tríceps 00:38:33

los elementos? aquí en estos nodos 00:38:37

aquí irían 00:38:38

que yo meto pedidos 00:38:40

este sería un pedido, este sería 00:38:42

otro, este sería otro, los guarda en un árbol 00:38:44

vale, y ahora diríais 00:38:47

¿cuál es el criterio 00:38:49

en qué nodo guarda cada pedido? 00:38:51

Ah, pues el tríceps 00:38:53

sigue el criterio de orden. 00:38:54

Esto es, el tríceps 00:38:58

es un árbol binario 00:38:59

ordenado. 00:39:01

¿Vale? Importante si no quieres sacar 00:39:03

un cero. ¿Vale? 00:39:04

Un árbol binario ordenado. 00:39:07

Esto significa que 00:39:09

yo aquí 00:39:11

tengo un elemento. Pues el que 00:39:13

esté hacia acá será menor que este y el que 00:39:15

esté hacia acá será mayor. Ahora, y quiero 00:39:16

meter uno nuevo. El que quiero meter es 00:39:18

mayor que este? Sí, va a la derecha. Vale. 00:39:20

Ahora lo comparo con este. ¿Es menor 00:39:22

que este? Pues va a la izquierda. 00:39:24

¿Vale? Imaginaos que aquí tengo otro. 00:39:27

Todo eso lo hace el tríceps por dentro, no nosotros. 00:39:29

¿A qué te refieres con que sea mayor o menor? 00:39:30

Mayor según un criterio de orden que hay que darle 00:39:32

al tríceps. Él no lo sabe. 00:39:35

Entonces, esa es 00:39:38

la única diferencia entre el hashel y el tríceps. 00:39:38

Entonces, 00:39:41

imaginaos que tengo un tríceps con cuatro elementos. 00:39:42

Pues mi tríceps internamente 00:39:45

sería esto. Estas ramitas 00:39:46

colgando no estarían. Vale. 00:39:48

Ahora, vamos a meter un quinto elemento. 00:39:51

Él dice, eso, este elemento es menor que este de aquí, 00:39:55

si es menor, pues va a tu izquierda. 00:39:59

Ah, que tienes otro a tu izquierda. 00:40:01

¿Es menor o es mayor? 00:40:03

Ah, no, es mayor que este, pues va a tu derecha. 00:40:04

Y ya está, ya no tiene más, pues ahí lo coloca. 00:40:06

Los va colocando siguiendo un criterio de orden. 00:40:09

Ahora me preguntaríais, ¿qué criterio de orden? 00:40:12

El criterio de orden, un segundo, 00:40:18

el criterio de orden que estos objetos 00:40:20

pedido 00:40:22

tengan dentro. 00:40:23

Con lo cual, si tú quieres hacer un triset, 00:40:26

los objetos 00:40:28

que tú vayas a meter en el triset tienen que tener 00:40:31

un criterio de orden. 00:40:32

Claro, porque esa es la forma de tener un criterio de orden. 00:40:34

Luego, 00:40:37

imaginaos que 00:40:38

yo tengo aquí pedido 00:40:39

y este pedido mío 00:40:42

no tiene 00:40:44

comparable porque no tiene, 00:40:46

porque no me da a mí la gana y no lo necesito. 00:40:48

Y no quiero comparable ni quiero nada. 00:40:50

Vale, pues entonces, no tiene comparable y no tiene este método de aquí. 00:40:53

¿Qué pasa? 00:41:10

Están dejando rectas cosas. 00:41:12

¿Eh? 00:41:14

Están dejando rectas cosas. 00:41:14

¿Rectas? 00:41:17

¿Qué dices? 00:41:19

Bueno, vale, entonces, pedido no tiene comparable. 00:41:21

entonces yo llego a mi main de pruebas 00:41:24

y digo, ay me voy a hacer un 00:41:26

triset que me han dicho que es 00:41:28

magnífico 00:41:29

voy a decidir un triset 00:41:31

pues venga, un triset de pedido 00:41:34

porque quiero yo un triset de pedidos 00:41:37

porque me han dicho que es súper guay 00:41:40

súper eficiente y súper la leche 00:41:41

¿quién te ha dicho eso? 00:41:43

Estefan 00:41:46

no 00:41:46

vale, pues entonces 00:41:47

yo me digo, que guay 00:41:57

voy a meter en pedidos 00:42:00

voy a meter un pedido que me da a mi la gana 00:42:01

este mismo que tengo por arriba 00:42:04

declarado 00:42:06

y que guay con mi triset 00:42:06

entonces yo ejecuto esto 00:42:09

ah bueno, es que me ha salido el anterior 00:42:11

vale, entonces 00:42:15

entonces ya ha parado, vamos a comentar esto 00:42:16

para que nos salga el error de antes 00:42:19

vale, ejecuto 00:42:21

esto y me dice 00:42:23

que pedido 00:42:24

que pedido 00:42:27

no es comparable amigo mío 00:42:28

te dice, perdona 00:42:31

yo no puedo hacer un triset 00:42:33

de alguien que no 00:42:35

sea comparable, porque yo como triset 00:42:37

me dio el criterio de orden para decir si vas a la derecha 00:42:39

a la izquierda, etcétera 00:42:41

ya 00:42:42

hasta puedo decirme, no, ¿para qué más 00:42:45

como a tal comparable, hijoputa? 00:42:47

pues no, es lo siguiente que voy a haber dicho 00:42:48

es que, a ver, mi generación es de los 80 00:42:50

entiende que no tenemos ningún tipo de moral 00:43:01

fuimos educados en el absoluto libertinaje 00:43:03

si te cuento lo que yo vi de niña 00:43:07

la roja me entiende cuando le he dicho 00:43:09

eso, claro 00:43:10

no como vosotros que ya habéis sido educados 00:43:13

en una cultura más reaccionaria 00:43:15

la mía es otra 00:43:19

bueno, a ver 00:43:19

vamos a ver, entonces claro 00:43:22

pedido tiene que ser comparable 00:43:24

imaginaos que yo no puedo irme a pedido 00:43:26

porque pedido está en un paquete modelo 00:43:29

que es la entidad de mi aplicación 00:43:31

y me dicen que no toques eso 00:43:33

porque eso lo usa mucha gente 00:43:34

pues estaría fastidiada para hacer el triset 00:43:36

en realidad no 00:43:38

porque triset 00:43:40

admite que yo en el constructor 00:43:41

le dé el comparator ese 00:43:44

otra vez, el rastreator 00:43:47

que de nuevo ahora mismo lo dejamos en el aire 00:43:49

admite que yo diga 00:43:51

uy, mira, pedido no es comparable 00:43:53

lo siento muchísimo, pero tú 00:43:55

para tu uso interno de tu arbolito 00:43:57

usa este criterio que te voy a dar 00:44:00

yo aquí 00:44:01

¿vale? 00:44:02

pero porque 00:44:07

preguntas, yo no iba a mencionar esto hasta que no 00:44:07

lo habíamos encontrado 00:44:09

pero me ha dicho, menciónalo aunque no lo vayas a explicar 00:44:11

Pues yo lo menciono. 00:44:14

¿Vale? 00:44:15

Entonces, podríamos aún así hacer un pedido sin implementar 00:44:16

comparable. 00:44:20

Le decimos aquí, usa este criterio de orden. 00:44:21

Pero como todavía no sabemos hacer criterios de orden 00:44:23

comparator independientes del mundo de cualquier entidad, 00:44:26

como todavía no sabemos, no se lo vamos a dar por ahí. 00:44:29

Sino que vamos a decir, ah, venga, pues pedido tú, 00:44:32

que seas comparable. 00:44:34

Ahí. 00:44:39

Tú ahora ya eres comparable. 00:44:41

implementas 00:44:43

comparable 00:44:46

y ahora ya 00:44:49

el triset magnífico 00:44:52

y ya está 00:44:54

y lo usamos igual 00:44:56

que cualquier set 00:44:58

claro, ¿qué es lo que ganamos con el triset 00:44:59

si es que eso nos interesa? 00:45:06

lo que ganamos es que como 00:45:08

él va metiendo, los va metiendo ordenaditos 00:45:10

luego él itera con ese orden 00:45:12

entonces el orden de iteración 00:45:14

va a ser 00:45:17

el orden del criterio de ordenación 00:45:18

del comparable 00:45:21

luego 00:45:21

recopilando un segundo 00:45:23

hashSet, linkedHashSet 00:45:26

y triset, los tres son 00:45:29

conjuntos, luego los tres 00:45:31

comparten que no hay una posición 00:45:33

asociada a cada elemento 00:45:35

eso está claro, luego yo no puedo 00:45:37

recuperar por posición con getIndex 00:45:39

no puedo recorrer con un 00:45:41

de índice, por tanto, no puedo borrar 00:45:43

por posición con remove index 00:45:45

no puedo sacar el 00:45:47

index of un elemento porque no 00:45:48

hay una posición en la que ese elemento está 00:45:51

eso es lo que comparto, vale 00:45:52

ahora, ¿cuál elijo? 00:45:54

haset es el más eficiente, vale 00:45:56

el más eficiente y a su vez el más 00:45:58

básico a la hora de lo que me ofrece 00:46:01

¿qué me ofrece? meter las cosas ahí 00:46:02

y ya está 00:46:05

y yo puedo iterar por él con el for each 00:46:06

y el orden en el que itero 00:46:09

no va a ser ni el orden 00:46:11

de inserción y ningún tipo de orden. 00:46:13

Será el que sea. Y a mí me da igual 00:46:15

porque no me importa en mi aplicación. 00:46:17

¿Vale? 00:46:19

Linked HACET. ¿Qué aporta respecto 00:46:20

a HACET? Es lo mismito, 00:46:23

pero cuando yo itero, 00:46:25

el orden en el que él me los saca 00:46:27

es el mismo en el que los inserté. 00:46:29

En el que los 00:46:32

inserté. Ya está. Es lo único que me aporta. 00:46:33

Si eso me interesa, genial. 00:46:35

TRICET. ¿Qué me aporta? Que es muy 00:46:37

eficiente y está muy bien porque un árbol binario 00:46:39

es un grafo muy fácil 00:46:41

de manejar computacionalmente 00:46:43

o sea, computacionalmente, luego 00:46:45

programar en él no 00:46:47

es fácil de, es computacionalmente 00:46:48

eficiente, me aporta eso 00:46:51

y a la hora de usarlo 00:46:52

implica que cuando yo uso 00:46:54

un triset, los objetos 00:46:57

que meto tienen que tener un criterio 00:46:59

de orden, que ese criterio de orden 00:47:01

normalmente los fijaremos 00:47:03

haciendo que esa clase implemente el 00:47:04

comparable, implementa el comparable 00:47:07

a partir de ahí 00:47:09

el triset me los mete 00:47:10

en el orden según el comparado 00:47:12

y ya está, todo lo demás 00:47:14

lo uso para lo mismo, add, remove 00:47:16

lo que sea, que 00:47:18

particularidad obtengo, que cuando 00:47:20

yo itero con un for each, que es mi forma 00:47:22

de iterar con un conjunto, porque for de índice 00:47:24

no tengo, cuando yo itero con un for each 00:47:26

el orden al que me los va sacando 00:47:29

es el orden del comparable 00:47:30

no el de inserción 00:47:33

sino el orden del comparable 00:47:34

porque él me los va 00:47:37

sacando del arbolito 00:47:38

de hecho 00:47:39

si nosotros aquí 00:47:41

por ejemplo, en mi 00:47:43

vamos a meter estos 00:47:46

tres pedidos otra vez en el tríceps 00:47:48

vale 00:47:50

mi criterio del comparable 00:47:59

era el índice, 3, 1 y 2 00:48:08

era el 00:48:10

el id, perdón, era el id 00:48:12

entonces yo lo he metido así 00:48:13

en un linked hashed la iteración sería 00:48:15

la misma, 3, 1, 2 00:48:18

En un triset 00:48:19

Yo ahora itero en un triset 00:48:21

Y me va a salir ordenado 00:48:23

Si es que eso me importa y me interesa 00:48:28

Pues ya está 00:48:32

Yo ejecuto esto 00:48:33

Y 00:48:41

Ya con tantos 00:48:44

No sé ni dónde estoy 00:48:47

Vamos a 00:48:49

Ah, en pedidos dos, claro 00:48:58

Es que ya decía yo, no me los ha sacado ordenados 00:49:05

Que estaba iterando en la otra, no entendía nada 00:49:06

vale, en pedidos 2 00:49:08

si Tero en pedidos 2 00:49:10

pues efectivamente 00:49:12

1, 2 y 3 00:49:14

me los saca ordenados según el orden 00:49:15

no de insercio 00:49:18

sino el orden del criterio del comparado 00:49:20

¿vale? 00:49:22

entonces 00:49:24

pues al comparable le cambias 00:49:24

ah bueno, espérate 00:49:29

que estaba por orden de precio 00:49:31

que tontería 00:49:33

sí, por precio 00:49:35

debe ser que coincide, que ha coincidido 00:49:38

porque 00:49:40

a ver, a ejecutar 00:49:41

a la ejecución que la tengo aquí 00:49:42

1, 2 y 3, ah, es que coincide 00:49:45

vale 00:49:48

ha coincidido el 00:49:49

vale, está ordenado por orden de precio 00:49:51

vale 00:49:54

no, no, no 00:49:56

vale, pues ya está 00:49:58

en realidad el triset es esto 00:50:01

que no nos olvidemos del comparable 00:50:03

y luego en la iteración tenemos la ventaja 00:50:06

pero los métodos son pues los mismos 00:50:08

add, remove, contains 00:50:10

ya está, nada más que eso 00:50:12

y respiramos 00:50:14

hondo un poquito 00:50:20

a ver, detalles internos de implementación 00:50:20

es que no te puedo ayudar mucho 00:50:38

tengo la idea de que es un árbol binario 00:50:39

y cómo funciona, pero no 00:50:42

más de eso, de cómo está implementado en concreto 00:50:43

no 00:50:46

no sé mucho, no te puedo 00:50:46

vale, te ibas a preguntar o te estirabas? 00:50:49

dime 00:50:52

bueno, a ver 00:50:52

para empezar es una estructura 00:50:56

bastante eficiente 00:50:58

un tríceps se usa bastante 00:50:59

más que el 00:51:02

haset, pues 00:51:04

depende también del código de hash 00:51:05

como sea, no lo sé 00:51:08

pero es una estructura que se usa bastante 00:51:09

con lo cual debe ser que es bastante eficiente 00:51:11

entonces la usas 00:51:13

por supuesto cuando 00:51:14

no quieras, la posición 00:51:16

no te interese, ¿vale? 00:51:19

eso está claro, porque si no sabes una lista 00:51:21

y luego si resulta que a ti el orden 00:51:22

te es interesante 00:51:25

por ejemplo, tú vas a trabajar 00:51:27

pues con alumnos 00:51:29

y te interesan los listados alfabéticos 00:51:30

pero solo eso 00:51:33

los listados alfabéticos, entonces tú podrías decir 00:51:35

Pues lo meto en una lista 00:51:37

Porque la lista permite hacer el sort 00:51:38

Pues no te hace falta 00:51:40

Si lo único que tú quieres en tu aplicación 00:51:42

Es un listado alfabético 00:51:44

Y dices, mira, me hago un triset 00:51:45

El comparable que sea con orden de nombre 00:51:46

Y para la funcionalidad del listado 00:51:49

Itero 00:51:52

Porque sé que el triset me lo va a sacar por orden alfabético 00:51:53

Por ejemplo 00:51:55

Y ya está 00:51:56

A ver 00:51:57

Cosa importantísima, la más importante del mundo 00:52:00

Que se me olvidaba 00:52:03

Del triset 00:52:04

que el criterio de igualdad del tree set 00:52:05

para el contains y el remove 00:52:08

no es el hashCode 00:52:10

y el equals, es el del compare 00:52:12

to 00:52:14

¿vale? es decir 00:52:15

yo aquí en tree set 00:52:20

he puesto pedido 00:52:22

y entonces he puesto 00:52:23

un compare to para darle un criterio 00:52:26

de orden, pues a partir 00:52:28

de ese momento el tree set 00:52:30

usa esto 00:52:32

para saber si un elemento es igual que otro 00:52:34

ya no usa el Haskell ni el Equals 00:52:36

pasa de él, usa este 00:52:38

es que tiene que estar 00:52:40

porque si no 00:52:43

no habías podido hacer un tríceps 00:52:44

porque te habría dado una excepción 00:52:46

no, no, tienes que ser comparable 00:52:48

tiene que estar 00:52:50

entonces, tiene que estar obligatoriamente 00:52:51

para tú poder hacer un tríceps 00:52:54

y ahora ya 00:52:55

este tríceps de aquí 00:52:57

vamos a ponerlo 00:53:00

aquí 00:53:01

esto, aquí tiene unas implicaciones 00:53:03

muy gordas, y es 00:53:21

que si yo quisiera meter dos pedidos 00:53:23

con el mismo precio 00:53:25

en este ejemplo en particular, que he puesto un compare 00:53:27

tú con precio, no me dejaría 00:53:29

porque usa el compare 00:53:32

tú para no me dejaría 00:53:34

o sea, tampoco se puede poner 00:53:35

ni que sea equals, ni que sea 00:53:37

el criterio de comparación 00:53:39

no, es que el preset del equals pasa 00:53:40

como si no existiera, para él la igualdad es el compare 00:53:43

tú 00:53:46

¿vale? porque él ha usado el compare 00:53:46

tú para colocar, para ver si es mayor o menor 00:53:49

entonces si encuentra uno 00:53:51

que es igual, según ese compare 00:53:53

tú tendría que plantarlo encima 00:53:55

y encima no va a plantarlo, con lo cual no lo mete 00:53:56

¿eh? 00:53:59

no, no, no, el compare tú 00:54:01

tú le pasas un objeto 00:54:03

y 00:54:04

a ver, el triset 00:54:05

tiene un equals, pero para ver si un objeto 00:54:12

triset es igual a otro objeto triset 00:54:13

que será el equals, el dado de object 00:54:16

unos hoyos, unos propios, pero vamos 00:54:17

pero que el método 00:54:19

equals que él usa para 00:54:21

los objetos que está metiendo 00:54:23

no es el equals, es el compare to 00:54:25

vale, entonces en este caso no 00:54:27

podríamos meter un elemento 00:54:29

del mismo precio, vale 00:54:31

si nosotros intentamos meter 00:54:33

en pedidos2 00:54:35

add 00:54:37

intentamos meter 00:54:39

un nuevo pedido 00:54:41

un nuevo pedido 00:54:42

este de aquí 00:54:49

con id 4 00:54:51

claro, el precio es el mismo 00:54:53

que uno que ya existe, 3,6 00:54:56

entonces 00:54:58

si volvemos a iterar 00:55:00

he iterado bien, sí, vale 00:55:05

lo que pasa es que estoy haciéndolo tan feo 00:55:12

ay, que he guardado, vale 00:55:13

que ya no, vale 00:55:16

¿veis? 00:55:17

esta es la última iteración 00:55:21

no me ha metido 00:55:22

el 3,6 no me lo ha metido dos veces 00:55:24

o sea, ha ignorado 00:55:26

eso 00:55:29

vale, entonces claro, eso 00:55:30

por eso 00:55:33

claro, por eso hay que 00:55:35

pensarse muy mucho este compare tú 00:55:37

que uno pone en pedido 00:55:39

porque es el compare tú, te limita 00:55:40

luego usarlo en un tríceps, porque es el criterio de igualdad 00:55:43

claro, luego aquí se dan 00:55:45

se dan 00:55:49

muchas situaciones a resolver 00:55:51

A ver, por ejemplo, a ti a lo mejor aquí te interesa un compare tú por nombre. 00:55:52

Pero luego tú quieres en un triset meter pedidos con diferente nombre. 00:55:58

Entonces, o no usas un triset o si usas un triset le dices, 00:56:03

oye triset, te voy a dar, ¿dónde estamos con el triset? 00:56:09

Te voy a dar un criterio específico. 00:56:14

No uses el del compare tú. 00:56:18

Ya estamos otra vez, pero eso. 00:56:20

Ahora mismo lo dejamos aparcado. 00:56:22

Pero la idea es que al tríset, como ya he dicho antes, 00:56:24

se le puede dar un criterio específico. 00:56:27

Y ese es el que va a usar siempre. 00:56:30

Si hubiera ya uno en la clase, porque implementar a compare 00:56:32

y un compare tú, entonces ese se le ignoraría. 00:56:34

Pesa más el que pongamos ahí. 00:56:36

Ese que tiene prioridad. 00:56:38

Entonces, como tú te ves en una situación en la cual la clase 00:56:40

pide, tiene ya un comparable con un compare tú, 00:56:42

pero a ti ese te fastidia porque entonces te impediría 00:56:45

meter objetos en el tríset. 00:56:47

Pues le das otro ahí. 00:56:49

le das otro, diferente 00:56:51

¿vale? pero ¿cómo darle otro? eso es lo que ya 00:56:52

olvidamos 00:56:55

¿vale? ¿cómo darle otro? por ahora 00:56:56

si no le damos otro ahí y lo damos en vacío 00:56:58

el criterio que va a usar el 00:57:01

triset va a ser 00:57:03

este, para la igualdad 00:57:04

si un objeto es igual que 00:57:06

otro, o sea, si un objeto devuelve 00:57:09

cero en el compare to, devuelve cero 00:57:11

para el triset es el mismo 00:57:13

entonces, ojo con lo que 00:57:15

hemos puesto aquí, porque en este caso 00:57:17

todos los pedidos que cuestan lo mismo 00:57:18

son iguales, solo, solo, solo 00:57:21

el triset es el único que usa eso 00:57:23

solo, ¿vale? 00:57:25

todos los objetos que tengan el mismo precio 00:57:26

serían todos iguales, luego usar un triset 00:57:28

para pedidos así, pues no tendría sentido 00:57:31

porque no puedo tener pedidos con el mismo precio 00:57:33

claro, en función de lo que tengas ahí 00:57:34

¿vale? 00:57:39

pues triset al 00:57:41

completo, completísimo 00:57:43

y todo 00:57:45

¿vale? 00:57:46

uy, un pedido 00:57:51

Un repaso rápido de map 00:57:53

Y nos vamos ya a gusto 00:57:55

Con todo 00:57:56

Sí, así podemos dedicar jueves y viernes 00:57:57

A ejercicios y ejercicios 00:57:59

Y hacéis ya el examen 00:58:01

Que te cagas 00:58:04

A ver 00:58:05

¿Qué? 00:58:11

Ya, pero bueno 00:58:16

Es una recopilación un poco de 00:58:18

Vale, pues entonces reencuéntrate 00:58:20

Porque como ahora vamos a hacer el repaso de map 00:58:24

Te puedes olvidar de lo anterior 00:58:26

Y 00:58:27

Vale 00:58:28

Último método, prueba mapas 00:58:30

Y nos piramos 00:58:35

Vale 00:58:37

Problema del haset 00:58:52

Que bonito y que estupendo y que maravilloso 00:58:55

Pues que hay que recorrerlo para cualquier cosa 00:58:58

¿Verdad? Por ejemplo aquí 00:59:02

Esto que hemos hecho antes 00:59:03

que queremos ver 00:59:06

qué elementos tienen como descripción 00:59:11

bolis para borrarlos 00:59:14

por ejemplo, pues lo recorro 00:59:16

aunque esto en particular me daría error 00:59:17

que quiero, imaginaos que lo que 00:59:19

queremos es en lugar de borrar 00:59:22

todos los 00:59:24

bolis, pues cambiar de precio 00:59:24

a los bolis, pues haríamos eso 00:59:27

por ejemplo, imaginamos que queremos 00:59:30

cambiar de precio a todos los bolis 00:59:32

al pedido bolis, tendríamos que 00:59:34

recorrer bolis, una vez que hemos 00:59:36

encontrado bolis, pues ya haríamos 00:59:37

pet.setPrecio 00:59:40

el precio que fuera. 00:59:43

No, porque 00:59:48

aquí no estoy, claro, aquí no tengo 00:59:49

otro bucle anidado. Vale, entonces 00:59:51

problema de los conjuntos, 00:59:53

ya no solo del haset, de todos 00:59:56

los conjuntos en general. 00:59:57

Que si yo quiero localizar 00:59:59

un objeto en concreto para hacer 01:00:01

algo con él, como este, 01:00:03

localizar el objeto cuya descripción es bolis 01:00:05

para cambiar el precio, 01:00:07

tengo que sacarlos todos 01:00:08

que quiero localizar el objeto 01:00:11

cuyo ID es 5, tengo que ir 01:00:12

uno por uno hasta que lo encuentro 01:00:15

que quiero localizar el objeto cuyo precio es 7 01:00:16

tengo que ir uno por uno hasta que lo encuentro 01:00:19

un rollo, ¿vale? 01:00:21

entonces, para no tener que ir uno por uno 01:00:23

hasta que encuentro el que me interesa 01:00:24

es para lo que se hicieron 01:00:26

los mapas, ¿vale? 01:00:29

entonces 01:00:31

pues la interfaz map 01:00:31

esta interfaz 01:00:37

es una interfaz aparte de collection 01:00:39

y es una colección 01:00:41

para guardar objetos 01:00:48

con una clave asociada. 01:00:56

Entonces, ¿qué implica esto? 01:01:00

Lo que implica esto, a efectos prácticos, 01:01:02

es que lo que se guarda es un par. 01:01:05

Un par así. 01:01:12

Clave, valor. 01:01:14

Entonces, meter algo en el map es siempre meter un par. 01:01:16

Tengo que meter dos cosas siempre 01:01:19

Clave y valor 01:01:21

Lo que se llama en terminología esta clave y valor 01:01:23

Que será el objeto, este es el objeto 01:01:26

Efectivamente 01:01:28

Y la clave que lo asocia 01:01:29

¿De qué tipo tiene que ser la clave? ¿De qué tipo es el valor? 01:01:31

El que a mí me dé la gana cada vez 01:01:35

Depende, pero siempre que meto algo 01:01:36

Lo meto en par 01:01:38

Siempre, no puedo meter un objeto suelto o una clave suelta 01:01:39

Siempre tiene que ir ahí 01:01:42

Vale, entonces restricciones 01:01:44

Las claves 01:01:46

Tienen que ser únicas 01:01:47

es decir, no puede haber 01:01:49

pares en el mapa 01:01:54

que compartan claves 01:01:57

en este caso sustituiría 01:01:58

el objeto con esa clave, no añade otro 01:02:02

con la misma clave, las claves son únicas 01:02:04

los objetos sí pueden estar repetidos 01:02:06

yo puedo meter el mismo 01:02:09

pedido dos veces, este pedido con la 01:02:10

clave 1 y el mismo pedido con la clave 2 01:02:12

el map lo único que va a verificar 01:02:14

es que no estoy metiendo la misma clave 01:02:16

dos veces, una segunda vez 01:02:19

es lo único que va a verificar 01:02:20

del objeto va a verificar nada 01:02:21

vale, pues con esta tontería 01:02:23

del par clave valor 01:02:25

me facilito recuperar objetos 01:02:26

porque en lugar de mirarlos todos 01:02:29

uno por uno, si yo sé la clave 01:02:31

que tienen asociada, si yo lo sé, digo 01:02:33

dame el de la clave y tal, y ya está 01:02:35

¿vale? entonces 01:02:37

implementaciones de map 01:02:39

esa 01:02:40

implementaciones de map, las que dijimos el otro día 01:02:45

hash map 01:02:49

linked 01:02:51

hash map 01:02:53

y trimap 01:02:55

y diréis vosotros 01:02:57

no, no, eso no, hombre, te sirve para 01:03:00

con suerte 01:03:05

ganar dinero en el futuro 01:03:06

no me apremies 01:03:07

¿para qué sirve esto? o sea, no, ya me he liado 01:03:09

¿ves? 01:03:12

¿qué casualidad que se llamen igual 01:03:14

que los set? vale, porque 01:03:16

hashmap 01:03:18

¿qué significa? que las claves 01:03:20

las guarda en un hashet 01:03:23

LinkedHashMap 01:03:24

¿qué significa? 01:03:26

que las claves 01:03:27

las guarda 01:03:28

en un 01:03:29

LinkedHashSet 01:03:30

y TrimApp 01:03:31

¿qué significa? 01:03:32

que las claves 01:03:33

las guarda 01:03:34

en un TrimApp 01:03:35

eso es lo que tenemos 01:03:35

que tener claro 01:03:36

luego 01:03:37

automáticamente 01:03:38

si tú usas 01:03:39

un HashMap 01:03:41

la clase 01:03:42

a la que pertenezca 01:03:43

la clave 01:03:44

tiene que tener 01:03:44

el Hasco de equals 01:03:45

porque como se va a guardar 01:03:46

en un HashSet 01:03:47

la clase 01:03:48

a la que pertenezca 01:03:49

el valor 01:03:50

da lo mismo 01:03:50

las claves 01:03:51

a la clase a la que 01:03:54

pertenezca la clave 01:03:55

tiene que tener un comparable 01:03:57

y la igualdad será el compare to 01:03:58

pero si usas un número no tienes que tener nada 01:04:01

no porque los integer 01:04:03

ya tienen, ya implementan comparable 01:04:05

ellos con el orden natural 01:04:07

luego cuando usamos un hash map 01:04:09

un linked hash map y un tree map podemos elegir 01:04:12

el que queramos pero 01:04:14

tenemos que acordarnos de eso 01:04:15

que yo uso un hash map, ahora lo ponemos 01:04:17

la clase a la que 01:04:19

pertenezca mi clave 01:04:22

Tiene que tener hasco de equals 01:04:23

Lo mismo si hace linked has map 01:04:25

Si uso un trimap 01:04:27

La clase a la que pertenezca mi clave 01:04:29

Tiene que tener 01:04:32

¿Es normal usar objetos como clave? 01:04:33

Pues no, pero normalmente la clave es un valor 01:04:37

Que tiene que ser rápido de generar 01:04:39

Entonces normalmente pues que sea un código string 01:04:41

Un número 01:04:43

Claro, entonces en ese caso ya lo tienen ellos 01:04:44

¿Vale? 01:04:47

Si usamos un trimap, la clase a la que pertenezca la clave 01:04:48

Tiene que tener comparable 01:04:51

porque 3MAP va a usar el compare to 01:04:52

para ver la igualdad de claves 01:04:55

para ver la igualdad de claves 01:04:57

entonces, luego esto se traduce en poca cosa 01:04:59

vale, por ejemplo 01:05:02

vamos a guardar los pedidos 01:05:03

¿perdón? 01:05:05

a ver, ¿el qué exactamente? 01:05:09

sí, a ver 01:05:15

hashMap, linked hashMap y 3MAP 01:05:17

tiene que ver 01:05:20

con cómo guarda 01:05:21

el mapa las claves 01:05:23

y sólo las claves. 01:05:25

En un HashMap 01:05:28

las claves se guardan en un HashSet. 01:05:29

En un LinkedHashMap 01:05:32

las claves se guardan 01:05:34

en un LinkedHashSet. 01:05:36

Y en un Trimap las claves 01:05:37

se guardan en un Triset. 01:05:40

Y eso tiene implicaciones 01:05:42

evidentes en que la clase 01:05:44

a la que pertenezca la clave 01:05:46

tendrá que tener Hasco de Equals 01:05:47

en estos primeros casos 01:05:49

y comparable en este. 01:05:51

¿En los dos tríceres Hasco de Equals? 01:05:54

¿Hasco de Equals? 01:05:56

Claro, porque si es un trícer. 01:05:58

Entonces, por ejemplo, 01:06:02

en nuestros pedidos famosos. 01:06:03

Venga, y no nos va a dar tiempo 01:06:07

a hacer el repaso completo de mapas, 01:06:08

pero no pasa nada. 01:06:10

El ejercicio del próximo día 01:06:10

ya lo tenemos que repasar. 01:06:11

¿Vale? 01:06:13

En nuestros pedidos famosos. 01:06:13

Por ejemplo, vamos a hacer un Has 01:06:15

Map 01:06:17

y ahora 01:06:20

pedidos 01:06:21

new hash map 01:06:24

y ahora de nuevo 01:06:28

yo tengo que 01:06:30

decidir aquí 01:06:30

dos tipos ahora 01:06:32

el tipo al que pertenece mi clave 01:06:35

y el tipo al que pertenece mi valor 01:06:37

mi valor va a ser pedido porque voy a guardar pedidos 01:06:39

ahí 01:06:41

pero mi clave 01:06:42

bueno pues elijo 01:06:44

un número entero 01:06:46

un código 01:06:48

vamos a suponer que un código 01:06:49

que voy a meter cada apellido asociado a un código 01:06:52

el código 01:06:54

si es una cadena pues pondría aquí string 01:06:56

y ya está 01:06:58

si pones la id 01:07:01

como la id es un entero 01:07:07

pues entonces tendrías que poner aquí 01:07:09

integer porque tipos primitivos no los puedes usar 01:07:11

nunca 01:07:13

para parametrizar datos 01:07:14

vale, da igual el tipo que pongas 01:07:17

el que tú decidas porque te interesa a ti 01:07:19

vale, entonces 01:07:21

y puede ser una clave que no sea nada 01:07:24

de lo que está aquí dentro 01:07:27

no tiene por qué serlo, de hecho vamos a poner 01:07:28

un string para que sea un código 01:07:31

entonces, como yo es 01:07:32

hasma, pues de nuevo lo importamos de java útil 01:07:37

y ahora 01:07:39

antes de seguir, tendríamos que verificar 01:07:43

uy, va a guardar 01:07:45

las claves en un hash set 01:07:47

string tiene hash code 01:07:49

equals, pues sí 01:07:51

aquí verifica, string no es 01:07:53

una clase que hemos hecho nosotros, string ya viene 01:07:55

y tiene su hascode y su equals. Luego nos 01:07:57

despreocupamos. Si la clave fuera 01:07:59

de un tipo hecho por nosotros, imaginamos 01:08:01

que hacemos una clase clave con 01:08:03

valores que sean la clave. Pues 01:08:05

tendría que tener hascode equals, porque si no, esto no 01:08:07

funciona. Vale. En nuestro 01:08:09

caso, string ya lo tiene y ya está. 01:08:11

Y ahora aquí ya metemos lo que nos dé la gana. 01:08:13

Por ejemplo, vamos a 01:08:15

meter esos pedidos y ya está. 01:08:17

Voy a copiar esto aquí. 01:08:19

¿Cómo metemos? Pues con el 01:08:26

put. 01:08:27

Voy a poner esta aquí para copiar y pegar, simplemente, venga, vamos a meter pedidos.put, clave, pues, venga, este va a ser el código, pa, pa, pa, valor, pues, va a ser este, este de aquí, vale, venga, vamos a meter otro. 01:08:29

Venga, a este le asocio 01:08:57

A esta clave 01:09:04

Y voy a meter este otro 01:09:06

Como si meto el mismo dos veces 01:09:08

Da igual 01:09:10

Estará dos veces 01:09:11

Lo que pasa es que son claves distintas 01:09:13

Claro, lo importante es que la clave no se repita 01:09:15

Que el mismo apellido está dos veces 01:09:18

Con dos claves diferentes 01:09:20

Pues yo qué sé, tú verás 01:09:21

Porque lo has metido así 01:09:22

Será que te interesa 01:09:23

Claro 01:09:24

porque el valor puede ser null, la clave no 01:09:28

la clave no puede ser null 01:09:30

vale, entonces bueno, esto ya lo borro 01:09:31

que era para copiar y pegar 01:09:33

bueno, pues ya tengo ahí los pares 01:09:35

si yo hiciera esto 01:09:38

el segundo no lo metería 01:09:40

el segundo no lo metería 01:09:46

porque la clave está repetida 01:09:48

según el jasco de equals de string 01:09:49

claro, lo que haría sería 01:09:52

sobrescribirlo 01:09:56

lo que haría sería 01:09:58

espérate, no lo tengo muy claro 01:09:59

porque hay un replace 01:10:05

vamos a comprobarlo 01:10:06

es que claviterar 01:10:08

sí que iba a dejarlo al próximo día porque es muy largo 01:10:10

vale, pero vamos a ver 01:10:12

vamos a hacer una cosa, vamos a verlo en la ayuda 01:10:15

y así nos lo aclara 01:10:17

porque es que tiene 01:10:18

vamos a verlo en la ayuda 01:10:20

a ver si lo reemplaza o no, porque es que como tiene un replace 01:10:22

creo que 01:10:25

Sí, vale, lo reemplaza 01:10:27

Lo reemplaza, vale 01:10:30

Que me había entrado la duda 01:10:31

Si el map ya lo tiene, lo reemplaza por ese 01:10:32

Es como un modifica 01:10:35

Vale 01:10:36

Entonces hay que tener cuidado, claro 01:10:37

Porque él no te avisa de que estás reemplazando nada 01:10:43

Entonces si no llevas un control de las claves 01:10:46

O puedes estar pisando algo que no quieres 01:10:48

Sí, luego, claro 01:10:50

Uno puede meterse ahí 01:10:54

hay un montón de métodos, lógicamente, para 01:10:56

facilitarte. Entonces, claro, ¿qué 01:10:58

ventaja tiene esto? Que ahora 01:10:59

que tú quieres eliminar uno, 01:11:01

pues mucho más fácil que con el set que tenías 01:11:04

que recorrerlo, o quieres cambiar 01:11:05

bueno, esto 01:11:07

lógicamente no, claro, 01:11:09

que tú quieres recuperar 01:11:14

el elemento 01:11:15

este, pues de 01:11:16

el primero, pues pedidos.get 01:11:21

y le pones 01:11:24

la clave. Y no tienes que 01:11:26

iterar por la colección hasta 01:11:32

que encuentras aquel cuyo código es 01:11:34

1, 1, 2, 2 01:11:35

no tienes que iterar, con el get 01:11:37

recuperas por clave 01:11:39

y ya está, pero eso sí, solo puedes recuperar por clave 01:11:40

ya está 01:11:43

si muestras pedidos también te muestras todos 01:11:44

que están en el map 01:11:47

sí, de hecho se usa 01:11:49

muchísimo, que quieres eliminar 01:11:51

facilísimo para eliminar 01:11:53

tú haces remove 01:11:55

y le pasas la clave 01:11:57

y ala, ya está 01:11:59

entonces si seleccionas bien la clave 01:12:01

es mucho más 01:12:04

lo único 01:12:06

y así que nos vamos es que 01:12:08

también tenemos que iterar 01:12:09

por el map, porque hay veces 01:12:12

que no es por clave por lo que yo quiero hacer cosas 01:12:13

sino que yo quiero 01:12:16

elimíname todos los pedidos 01:12:17

con descripción bolis 01:12:19

entonces aquí la clave no me vale para nada 01:12:21

tengo que iterar igualmente 01:12:24

por los pares hasta que 01:12:26

encuentre todos cuya descripción sea bolis 01:12:28

iterar en un map también tenemos que aprender a hacerlo 01:12:30

no, porque son pares 01:12:32

se itera de una manera un pelín más complicada 01:12:36

que ya sí que vemos el próximo día 01:12:39

pero lo único que nos falta 01:12:40

es iterar por el map 01:12:42

por si necesitamos ver todos los pares 01:12:44

hasta encontrar el que nos guste 01:12:46

lo demás es ver los métodos que tiene pedidos 01:12:48

o sea, ver los métodos que tiene el map 01:12:51

que tiene cosas muy apañadas 01:12:52

efectivamente 01:12:55

¿podría dar una write con lista clave? 01:12:56

claro, tiene un montón de métodos para hacer cosas 01:12:58

puedes limpiarlo 01:13:01

sacar el conjunto 01:13:03

con las claves 01:13:07

que nos va a venir muy bien para iterar 01:13:08

meter con el put 01:13:10

meter si no está 01:13:13

con esto te ahorras el que sobrescriba 01:13:16

vale 01:13:18

si pones este 01:13:20

eliminar, reemplazar 01:13:22

que es el 01:13:25

reemplazar este si no están 01:13:25

la diferencia con put es que put si no está te lo mete 01:13:30

reemplazar no te mete uno nuevo 01:13:32

y ya está, no tiene más 01:13:34

métodos que estos, o sea nos falta iterar 01:13:36

por el map y ya está 01:13:38

a ver, pues nada 01:13:39

a ver, bañado 01:13:41

20250211 RepasoColecciones_2 - Contenido educativo

Del mismo autor…

LA PREHISTORIA. HUGO

INVESTIGAMOS LA PREHISTORIA. IVÁN

Calendario Navideño 6ºB

Títeres Boca

Botánico

Polvoranca

Taller de cocina