Saltar navegación

20250211 Ejemplos Comparator - Contenido educativo

Ajuste de pantalla

El ajuste de pantalla se aprecia al ver el vídeo en pantalla completa. Elige la presentación que más te guste:

Subido el 11 de febrero de 2025 por Stefano C.

5 visualizaciones

Más información Transcripción

Descargar la transcripción

si habláis me dais la posibilidad el permiso para que es grave vale vamos a 00:00:00
crear una clase persona que ahora vamos a utilizar vale esta clase persona le 00:00:06
vamos a poner algunas cosillas le vamos a poner que tiene una string nombre un 00:00:11
un int edad, lo de clásico, y public persona de string n int e, y esto me crea un dis.nombre 00:00:20
es igual a n, dis.edad es igual a e. ¿Vale? Más o menos. 00:00:41
Ok, lo que yo quiero hacer es crear una colección de personas 00:00:46
¿Vale? 00:00:52
Y luego quiero crearme un metodillo que ordene estas personas 00:00:53
¿Parece bien? 00:00:59
¿Sí? 00:01:03
Ejercicio sencillo 00:01:03
Pero luego a partir de allí vamos a ver cómo podemos mejorar un poquito las cosas 00:01:04
¿Vale? 00:01:10
Vale 00:01:12
Entonces vamos a hacer un main 00:01:21
Aquí ponemos un main 00:01:23
vale, entonces aquí nosotros 00:01:28
creamos una colección y metemos dentro personas 00:01:33
¿qué 00:01:35
sobre 00:01:39
¿qué colección queréis usar? 00:01:40
hacer una lista de personas 00:01:49
un conjunto de personas 00:01:50
si queréis usar 00:01:52
una 00:01:54
esto es más bien sobre 00:01:55
no es sobre maps, luego hacemos 00:01:58
un ejercicio de maps 00:02:00
¿vale? 00:02:01
la cuestión es, si tenéis una colección 00:02:05
que no hemos usado que queréis usar que si yo el asset o preferís usar el 00:02:09
arre list lo dejo más fácil arre list 00:02:14
linked list son igual estas dos son prácticamente lo mismo de hecho puede 00:02:19
usar una list a ver que había usado ya aquí arre list 00:02:25
da igual da igual no es eso lo que vamos a mirar hagamos una lista luego lo 00:02:40
complicamos en otro momento hagamos una lista de personas personas es igual a new array list 00:02:47
de persona clic clic vale vale entonces tenemos esta persona de aquí añado unas personas al azar 00:02:55
vale persona perdón personas punto ad de new persona de algo y ponemos sara 40 00:03:12
ponemos antonio 24 y ponemos 00:03:33
quizá 45 vale he puesto personas podrían ser 23 me da igual es para crear una persona una 00:03:46
lista vale ahora yo tengo esta esta lista de aquí lo que quiero es un metodito que pille 00:03:57
estas personas y esta lista y las ordene vale entonces aquí yo tendré un ordenar personas 00:04:04
este ordenar a lo mejor puedo que me devuelva algo sí y podría hacer que personas es igual 00:04:16
a ordenar personas si son personas entonces la idea es la siguiente sin ordenar y está ordenada 00:04:26
return personas 00:04:59
hay error 00:05:09
a ver si haga este de aquí 00:05:14
cuando ayer hice algo 00:05:16
y me cargué 00:05:40
vale, he cambiado 00:05:41
de proyecto para que funcione 00:06:24
porque el otro no sé por qué tiene algún parámetro 00:06:26
que no me funciona, no quiero perder tiempo 00:06:28
pues cuando lanzo este 00:06:29
programa me sale este de aquí 00:06:32
¿cómo lo mejoro? ¿qué hago? 00:06:34
vale 00:06:47
empezamos por aquí 00:06:47
me pongo aquí, botón derecho 00:06:49
source, toString 00:06:52
que quiero que aparezca 00:06:53
nombre, edad, lo genero 00:06:55
pues ya está 00:06:58
no, no me sirve, toString, aquí está 00:06:59
¿vale? entonces me escribirá 00:07:02
la persona, nombre, cosas así 00:07:04
si no me gusta, porque a lo mejor esto sale 00:07:06
muy grande 00:07:08
pues entonces le pongo 00:07:09
directamente el nombre 00:07:12
más 00:07:14
entre paréntesis la edad. 00:07:19
Entonces, ahora me sale así. 00:07:29
No quiero esta coma. 00:07:32
Ahora me sale así. 00:07:35
¿Sí? Así veo 00:07:38
mi cosa. Claro, como mi programa 00:07:39
ordenar no hace nada, 00:07:41
pues entonces no hace nada. 00:07:44
¿Sí? 00:07:46
Ok. Vale. 00:07:47
Metámonos 00:07:51
aquí. 00:07:52
¿Cómo puedo ordenar 00:07:53
esta cosa? Lo hacemos antes 00:07:55
De la versión fácil 00:08:01
Vale 00:08:02
¿Vosotros os acordáis que 00:08:04
Arrays 00:08:07
Tenía un metodillo para ordenar? 00:08:07
Pues las colecciones tienen un metodillo 00:08:12
Para ordenar 00:08:15
Que es collections 00:08:16
¿Vale? 00:08:17
Collections.sort 00:08:20
¿Si? 00:08:22
En collections.sort 00:08:25
Le puedo pasar 00:08:27
Personas 00:08:28
esto se enfada 00:08:30
el método sort de list 00:08:32
en el connection es aplicable 00:08:35
a list de persona 00:08:37
porque tendré que ponerle 00:08:39
aquí persona 00:08:44
a ver 00:08:49
como se usa esto 00:08:52
este aquí me está diciendo que el método 00:08:55
sort de la list 00:08:58
de tipo 00:09:00
colecciones no es aplicable 00:09:02
al argumento list de persona 00:09:04
¿Y por qué? 00:09:06
Vamos a ver la API 00:09:11
Vamos a ver qué me dice 00:09:12
API Collections Java 00:09:13
Entonces, estos son 00:09:24
Esta es como una clase comodín 00:09:30
Para gestionar colecciones 00:09:32
Que me da varios métodos 00:09:34
Sobre el que puedo utilizar 00:09:37
Las colecciones 00:09:38
Tipo, dame el máximo de una colección 00:09:40
Dame el mínimo de una colección 00:09:42
O hazme un sort, ¿vale? Ah, ok, ahora lo sé. ¿Por qué creéis que se va a enfadar? ¿Vale? Este es un método que organiza, ¿sí? Lo que tiene que hacer es, sustancialmente, pillarme las personas y decir, oye, mila, ordénamela. ¿En qué sentido? 00:09:44
Es que hay un criterio de ordenación para personas. No sabemos cómo se ordenan las personas, justo. Entonces la pregunta es, ¿cómo puede existir un método sort que ordene cosas sin saber si estas cosas son ordenadas o no? 00:10:16
Y en el momento en que tú sabes, estableces un orden, ¿cómo puede sort saber cuál es el orden? ¿Qué podríamos hacer nosotros en sort si fuéramos nosotros el que implementan sort para decir, oye, mira, lo que me estás pasando es ordenable? 00:10:40
Pero entonces tienes que rehacerlo desde cero. Y nosotros no queremos rehacerlo desde cero. Porque entonces por eso me hago yo mi programa aquí, que es la versión difícil en el sentido de hacerlo nosotros el sort. 00:10:59
efectivamente, o sea 00:11:24
¿qué pensáis que pilla como parámetro 00:11:29
el método sort? 00:11:32
una lista cualquiera 00:11:34
una colección cualquiera 00:11:38
repito la pregunta 00:11:41
¿quién ha hecho sort? 00:11:46
¿vale? 00:11:50
que supuestamente me ordena las cosas 00:11:50
¿pensáis que como parámetro aquí 00:11:52
en su definición ha puesto 00:11:56
ponme una colección cualquiera y yo te la ordeno? 00:11:57
no, no podría ser eso 00:12:01
¿Vale? Porque, por ejemplo, si no me habría ordenado esta de aquí, pero esta de aquí no me la puede ordenar. ¿Por qué no me la puede ordenar? Porque persona no se sabe cómo se ordena. Entonces, ¿cómo podría yo estar seguro que lo que me pases aquí, la lista que me pases aquí, sea posible ordenarla? 00:12:02
haciendo comparto, es decir 00:12:23
que parámetro le pondría 00:12:25
yo a sort, es decir 00:12:28
el parámetro que me das tiene que ser un 00:12:30
una colección, ¿de qué? 00:12:32
de enteros, entonces solo ordeno 00:12:36
los enteros, un string yo no puedo 00:12:38
cualquier cosa que yo le pase 00:12:40
que se ordene, y para estar seguro 00:12:46
que lo que me pases tú 00:12:48
es ordenable 00:12:50
quiere decir que el tipo 00:12:51
de las listas 00:12:54
o de las colecciones que me pases es una colección de 00:12:56
¿Ojetos de qué tipo? 00:12:58
¿De string? Pues ordenaría solo string 00:13:03
¿Integer? Ordenaría solo integer 00:13:05
¿Persona? Pues persona ni siquiera la puedo ordenar 00:13:07
¿Cómo puedo 00:13:09
Decir 00:13:10
En general que cualquier cosa 00:13:12
Que tú me pongas aquí 00:13:15
Seguramente yo la puedo ordenar 00:13:16
Con un tipo genérico 00:13:18
Si no 00:13:26
Porque 00:13:28
¿Qué hace que un objeto 00:13:30
Tú has contestado 00:13:35
Me falta el siguiente paso. 00:13:38
O sea, yo tengo un método. 00:13:41
Va a recibir una lista, ¿vale? 00:13:42
Pero si yo pusiera una lista de cualquier cosa, una lista de T, 00:13:44
yo habría podido pasarle lista de personas. 00:13:48
Y habría tenido el problema que personas no las puedo ordenar. 00:13:52
Entonces, ¿cómo puedo decir, no, mira, no me pases cualquier lista? 00:13:57
Porque las listas de objetos no ordenables, yo no puedo ordenarlos. 00:14:00
Si no me dices un criterio de ordenación, yo no lo puedo hacer. 00:14:05
Pero yo tengo una forma de decirte, oye, mira, dame una lista de objetos especiales 00:14:09
que sí tienen que tener un criterio de ordenación. 00:14:15
Y a partir de allí yo puedo hacer lo que me haga la gana. 00:14:20
No, ¿eh? 00:14:26
Pues vamos a verlo aquí. 00:14:26
¿Qué pilla list? 00:14:32
El concepto es que los tipos que pongo aquí deberían ser comparable. Si los tipos que pongo aquí son comparable, ¿vale? All elements in the list, más simplemente de comparable interface. 00:14:37
entonces yo puedo 00:14:59
si tú me pasas un list 00:15:03
de un objeto y este objeto es 00:15:05
de tipo comparable, es una instancia comparable 00:15:07
que no puede ser porque es una interfaz 00:15:09
pero ¿os acordáis que podía usar las referencias 00:15:10
como instancias 00:15:13
y cosas por el estilo? Si yo te digo 00:15:15
el objeto que me pones 00:15:17
aquí dentro tiene que ser un comparable 00:15:19
lo que me estás 00:15:21
diciendo es que dentro tiene que tener 00:15:23
un compareTo y si tiene 00:15:25
el compareTo yo puedo usar el compareTo 00:15:27
para decir si esto viene antes que esto. 00:15:29
Entonces, si me das un list de persona, 00:15:33
yo no te lo acepto. 00:15:35
Pero si me das un list de persona 00:15:37
que implementa comparable, 00:15:39
o sea, si me estás dando sustancialmente 00:15:42
un objeto comparable, 00:15:43
pues entonces sí ahora sé pillar a esta persona, 00:15:46
sé decirle compare to y hacerlo. 00:15:48
¿Me entendéis lo que quiero decir? 00:15:51
Esto es interfaces. 00:15:53
Entonces, ¿por qué se enfada este de aquí? 00:15:59
Creo. 00:16:01
porque sort no admite 00:16:01
lista de personas 00:16:04
porque persona no implementa comparable 00:16:06
vamos a 00:16:08
implementarle comparable 00:16:12
implements comparable 00:16:14
ahora le voy a decir 00:16:16
mira persona, te voy a añadir 00:16:20
algo que permite 00:16:22
dame dos personas y te digo 00:16:23
quien viene antes y quien viene después 00:16:26
esto 00:16:27
se enfada porque dice 00:16:30
si me has dicho que implementas comparable 00:16:31
pero no tienes el método compare to vale comparamos creamos los métodos cuando creo 00:16:33
compare to me da un objeto vale porque compare to siempre se compara con un objeto y aquí hay 00:16:41
que hacer cosas como ver si el objeto es de la misma clase ver si hay cosas por el estilo vale 00:16:49
Ahora vamos a verlo. No sé si esto tengo suerte, me da Compertú. No, lo tengo que hacer yo el Compertú. Entonces, el concepto es, yo tengo dos objetos aquí dentro. Esta es la interfaz de Compr y ya lo hemos hecho. Pero ya que estamos, la repasamos. 00:16:55
¿Vale? Entonces, yo aquí tengo dos objetos. ¿Cuál es el primer objeto? This. Esta persona. ¿Y la voy a comparar con qué objeto? O. Estos son mis dos objetos. ¿Sí? Un objeto que es this y un objeto que es o. Quiero comparar estos dos. ¿Sí? 00:17:16
El primer problema que tengo es que esto es un objeto cualquiera. 00:17:56
Y si no es comparable, debería pasar algo. 00:18:02
Vamos a ver un momento si nos ayuda Java API comparable. 00:18:05
Espera, que aquí a lo mejor es... 00:18:13
Si os acordáis, comparable, que era esta interfaz de aquí, 00:18:20
dice implementa compare to, implementa compare to de un objeto. 00:18:24
lo que tienes que hacer es devolver un entero 00:18:29
y cuando devuelves un entero 00:18:32
le tienes que decir 00:18:34
cero si son equivalentes 00:18:37
menor si el primero es anterior que el segundo 00:18:41
y un número mayor que cero 00:18:45
si el segundo es anterior que el primero 00:18:47
¿os acordáis, no? 00:18:50
también, si yo miro 00:18:52
comparable tiene un tipo genérico 00:18:54
entonces aquí tengo dos opciones 00:18:58
o lo dejo así como estoy 00:19:01
y compruebo allí dentro 00:19:03
si esto es de mi tipo 00:19:07
correcto 00:19:09
ahora lo hacemos si queréis 00:19:10
o digo que no es que implementas 00:19:13
comparable cualquiera 00:19:15
implementas comparable de persona 00:19:17
porque si os fijáis 00:19:19
la interfaz 00:19:24
es comparable de un tipo genérico 00:19:29
y luego aquí 00:19:31
lo que me hace es comparar 00:19:33
con ese tipo genérico. 00:19:36
¿Lo veis que comparó? Entonces, si yo le digo 00:19:42
que eres comparable con otra persona, 00:19:44
pues aquí me hace tras solo una persona. 00:19:45
Y me quito el problema de que estoy 00:19:48
comparando con un objeto. 00:19:49
Si lo quisiera hacer así, fijaos que 00:19:51
si yo intento 00:19:54
hacer un... 00:19:56
comparar 00:19:59
este objeto, una persona, 00:20:00
con un gato, lo que 00:20:02
debería pasar es esto. 00:20:03
ClassCastException 00:20:06
Tú me estás diciendo 00:20:09
Que me has pasado un gato 00:20:11
Pero estabas trabajando con personas 00:20:12
Pues cuando yo intento hacer 00:20:15
Un casting de este objeto que me has pasado 00:20:17
A persona, pero no es una persona 00:20:19
Porque me has pasado un gato 00:20:21
Pues exploto 00:20:22
¿Sí? 00:20:23
Y esto se podría lograr en nuestro 00:20:26
En nuestro ejemplo 00:20:29
Sin persona 00:20:31
Así 00:20:32
Simplemente haciendo, vale, paso 1 00:20:34
personaP es igual 00:20:37
a persona 00:20:40
de O 00:20:41
esta cosa de aquí 00:20:43
lo que está intentando hacer es convertirme 00:20:47
este objeto 00:20:50
en una persona 00:20:51
si este objeto es una persona 00:20:53
funcionará 00:20:55
si este objeto no es una persona, ¿qué lanzará? 00:20:57
una excepción 00:21:02
¿qué tipo de excepción? 00:21:03
classCasterException 00:21:07
y entonces es 00:21:08
Y es lo que yo me espero, porque me lo dice el API, ¿vale? El API me dice, oye, mira, que si el objeto que has pasado no se puede comparar con este objeto porque no son del mismo tipo, lanza un class cast exception. 00:21:10
perfecto 00:21:24
para hacerlo más bonito 00:21:28
y más sencillo para nosotros 00:21:31
y así repasamos y usamos también 00:21:34
los tipos 00:21:36
voy a decirle 00:21:37
que implementa comparable de persona 00:21:40
fijaos que ahora cuando le digo 00:21:43
añádeme los métodos no implementados 00:21:44
no me añade de objeto 00:21:47
me añade de persona 00:21:49
porque ahora estoy trabajando con persona 00:21:50
¿Están de acuerdo? 00:21:54
Entonces, ahora tengo dos objetos. 00:21:57
Tengo el objeto dis de tipo hola, persona. 00:21:59
Y tengo el objeto o de tipo persona. 00:22:12
Dos personas. 00:22:17
¿Cómo ordeno las personas? 00:22:19
Por nombre, claramente. 00:22:26
Por nombre, claramente. 00:22:31
¿Sí? Entonces, ¿cómo ordeno, cómo digo si una persona es más, o sea, viene antes o después de otra persona? Que no, que no, que no. ¿Por nombre? ¿Por la edad? No, por la edad no, por nombre. ¿Por la edad? No, tampoco por la edad, por nombre. 00:22:33
¿Cómo le digo qué tengo que escribir aquí? 00:22:56
¿Qué operaciones tengo que decir para decir tengo dis y tengo 0? 00:22:59
Tengo o, perdón. 00:23:03
Quiero, si dis viene antes de o, un número negativo. 00:23:04
Si o, dis y o van al mismo nivel, pues son el mismo nombre, 00:23:09
tienen el mismo nombre, pues tiene que dar un 0. 00:23:14
Y si en vez va antes o que dis, pues tendré que dar un número positivo. 00:23:16
char t1 es igual a dis.nombre.charat0, punto y coma, sí, siguen existiendo los char, char oc, pongamos este c, es igual a o.nombre.charat0, ¿eh? 00:23:21
Ahora, si os acordáis, estos señores eran también números. 00:24:15
Entonces, a lo mejor yo lo que puedo hacer es devuelve tc menos c, o c menos tc. 00:24:21
Si esta es una a, pongamos, si esta es una a, 28, y esta es una z, 30, más grande que 28, 40, 00:24:30
Pues si hago esto menos esto, saldrá positivo 00:24:50
Y entonces, esto es mayor 00:24:54
Pues al revés, ¿no? 00:24:59
Debería ser 00:25:00
Eso, no sé si es TC menos OC o OC menos TC 00:25:01
Pero eso lo miramos, ¿vale? 00:25:05
Posiblemente es TC menos OC 00:25:07
Vamos a hacer una prueba 00:25:09
¿Así o al revés? 00:25:10
Vamos a probarlo 00:25:22
Main 00:25:23
Me hago un pequeño main aquí 00:25:24
De prueba, ¿vale? 00:25:26
donde me creo dos personas, le pregunto COMPARTOO y veo que pasa. 00:25:28
Ya está. 00:25:33
Entonces, persona1 es igual a new persona de AAA22. 00:25:34
Y persona2 es igual a new persona de BBB22. 00:25:43
Tanto esto no lo usa en el COMPARTOO. 00:25:52
Y ahora me pregunto, si eso, 1.2, ¿qué me debería dar? ¿Número positivo, negativo o cero? 00:25:54
Negativo, ¿no? Porque esto viene antes que esto. 00:26:12
Vamos a ver que sale, menos 1. ¡Perfecto! 00:26:17
Y si esto fuera el señor Z, perfecto. 00:26:21
Y si esto fuera el señor Z mayúscula, y esto fuera A, ¿qué opináis? ¿Funciona esto o no? 00:26:28
No sé si hay un caso en el que esto pueda funcionar. 00:27:05
Aquí tenemos mayúsculas y minúsculas. Si os acordáis, la mayúscula y la minúscula venían separadas. 00:27:24
Entonces el riesgo que tengo aquí, que me da un poquito de miedo, es que si uno pilla una mayúscula y uno una minúscula, pues no funcione. 00:27:28
Pero lo puedo solucionar. 00:27:35
cuando pillo el nombre lo pongo en minúscula entonces me da igual que sea mayúscula o 00:27:36
minúscula lo pongo en minúscula y luego lo comparo si no nos complicamos demasiado pero 00:27:53
la idea es esa vale efectivamente si luego ya aquí le pongo asterisco ya la cosa se complica 00:28:08
pero oye seguirá su orden lo pondrá antes o después pero seguirá los órdenes algunos 00:28:14
símbolos lo podrán antes, algunos símbolos 00:28:22
lo pondrán después, pero un orden está 00:28:24
por allí. ¿Sí? Que es el 00:28:26
ordenashi, al fin y al cabo. 00:28:28
¿Sí? ¿Os gusta esta 00:28:30
cosa? Claro, 00:28:34
fenomenal, porque 00:28:39
nosotros nos gusta 00:28:41
sufrir, 00:28:42
nos gusta 00:28:45
ser, 00:28:46
nos gusta reinventar la rueda 00:28:49
una y otra vez, 00:28:51
y otra vez, y otra vez, 00:28:53
y otra vez, y otra vez. 00:28:55
ya está porque si string implementa comparable qué solución nos parece mejor está o está se 00:28:57
entiende vale el concepto es este de aquí está bien como ejercicio para pensar es esta no es 00:29:36
esta esto es como ejercicio de pensar cómo lo puede hacer y es correcto esto lo hemos hecho 00:29:43
hecho de hecho a uno de los ejercicios que hemos hecho en pasado era de ver si una palabra venía 00:29:48
antes que la otra esto en octubre sí y más o menos lo hacíamos así esta es mi implementación 00:29:54
vale pero yo sé que string o debería que saber que string implementa con perol si no lo sé qué hago 00:30:01
lo busco 00:30:07
me voy aquí 00:30:10
string api 00:30:11
java 22 00:30:14
me voy a string 00:30:17
y voy a preguntarme 00:30:19
¿esto implementa? ¿qué implementa? 00:30:21
implementa comparable de string 00:30:24
o sea que ya se pueden comparar 00:30:25
dos strings y nosotros hemos dicho 00:30:27
que quiero comparar las personas 00:30:29
en base al nombre, por lo tanto 00:30:31
¿qué hago? pillo el nombre 00:30:33
de este objeto 00:30:35
y el nombre del objeto que estoy comparando 00:30:37
y comparo estas dos strings 00:30:39
y me quito de encima 00:30:42
de problemas de masada mayúsculas 00:30:43
masada mayúsculas, masada lo que sea 00:30:45
pues uso la forma con que 00:30:46
se comparan dos strings 00:30:49
ya lo han hecho ellos 00:30:51
¿sí? 00:30:53
entonces esto me dará 00:30:56
el número que me dará, ¿cómo está hecho esto 00:30:57
por debajo? no lo sé, pero sé que 00:30:59
me ordena lexicográficamente 00:31:01
¿sí? 00:31:03
¿Dudas? Fijaos en el momento en que este señor es comparable y ha implementado el compareTo, mágicamente mi error del sort que pasaba aquí ha desaparecido. 00:31:05
Porque ahora sort pilla un objeto list de un objeto que es comparable. 00:31:21
Y entonces lo puede comparar. 00:31:29
¿Vale? 00:31:32
Esto hace algo. 00:31:34
A ver. 00:31:36
Tenía Sara, Antonio y Luisa. 00:31:43
Y ahora tengo Antonio, Luisa y Sara. 00:31:45
Esto ya me lo he ordenado. 00:31:49
Lo que me hace pensar también que sort... 00:31:50
¿Qué hace sort? 00:31:52
Este método de aquí. 00:31:54
Ordena de menor a mayor, pero me crea una nueva colección y me la devuelve. 00:31:59
Esto está trabajando sobre la propia colección. 00:32:07
Yo no he hecho personas igual esta cosa de aquí 00:32:10
He hecho 00:32:13
Ordename persona 00:32:15
Y automáticamente personas se volverán 00:32:16
Cuidado 00:32:18
Porque si yo quería mantener la original 00:32:19
Ahora la he perdido 00:32:23
Ahora la tengo ordenada 00:32:24
Hacer una copia, ordenar la copia 00:32:25
Utilizar otro tipo de sort 00:32:33
Mirar si hay un sort ya hecho 00:32:35
Que devuelve la cosa 00:32:37
Fijaos también que 00:32:39
El sort, si no me equivoco 00:32:41
si devuelve algo 00:32:43
no, void 00:32:45
por lo tanto no 00:32:50
trabaja sobre esta cosa 00:32:55
entonces efectivamente 00:32:57
si quisiera mantener la original 00:32:59
pues lo que debería hacer posiblemente 00:33:01
es cambiar 00:33:03
el original 00:33:04
copiar el original, hacer una copia 00:33:06
hacer un clone, hacer algo 00:33:09
para copiar esta lista y luego ordenar 00:33:10
otra lista 00:33:13
si, dudas 00:33:14
¿cómo copio una lista? 00:33:17
si yo hiciera lista 2 y esta persona 2 es igual a personas ahora tengo dos listas tengo dos enlaces 00:33:30
al mismo objeto no he copiado nada que debería hacer es crearme una nueva lista o una nueva 00:33:48
lista de persona vacía hacerme un iterador sobre la vieja por cada objeto meterlo en la nueva y 00:34:01
ahora tengo una copia o me voy a mirar en lista donde estará esto está listo pero no collection 00:34:09
collection list list vamos a ver en list si por si acaso hay un método en lista que me permite copiar 00:34:26
todo esto como por ejemplo copy off copy off a lo mejor man hace algo devuelve una lista 00:34:33
inmodificable contenente los elementos de la colección ya dada es estático vale puedo hacer 00:34:45
list punto copy off de una colección y esto me dará una copia de esta colección y una vez que 00:34:50
tengo la copia una la ordenó en la otra la tengo por ejemplo ya que por aquí si buscáis un poco 00:34:56
métodos interesantes los hay si no os lo complementáis vosotros vale estamos 00:35:03
de acuerdo hasta aquí entonces tengo ordenar que pilla personas la ordena 00:35:12
fenomenal vale ahora tengo las personas ordenadas por nombre pero ahora de 00:35:21
repente no quiero ordenar por nombre quiero ordenar por edad porque me lo 00:35:26
pide el botón de la ventanita que ha pulsado el usuario y ha dicho ahora 00:35:37
Ahora no quiero que ordene por nombre. 00:35:42
Quiero que ordenes por la columna edad. 00:35:46
Entonces quiero ordenar por edad. 00:35:48
¿Por qué? 00:35:50
Le puedo poner una pantalla al usuario diciendo, 00:35:50
¿y por qué? 00:35:53
Pero ahora él tendrá sus razones. 00:35:54
O ordenárselo por nombre, diciendo, 00:35:58
por edad, por nombre, porque sí. 00:36:00
Pero los usuarios no suelen ser felices de eso. 00:36:02
Entonces, sí, mensaje. 00:36:06
System.org.pl en la vida no es justa. 00:36:10
Entonces, ahora yo quiero pillar esto, hacer que personas es igual a ordenar por edad personas, y ver qué pasa. 00:36:14
¿Sí? Y lo voy a hacer si hizo personas otra vez. 00:36:30
Entonces, este señor de aquí, de hecho, tened en cuenta que esto podría ser void. 00:36:37
Y podría ser que no lo guarde aquí. 00:36:44
Porque al fin y al cabo estoy trabajando sobre personas. 00:36:48
¿Lo veis? 00:36:52
Entonces lo hacemos void. 00:36:56
Como sort modifica esto que le paso, no hace falta guardarlo otra vez. 00:37:04
Ya se ha modificado. 00:37:10
Entonces, ahora tengo esto. 00:37:12
Es parecido. 00:37:15
Esto devuelve una lista, pero es la misma lista que me ha pasado. 00:37:17
Y este de aquí, en vez, trabaja directamente aquí arriba. 00:37:21
La pregunta es, vale, y ahora puedo hacer collection.sort esto. 00:37:25
¿Qué pasaría si yo hago esto otra vez? 00:37:34
Hace lo mismo. 00:37:38
Pues entonces podría ir a persona y decir, oye, no, a mi persona, no me compares por nombre. 00:37:39
Compárame por otra cosa. 00:37:46
Pero entonces también esto compararía para la otra cosa. 00:37:48
Entonces, ¿qué hago en una situación en la que existen objetos que tienen un orden natural, que es esto, 00:37:54
las personas, el orden natural de las personas que he decidido yo, es que se ordenan por nombre? 00:38:05
Podría haber puesto aquí también, y luego, si el nombre es igual, puedes ordenar también por edad. 00:38:14
No lo sé. Aquí la edad no la tienen consideración. Me da igual. 00:38:20
Pero esto es cómo se ordenan las personas. Las personas se ordenan por nombre. 00:38:23
Es su forma natural de ordenarse. 00:38:27
Pero ahora yo quiero ordenar estas personas con un criterio distinto. 00:38:30
¿Cómo lo hago? 00:38:36
Pues para hacer esto, y ahora lo hacemos de una forma un poquito fea, 00:38:42
Me crea un objeto 00:38:46
Que es un objeto 00:38:50
Orden 00:38:53
Por 00:38:57
Orden 00:38:58
Por 00:39:00
Edad 00:39:02
Y le digo que este señor 00:39:04
Implementa 00:39:09
Comparator 00:39:11
De persona 00:39:15
La persona me lo pillará 00:39:17
Porto 00:39:21
Y voy a mirar 00:39:25
Que método 00:39:28
Tengo que implementar 00:39:29
El método que tengo que implementar 00:39:31
Es un método 00:39:33
Que compara 00:39:35
Un objeto o uno 00:39:37
Con un objeto o dos 00:39:40
Siendo los dos objetos personas 00:39:41
O sea, es distinto del 00:39:43
Compertú 00:39:47
Compertú pilla un solo 00:39:48
Parámetro 00:39:51
Y compara 00:39:53
Un objeto 00:39:54
Con el objeto pasado por parámetro 00:39:56
La interfaz comparator implementa el método compare, no compare to, que pilla dos parámetros 00:39:59
Y es lo mismo, devuelve o uno, o sea, un número menor, desde que cero, si o uno es menor que o dos 00:40:13
Cero si son iguales y un número mayor si o uno es mayor que o dos 00:40:24
Pero esto me permite sostancialmente establecer otro criterio con el que comparo dos personas 00:40:31
Que por ejemplo en este caso es por edad 00:40:41
Entonces este de aquí lo que devolverá será o1.edad menos o2.edad 00:40:43
Si este tiene 10 años y este tiene 20 me dará un número negativo 00:40:52
Si tiene la misma edad me dará 0 00:40:58
si tengo este de aquí 00:41:01
que tiene 40 años y este tiene 20 00:41:04
me dará un número positivo 00:41:06
¿se entiende? 00:41:07
¿sí? 00:41:10
entonces, ¿ahora cómo uso esta cosa? 00:41:12
pues si vosotros vais a 00:41:17
el API, vuestro mejor amigo 00:41:19
y vais a collection 00:41:21
veréis que collection tiene sort 00:41:23
que pilla una lista 00:41:25
si yo uso esto 00:41:27
lo que se está utilizando 00:41:29
es el compare to 00:41:31
el comparable, pero existe también otro sort 00:41:33
que pilla dos parámetros, pilla una lista 00:41:38
y después un objeto de tipo comparator 00:41:41
y si tú me has dado un objeto 00:41:46
de tipo comparator, pues yo lo que hago es 00:41:49
hacer el sort, pero usando esto, o sea voy a 00:41:53
comparar los objetos usando el compare de estos dos objetos 00:41:57
no el COMPERTÚ, o sea que voy a ordenarlo según el criterio de ordenación que me has 00:42:01
dado en el COMPERTÚ. Vamos a verlo. ¿Cómo se usa? Pues esto se usaría más o menos 00:42:09
así. Cuando hago este sort de aquí, que es ordenar por edad, en realidad antes me 00:42:16
Creo un orden por edad e, o es igual a new orden por edad. 00:42:24
Me creo un objeto de tipo orden por edad que implementa comparator. 00:42:34
Entonces aquí le paso como segundo parámetro este objeto. 00:42:41
objeto. Él, dentro, podrá hacer orden.compare y poner aquí dos personas, la persona uno 00:42:51
y la persona dos. Entonces, utilizando este objeto, él puede hacer la comparación de 00:43:00
las personas que están en esta lista. Y entonces me ordena la lista, pero no en base a las 00:43:05
personas al nombre perdón más en base a este nuevo orden definido en este 00:43:14
objeto si dudas porque tú normalmente un objeto lo defines con un comparable y 00:43:21
normalmente cuando tú ordenas ese objeto es bastante común que tú lo ordenes 00:43:40
según el objeto mismo si el que ha desarrollado ese objeto ha decidido 00:43:46
ordenarlo de una determinada forma porque naturalmente se ordena de esta forma ahora 00:43:52
puede ser como por ejemplo un caso no esto que el usuario te diga si lo quiero por otro criterio 00:43:58
pues entonces tengo este modo de aquí y veamos si funciona tec fijaos este era el original esto 00:44:03
es ordenado de forma natural por nombre y este de aquí es ordenado con el nuevo criterio 24 40 00:44:15
45 y como lo sobre escribe para sobre escribir el compare tú necesitaría hacer otra clase que 00:44:26
herede de persona pero luego los objetos que tengo yo son personas no de la subclase tú tú 00:44:44
puedes sobreescribir cuando tienes una subclase 00:44:53
y sobreescribes el método de la superclase. 00:44:55
Entonces, si persona 00:44:58
tiene tu Compertú 00:44:59
y lo quieres sobreescribir, 00:45:01
tienes que crearte 00:45:03
persona ordenada por edad 00:45:04
y aquí sobreescribir 00:45:07
el caso. Pero luego los objetos que 00:45:09
tienes en la lista son objetos personas, ¿no? 00:45:11
Objetos personas ordenadas por edad. 00:45:13
Y entonces cuando tú llamarás el 00:45:15
Compertú, llamarás siempre el de persona. 00:45:17
Entonces no te funciona. 00:45:20
¿Dudas? 00:45:23
Vale, ahora, la cosa fea de esto, ¿sí?, es que nosotros nos estamos creando un objeto que no sirve de nada. 00:45:27
¿Cuándo vas a crear estos objetos de aquí? Nunca. Lo vas a crear cuando tienes que hacer este trabajo de aquí. 00:45:45
pero luego este objeto de aquí 00:45:55
no te sirve de nada, es como un objeto comodín 00:46:01
que necesitas pasarle aquí 00:46:03
porque él sabrá que dentro 00:46:05
de aquí está el método compare 00:46:07
que es el método que tiene que usar para comparar 00:46:09
las personas y ordenarlas 00:46:11
entonces vamos a hacer el último paso 00:46:13
al revés 00:46:18
porque ahora que he aprendido que 00:46:25
puedo cambiar el criterio como me da la gana 00:46:31
quiero un metodito que en vez de ordenarlo 00:46:33
de más joven a más viejo 00:46:34
hace de más viejo a más joven 00:46:36
¿sí? es otro criterio 00:46:38
entonces ahora tengo 00:46:40
este nuevo método de aquí 00:46:50
que lo que hace es utilizar 00:46:52
el coso 00:46:55
¿vale? entonces por como lo hemos 00:46:57
aprendido nosotros y por como lo podéis usar 00:46:59
vosotros tranquilamente 00:47:01
pues lo que hacéis es me crearía 00:47:02
otro objeto que es 00:47:05
orden por edad invertido 00:47:06
cambiar esto con esto 00:47:08
y ya está 00:47:11
justo 00:47:12
pero vamos a ver una cosilla 00:47:14
que os encontráis por allí 00:47:17
y que a lo mejor 00:47:18
os puede dar molestar 00:47:19
si la veis y no sabéis que es 00:47:23
aquí 00:47:25
que es donde pondría el objeto 00:47:27
nuevo 00:47:30
le digo new 00:47:31
comparator 00:47:33
de persona 00:47:37
persona. Y la sintaxis es un problema. Paréntesis y paréntesis. A ver si se ve todo. No se 00:47:38
ve todo. ¿Lo veis esta cosa maléfica y malvada aquí? Aquí lo que estoy haciendo es crear 00:47:57
un nuevo objeto, pero no estoy creando un objeto de algo que existe, mas estoy definiendo 00:48:11
la clase de este objeto 00:48:20
aquí dentro 00:48:21
esta se llama clase anónima 00:48:23
estoy creando 00:48:29
una nueva clase sin definir esa clase 00:48:31
y le estoy diciendo que es un new comparator 00:48:33
cuidado, que yo os había dicho 00:48:37
no se puede hacer un new de una 00:48:38
clase, de una interfaz 00:48:40
pero cuando lo haces así, sí 00:48:43
porque lo estás definiendo aquí 00:48:45
de hecho él se enfada porque dice 00:48:47
me falta saber 00:48:50
me dice, oye, mira, que le falta el método 00:48:52
porque para que sea un comparator, quiere decir que tiene que implementar 00:48:57
esta clase, que no sé cómo se llama, es una clase anónima, no tiene nombre 00:49:01
pero como tú me dices que es un tipo comparator, tiene que tener el método compare 00:49:05
¿dónde se lo pongo? 00:49:10
pues en su definición de clase, es decir, entre estos dos 00:49:13
estas dos llaves de aquí 00:49:17
entonces pincho aquí 00:49:19
y veis que me lo añade aquí dentro 00:49:22
o sea que ahora sin tener que crearme una clase extra 00:49:26
y luego crear un objeto de esto 00:49:30
le estoy diciendo, oye mira, tú ordename personas 00:49:32
y el criterio de ordenación te lo voy a definir aquí 00:49:35
usando una clase anónima 00:49:39
que implementa comparator 00:49:41
y que aquí es donde te defino 00:49:44
Pero, ¿cómo se compara? ¿Qué es? Hemos dicho al revés de esto. Esto me evita de crear una clase externa para hacer una cosa como esto que solo me sirve aquí. 00:49:46
Ahora, si yo esto lo uso 100 veces, en momentos distintos, pues cada vez tengo que volver a reescribir esto. Entonces a lo mejor me compensa escribirlo fuera, crearme un objeto solo de esto aquí y usarlo todas las veces que quiero. 00:50:10
Pero si lo uso solo aquí 00:50:24
Pues tengo esta opción de aquí 00:50:26
¿Por qué os hago ver esto? 00:50:28
Porque esto aparece 00:50:31
Si vosotros buscáis en 00:50:33
Stack Overflow 00:50:35
Si vosotros buscáis en 00:50:37
ChartGPT, como no 00:50:39
Es posible que la solución 00:50:40
Que os da sea esta 00:50:43
Y para que vosotros la entendáis 00:50:44
¿Quiero que la uséis? 00:50:46
Claro, si sabéis usarla, perfecto 00:50:48
Pero no va a restar ni a sumar puntos 00:50:50
hacerlo así o hacerlo así esto es estándar de como hemos visto de 00:50:52
implementar comparator etcétera etcétera por lo tanto esto lo tenéis que saber 00:51:00
hacer este de aquí si sois programadores más avanzados si queréis aplicar esta 00:51:04
nueva forma de definir las cosas quién soy 00:51:11
yo para para decir que no vale esto cuanto más aumenta la complejidad de lo 00:51:16
que vais a mirando los ejercicios más se empieza a parecer pero por ahora si no lo sabéis usar y 00:51:23
no queréis aprenderlo ningún problema y os lo digo para que si lo veáis si lo veis una cosa 00:51:30
así digáis oye qué es eso y vamos a ver si funciona pues ya está original ordenado por 00:51:36
nombre que es el short sin nada ordenado por de menor a mayor edad utilizando el objeto orden por 00:51:47
edad y este de aquí es el último que hemos hecho, que me lo ordena por edad descendiente 00:51:56
usando la clase anónima. Entonces, ¿para qué sirve la interfaz comparable? Para establecer 00:52:02
un orden estándar con el que se ordenan mis objetos. Muchas clases o muchos métodos pueden 00:52:30
requerer que yo 00:52:43
tenga establecido un orden 00:52:45
de mis objetos para poder ordenarlos 00:52:47
o para poder hacer algo como pillar 00:52:49
el menor. Si tú no me has definido 00:52:51
cómo se comparan dos objetos entre ellos 00:52:53
no te puedo pillar el menor. 00:52:55
¿Sí? ¿Make sense? 00:52:58
Una clase que 00:53:00
conocéis vosotros que entra en el examen 00:53:01
que necesita 00:53:03
comparable. 00:53:05
Que necesita que los objetos que usa 00:53:07
sean comparable. 00:53:09
Triset, por ejemplo. 00:53:13
TRIMAP, ¿sí? Todo lo que son TRI, como el árbol se construye en base a si este objeto que voy a insertar es mayor o menor, 00:53:15
pues necesitan, los objetos que manejo necesitan implementar COMPARABLE. 00:53:27
Entonces, ¿para qué sirve COMPARABLE? Para definir un orden estándar, un orden natural de mis objetos. 00:53:33
Y pertenecerá al mismo objeto, a la clase que define el objeto, persona, pues implementa su posibilidad de ser ordenado. 00:53:39
¿Para qué sirve la interfaz comparator? 00:53:49
Para establecer un criterio distinto del natural, de los estándar, para comparar dos objetos. 00:54:05
para establecer un criterio de comparación distinto del natural que ya está en la cosa, ¿vale? 00:54:11
Un ejemplo de utilizo es el sort, ¿vale? 00:54:24
El sort, si yo no le digo nada, me lo ordenará de forma natural. 00:54:27
Si yo le digo, ordénamelo según otro criterio, pasándole el criterio, 00:54:31
Sea porque me he hecho un objeto que implemente compare o comparator, o sea porque le implemento aquí directamente, hago una clase anónima poniéndole aquí el objeto comparator y la implementación del compare, pues me ordena según este otro criterio. 00:54:37
¿Dudas? 00:54:57
Materias:
Programación
Niveles educativos:
▼ Mostrar / ocultar niveles
  • Formación Profesional
    • Ciclo formativo de grado superior
      • Primer Curso
Autor/es:
Stefano Chiesa
Subido por:
Stefano C.
Licencia:
Reconocimiento - No comercial
Visualizaciones:
5
Fecha:
11 de febrero de 2025 - 12:38
Visibilidad:
Clave
Centro:
IES ROSA CHACEL
Duración:
55′ 05″
Relación de aspecto:
16:10 El estándar usado por los portátiles de 15,4" y algunos otros, es ancho como el 16:9.
Resolución:
1152x720 píxeles
Tamaño:
219.00 MBytes

Del mismo autor…

Ver más del mismo autor

EducaMadrid, Plataforma Educativa de la Comunidad de Madrid

Plataforma Educativa EducaMadrid