2025-04-07-Programacion | Mediateca de EducaMadrid

La semana pasada habíamos empezado ya, bueno hace dos en realidad, que tuvimos el problema con el audio, habíamos empezado a hablar ya de... 00:00:01

Bueno, ¿tenéis alguna pregunta que me queréis hacer antes de arrancar yo a contaros nuevas cosas? 00:00:08

Si no hay nada en particular, pues ya os digo, continúo un poco con el repaso de los contenidos del tema. 00:00:20

Si durante la clase os surge alguna cosita, pues ya me vais diciendo. 00:00:27

os estaba diciendo que hace un par de semanas 00:00:31

habíamos hecho ya un primer repaso del tema de colecciones 00:00:34

con las clases genéricas y colecciones 00:00:36

como no se grabó la semana pasada volvimos a reincidir en lo mismo 00:00:38

y nos hemos quedado a mitad de ver el temario 00:00:42

que contempla esta unidad 00:00:46

pues vamos a ir con ello 00:00:48

la semana que viene estamos en vacaciones 00:00:50

y luego incluso me parece que después 00:00:55

a la vuelta de Semana Santa creo que 00:00:58

volvemos un martes, con lo cual ese lunes tampoco 00:01:01

tendremos clase. Entre medias 00:01:02

durante Semana Santa abre 00:01:05

un tema. Igual la 00:01:06

planificación no la teníamos que haber hecho para que abriera 00:01:08

un tema en mitad de día lectivos. 00:01:11

O sea, de día no lectivos, pero bueno, 00:01:13

al fin y al cabo, en vuestro caso da un poco 00:01:15

igual, al ser a distancia. 00:01:17

Lo que yo creo que voy a hacer va a ser dejarlo abierto 00:01:19

el siguiente tema 00:01:20

pues justo durante esta semana para que lo 00:01:22

tengáis disponible desde el día uno de 00:01:24

las vacaciones de Semana Santa. 00:01:26

que, bueno, que están bien para descansar, pero si alguien tiene algún ratillo y le apetece mirar cosas, pues, bueno, que lo tenga ya el siguiente tema abierto. El siguiente tema trata sobre el flujo de datos. En cuanto a flujos de datos, hemos estado ya trabajando con algunos. Los flujos de datos se puede decir que son las vías de comunicación del programa con fuentes externas, pues, tanto para enviar datos del programa hacia afuera como para recibirlos. 00:01:28

y bueno pues con cuáles hemos trabajado principalmente pues con la lectura de teclado 00:01:53

y la salida a pantalla pues ya son dos flujos de datos y luego y luego aparte de estos dos flujos 00:01:59

de datos no sé si tenéis el micrófono abierto a alguien por ahí a lo mejor para que no se mezclen 00:02:05

los sonidos si no vais a participar ahora mejor silenciarlo y nada os decía que en cuanto a los 00:02:11

flujos de datos pues las comunicaciones de programa no sólo se realizan a través de teclado 00:02:18

y pantalla, que sí que es verdad que es una de las fuentes 00:02:23

de comunicación más habituales. También leemos de ficheros. 00:02:27

El año que viene trabajaréis mucho con conexiones con sockets en la asignatura 00:02:31

de programación de servicios y procesos. Bueno, pues diferentes caminos 00:02:35

para comunicar nuestra aplicación con otras fuentes 00:02:39

o con otra aplicación directamente. Entonces, todo esto son flujos de datos 00:02:43

y veremos los flujos de datos, pero en particular para la lectura de ficheros, 00:02:46

lectura y escritura. Pero bueno, no me adelanto porque eso 00:02:51

es el siguiente tema y ya tendremos las tutorías para trabajar 00:02:54

sobre eso. Retomando en la que 00:02:57

estamos ahora, que son las estructuras dinámicas de datos, pues habíamos 00:03:00

hablado de que teníamos dos tipos, las colecciones 00:03:03

y los mapas. Hemos estado trabajando 00:03:05

sobre las colecciones principalmente o 00:03:09

exclusivamente durante estas dos sesiones 00:03:12

y las colecciones, bueno, pues las 00:03:15

vamos a escribir aquí un poquito, aunque ahora lo borre, las colecciones eran aquellas 00:03:18

que almacenaban datos, el uso 00:03:22

de la memoria es dinámico, no como los arrays, una de las diferencias que teníamos 00:03:26

y almacenábamos datos que podían ser de diferentes tipos, o bien primitivos 00:03:30

datos primitivos, como enteros, aunque fueran a través de su, enteros 00:03:34

long, todos estos, aunque fueran a través de sus clases wrapper 00:03:38

o bien referenciados, pues objetos de clases que tengamos nosotros en el 00:03:42

programa como por ejemplo aquí la principal que hemos estado trabajando el otro día sobre ella 00:03:46

todos los datos que se guardan en una colección pues son del mismo tipo entonces en el momento 00:03:50

que definimos la colección entre el símbolo de mayor y menor decimos el tipo sobre el que va a 00:03:57

trabajar esa colección podría ser string o igual podría ser string como podría ser de tipo de 00:04:02

objetos de la clase principal. Acordaros que esto del símbolo menor y mayor tiene mucho que ver con 00:04:10

las clases genéricas. ¿Por qué? Porque en la librería de Java aquel código que trabaja con 00:04:19

las colecciones trabaja de forma genérica con los tipos de tal forma que el mismo código nos sirve 00:04:24

para cualquier tipo que queramos asociar a la colección con la que estemos trabajando. Y luego 00:04:30

dentro de las librerías tenemos diferentes tipos 00:04:35

de colecciones. Tenemos unas colecciones 00:04:39

que son las que llaman durante el tema listas 00:04:43

que son los ArrayList y los 00:04:48

LinkedHashCode 00:04:53

Esto yo creo. Bueno, pues estos dos 00:05:00

lo que permiten es almacenar tantos datos como 00:05:03

vayamos solicitando mediante los métodos que tenemos disponibles 00:05:06

para las colecciones, que la mayoría de ellos son comunes 00:05:10

para todas las colecciones porque todas ellas implementan un interfaz 00:05:14

que es el interfaz collection que nos define estos métodos que veíamos el otro día 00:05:18

y bueno, pues estos dos principalmente trabajan con colecciones 00:05:22

que permiten tanto duplicados, es decir, meter 00:05:26

varias veces el mismo dato y 00:05:30

no tienen un orden, orden en particular 00:05:34

y luego tenemos las que 00:05:37

podemos ordenar bajo un criterio que tengamos 00:05:42

nosotros definido en nuestro algoritmo, que son aquellas que aparecen como tree 00:05:46

como árbol, por ejemplo una tree set 00:05:49

como tiene la parte tree, está ordenado 00:05:53

por el concepto, por la parte tree 00:05:58

Y esta que tenemos tiene un orden en base a un criterio que definamos nosotros en el programa. 00:06:02

A un criterio definido como requisito para el programa. 00:06:12

Y luego las que aparecen en el set, que también está incluido aquí el set, 00:06:19

estas colecciones no tienen duplicados. 00:06:23

Bueno, en toda esta jugada, en esta distribución de la que estamos hablando, nos fijábamos, por ejemplo, en una colección de tipo triset y decíamos, si está ordenado y no tiene duplicados, en base a que el programa decide que algo está ordenado y no tiene duplicados. 00:06:26

parece más o menos evidente, por ejemplo, si estamos utilizando una colección 00:06:49

que sea de tipo integer, la clase gripper 00:06:54

del tipo primitivo int, pues parece que tiene 00:06:59

toda la lógica que el orden será de menor a mayor y que los duplicados 00:07:04

si intentamos meter un 7 dos veces, pues eso estaría 00:07:07

duplicado, pero el orden y la cuestión de duplicados 00:07:11

cuando empezamos a pensar en clases propias, como por ejemplo podría ser la clase 00:07:16

persona aquí. Resulta que esta clase de personas, según la hemos definido nosotros 00:07:19

en nuestro programa, porque así nos lo sugería, digamos el enunciado que pudiéramos 00:07:25

tener, tiene como atributos un nombre y una edad. 00:07:29

Entonces, en un programa resulta que las personas 00:07:34

podrían estar ordenadas por nombre, pero en otro a lo mejor nos interesa que estén 00:07:37

ordenadas por edad, o a lo mejor nos interesa que esté ordenado por edad 00:07:40

de forma descendente. Entonces, cuando las colecciones van a 00:07:44

vamos a utilizar una colección de tipo 00:07:48

tree que va a estar ordenado 00:07:51

según el criterio de personas y esto puede ser cambiante 00:07:53

aquel código que está en la librería de java 00:07:57

se tendrá que fijar en algo para ver cuál es ese criterio 00:07:59

como la clase personal estamos codificando 00:08:02

nosotros el criterio que va a utilizar para la ordenación 00:08:05

y a su vez para si es un triset 00:08:09

para que no haya duplicados va a ser el que definamos 00:08:12

tenemos dos opciones que el otro día trabajamos con 00:08:14

una. Sobre la clase que vamos a utilizar en la colección, en este caso triset, para ir almacenando 00:08:18

elementos, lo que podemos hacer, una de ellas es implementar el interfaz comparable. El interfaz 00:08:25

comparable nos obliga a meter el método compareTo. Entonces, desde aquel código que está en las 00:08:31

librerías, cuando vayamos añadiendo nuevas personas a la colección y quiera mirar a ver si ya están 00:08:37

duplicadas y quiera ir manteniendo un orden bajo un criterio 00:08:43

lo que hará desde la colección, aunque no seamos directamente conscientes 00:08:47

aunque sí que pusimos estas trazas y vimos que efectivamente hacía accesos este método 00:08:51

es buscarlo aquí en este método compareTo 00:08:55

que nos comparará en este caso las dos 00:08:58

personas con las que estamos trabajando para ordenarlas o para ver si están 00:09:03

duplicadas, una será aquel que esté llamando al método y la 00:09:07

segunda será aquella persona que reciba aquí como 00:09:11

atributo este método. Entonces fijaros como este atributo lo cargamos 00:09:15

que sea de tipo object para que sea genérico, lo hacemos un casting 00:09:19

a un objeto de clase persona y a partir de aquí comparamos este 00:09:23

que hemos recibido con this, que es el que está haciendo la llamada 00:09:27

al método. De esta comparación resulta que nos tiene que devolver 00:09:31

un entero que podrá ser cero si se consideran los dos iguales 00:09:35

en cuyo caso, si nos termina devolviendo el compareTo 00:09:39

un cero entre esas dos personas, si es un triset, ya no lo añadirá 00:09:43

porque se estaría considerando que es la misma persona 00:09:48

que igual en este compareTo hemos dicho que dos personas iguales son aquellas que tienen el mismo nombre 00:09:51

o aquellas que tienen la misma edad, aunque sean personas 00:09:55

diferentes en sí, objetos de personas diferentes 00:09:59

y si una es mayor que otra, devolverá un valor mayor que cero 00:10:02

y si la otra es la otra mayor que una pues un valor menor que cero no hay un menos uno por ejemplo 00:10:06

y esto lo que estoy moviendo el otro día para ver un poco más el desarrollo en profundidad 00:10:12

pues nada os invito a que veáis el vídeo del otro día y así avanzamos para seguir viendo cosas 00:10:18

Fijaros pensad que aquí en este programa donde estamos hablando de ver este call que tiene 00:10:25

este es anterior en este programa estábamos estamos considerando 00:10:33

por ejemplo, una colección de tipo triset de personas. 00:10:37

Aquí lo tenemos, de personas. 00:10:42

Y para ver si hay duplicados y ver el orden, 00:10:43

hemos dicho que hemos implementado el interfaz comparable 00:10:48

en la clase persona, de lo que estamos hablando. 00:10:52

Pero pensad que a lo mejor en este programa 00:10:56

y en todo el programa en su conjunto, 00:10:59

que podría tener más clases o incluso dentro de este mismo 00:11:01

método main de la clase principal, 00:11:03

Resulta que en un tramo me interesa tener una colección de objetos de la clase persona ordenados bajo el criterio que esté aquí, que parece que es la edad, ¿verdad? Y en caso de la misma edad, el nombre. Y resulta que en otro contexto de la ejecución del programa, también me interesa tener un triset de personas, pero justo en este caso no me interesa que estén ordenadas esa colección por la edad y luego por el nombre en caso de empate. 00:11:07

entonces si yo utilizo este criterio 00:11:35

el interfaz comparable 00:11:39

el único criterio por el que se ordenan las personas 00:11:42

en una, en dos o en veinte colecciones que tenga 00:11:45

será el que indica aquí en el compare tú 00:11:48

entonces si yo aquí, porque en una parte del programa me interesa ordenarlos 00:11:51

por edad, he puesto este criterio 00:11:54

como vimos que el otro día funcionaba razonablemente 00:11:56

en otra parte del código donde me interese también 00:11:59

en una colección de personas, objetos de esta misma clase, pero cuyo criterio sea el orden por nombre, pues ya no me valdrá. ¿Por qué? 00:12:03

Porque si vuelvo a utilizar el interfaz comparable, seguirá siendo exactamente este el criterio que utiliza, el que está en el método compareTo. 00:12:12

¿Cómo podemos resolver esto? Pues para identificar en un triset, por ejemplo, si los duplicados y el orden tenemos una segunda alternativa. 00:12:21

Esta segunda alternativa es la siguiente. 00:12:32

A ver en qué proyecto estamos, por aquí. 00:12:36

Este es el proyecto call, yo creo. 00:12:39

A ver, sí, aquí estamos. 00:12:41

Pues mirad, en lugar de hacerlo directamente sobre la clase persona, 00:12:46

tenemos la posibilidad de definir una nueva clase 00:12:50

que va a tener dedicación exclusiva a definir un criterio de orden, 00:12:52

en este caso, por ejemplo, entre personas, 00:12:59

entre objetos de la clase persona. 00:13:01

Entonces vamos a llamar, por ejemplo, a esta clase comparar. 00:13:03

estoy definiendo una nueva clase independiente de la clase persona 00:13:06

en esta clase comparar, lo que vamos a hacer va a ser implementar 00:13:09

un interfaz diferente, aquí implementamos en la clase persona 00:13:15

el interfaz comparable en uno de los criterios, pues aquí 00:13:19

vamos a implementar el interfaz comparator 00:13:23

java útil por aquí me dice que añada los métodos que no están 00:13:29

implementados y el interfaz comparator me obliga 00:13:38

a tener un método, el método compare. Fijaros, este método 00:13:43

si en la clase persona teníamos, recibíamos 00:13:46

en el compareTo un objeto que al final iba a ser una persona 00:13:52

que comparábamos este objeto en el compareTo 00:13:56

del interfaz comparable con el que estaba llamando al método compareTo 00:13:59

el otro objeto de la clase persona, aquí lo que recibimos son dos objetos. 00:14:03

Es decir, vamos a comparar dos objetos que estemos recibiendo por aquí. 00:14:08

entonces imaginaos que son dos objetos de la clase 00:14:11

persona, por ejemplo, para los que lo vamos a utilizar 00:14:16

pues ¿qué podemos hacer? Pues mirad, podemos coger y decir 00:14:20

fijaros que devuelve, el criterio de devolver es también un entero que será 00:14:23

cero, si ambos son iguales, un valor mayor que cero 00:14:27

si una de las personas es mayor que la otra y un valor menor que cero si lo es la otra 00:14:31

en este aspecto es la misma idea que antes 00:14:36

y lo que hacemos aquí es definir, definimos un objeto de la clase persona 00:14:39

per 1, una referencia 00:14:43

para hacer un casting a 1, que es uno de los dos 00:14:48

que estamos recibiendo, como lo recibimos con formato object 00:14:52

hacemos un casting a la persona y ponemos aquí a 1 00:14:55

las dos personas que vamos a comparar las hemos recibido 00:14:58

aquí como atributo, hacemos un casting al tipo 00:15:06

propio de lo que queremos comparar para no estar trabajando con 00:15:10

uno que en realidad es de tipo object. Y ahora vamos a poner aquí 00:15:14

int y result. Igual a cero. 00:15:19

Y aquí vamos a poner la variable que queremos 00:15:25

devolver. Y ahora aquí en medio vamos a ver 00:15:27

según el criterio con el que queramos comparar estas dos personas, vamos a 00:15:31

trabajarlo aquí entre medias. 00:15:35

mirad, las personas tenían por ejemplo edad, vamos a suponer que queremos hacer una comparación 00:15:37

de esas dos personas por edad, entonces digo 00:15:43

if per1, que es esta persona que he recibido aquí como parámetro 00:15:47

punto y edad, es mayor 00:15:56

que per2 punto y edad 00:15:59

pues entonces esta variable que es la que voy a devolver al final 00:16:03

voy a decir un 1. Esto indica que la primera 00:16:07

de las personas es mayor que la segunda. Devolver un valor mayor que 0. 00:16:11

El SIF es menor si es, este era 00:16:19

el caso si era mayor, pues si es menor uno que otro devuelvo un menos uno. 00:16:26

Y si no es ni mayor ni menor, pues quiere decir que es igual. Y como lo he inicializado 00:16:30

aquí a 0, no hace falta poner un SIF de igual. Si queréis 00:16:34

si alguien lo ve más claro, podríamos decir que si los SIF 00:16:38

Si son iguales, podríamos decir aquí que sea igual a cero. 00:16:42

Ya os digo que esto es innecesario, porque si no pasa por ninguna de estas dos, 00:16:49

pues lógicamente mantendrá el cero de aquí de la inicialización. 00:16:54

Voy a quitar. 00:16:58

Lo que estamos haciendo es comparar las dos personas de acuerdo a un criterio, que es la edad. 00:16:59

Bien, ya tenemos aquí el mecanismo para comparar a las dos personas. 00:17:06

¿Cómo lo estábamos haciendo hasta ahora? 00:17:09

considerando el interfaz comparable en principal, pues nada, directamente creamos el triset 00:17:11

y ya él iba cogiendo y iba llamando al compareTo del interfaz comparable. 00:17:20

¿Qué tenemos que hacer en caso de no querer considerar el comparable y utilizar este otro criterio? 00:17:26

Pues lo que podemos hacer aquí es crear un objeto de la clase comparar, 00:17:33

un objeto de la clase comparar, que es la que acabamos de 00:17:38

implementar aquí, de desarrollar aquí, que implementa 00:17:51

el interfaz comparator y en el método compare hemos dado el 00:17:55

criterio por el cual comparamos dos objetos que resultan ser 00:17:59

dos personas, ¿verdad? Y para asociarlo a la colección 00:18:03

lo que hacemos ahora es, en el triset 00:18:07

comento este del otro día, lo mantengo ahí, lo que hago es pasarle 00:18:10

este objeto de esta clase al constructor 00:18:16

que tenemos en el momento en el que creamos la colección. 00:18:18

Al pasarle, digamos, el constructor del triset está 00:18:23

sobrecargado. Por un lado tiene el constructor vacío y por otro 00:18:28

un constructor que permite recibir un 00:18:32

objeto de una clase, sea la que sea, con la condición 00:18:36

de que esté implementando esa clase el interfaz 00:18:40

comparator. Con lo cual, la ordenación 00:18:44

que vamos a tener de esta colección, mi ARCOL, que es de la clase 00:18:48

persona, en principio lo que buscamos es que tenga 00:18:51

en cuenta los criterios que habíamos puesto en este objeto, que es 00:18:57

un objeto de la clase comparar. Vamos a hacer una ejecución, tengo ahora mismo dudas, no recuerdo 00:19:01

muy bien si es necesario quitar la interfaz comparable en la clase 00:19:06

persona o aunque exista, no le importa porque al haberlo 00:19:10

al haber inicializado la colección 00:19:14

con este constructor, ya va a ir a tener este criterio. 00:19:18

En caso de que no sea así, pues le quitamos el... 00:19:22

Como estamos ahora apoyándonos en el interfaz 00:19:25

implementando el interfaz comparator, quitaríamos en ese caso el interfaz 00:19:28

comparable y con lo cual haríamos desaparecer este método. Pero yo creo que no es 00:19:33

necesario. El criterio que hemos puesto aquí ha sido de edad, ¿verdad? 00:19:37

pues vamos a ver si esta colección nos funciona de esta forma. 00:19:43

Vamos a poner, por ejemplo, primero, vamos a considerar que los dos objetos 00:19:50

que metemos en la colección tienen la misma edad. Esto hará que al tener la misma edad 00:19:54

los considere por esta interfaz como la misma persona. 00:19:58

Vamos a cambiar aquí para que solamente sea la edad. 00:20:03

El nombre de una sea August, el nombre de otra Miguel, y los dos con la misma edad. 00:20:06

Según este criterio, al ser los dos con la misma edad, no entraría 00:20:12

ni por el if ni por el else nos devolvería un 0 y que nos devuelva un 0 implica 00:20:16

mismo elemento como es set 00:20:20

al ser un triset es set, no admite duplicados, pues solamente 00:20:23

debería meter uno de los elementos, esto debería decirnos que solamente tiene un elemento 00:20:28

vamos a ver, fijaros como efectivamente nos dice 00:20:32

que tiene un solo elemento, si cogemos y le cambiamos y le ponemos aquí 21 00:20:38

para que tenga edad diferente, ya tiene dos elementos 00:20:44

es decir se está apoyando en éste para que no tengamos ninguna duda de que va por ahí vamos a 00:20:50

quitar a la clase persona esto y vamos a quitarle el método también pues si lo queremos retomar lo 00:20:58

que voy a hacer va a ser comentarlo mantengo una línea con un comentario ahí arriba y esto 00:21:09

ahora lo comentas la clase persona ya no tiene de aumentar más abajo yo creo aquí quizás a ver 00:21:18

la clase persona se quedará con los dos atributos solos y aún así el programa no sigue funcionando 00:21:38

porque ahora el tríceps en realidad utiliza la clase un objeto a la clase comparar no el compare 00:21:45

tú de la clase persona vamos a ver si sigue funcionando efectivamente vale pues como ahora 00:21:52

los datos son 21 y 20 fijaros pues el criterio en la edad pues ya me dice que tenemos dos elementos 00:21:58

Y además, observad cómo, a pesar de que he insertado primero mi PER que tiene la edad 21 y en segundo lugar mi PER2 que tiene la edad 20, a la hora de mostrármelos en este iterador, me muestra primero el del 20. ¿Por qué? Por el criterio de ordenación. 00:22:05

si aquí en comparar me vengo y le cambio 00:22:22

justo el criterio, le pongo aquí el menos uno y aquí el uno 00:22:25

al ejecutar, pues ahora el criterio de ordenación es 00:22:27

de mayor edad a menor edad y ya me dice 00:22:34

que August que tiene 21 es el primero de los elementos 00:22:37

que se encuentra en esta colección. Hasta aquí 00:22:40

si tenemos una única colección, pues bueno pues 00:22:44

de personas, pues nos valen 00:22:47

por igual los dos interfaces, como lo teníamos antes 00:22:51

así como lo teníamos ahora. En un caso, en el compare tú de la clase persona, 00:22:54

metemos el criterio de ordenación por edad y en otro caso 00:22:57

lo estamos definiendo en esta otra clase. 00:23:00

Pero la principal ventaja que tiene, 00:23:02

si os apetece hacerlo más con una clase extra, 00:23:05

es que podemos tener dos colecciones 00:23:11

de la clase persona en nuestro programa 00:23:13

que a lo mejor es necesario, con criterios de ordenación distintos. 00:23:16

Entonces, si cogemos y aquí definimos 00:23:23

una segunda clase, que llamamos, por ejemplo, comparar2, comparar2, ahí la tenemos, vamos 00:23:24

a hacer copy-pega de esto, aquí el import, tengo que decirle que implemente comparator 00:23:36

también, esta nueva, ahí lo tenemos, al implementar comparator en esta nueva clase 00:24:02

nos obliga a tener el método compare. Este es el criterio de orden de mayor a menor que 00:24:11

teníamos aquí pues mirad en esta colección vamos a volver a poner el orden de mayor a menor podríamos 00:24:18

poner cualquier otro criterio que estuviera que ver por ejemplo con el nombre de la persona a la 00:24:25

hora de ordenarlo aquí por código definirse el que sea esta colección decimos que se base la 00:24:29

ordenación en este objeto que es de la clase comparar con lo cual aquí estamos manteniendo 00:24:38

el criterio de orden de mayor a menor por edad y ahora lo que vamos a hacer aquí abajo vamos a 00:24:42

voy a hacer copy-pega y ahora vamos haciendo los cambios oportunos 00:24:56

para que vaya más rápido. Digo, quiero definir un objeto de la clase 00:25:00

comparar2 que sea mi.com.2, que es esta otra, a la cual 00:25:04

os recuerdo que le hemos dado la vuelta a estos números para que la forma de ordenación 00:25:12

siga siendo por edad, que ya os digo, podría ser otro criterio, pero en este caso 00:25:16

comparar2 ordena de menor a mayor, comparar1 de mayor a menor. 00:25:20

El menos uno está aquí en este caso y el menos uno aquí en este otro. 00:25:25

creo un objeto, creo una colección diferente en mi programa 00:25:28

que también es de la clase persona, si estuviéramos utilizando 00:25:35

la forma de ordenación a través de 00:25:38

el interfaz comparable aquí, no tendríamos opción de ordenar de dos formas porque este 00:25:43

método en toda la clase persona es único, el compare tú 00:25:47

pero aquí sí que a cada una de las dos colecciones le vamos a dar 00:25:50

un criterio diferente, a pesar de que las dos colecciones son 00:25:54

de la clase persona. Bueno, pues 00:25:59

a esta nueva colección le volvemos a meter los dos 00:26:05

mismos elementos, si os parece, por no andar perdiendo mucho 00:26:08

el tiempo. MiPer y MiPer2, que son 00:26:11

los dos objetos que habíamos dado de alta aquí, 00:26:14

hemos metido información aquí, aquí se lo añadimos a una colección 00:26:17

y aquí se lo estamos añadiendo ahora a la segunda colección. 00:26:21

Fijaros el 2. Creamos un iterador 00:26:24

para mostrar los datos, no sobre la primera colección, 00:26:31

sino sobre la segunda, y ya lo tenemos, entonces si ejecutamos ahora, voy a meter aquí algo que 00:26:34

nos claramente nos separe la información de una colección y la de otra, vamos a meter aquí unos 00:26:50

asteriscos por ejemplo, entonces si ejecutamos, a ver qué he hecho, bueno me falta aquí modificar 00:26:58

ese dato, ahí estamos, ejecutamos 00:27:15

y aquí lo tenemos. Los datos son los mismos porque hemos metido los dos 00:27:20

mismos objetos, pero fijaros como esta nos ha mostrado la 00:27:25

ordenación de los elementos de mayor a menor edad y esta 00:27:28

de menor a mayor, que es justo los criterios que hemos puesto por aquí. 00:27:33

Bueno, pues esta otra técnica tenemos para los trisets. 00:27:39

No sé si hay alguna pregunta por ahí y si no, pues a lo sigo contando 00:27:46

más cosas. Dentro de las colecciones 00:27:53

tenemos, estamos hablando ahora de cómo 00:27:57

podemos trabajar con los trisets, que 00:28:01

decimos que tienen orden y no permiten duplicados, habíamos hablado de 00:28:05

luego después os hago un comentario más sobre los ArrayList o los 00:28:09

LinkedList, que lo que tienen, permiten duplicados 00:28:13

y no tienen un orden, al menos con criterio propio en el 00:28:18

programa, pero luego tenemos otras colecciones que son los set, pero que no son tree, es decir, no están 00:28:21

ordenados, pero no permiten duplicados. Por ejemplo, en este caso podríamos hablar de los, a ver, 00:28:28

de cuáles, por ejemplo, de los linked set, como son, no recuerdo cómo son estas, de los hash set, por ejemplo. 00:28:36

Estas colecciones, las colecciones Haset, que también las tenemos disponibles en las colecciones de Java, aquí tenemos uno de ellos. 00:28:49

Fijaros cómo no permite duplicados, pero al no tener el tree, no tiene una ordenación en particular. Si no tiene una ordenación en particular, aunque solo sea por nombre, no parece que tenga mucho sentido que sea el interfaz implement comparable que tiene el compare to el que nos permita hacer las comprobaciones de los duplicados. 00:28:58

duplicados. ¿Qué utilizan los set que no están ordenados? 00:29:17

Pues utilizan otros métodos diferentes. 00:29:21

Vamos a hacer un, para verlo por código, voy a comentar todo esto, 00:29:31

luego voy cogiendo código si lo necesito. Vamos a hacer, por ejemplo, un 00:29:40

has set de personas. Cada nueva persona cañada 00:29:43

habrá que comprobar si ya existe en la colección, 00:30:02

bueno, habrá que comprobar, la colección comprueba si ya existe en la colección 00:30:06

para evitar que haya duplicados. No le preocupa el orden 00:30:10

porque no es un tree, pero sí que es un conjunto, no nos permite 00:30:14

duplicados. Entonces, si tenemos aquí dos personas 00:30:18

damos de alta las dos personas de antes 00:30:22

podríamos coger y decir, bien, añado 00:30:26

una persona y otra, y luego miro el 00:30:36

tamaño que tiene la colección 00:30:49

y ejecutándolo así de primeras, pues me dice que hay dos elementos 00:30:53

en la colección. Pero según mi enunciado 00:30:58

podríamos tener un criterio para decir, oye, estas dos personas son iguales 00:31:02

si tienen la misma edad. Si, un enunciado será 00:31:07

si tienen el mismo nombre. Solamente son iguales si tienen 00:31:11

la misma edad y a la vez tienen el mismo nombre. Bueno, pues todo ese criterio 00:31:15

igual que antes hacíamos en el compare tool, lo podemos programar nosotros por código 00:31:18

y qué métodos son los que se utilizan para los set que no son tres y para los conjuntos que no 00:31:23

están ordenados pues en la clase persona igual que antes para los tres utilizábamos el compare 00:31:29

tú en este caso son otros dos métodos los con los que se trabajan que son una combinación del 00:31:35

public int hashCode y otra una combinación de estos dos métodos y otra el public boolean equals 00:31:42

que recibe un parámetro del tipo object combinando estas dos estos dos métodos el hashCode estos dos 00:32:06

métodos son luego ponemos un system out de una colección que sea por ejemplo un hashSet son los 00:32:24

que la colección desde aquel código que está en las librerías consultará para determinar si, ya que es una colección tipo set, esos dos objetos son duplicados. 00:32:29

Como son dos métodos de la clase persona, estará comparando en particular el método, el equals, porque del Hasco de ahora os voy a decir que en principio vamos a olvidarnos un poco, 00:32:39

mirará este objeto con el objeto 00:32:50

del que está haciendo la llamada. Para centralizar 00:32:56

todo en un solo método, lo que podemos hacer es directamente 00:32:59

el hashCode decir que el return 0, ya está. 00:33:03

Vamos a poner un system out aquí para luego ver que efectivamente va pasando en las comprobaciones 00:33:07

por este método, pero digamos que de esta forma nos olvidamos 00:33:12

de cualquier codificación aquí. Y todo el criterio de comparación lo podemos poner 00:33:23

aquí. Para esto lo que hacemos es, igual que antes en el compareTo, pues decimos 00:33:27

persona, mi per 00:33:31

o per aus, vamos a poner que sea igual, hacemos un casting 00:33:34

de persona del atributo que estamos recibiendo como parámetro 00:33:40

y ahora aquí hacemos la comparación que nos interesa 00:33:47

que nos interese para nuestro programa 00:33:52

la comparación que nos interese para determinar si la persona que está llamando al método 00:33:55

y la que ha recibido como parámetros son iguales. 00:34:04

Y en base a esto, la colección añadirá o no añadirá el método 00:34:07

porque al ser un set solamente lo hará en caso de que sean diferentes. 00:34:11

Como estábamos diciendo que tenga la misma edad, 00:34:15

pues podríamos decir id, sí. 00:34:17

Dis yo mi edad es igual a la edad de la persona 00:34:20

que estoy recibiendo como parámetro aquí, 00:34:26

per aus punto y edad, si es igual, 00:34:35

lo vamos a iniciar a falso, falso significa 00:34:39

no son iguales y en caso de que sea igual 00:34:53

lo ponemos a true 00:34:56

y ahora devolvemos bReturn 00:35:00

si cuando se llame a este método se determina 00:35:03

que la persona que estamos recibiendo como parámetro 00:35:08

comparándola con la persona actual bajo el criterio 00:35:11

de que sea la misma edad porque nuestro enunciado en este ejercicio 00:35:15

es el criterio que hemos tenido para que dos personas sean iguales 00:35:18

así es, lo que hago es poner la variable bReturn a true 00:35:20

para que nos devuelva true, indicador de que ambas dos son iguales 00:35:23

si no entra por aquí, pues tendremos el valor en bReturn 00:35:27

de la inicialización que es falso y nos estará devolviendo falso, es decir, son diferentes 00:35:32

para ver también que pasa por ahí cuando está haciendo 00:35:36

este criterio, vamos a poner que nos pasa equals 00:35:40

vamos a ponerlo aquí para que nos haga el mensaje de tanto cuando son iguales 00:35:51

como cuando no, que ha pasado por ahí 00:35:59

pues ya está, igual que antes el compareTool 00:36:00

el que utilizábamos en el triset, pues ahora son estas dos 00:36:05

esta la fijamos para que no tenga 00:36:07

trascendencia a la hora de hacer la comparación 00:36:10

entre las dos personas y en este caso es donde metemos el código 00:36:14

según la lógica que nos interese programar 00:36:16

entonces fijaros, aquí estamos añadiendo dos personas 00:36:19

en un hashSet, es previsible 00:36:25

que se vaya a fijar precisamente en estos métodos para determinar 00:36:28

si son iguales, vamos a hacer una ejecución a ver qué pasa. 00:36:32

Si hacemos una primera ejecución con edades diferentes, 00:36:35

como el criterio que hemos puesto para que las personas sean iguales, 00:36:38

tendría que añadir los dos. 00:36:41

Y fijaros cómo, aunque nosotros no tenemos aquí llamadas 00:36:45

a esos métodos, nos salen las trazas que hemos puesto aquí 00:36:48

porque desde el código que tenemos en las librerías 00:36:52

para el HashCode se apoyan estos métodos 00:36:58

para hacer esas comprobaciones. 00:37:01

Y si cogemos y decimos que las dos personas sean iguales, 00:37:04

fijaros como ahora efectivamente solamente añade una 00:37:06

porque el criterio que hemos programado en esos métodos es 00:37:11

que tengan la misma edad para que estén repetidos 00:37:15

en otro ejercicio, bueno pues si el criterio que fuésemos a considerar 00:37:18

fuese que dos personas con el mismo nombre 00:37:24

son aquellas que son iguales, pues lo que tendríamos que hacer 00:37:26

si vamos a utilizar un hashSet 00:37:30

sería en la clase persona aquí programar 00:37:32

para que devuelva verdadero o falso 00:37:35

en el caso en que los nombres sean iguales, simplemente 00:37:37

no voy a incidir mucho en esto porque 00:37:41

creo que ya más o menos lo sabréis hacer, pero lo único que 00:37:43

cuidado que los nombres no los podemos comparar de esta forma 00:37:50

con el igual igual los nombres hay que compararlos con 00:37:54

punto compareTo, fijaros el método compareTo 00:38:00

y aquí pondríamos 00:38:05

miper 00:38:09

y 00:38:10

peraus 00:38:12

Ah, bueno, con el equals también, sí 00:38:14

Sí, sí, vale 00:38:27

Si lo hacemos así, de hecho es más directo el equals 00:38:28

Me preguntan que 00:38:32

para la grabación si con el equals se puede comparar 00:38:33

porque esto devolvería un valor 00:38:35

numérico 0, 1, menos 1 00:38:37

Este, para que se convierta en boolean, habría que 00:38:39

hacer esto 00:38:41

Y en cambio con el equals fue mucho mejor, la verdad 00:38:42

En ese caso 00:38:45

pero el equals de la clase string 00:38:47

porque esto es un string, entonces podríamos 00:38:50

equals y aquí le diríamos 00:38:52

peraus y bueno pues aquí 00:39:05

esta sería la forma de comparar dos strings 00:39:20

el equals este nos devolvería verdadero o falso si los dos 00:39:22

strings son iguales, esto sería otra forma la verdad 00:39:26

si el compare tú las dos son iguales nos devuelve cero 00:39:28

pero este nos da más información que en este caso no necesitamos 00:39:31

si hay alguna duda para los set 00:39:35

Bueno, pues si no tenéis más dudas, os sigo contando más cosas. 00:39:42

Mirad, otro tipo de datos que, voy a seguir comentando por aquí, 00:39:57

otra estructura de datos que se da típicamente en la algoritmia 00:40:03

son las pilas y las colas. 00:40:09

¿Una pila qué es? 00:40:16

Pues siempre se comenta, se pone el ejemplo de una pila de platos cuando estamos, si no hemos puesto el lavavajillas porque lo tenemos averiado y tenemos que fregar los platos ahí a mano, pues según vamos cogiendo cada uno de los platos, lo ponemos encima, después de lavarlo, lo ponemos encima del fregadero, ¿no hay? O encima de la encimera. 00:40:17

el segundo plato va encima del primero, el tercero va encima 00:40:38

del segundo y así, vamos haciendo una pila de platos 00:40:42

cuando lo vamos a recoger, a no ser que queramos correr el riesgo 00:40:46

de que se nos rompa a todos, ¿qué es lo que hacemos? Pues el primero que cogemos es 00:40:51

el último que hemos puesto, que es el que está arriba del todo, el segundo que cogemos, para ya guardarlo 00:40:54

ahí en el cajón, el segundo que cogemos es el penúltimo que pusimos 00:40:59

entonces, las pilas 00:41:03

son estructura de datos 00:41:07

como se llaman, LIFO 00:41:10

LIFO, LAST 00:41:11

último en entrar, LAST INPUT 00:41:14

FIRST primero en salir, son estructuras 00:41:16

LIFO 00:41:18

y luego las colas 00:41:18

pues estas son cuando vamos a comprar 00:41:21

a la carnicería 00:41:28

si no hay alguno con un poquito más cara 00:41:30

o que lleva más prisa y pide permiso 00:41:32

lo normal es que el primero que llega 00:41:34

es el primero que se atiende 00:41:36

y llegas tú allí, coges tu 00:41:38

número y tienes el número 1 y llega otro, coge el número 2, otro el número 3, 00:41:40

pues cuando el carnicero quiere atender a uno, dice el número 1, el primero que llegó, 00:41:45

es el primero que atiende. Al contrario que en las pilas, que el último que llega es el primero que 00:41:48

es atendido. Esas estructuras son las FIFO. Entonces, 00:41:52

estas dos estructuras se dan en la algoritmia 00:41:56

muy habitualmente y podemos trabajar con 00:41:59

colecciones de datos un poco bajo este 00:42:04

criterio. ¿Qué colección de datos tiene métodos que nos permiten trabajar con este criterio de 00:42:08

pilas o de colas? Pues la LinkedList. Vamos a hacer una LinkedList, por ejemplo, enteros, integer. 00:42:14

La LinkedList, fijaros, son colecciones que no son ni tree ni set, es decir, admiten duplicados y en 00:42:43

principio no tiene una ordenación especial una colección linkedin leads pues tendrá el método 00:42:50

add como todas las colecciones que le viene heredado de colección pero la link el dis además 00:42:59

como se pueden comportar como en su código que a lo mejor no la tienen todas las colecciones ya que 00:43:06

no todas soportan el concepto de pilas y colas si vamos a hacer primero vamos a trabajar primero con 00:43:14

una con una pila vamos a ver la pila pues las pilas tienen el método push el método push es 00:43:23

el que nos permite ir apilando los elementos es decir saco del fregadero el plato que acabo de 00:43:34

limpiar y lo pongo sobre la encimera. Poner el plato 00:43:41

sobre la encimera es hacer un push. El segundo plato haría un segundo push 00:43:45

que lo pondría sobre el primero. Es decir, va guardando en la colección 00:43:49

los datos bajo el criterio de una 00:43:54

pila. Después, como hemos hecho 00:43:58

una linked list de integers, podría ser de cualquier tipo, igual que estamos 00:44:00

viendo en las colecciones, vamos a poner, por ejemplo, que almacenamos 00:44:05

el dato 4, el siguiente 00:44:09

vamos a poner que anotamos el 6, el siguiente el 2 00:44:14

estamos guardando la información en esta colección 00:44:21

que en particular es de elementos integer, podría ser de cualquier 00:44:26

otro y como queremos hacerlo bajo el criterio de pila 00:44:30

utilizamos el método push de la colección linked list 00:44:34

para recuperar los datos 00:44:39

es decir, ir cogiendo los platos y supuestamente el primero que tendrá que coger, ya que las pilas tienen un criterio LIFO, Last Input, First Output, el último que entra es el primero que sale, si se comporta de verdad bajo el criterio de LIFO, el primero que debería salir sería este el 2, el segundo el 6 y el tercero el 4. 00:44:42

¿Cómo podemos ir recuperando los datos? Pues con el método pop. Este método pop me devolverá un elemento de este tipo, que es el que tiene la colección, y si sigue el comportamiento de pila, tendría que ser el último elemento que hemos metido, que por la secuencia aquí de inserción de elementos sería el 2. 00:45:05

si lo que me devuelve lo voy a meter en un system.println 00:45:30

para de verdad comprobar que se comporta como 00:45:35

una pila, decimos que el método 00:45:39

pop, vamos a sacar un primer elemento y vamos a sacar 00:45:46

un segundo, el primer elemento debería sacarnos este, el segundo 00:45:52

debería sacarnos el 6, hacemos una ejecución 00:45:55

veis el primero que saca es el 2 00:45:58

y el segundo el 6, si saco un tercer 00:46:01

elemento, pues cuál sería, pues el siguiente elemento que tenemos 00:46:05

aquí el 4, 2, 6 y 4. Su comportamiento es como una pila. Sí, os cuento justo esto. Ahora, ¿en qué situación podemos trabajar con una pila? Pues bueno, podemos trabajar con una pila según nos lo demande el ejercicio. 00:46:11

Ahora tenemos una herramienta más ahí en la mochila, que es poder trabajar con pilas de elementos, en este caso, cuyo tipo es integer y en otro caso podría ser de otro tipo. 00:46:34

bueno, preguntabais que si en el momento 00:46:46

que se pierde de la pila el dato, se pierde de la pila si utilizamos el método 00:46:51

pop, si queremos trabajar con el elemento 00:46:55

que toca en la pila, pero que no se pierda de ahí 00:46:59

la colección linked list nos ofrece 00:47:02

otro método diferente que es el system 00:47:07

que es el system.out, no, este lo pongo para que lo podamos ver 00:47:10

por pantalla mi colet punto pic pic nos recupera el elemento que tenemos arriba del todo en la 00:47:15

pila pero no lo elimina de la no lo elimina de tal forma que si por ejemplo aquí cogemos vamos 00:47:26

a poner el pic aquí qué comportamiento sería el previsible del programa ahora lo comprobamos 00:47:35

Aquí hacemos un pop, nos cogerá el último elemento. Como es un pop, este elemento lo eliminará de la pila y se vendrá aquí. En este caso hacemos un pick. Este pick, al tener ahora mismo el dedito que apunta a la pila en el 6, nos devolverá un 6, pero al ser un pick y no ser un pop, no elimina el 6. 00:47:42

con lo cual aquí es previsible que nos muestre 00:48:07

el 6 y luego este pop es previsible 00:48:09

que nos vuelva a mostrar el 6 y este siguiente 00:48:11

pop que nos muestre ya el 4 00:48:13

eso es lo que yo creo que debería 00:48:15

pasar, vamos a hacer una ejecución y comprobamos 00:48:17

mirad, primero nos saca 00:48:19

este system out, el dato 00:48:23

que recogemos de aquí, que es un 2 00:48:25

el 2, el último que había entrado 00:48:27

el pick 00:48:29

recupera el siguiente, donde está 00:48:31

apuntando ahora el indicador en la pila 00:48:33

que es el 6, pero no avanza porque luego 00:48:35

el siguiente pop vuelve a ofrecernos para mostrar 00:48:37

el system out, el 6, pero en este caso sí, es un pop, entonces avanzamos 00:48:41

y el siguiente pop ya nos muestra un 4, entonces con pick 00:48:45

cogemos el dato, pero no lo muestra, mira, si fuera una pila 00:48:49

de personas 00:48:55

volver un poco más a la variedad, personas, pues aquí meteríamos en la 00:48:59

pila, mi per 1 y mi per 2, las dos personas 00:49:09

que tenemos aquí vale hemos metido dos personas entonces ahora si hacemos un pop lo que haría 00:49:16

se recupera sería recuperar esta primera persona de lo que podríamos hacer aquí fijaros en este 00:49:25

caso como no es tan directo podríamos decir persona de aus es igual y hacemos un poco esto 00:49:30

me devolverá este pop la primera de las personas la referencia a la primera de las personas que 00:49:38

apuntará a PAUS y ahora podemos hacer aquí 00:49:45

un System of Println 00:49:47

de este PAUS 00:49:50

que estará apuntando a la primera de las 00:49:51

personas que me ha devuelto la pila 00:49:53

que será la última que metimos 00:49:55

es previsible que sea PER2 00:49:56

vamos a poner los datos para poder 00:49:58

identificarlos 00:50:01

que será PER2, que PER2 00:50:02

tiene por nombre 00:50:09

Miguel, entonces si hacemos ahora aquí un System 00:50:11

of Println 00:50:13

de PAUS 00:50:14

punto ese nombre 00:50:18

lo previsible es que nos diga que ese 00:50:22

es Miguel, si luego cogemos y cogemos de la pila 00:50:26

bueno, hacemos, mira en lugar de 00:50:33

este, para ver todos los métodos vamos a hacer aquí un pick primero 00:50:41

que nos coja este, pero no avance la pila, con lo cual 00:50:44

se supone que peaus será per2, luego hacemos un pop 00:50:48

y peaus volverá a ser per2, vamos a mostrar de nuevo 00:50:52

dos veces el nombre de Miguel. Y luego 00:50:56

hacemos un nuevo pop 00:50:59

que nos muestre ya el nombre de PAUS, este nuevo pop 00:51:01

ya sería pop1 porque 00:51:06

este pop habría hecho avanzar al penúltimo 00:51:08

de los elementos que tenemos en la pila. 00:51:12

¿Veis? Entonces tenemos dos Miguel y un PAUS. 00:51:17

No sé si lo veis, pero que sí. 00:51:25

Si queremos que, avanzo si no me decís 00:51:30

nada, si queremos que el comportamiento en lugar de una pila 00:51:33

que tiene esa forma sea una cola, es decir, su comportamiento 00:51:37

sea fifo, los cambios respecto a la pila 00:51:45

son muy pocos, luego funcionalmente nos dará ese otro comportamiento 00:51:49

que será el que querremos, pero son muy pocos, a la hora de hacer las inserciones 00:51:53

lo que tenemos que hacer es en lugar de utilizar el método pub 00:51:57

push, podemos utilizar el método que tenemos 00:52:02

siempre para las colecciones el método ata porque los linked list tiene una ordenación no según 00:52:06

nuestro criterio como sería si fuera un tri pero sí según el criterio de inserción entonces el 00:52:17

hecho de cambiar esto al crítica este criterio lo que hace es que nuestra colección tenga linked 00:52:23

list tenga el comportamiento típico de cuando vamos a la carnicería que el primero que coge 00:52:29

el ticket para el turno, pues es el primero que llaman. 00:52:33

Entonces, si ahora aquí metemos Miper 00:52:39

antes que Miper2, 00:52:41

estaremos metiendo Agus antes que Miguel 00:52:45

y ahora al hacer aquí el pop o el pick 00:52:47

nos dirá Agus, Agus, Miguel, la ejecución. 00:52:51

Ahí lo tenéis. 00:52:57

Su comportamiento ya es según una cola. 00:52:58

FIFO. 00:53:01

No sé si tenéis alguna cosa por ahí. 00:53:09

No. 00:53:19

Vale, pues avanzamos un poquito más y nos vamos a, de momento vamos a dejar aparcados las colecciones y vamos a hablar un poco de los mapas. 00:53:21

¿Cuál es la diferencia principal entre una colección y un mapa? 00:53:34

Una colección almacena datos de tipos a través de grupos primitivos o referenciados, pero un solo dato. 00:53:37

el dato que almacena, pues será así, pues será de tipo string o de lo que sea. 00:53:53

Los mapas lo que hacen es que en su estructura de memoria guardan pares. 00:53:57

Y estos pares, bueno, pues son, hay un primero y separado de una coma, un segundo. 00:54:04

Cualquiera de estos dos puede ser de cualquier tipo, al igual que el tema de las colecciones. 00:54:12

Con la diferencia de que este primero se convierte en una clave que identifica el segundo de los datos. 00:54:18

Yo creo que se entiende, el otro día lo comentaba, si pensamos en un array de los que conocemos, entre los corchetes, para acceder a uno, si es un array de enteros, 00:54:24

para acceder a uno u otro, aquí lo que ponemos es un numerito que va de 0 hasta la longitud del array menos 1. 00:54:37

Pues esto en ese caso vendría a ser el criterio para acceder al elemento. El tipo de elementos en el array al que estamos accediendo sería este segundo que identificamos aquí en el mapa y el primero sería este. 00:54:48

En un array solamente este primero podría ser de tipo integer, porque los índices de los arrays son siempre posicionales, pero en un mapa puede ser cualquier tipo, puede ser la clave que no se puede nunca repetir, podrá ser un string, podrá ser lo que sea. 00:55:02

en una clase persona, si tuviéramos un mapa de la clase persona 00:55:21

¿quién podría ser un típico candidato en la mayor parte de los mapas 00:55:25

en los que trabajas en personas? Pues su DNI, los DNI son 00:55:29

números o combinaciones de números y una letra al final 00:55:33

que nos identifica a cada uno y que además no hay posibilidad 00:55:38

de repetirlo, aquí podría ser el DNI, pero ya digo que puede ser cualquier cosa 00:55:41

si nosotros definimos un mapa 00:55:45

con estas características, pues resulta que podría tener en este mapa 00:55:49

una entrada cada uno de los DNIs. 00:55:56

Yo, con mi objeto persona, con mi dato, mi edad, mi nombre, 00:55:59

los atributos que tenga la clase persona, en este mapa estoy identificado por mi DNI. 00:56:04

Cualquier otra persona está identificado por su DNI. 00:56:10

Para acceder a todos mis datos, desde el mapa puedo hacer un get 00:56:13

y decirle que lo haga y meter el dato de mi DNI 00:56:17

y que me devolverá el objeto persona que está almacenado en el mapa 00:56:22

asociado a mi clave. 00:56:26

Igual que aquí, en el array, poníamos una posición 00:56:28

y nos devolvía un objeto de la clase persona también, 00:56:31

si es un array de personas. 00:56:34

Las colecciones hablábamos de aquellas que permiten duplicados 00:56:38

y sin orden. 00:56:44

Y luego los otros criterios que teníamos eran 00:56:47

sin duplicados y sin duplicados y además y ordenados. 00:56:49

Los mapas, el tema de los duplicados no ha lugar. 00:57:03

Todos los mapas son sin duplicados. 00:57:07

Y el criterio para mirar a ver si hay duplicados es la clave, este primero. 00:57:12

Tú si pones para una persona, haces trampas y dices una misma persona con sus datos 00:57:18

tiene tres DNIs, podrás tener tres entradas ahí. 00:57:24

Lo que nunca podrás tener es, incluso siendo dos diferentes personas, 00:57:28

el mismo DNI para diferentes objetos de la clase Persona. 00:57:33

Y teniendo en consideración que nunca permite duplicados, 00:57:39

lo que sí que puede estar es ordenados o sin orden. 00:57:44

Si tienen un orden establecido a través de un criterio 00:57:50

que tengamos nosotros como requisito en el programa 00:57:54

serán los tree, otra vez, en este caso los tree map 00:57:58

pues nada, vamos a implementar un mapa 00:58:02

y vemos ahí un ejemplo de como podemos trabajar 00:58:08

un poco con él, y vamos a empezar 00:58:13

haciendo un mapa de 00:58:25

un mapa que no está ordenado, un hash map 00:58:29

Vamos a poner, por ejemplo, para empezar, que su clave sea un integer y que almacene un integer. MiMapa, metemos de la librería Java útil el HashMap y ahí lo tenemos. 00:58:35

como podemos añadir elementos a un mapa 00:59:05

pues ponemos mi mapa 00:59:09

punto put, el método put 00:59:11

fijaros que ahora me pide dos atributos, uno es la clave 00:59:15

y otro es el valor que quiero meter 00:59:18

entonces digo put y digo 00:59:21

con la clave 1 que meta un 10 00:59:24

con la clave 2 que meta un 20 00:59:27

ahora voy a decir que con la clave 1 meta un 30 00:59:34

repitiendo clave de aquí 00:59:37

con la clave 3 que meta a 40 00:59:40

estos datos por los que nos fuera pidiendo el programa 00:59:45

y con la clave 4 que meta en 50 00:59:48

si hago un system.out.println 00:59:50

del mapa, miMapa.site 00:59:57

pues es de esperar que tengamos 01:00:01

como el criterio es la clave 01:00:04

y nunca permite repetidos 01:00:06

que tengamos 1, 2, 3 y 4 01:00:08

porque este no lo considerará 01:00:10

al estar metido este 01:00:12

En realidad los mapas yo creo que nos actualizará el valor, mantendrá esta clave pero el mecanismo de actualización es a través de un put, es decir no mete un nuevo registro pero yo creo que el valor final que va a tener va a ser este, ahora después lo comprobamos. 01:00:13

Vamos a hacer una primera ejecución, me dice que tengo cuatro elementos, uno, dos, tres y cuatro, este no ha metido dos entradas con esta clave. 01:00:27

Si queremos recorrer el mapa, hay un mecanismo para hacer un iterador y otro con los for estos más rápidos, pues podemos decir for, vamos a decir que, integer, ahora repasamos justo esta instrucción que estamos metiendo, mi clave del mapa, mi mapa, tiene un método que es el kset, que es el conjunto de claves, 01:00:36

aquí lo que estamos diciendo es 01:01:10

estamos diciendo 01:01:16

para todo el conjunto 01:01:23

de claves del mapa 01:01:26

ves una a una 01:01:27

cargándolo en la variable 01:01:30

mi clave y mi clave 01:01:32

es de tipo integer porque 01:01:34

las claves que tiene el mapa 01:01:36

hemos hecho aquí que sean de tipo integer 01:01:38

entonces aquí para 01:01:40

coger el valor fijaros el mapa tiene 01:01:46

el conjunto de claves a través del método 01:01:48

case cell lo podemos recuperar para recorrer 01:01:50

todos ellos y el tipo de datos que nos devuelve fijaros es también de tipo entero en este caso 01:01:52

entonces podemos decir mira devuelve voy a cargar mi val aquí en una variable de tipo entero y vamos 01:01:57

a decir mi clave mi clave en cada una de las iteraciones del ford será una de las claves 01:02:03

que me está devolviendo el case set del mapa el conjunto de claves que tiene el mapa punto 01:02:10

.get 01:02:16

.get 01:02:18

de la variable 01:02:26

mi clave, .get 01:02:28

no, perdón 01:02:33

el mapa 01:02:42

mapa.get 01:02:43

mirad esto 01:02:45

si lo intentamos llevar 01:02:47

conceptualmente a lo que conocemos de los 01:02:50

arrays, pues imaginaos que tenemos 01:02:52

un array de integers 01:02:54

que tiene esta definición 01:02:55

bueno, le hemos hecho un new 01:03:06

le hemos metido datos vamos a suponer entonces el array sería mirar el nombre del array para 01:03:09

acceder al primero al segundo de los elementos y aquí pondríamos un 2 pues este 2 es el que 01:03:16

estamos poniendo aquí como clave la clave es cada una de las claves que tiene el mapa cuando estamos 01:03:23

recorriendo el ford que será cada una de estas que hemos metido en el punto y que nos devuelve 01:03:28

esto, el nombre del array y aquí decimos del mapa 01:03:35

para el mapa dame esta clave con el get y que me está 01:03:40

devolviendo, pues me está devolviendo el dato que tenga, en este caso es de tipo integer 01:03:44

nos está cargando aquí en una variable de tipo integer 01:03:48

ahora si hacemos aquí un system.out.println 01:03:51

de mi val, pues nada, hacemos un recorrido 01:03:56

de todos los elementos que tiene ese mapa, fijaros los datos 01:04:03

que me muestra son 30, 20, 40 y 50. 01:04:07

Es decir, para este, no ha metido un duplicado, 01:04:11

pero el dato que ha terminado metiendo es este, ¿veis? 01:04:15

Un 30. 01:04:20

Es decir, lo ha sobrescrito. 01:04:24

No permite duplicados, pero el put, en este caso, 01:04:25

lo que hace es sobrescribirlo, no ignorarlo porque ya existe 01:04:28

un elemento dentro del mapa. 01:04:31

Otro pasito más para trasladarlo a código un poco más, 01:04:35

que nos dé más alternativas. 01:04:42

Imaginaos que tenemos un mapa de, por ejemplo, íntegros, pero cuyos elementos son de la clase persona. 01:04:43

Indicamos aquí por dos sitios y ahora el put, nos volvemos a traer las dos personas que tenemos por aquí, dar de alta ya más veces. 01:05:03

Fijaros cómo ella se queja, ¿por qué? Porque es verdad que la clave es íntegro, pero el dato es de persona, entonces vamos a meterle persona aquí. 01:05:18

bueno, vamos a hacer otra cosa antes 01:05:25

no lo voy a eliminar esto 01:05:34

pero porque me vale la estructura 01:05:39

que tengo de antes, va a ser más rápido 01:05:41

que no luego volver a escribir 01:05:44

todo el código, bueno he vuelto al ejercicio 01:05:45

de antes, veis, el mapa vuelve a ser 01:05:50

de enteros y estamos 01:05:51

metiendo datos de enteros 01:05:53

estábamos trabajando con un hash map 01:05:55

no permite 01:05:57

duplicados, es verdad, por clave 01:06:00

como hemos comprobado, ningún mapa lo permite 01:06:02

este 4 es de este size, es del tamaño 01:06:03

y luego cada uno de los datos, pero si yo utilizo un tree map 01:06:06

¿qué es lo que mete el tree? pues el tree lo que nos 01:06:15

mete es orden, ¿verdad? voy a importar 01:06:19

con un tree map lo que nos mete es orden, ¿orden bajo qué criterio? 01:06:30

bajo el criterio del integer, entonces 01:06:36

justo los había puesto ordenados aquí 01:06:39

a la hora de insertarlos, voy a volver al hash map 01:06:44

y lo voy a insertar de forma desordenada para hacer una ejecución 01:06:49

con desorden, meto primero el 3 01:06:54

luego el 2, voy a quitar este 1 01:06:57

ya el tema del duplicado ya lo hemos comprobado, meto el 3, el 2, el 1 y el 4 01:07:08

con un hashMap hago una ejecución 01:07:14

vaya me lo ha sacado aquí, busca un criterio de ordenación 01:07:17

el hashMap, ah bueno porque busca un criterio de ordenación 01:07:27

propio de este. 01:07:32

Bueno, pues el HashMap 01:07:40

me lo está ordenando también según el criterio 01:07:41

este, bajo este criterio 01:07:44

de ordenación. Curioso. 01:07:46

No esperaba yo que lo fuera 01:07:50

a hacer esto. Bueno, pues 01:07:51

nos hace esto. Si le metemos un TRIMAP 01:07:53

pues nos va a dar lo mismo, porque ya estoy viendo que lo está 01:07:55

metiendo ordenado. Un TRIMAP 01:07:57

sí que claramente 01:08:05

hace esto. Vamos a meter 01:08:07

aquí 01:08:11

vamos a irnos a un HashMap 01:08:11

y a un trimap, pero de la clase persona, para intentar ver la diferencia 01:08:15

entre los dos. HisMap de la clase persona. 01:08:18

Porque con el tipo integer 01:08:28

se han comportado los dos igual. 01:08:30

Deja un poco descolocado, porque yo pensaba que el orden 01:08:36

lo iba a poner no según el dato, sino según 01:08:54

la clave. Y claro, los ha ordenado según el dato. 01:08:59

A ver, bueno, vamos a ir investigando. 01:09:05

Nos sirve para investigarlo. 01:09:07

De tal forma, si no llegamos a una conclusión definitiva, 01:09:10

luego intento echarle un ojo y os digo por el foro. Yo pensaba que desde luego el criterio de duplicado sí que está utilizando la clave, sí o sí, y yo pensaba que el criterio de orden de todo el mapa iba a ser según la clave, pero por lo que estamos viendo aquí no, está utilizando como criterio de orden el dato. 01:09:12

nos lo ha ordenado tanto con el hash map como con el tree map 01:09:32

al 10, 20, 40, 50, que no es precisamente el orden 01:09:36

en el que habíamos insertado por aquí, ah bueno, pero también tiene justo este mismo 01:09:40

orden, la clave, perdonad que estoy aquí divagando un poco 01:09:49

vamos por lo menos a comprobar que el criterio de ordenación lo hace a través 01:09:55

de clave, el hash map 01:10:03

bien, vamos a poner 01:10:05

es que justo ha coincidido que fijaros, aunque aquí nos ha mostrado un 10 01:10:19

que me estaba haciendo a mí dudar que el dato era el criterio de ordenación, resulta que el 10 01:10:24

tiene el 1, que el 20 tiene el 2, el siguiente 01:10:28

muestra es el 40 que tiene el 3 y el siguiente muestra es el 50 que tiene el 5 01:10:32

entonces coincide el orden tanto del dato como de la clave 01:10:36

entonces voy a poner aquí un 1, un 1 solo 01:10:38

y vamos a ver si el tercero que muestra es el 1, entonces es 01:10:44

el criterio de ordenación lo hace a través de la clave, no me muestra ninguno porque he comentado aquí, efectivamente, bueno, efectivamente ordena el HashMap, pero los criterios de ordenación y de duplicados son a través de la clave, porque fijaros como ahora, este que en cuanto a clave es el tercero, es el tercero que nos aparece a pesar de que uno es menor que algunos de los datos que hay por aquí y menor que el último también, y aparece por ahí, es decir, el criterio de ordenación es por clave, eso sí. 01:10:47

Vamos a ver, como el criterio de ordenación es por la persona, si queremos trabajar nosotros según nuestro criterio el orden del trimap, tendremos que poner algo aquí que sea ordenable a cuyo código podamos llegar nosotros, 01:11:23

si no siempre va a trabajar por el código que tenemos en la librería de Java en la clase integer. 01:11:44

Entonces vamos a decir lo contrario. 01:11:51

Mirad, que esté ordenado por persona, es decir, la clave sea una persona y el dato sea un integer. 01:11:53

Como se supone que va a estar ordenado por la clase persona, vamos a ponerlo aquí igual. 01:12:38

Vamos a aumentar por aquí. 01:12:57

el criterio para ver cómo el mapa ordena dos personas 01:12:58

pues volverá a ser el que tengamos aquí 01:13:12

en el compare to, entonces retomamos aquí el implement comparable 01:13:16

ahora se nos queja porque tenemos que descomentar aquí 01:13:23

el compare to, y el primer criterio que tenemos para ordenar es la edad 01:13:31

en el trimap 01:13:39

le falta por aquí una llave 01:13:41

y le falta un return 01:14:00

vale, por aquí lo tenemos, ya nos compila 01:14:13

entonces vamos a añadir ahora al mapa las dos personas 01:14:19

que tenemos, que son estas dos, que tendrán que estar por encima 01:14:29

del momento en el que las añadimos, fijaros en este 01:14:36

según la definición de este ejercicio ahora, la clave es una persona 01:14:52

y añadimos un integer como dato 01:14:56

Es una situación funcional quizás un poco rara, es más normal que sea un entero aquí, para el que sea el DNI y la persona, pero nos vamos a retorcer un poco para ver cómo trabaja. 01:15:00

Vamos a ver aquí el tamaño. 01:15:15

En principio esta persona y esta son diferentes porque aquí tenemos la misma edad, vamos a poner diferente edad, 20. 01:15:21

Entonces serían dos personas diferentes porque lo que estamos comparando en el compare aquí de las compare tú de las personas es la edad de las dos. 01:15:35

Si damos aquí una ejecución, nos dice que el tamaño es dos, es decir, se añaden las dos personas perfectamente. 01:15:43

Si ponemos aquí que sea la misma edad, nos dice dos. 01:15:50

Pues no está mirando, si pasa por aquí por el compare tú, a ver. 01:15:58

vale, lo que sucede es que 01:16:01

en caso de tener la misma edad, compara el nombre 01:16:03

lo que tenemos en el compareto, entonces si a los dos lo llamamos Agus 01:16:08

también, en la clase persona, estamos diciendo 01:16:14

que dos personas son iguales cuando tienen la misma edad 01:16:20

y tienen el mismo nombre, en ese caso se ha ido a uno 01:16:23

es decir, la clave para mirar si están duplicados 01:16:31

en un mapa va según el criterio de la clave y en la clave esta hemos dicho que dos personas son 01:16:36

iguales según lo que hemos codificado aquí al implementar igual que hacemos en las colecciones 01:16:45

el interfaz comparable dentro del código compare tú que hemos dicho que dos personas sean iguales 01:16:50

aquí se devuelve a un cero que es a lo que lo iniciamos aquí cuando dos personas con la misma 01:16:56

edad tienen el mismo nombre es el único caso en el que no se modifica el valor diva al def si ya 01:17:02

tienen diferente edad ya nos inserta las dos y fijaros como nos muestra el pasa por aquí porque 01:17:11

efectivamente la comprobación la está haciendo mediante la llamada al compare tú con esta traza 01:17:19

como es un trimap se entiende que el criterio para ordenar los mapas se basan en la clave y 01:17:30

Y al basarse en la clave, aunque el HashMap también habíamos visto que hacía algo parecido y no es un TRIMAP. 01:17:39

No sé si es por orden de inserción por lo que no lo estaba poniendo. 01:17:46

Bueno, el TRIMAP se basa en la, en principio es así que por definición la clave sí o sí. 01:17:49

Entonces al basarse en la clave, mira el compare tú y ordenará según este criterio. 01:17:56

En principio la edad y segundo el nombre. 01:18:02

Entonces, si ahora cogemos y mostramos aquí los datos, vamos a hacer un recorrido de todo el mapa, les comentamos por aquí, y decimos, vamos a recuperar cada una de las claves que tiene el mapa. 01:18:06

Pero cada una de las claves ahora ya no son Integer, son personas. 01:18:27

Entonces, para cada una de las personas que se mete aquí, 01:18:33

obtén de la clave y lo que devuelve es un entero, Integer. 01:18:37

Ahí está. 01:18:50

Y lo que hacemos es mostrarlo por pantalla. 01:18:51

Fijaros cómo para la primera de las personas, que es Agus, 01:18:53

hemos metido un valor de un 1 y para la segunda de las personas, 01:19:01

que es Miguel, hemos metido un valor 20 01:19:04

que son los dos valores que estamos intentando recuperar por aquí 01:19:10

vamos a ejecutar por aquí, bueno, me muestra 01:19:13

dice 2 el tamaño, aquí está con las comparaciones pasando por ahí 01:19:18

y me devuelve 1 y 20, este 1 y este 20 01:19:22

son estos dos datos y me los ha devuelto según el criterio de orden 01:19:26

que tenemos para mi per y mi per2 01:19:30

si cambiamos la edad aquí, fijaros que acordaros que el primer 01:19:33

criterio de ordenación era a través de la edad 01:19:38

con mi per a dos 01:19:41

de edad, me ha dicho que el primero de ellos era el que tenía 01:19:46

como dato un uno y el segundo el que tenía un veinte 01:19:50

si le cambiamos la edad aquí y ponemos aquí veintidós para que esta edad ahora sea mayor que esta 01:19:54

es de esperar que estos dos datos estén intercambiados en cuanto 01:19:58

al orden, entonces fijaros como ahora pone aquí 20 y aquí 1 01:20:02

y ahora ya lo único que nos queda es comprobar a ver que 01:20:05

hace con un HashMap, habría que ir a la teoría a ver como se comporta 01:20:13

en cuanto al orden los HashMap, vamos a ver que hace, bueno fijaros 01:20:18

aquí ya con el, cuando la clave era un entero 01:20:22

pues no sabemos muy bien lo que estaba pasando por ahí en las librerías de Java 01:20:27

seguro que tiene su explicación, otra cosa es que yo 01:20:30

contaros la hora, pero fijaros, con el trimap sí que está respondiendo 01:20:34

como estábamos viendo al criterio de ordenación que estábamos diciendo, entonces con estos datos 01:20:39

ahora, fijaros como el orden, me lo decía 01:20:43

20 y 1, cambio esta misma colección, si la pongo como hash map 01:20:47

bueno, pues ya se irá al, entiendo que se estará yendo al criterio de ordenación 01:20:51

de nada, porque es sobre la clave, pero fijaros 01:20:58

como aquí con el trimap me han mostrado 20 y 1 en el orden, y aquí me muestra 01:21:03

1 y 20. 01:21:07

Y claro, ahora por más... A ver si... 01:21:10

Porque es un HashMap 01:21:13

que ya no se preocupa de la ordenación. 01:21:15

De hecho, fijaros, ahora ya está mirando 01:21:18

en el HashMap... Vale, vale. 01:21:19

En el HashMap está mirando el método 01:21:21

Equals y el HashCode. 01:21:23

Tiene sentido. 01:21:27

Vale. 01:21:28

Creo que ya lo he entendido. 01:21:30

Vamos a intentar recapitular. 01:21:31

El TreeMap, fijaros, 01:21:33

en las colecciones, 01:21:35

cuando teníamos una colección que era una set pero no map 01:21:36

no tree, que era que métodos hemos dicho que mirábamos para ver 01:21:46

si eran iguales y sobre que métodos trabajaba, pues trabajaba 01:21:50

sobre el método hashCode y el método equals 01:21:54

y le daba un poco igual el orden 01:21:59

y cuando teníamos una colección, una que era tree, todas las comprobaciones 01:22:02

se hacían ya sobre el método compareTo 01:22:10

y en los mapas pasa algo parecido 01:22:14

fijaros ahora que tenemos un hashMap que ya no es tree 01:22:17

fijaros que traza nos está mostrando aquí, pasa por hashCode y pasa por 01:22:21

equals de la clase persona, es decir, no está utilizando el compareTo 01:22:26

y para ver si son duplicados está utilizando estas dos 01:22:30

igual que en las colecciones, en cambio cuando teníamos el treeMap 01:22:34

el criterio lo buscaba de ordenación en el compareTo 01:22:37

alguna pregunta 01:22:40

que os surja 01:22:50

alguna cosilla nos queda clara 01:22:52

por ahí 01:22:53

bueno pues nada vamos a ver 01:22:58

una cosa más que todavía nos queda un poquito 01:23:06

tiempo aunque ya vayamos 01:23:09

cerrando en realidad yo creo 01:23:11

que hemos dado un repaso grande 01:23:12

a las colecciones y los mapas 01:23:14

si tenéis más dudas luego me vais 01:23:16

preguntando por los foros en cualquier caso 01:23:18

mirad las 01:23:20

la clase colección tiene 01:23:22

algunos métodos que bueno que son interesantes para trabajar directamente con colecciones 01:23:28

directamente como como métodos estáticos de la clase colección y una de ellas por ejemplo es 01:23:33

el método sufre este que es bueno para jarno es un método que nos viene bien para la tarea 01:23:40

así si no lo habéis trabajado la estéis trabajando porque hay un momento que habla la tarea de una 01:23:48

baraja y dice barajar las cartas que las tendré guardadas en una colección pues igual con este 01:23:53

método lo podéis hacer entonces si tenemos una colección que sea una por ejemplo una linked 01:23:59

list de tipo entero enteros de ver y mi lista vamos a poner que es una lista como es una link 01:24:08

el dis amite duplicados verdad no se preocupa del orden en especial se puede estar no tiene 01:24:22

un orden definido lo cual nos va a permitir barajar o mezclar en un orden diferente sus 01:24:29

datos me falta el new por aquí y la definido de enteros pues entonces podría hacer aquí mi lista 01:24:37

punto, add 01:24:48

y voy a meter aquí enteros 01:24:50

voy a decir un 2 01:24:55

un 5 01:24:56

un 1 01:24:59

y un 3 01:25:01

en principio nos sigue un orden según los he metido 01:25:03

en particular 01:25:07

vamos a recorrer esta colección 01:25:08

voy a llevar aquí 01:25:19

la estructura de un iterador 01:25:22

por no escribir tanto 01:25:26

definimos un iterador, en este caso 01:25:27

un iterador de tipos enteros 01:25:32

la colección se llama mi lista 01:25:34

mientras haya elementos 01:25:36

y muestro el valor del iterador 01:25:40

vale 01:25:53

entonces si ejecuto por aquí 01:25:55

bueno pues fijaros como 01:25:56

me muestra los datos en el orden en los que 01:26:00

lo he introducido, no tiene un orden 01:26:03

funcional como si fuera 01:26:05

un trimap o algo de eso 01:26:06

según enteros, si esto fuese un trimap 01:26:09

pues me los habría ordenado a través de los números 01:26:11

vamos a hacerlo en un momento 01:26:15

como cambiamos muy rápido de uno a otro 01:26:16

no un trimap, no, un triset 01:26:21

para que sea una colección 01:26:27

de aquí que tiene el orden según los hemos metido 01:26:32

fijaros con un triset, pues ahora ya me salen según 01:26:35

un orden definido 01:26:38

para los enteros en las librerías de Java 01:26:41

en el integer no podemos sobreescribir el método compareTo 01:26:44

como sí que hemos hecho en la clase persona 01:26:47

volvemos al linked list y del 01:26:49

orden numérico del dato, pues ahora vemos que está 01:26:55

del orden según los hemos ido introduciendo. Pues si yo cojo aquí 01:26:58

y llamo al método estático 01:27:02

shuffle y le paso como parámetro una colección, en este 01:27:11

caso la colección con la que estoy trabajando 01:27:16

pues se supone que de este orden que es el que tiene cuando arranca 01:27:19

pues los está mezclando. Entonces si yo ahora cojo y establezco 01:27:24

otra vez el iterador y vuelvo a mostrarlo por pantalla, voy a definir dos veces 01:27:28

la variable, fijaros lo que estoy haciendo, defino 01:27:35

la colección, añado unos cuantos elementos, con el iterador los muestro 01:27:39

barajo, mezclo de forma aleatoria 01:27:42

los datos que tiene esa colección y los vuelvo a muestrar 01:27:47

entonces aquí, damos una ejecución, voy a meter aquí una separación 01:27:50

entre los dos, un momento para que se vea más claro, mirad el primer orden 01:27:58

iba 2, 5, 1, 3, que coincide con como los hemos metido 01:28:12

y después de hacer la mezcla, la mezcla que le hago aquí, 01:28:16

bueno, me saca esta línea, ¿verdad? La mezcla la hago aquí, vuelvo a meter 01:28:25

los datos y ahora saben, bueno, pues mezcla con otro orden diferente 01:28:28

el que le ha querido dar el método SAFEL. Fijaros en diferentes 01:28:32

ejecuciones. Salen aquí una vez mezclados diferentes 01:28:36

datos. 1, 2, 5, 3. 5, 3, 2, 1. 01:28:40

5, 1, 3, 2. Bueno, pues nada, un método 01:28:45

que tenemos ahí en Colesions. 01:28:48

Hay algunos métodos más 01:28:51

que están disponibles 01:28:53

para coger de una lista a una sublista 01:28:54

y algunas otras alternativas. 01:28:57

Bueno, pues echarles un ojillo 01:28:59

y si se os atascan, 01:29:01

pues ya me vais diciendo. 01:29:04

Y no sé si contaron muchas más cosas. 01:29:08

Lo siguiente que tenía por aquí apuntado, 01:29:11

pero eso es una cosa 01:29:14

que igual nos lleva una clase entera 01:29:15

y es un poco 01:29:17

por culturilla general y ver cómo se puede programar, era 01:29:19

programar nosotros, no sé si lo haremos algún día, si nos sobra 01:29:23

algún día igual lo retomamos, programar nosotros lo que podría ser 01:29:27

por ejemplo una ArrayList, una colección que en lugar 01:29:31

de estar llamando a las librerías, nos cree una lista que a medida 01:29:38

por ejemplo duplicados y que esté enlazado uno detrás de otro, a ver cómo lo podríamos 01:29:42

hacer nosotros intentando simular el código que las 01:29:46

librerías tienen para las colecciones? 01:29:50

Bueno, pues 01:29:53

no es una cosa muy 01:29:53

necesaria en el fondo, es más 01:29:56

por ahondar un poco en tema 01:29:58

de algoritmo y ver cómo se puede organizar eso 01:30:00

porque en verdad cuando necesitáis 01:30:02

una lista no la vais a programar vosotros, vais a utilizar 01:30:04

una de las que están disponibles ya en las colecciones. 01:30:06

Y en principio yo creo 01:30:12

que ya os he contado muchas cosas hoy, no sé 01:30:13

si echáis alguna cosa 01:30:15

en falta, que creéis que le demos una 01:30:17

vuelta o alguna cosa no entendéis de lo que 01:30:19

hemos hablado, o necesitáis madurar 01:30:21

o quizás un poco para que os surjan 01:30:24

las dudas. Si no tenéis 01:30:27

nada en particular, yo creo que vamos a ir terminando 01:30:35

ya por hoy. 01:30:37

Por no hacer esto ya mucho más largo. 01:30:39

¿No tenéis 01:30:43

alguna pregunta así en particular? 01:30:44

¿Qué queréis hacerme? 01:30:46

Pues nada, pues 01:30:50

os voy dejando entonces. 01:30:52

Si tenéis alguna cosita, 01:30:55

bueno, pues en Semana Santa igual 01:30:57

no soy tan ágil para responderos, pero 01:30:58

iré echando un ojo de vez en cuando, así que 01:31:00

si me preguntáis alguna cosita por ahí 01:31:02

os intentaré ir respondiendo 01:31:04

aunque también por descargar 01:31:06

descansar, cargar las pilas 01:31:08

y luego ya a la vuelta 01:31:11

seguimos dándole ahí duro 01:31:12

claro, tenemos dentro de mucho 01:31:17

porque vienen estas dos 01:31:19

que caen justo Semana Santa 01:31:22

y luego volvemos justo en un martes 01:31:23

así que sí, en tres semanitas 01:31:25

eso es 01:31:27

bueno 01:31:28

pues 01:31:33

que paséis 01:31:34

que descanséis estos días 01:31:36

descanséis o no descanséis, lo que mejor os venga 01:31:38

a cada uno 01:31:40

venga, nos vemos a la vuelta, hasta luego 01:31:41

2025-04-07-Programacion - Contenido educativo

Del mismo autor…

Entrevista a alumno en excursión

Entrevista a Laura en el bus

"Tertulias con sabor a chocolate"

Herencia 2

Video Costes Embalajes

Costes de manutención

Signos de febrero