Saltar navegación

Activa JavaScript para disfrutar de los vídeos de la Mediateca.

Clase 27-02-24 - 2 - Contenido educativo

Ajuste de pantalla

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

Subido el 27 de febrero de 2024 por Raquel G.

6 visualizaciones

Más información Transcripción

Descargar la transcripción

a usarlas. Pues venga, vamos a hacernos una clasecita alumno, por ejemplo, para poder 00:00:00
guardar objetos de un tipo más sofisticado que string o cualquier otra cosa. Venga, me 00:00:09
voy a hacer un paquete, model para guardar las entidades y me voy a hacer un alumno. 00:00:16
Venga, pues este alumno 00:00:23
Se va a caracterizar 00:00:33
Por su número de matrícula 00:00:36
Por ejemplo 00:00:38
¿Vale? 00:00:39
Su nombre 00:00:49
Vamos a dejarle por ahora con esas dos propiedades 00:00:50
Solo 00:00:59
Tenemos un constructor 00:00:59
dime 00:01:11
bueno pues tenemos una aplicación para gestionar 00:01:16
alumnos 00:01:38
y ya está 00:01:39
bueno vamos a ponerle ya una edad 00:01:40
para poder hacer alguna operativa 00:01:44
aunque sea de pues comparar edades 00:01:45
o algo así 00:01:47
entonces añado esto aquí al 00:01:48
constructor 00:02:05
y me falta el getty set de la edad 00:02:06
bueno pues ya está 00:02:13
tengo un alumno con tres propiedades y una aplicación 00:02:23
que va a gestionar estos alumnos 00:02:26
entonces la aplicación 00:02:27
va a tener 00:02:32
esto de aquí 00:02:34
pues la aplicación va a tener 00:02:35
un montón de alumnos 00:02:37
entonces un montón de alumnos 00:02:39
hasta ahora nosotros pues que hacíamos 00:02:40
pues los metíamos todos en algo así 00:02:42
vale 00:02:46
los metíamos todos en algo así 00:02:48
y aquí teníamos el problema efectivamente 00:02:50
de que tenemos que comprometer 00:02:53
el tamaño 00:02:55
yo aquí tengo que decir si 100 00:02:56
o cuantos, la solución que 00:02:59
hacíamos, que nos 00:03:01
implicaba escribir mucho código 00:03:03
era decir, bueno, inicialmente 00:03:05
me hago un array de 0 00:03:07
posiciones, inicialmente de 0 00:03:09
y cuando me quiera meter uno nuevo 00:03:11
hago todo el rollo de hacer un auxiliar 00:03:13
con una posición más, copiar 00:03:15
añadir el nuevo y sustituir 00:03:17
era la solución que usábamos 00:03:19
para no comprometernos desde aquí al tamaño 00:03:21
pero realmente, hombre 00:03:23
el uso de los arrays cuando son 00:03:25
eficientes, es si tú sabes 00:03:27
un tamaño lo dices y el array se queda 00:03:29
ya siempre quieto y ahora ya 00:03:31
acceder por posición, recorrer 00:03:33
es computacionalmente inmediato 00:03:35
es lo más rápido y lo más eficiente 00:03:37
no hay nada más eficiente que un array 00:03:38
pero 00:03:41
tienes que fijar aquí 00:03:42
el número de posiciones 00:03:44
y se van a quedar siempre las mismas 00:03:46
no se puede cambiar, si tienes que 00:03:49
tirar la basura y coger otro 00:03:51
ya se ha perdido la eficiencia computacional 00:03:52
porque ya estás tirando la basura y cogiendo lo otro 00:03:54
bueno pues entonces 00:03:56
esto es lo que hacíamos hasta ahora 00:03:58
ahora ya 00:04:00
no tenemos por qué coger una 00:04:02
una RAI obligatoriamente 00:04:04
si sabemos que va a haber 20 y son 20 00:04:06
y punto pelota 00:04:08
cogeríamos una RAI, eso es lo que cogeríamos 00:04:10
siempre 00:04:12
pero en nuestro caso, no sé, a lo mejor 00:04:13
un año tengo 17, luego se 00:04:16
matriculan 4 de golpe, luego se van 3 00:04:18
no lo sé, va a ser 00:04:20
un número de alumnos variable, pues entonces 00:04:22
cogeríamos alguna de las clases 00:04:24
colección, que ya están hechas 00:04:26
¿cuáles? 00:04:28
ahora mismo estamos viendo listas 00:04:31
pues de listas 00:04:33
cogeríamos una lista 00:04:34
pues venga, entonces yo puedo 00:04:36
hacer esto 00:04:39
¿la lista de qué tipo va a ser? 00:04:39
va a ser una lista de tipo 00:04:42
alumno 00:04:44
pues me comprometo el tipo 00:04:45
porque ya hemos visto que lista 00:04:48
es genérica 00:04:50
lista te dice, oye cuando me instancies 00:04:53
instancias, dime qué tipo de dato me vas a meter dentro, ¿vale? 00:04:55
Porque esto es una clase genérica, que lo vimos ayer. 00:05:00
Una clase que se declara en función de un tipo que todavía está por comprometer, no se sabe. 00:05:03
Y cuando tú ya instancias un ejemplo concreto, cuando lo instancias, dices, 00:05:09
oye, dime ya cuál, porque ahora ya sí que estás creando algo real. 00:05:14
Estás creando algo real, tienes que decir qué tipo es. 00:05:17
No puedes crear algo real y dejarlo en el aire. 00:05:20
solo dejamos las cosas en el aire cuando estamos declarando 00:05:23
cuando estamos ya creando 00:05:26
no podemos dejarlo en el aire 00:05:27
bueno, pues aquí en mi main 00:05:28
estamos ya creando una lista 00:05:31
pues tenemos que decir de qué tipo va a ser 00:05:34
y lo decimos de esta manera 00:05:36
poniendo ahí 00:05:37
vale, entonces mi lista de alumnos 00:05:38
la declaro como sea 00:05:42
entonces con esto he hecho la declaración sin más 00:05:43
he declarado el objeto 00:05:45
pero no lo he creado, he dicho 00:05:47
mi referencia alumnos 00:05:49
va a ser una lista de datos 00:05:51
de tipo alumno, es una declaración 00:05:53
por ahora de variable 00:05:55
de un objeto variable 00:05:56
pero hombre, tenemos que instanciarlo 00:05:58
claro, tenemos que instanciar 00:06:00
para que exista ya esa colección 00:06:02
para que exista, tenemos que instanciarla 00:06:04
bueno 00:06:06
pues 00:06:08
no podemos instanciarla 00:06:09
así, esto no podemos hacerlo 00:06:13
esto no podemos hacerlo 00:06:15
porque ya sabemos que lista 00:06:18
es una interfaz, lista no es 00:06:20
una clase concreta, lista es una interfaz 00:06:22
entonces yo tengo que instanciar 00:06:24
de cualquier cosa que implemente 00:06:26
esto, de cualquier cosa 00:06:28
que lo implemente 00:06:30
¿no? cuando teníamos una interfaz 00:06:31
animal, que la implementaban 00:06:34
perro, gato, tú podías declarar la variable 00:06:36
de tipo animal a, pero luego lo instanciabas 00:06:38
new perro, new gato, así funcionaba 00:06:41
¿no? eso es lo que hemos visto de interfaces y de todo 00:06:42
pues yo aquí tengo que decir 00:06:44
oye, dime una implementación concreta 00:06:46
de la lista, ¿qué implementación quieres? 00:06:48
Te ofrezco dos. Elige. Bueno, pues esta es una. ArrayList dejaba útil. Pero tenemos otra. Vamos a imaginar que tenemos dos listas de alumnos. También tengo esta otra. Estas son las dos implementaciones posibles para las listas. 00:06:50
esta 00:07:31
dentro está hecha como un array 00:07:33
que se tira y se hace 00:07:36
de nuevo cada vez que haga falta 00:07:38
y esta está hecha como una lista 00:07:39
enlazada como la que vimos ayer 00:07:42
¿vale? ¿cómo se usan? 00:07:43
se usan exactamente igual 00:07:48
nosotros las estamos usando 00:07:49
esto ya es 00:07:51
transparente para nosotros 00:07:53
cuando nosotros queramos insertar alumnos 00:07:55
los insertaremos con el método correspondiente 00:07:57
¿y cómo lo haga por dentro? me da igual 00:07:59
que hará bien un alumno nuevo 00:08:01
y vamos a ponerlo en la lista 00:08:03
alumnos, pues venga 00:08:06
para eso que tengo, pues fijaos 00:08:08
todos los métodos que tengo de alumnos 00:08:10
para la lista 00:08:12
pues fijaos todo lo que puedo hacer con la lista 00:08:15
añadir un alumno 00:08:26
añadir un alumno en una posición 00:08:28
concreta, añadir de golpe 00:08:30
un montón de alumnos 00:08:32
que los tengo a su vez en otra colección 00:08:34
añadir al principio 00:08:36
añadir al final, eliminar la colección 00:08:38
ver si un alumno 00:08:41
está en una 00:08:43
un objeto 00:08:44
que yo le pase, está en esa colección 00:08:47
o no está 00:08:49
recuperar el primero, recuperar 00:08:49
el último, decirme 00:08:53
en qué posición está el objeto que yo le paso 00:08:55
eliminar 00:08:57
recuperar por posición, todo eso 00:08:59
puedo hacer con una lista, todo eso 00:09:02
y me da igual hacerlo con alumnos 00:09:04
uno 00:09:07
con alumnos 2 00:09:07
tengo lo mismo 00:09:10
lo que pasa es que internamente 00:09:11
alumnos 1 lo hace de una manera 00:09:13
y alumnos 2 lo hace de otra 00:09:15
porque alumnos 1 es un ArrayList 00:09:18
y alumnos 2 es un LinkedList 00:09:19
cada uno lo hace a su manera 00:09:21
pero el uso es el mismo 00:09:22
yo lo uso para meter cosas, sacarlas, recorrer 00:09:24
y para eso es para lo que lo uso 00:09:28
¿cuándo elegiré una y cuándo elegiré otra? 00:09:29
pues ya lo hemos dicho 00:09:33
ArrayList es muy buena para consultas 00:09:34
Porque consultar un array es inmediato 00:09:37
LinkedList es muy buena 00:09:38
Para inserciones y eliminados 00:09:41
Porque lo único que tengo que hacer es mover enlaces 00:09:43
Mover punteros de direcciones de memoria 00:09:45
Ya está 00:09:47
Cuando tengo pocos datos 00:09:48
Que estoy haciendo una cosa así 00:09:52
Estoy resolviendo algo así sobre la marcha rápidamente 00:09:54
Pues hombre, ArrayList es lo mejor 00:09:57
Porque el array siempre es lo mejor 00:09:59
Pero como tenga muchos datos 00:10:01
Y esté metiendo y se ha acabado todo el rato 00:10:03
ArrayList ya 00:10:04
Tarda más 00:10:05
bueno, pues entonces 00:10:08
vamos a 00:10:10
como las dos se usan igual 00:10:13
las dos se usarían igual 00:10:16
y todo lo que vamos a probar a partir de ahora 00:10:17
aplica igual para las dos 00:10:20
porque repito, la única diferencia 00:10:22
es como lo hacen por dentro, pero es que eso 00:10:24
no nos da igual, no tiene ninguna implicación para nosotros 00:10:26
salvo el tiempo que tardan 00:10:28
a la vista 00:10:29
el envoltorio, una vez puesto el envoltorio 00:10:31
hacia afuera ofrecen lo mismo las dos 00:10:34
ofrecen lo mismo 00:10:35
vale, entonces lo que 00:10:36
haga con una lo puedo hacer con la otra igualmente 00:10:39
vale, pues vamos a 00:10:41
por ejemplo, insertar unos cuantos 00:10:43
alumnos 00:10:45
en la primera, pues venga 00:10:46
vamos a insertar 00:10:49
un nuevo alumno 00:10:50
con su número 00:10:53
de matrícula 00:10:55
que no sé si era int o que era 00:10:56
era int, número de matrícula 00:10:58
uno 00:11:01
vale, este alumno 00:11:02
que tiene 20 00:11:05
ala, ya tengo este alumno en la colección 00:11:06
y ya está, y tan fácil 00:11:10
y tan cómodo 00:11:12
¿que inserto un segundo alumno? 00:11:15
pues ala, ya tengo el segundo alumno en la colección 00:11:24
entonces, insertar es comodísimo 00:11:26
por ejemplo, en la lista 00:11:28
alumnos 2, que es una lista 00:11:35
está el método 00:11:37
addAll, que lo hemos visto ahí 00:11:38
a ver que lo... 00:11:41
y este método, por ejemplo, ¿qué hace? 00:11:49
aquí uno se trata de mirar la ayuda 00:11:52
es decir, pues este te añade de golpe 00:11:53
todos los alumnos que haya en la colección 00:11:56
que tú le pasas 00:11:59
pues por ejemplo aquí habríamos añadido 00:12:00
a alumnos 2 00:12:03
todos los alumnos que están en la colección 00:12:04
que tú le estás pasando 00:12:07
o sea habríamos añadido los de alumnos 1 00:12:08
por ejemplo 00:12:10
entonces se trata aquí de ver que métodos tengo 00:12:11
para usarlos 00:12:13
nada más 00:12:15
que ahora queremos añadir un alumno 00:12:16
pero en medio de los otros anteriores 00:12:19
pues había el método 00:12:21
añadir, este estaba sobrecargado 00:12:24
tú le pasabas una posición 00:12:26
vamos a decirle en la posición 1 00:12:28
y le vamos a añadir un nuevo alumno 00:12:30
este 00:12:33
ala, este aquí 00:12:42
por ejemplo, esta es otra versión de add 00:12:48
sobrecargada que tú le dices en qué 00:12:52
posición quieres 00:12:54
bueno y así podemos insertar 00:12:55
sin problema 00:12:59
que ahora queremos recorrer 00:12:59
la colección para mostrar lo que hay 00:13:03
bueno, tenemos el método get 00:13:04
que te recupera en la posición que tú le digas 00:13:07
pues podríamos 00:13:09
combinar el for de toda la vida 00:13:11
con el método get y ya está 00:13:13
como hacíamos en la colección 00:13:15
que hicimos nosotros 00:13:18
desde igual a cero, mientras si sea menor que 00:13:18
¿quién? que alumnos1.size 00:13:21
porque tenemos el método size 00:13:25
que me dice el número de elementos de la colección 00:13:27
incrementando y 00:13:29
pues vamos a mostrar 00:13:31
alumnos1 00:13:35
get 00:13:39
y, ¿vale? 00:13:40
Combinando el método get que me devuelve 00:13:47
el alumno en la posición y 00:13:49
con el for 00:13:50
puedo recorrerlo y mostrarlo 00:13:52
exactamente igual que recorría un array. 00:13:54
Vale, ahora pregunto 00:13:59
cuando yo haga este system.out.println 00:14:01
me va a mostrar los 00:14:05
tres alumnos de alumnos1, ¿verdad? 00:14:08
alumnos1 tiene tres, porque le he metido 00:14:11
aquí dos, luego le he metido otro 00:14:12
entre medias. ¿Pero cómo me lo va a mostrar? 00:14:14
¿Qué me va a mostrar de esos alumnos? 00:14:17
¿Qué me va a mostrar? 00:14:21
¿Me va a mostrar 00:14:23
la edad? ¿Me va a mostrar la...? 00:14:24
Me va a mostrar una cosa muy rara 00:14:28
porque ya sabemos que este 00:14:30
llamará al toString de ese 00:14:32
objeto y el toString 00:14:34
de la clase alumno es el dado de object 00:14:36
que te muestra una patata. 00:14:38
Pues entonces no queremos que nos muestre una patata. 00:14:40
Vamos a sobreescribir toString en alumno. 00:14:42
Vamos a sobreescribir toString 00:14:45
un alumno. ¿Nos gusta 00:14:46
esto que nos ofrece? 00:14:56
Venga, vale, nos gusta. Lo podríamos cambiar 00:14:58
y poner el tu stream que quisiéramos. 00:15:00
Bueno, vamos a hacer este main. 00:15:03
Ups, a ver si 00:15:04
me ha insertado a Pepe, a Javi 00:15:06
y a ver dónde me ha metido a Luis, que le he dicho en la posición 00:15:10
uno. A ver cómo interpreta a la uno. Si la interpreta 00:15:12
como la segunda, a ver cómo, dónde me la ha metido. 00:15:14
Porque no sé seguro 00:15:17
la uno, cómo me la está interpretando 00:15:18
a la hora de meterlo dentro. Si es después 00:15:20
de ese o delante. 00:15:22
vamos a ejecutar esto 00:15:23
vale, me lo ha puesto 00:15:25
en la posición 1, efectivamente 00:15:33
esta es la 0 00:15:35
esta es la 1 00:15:36
a donde me ha colado 00:15:39
a la 1 me ha colado este 00:15:40
y esta es la 3 00:15:42
vale 00:15:45
bueno, pues una forma 00:15:46
muy cómoda de guardar un montón 00:15:48
de datos, me hago una ArrayList o un LinkedList 00:15:51
me da lo mismo, porque el uso 00:15:53
sería idéntico, son los mismos métodos 00:15:55
me da lo mismo uno que otro 00:15:57
y ahí meto datos 00:15:58
y lo recorro 00:16:00
meto datos y recorro, si quiero 00:16:02
vale, ¿qué pasa si quiero eliminar? 00:16:04
también puedo eliminar, porque de unos datos 00:16:09
recordad que esencialmente lo que se hacía 00:16:11
era 00:16:13
insertar 00:16:13
consultar, eliminar y 00:16:16
modificar, no a un dato 00:16:19
pues cambiarle lo que tuviera, lo que tiene dentro 00:16:20
entonces hemos hecho 00:16:22
insertar, add, insertar 00:16:24
es add, add first, add, me da lo mismo 00:16:26
los métodos que me ofrezca 00:16:28
insertar, hemos consultado 00:16:29
combinando el get y el for 00:16:31
que yo quiero eliminar un dato de la colección 00:16:33
lo tengo mucho más fácil con el array 00:16:36
eliminar el array es que aparte 00:16:37
no se podía hacer, teníamos que inventárnoslo 00:16:40
teníamos que hacer un array de menos posiciones 00:16:42
copiar saltándonos 00:16:44
teníamos que hacer todo eso, porque eliminar de un array 00:16:46
como tal no se puede, el array es el que es 00:16:48
y no pueden coger 00:16:50
pues aquí sí que podemos 00:16:51
porque aquí 00:16:53
alumnos1 tiene dos variantes 00:16:55
del método remove 00:16:58
o varias, no dos, tiene muchas 00:16:59
aloop 00:17:02
nos 00:17:13
uno tiene 00:17:15
del método remove 00:17:17
fijaos cuantas variantes tiene 00:17:19
borrar por posición, le pasas una posición 00:17:20
y te borra el de esa posición, ya está 00:17:23
como lo haga ella, me da igual 00:17:25
que lo hace como array, como linked list 00:17:27
depende, la que hayamos elegido 00:17:29
le pasas un objeto 00:17:31
y te borra el objeto que sea igual a ese 00:17:33
Te borra todos los de una colección 00:17:35
Que si tú le pasas remove all 00:17:38
Te borra el primero 00:17:40
Te borra el que cumple un predicado 00:17:41
Pero construir predicados no sabemos hacerlo 00:17:44
Esto es como construir una condición 00:17:46
Tiene que ver con interfaces funcionales 00:17:48
Que no estamos en ello 00:17:50
Con programación funcional 00:17:51
Vale, remove last, te borra el último 00:17:53
Tiene bastantes variantes de remove 00:17:55
Que yo quiero borrar 00:17:58
El que está entre medias 00:18:05
Pues hombre 00:18:08
puedo usar esto 00:18:09
puedo usar esto y efectivamente 00:18:11
si vuelvo a recorrerlo 00:18:13
me habría borrado el que está en la 00:18:14
posición 1, vale 00:18:17
si yo ahora vuelvo a recorrer, he borrado el de 00:18:22
posición 1 y vuelvo a 00:18:24
hacer el recorrido, vuelvo 00:18:26
a hacerlo, voy a poner aquí un 00:18:29
separador para que 00:18:31
se vea, pues 00:18:36
efectivamente me ha 00:18:41
borrado el de posición 1, vale 00:18:45
pues hala, muy útil 00:18:47
muy útil, ¿verdad? las listas 00:18:48
para guardar cosas, eliminarlas, etc 00:18:50
y no solo eso, sino 00:18:53
para diferentes utilidades, por ejemplo 00:18:56
si seguimos mirando métodos que haya 00:18:59
en el list 00:19:01
este de aquí 00:19:04
ay, que agollón lupa quería poner 00:19:06
esto 00:19:08
fijaos, tiene un sort 00:19:11
un sort 00:19:24
que tiene 00:19:26
toda la pinta 00:19:28
de que te ordena 00:19:29
¿verdad? tiene toda la pinta de que te ordena 00:19:31
los elementos de la lista, ostras, eso es 00:19:34
complicadísimo hacer en una lista enlazada 00:19:36
en un array, tienes que estar a través 00:19:38
de un intermedio, subir a una lista enlazada 00:19:40
pues tienes ya un método que te lo hace 00:19:41
tienes un método 00:19:44
que te ordena 00:19:46
¿vale? pero claro, hay que 00:19:50
pasarle 00:19:54
una cosa 00:19:56
que dice aquí, que es 00:20:04
el criterio de ordenación 00:20:05
¿no? 00:20:07
yo he hablado, te ordena alumnos 00:20:08
y los alumnos como se ordenan, ni idea 00:20:12
los alumnos no sabemos como se ordenan 00:20:14
no es como los números, los números tienen un orden 00:20:15
los int, los double 00:20:18
tienen ya un orden intrínseco que ya 00:20:20
la máquina virtual lo sabe 00:20:21
porque está ya programado en la JDK 00:20:23
está programado, tiene un orden que es su orden natural 00:20:25
el orden natural numérico del álgebra 00:20:27
de toda la vida, pero los alumnos 00:20:29
no tienen un orden 00:20:31
entonces si llegamos a este método 00:20:32
hay que decirle 00:20:35
cuál es el criterio de ordenación que queremos dar. 00:20:37
¿Vale? 00:20:41
Pues vamos a hacerlo. 00:20:42
Porque esto nos vale para repasar también lo de interfaces. 00:20:44
¿Vale? 00:20:49
Vamos a, en este proyecto de ejemplo, 00:20:49
a ordenar estos alumnos. 00:20:51
Vamos a ordenar estos alumnos. 00:20:52
Vamos a ver. 00:20:58
Ordenamos los alumnos. 00:21:05
Los vamos a ordenar. 00:21:07
Vamos a decidir un criterio. 00:21:08
Pues por edad, por orden alfabético, 00:21:11
o por número de matrícula? 00:21:14
¿Qué orden queremos? 00:21:16
Vaya. 00:21:21
Prefería por alfabeto 00:21:22
que era más difícil. 00:21:24
Bueno, venga, empezamos por número de matrícula. 00:21:26
Vale. 00:21:27
Ya, porque pensaba que 00:21:29
queríais complicaros la vida. 00:21:31
Vale, vamos a ordenar por número de matrícula. 00:21:36
Entonces, 00:21:38
afortunadamente no tenemos que 00:21:39
implementar nosotros un algoritmo de ordenación 00:21:42
como la burbuja, ir copiando 00:21:44
de un lado a otro que tuviéramos que hacerlo es 00:21:46
complicado, no tenemos 00:21:48
porque está este método, sort, vale 00:21:49
pero a sort hay que pasarle 00:21:52
una cosa 00:21:54
que es un objeto 00:21:55
un objeto 00:21:57
que sea un objeto que 00:21:59
lleve dentro el criterio 00:22:01
de ordenación 00:22:06
vale, entonces este objeto 00:22:07
que le pasemos tiene que ser de una clase 00:22:10
pues yo que sé 00:22:12
vamos a llamar a esa clase 00:22:14
criterio num matricula 00:22:15
pues este objeto que yo le paso 00:22:17
tiene que ser un objeto 00:22:25
que lleve dentro 00:22:27
el criterio que yo decido 00:22:28
para esta ordenación 00:22:30
el criterio que yo decido 00:22:32
¿vale? entonces 00:22:33
este objeto no está hecho 00:22:36
este objeto lo tengo 00:22:39
tengo que declarar yo esta clase 00:22:40
perdón, esta clase no está hecha 00:22:42
tengo que declararla, tengo que declararla esa clase 00:22:44
para que tenga dentro 00:22:46
para que tenga dentro ese criterio 00:22:48
de ordenación, venga pues 00:22:50
vamos a crear esa clase 00:22:52
vamos a 00:22:53
que ya me lo ha hecho solito, no lo quiero 00:22:58
vale, esta es 00:23:04
la clase que tenemos que hacer, y esto fuera 00:23:06
vale, esta es la clase que tenemos 00:23:08
que hacer, ¿verdad? esta es la clase 00:23:14
que tenemos que hacer 00:23:16
para crear aquí 00:23:17
ahí no, ahí 00:23:19
un objeto de esa clase 00:23:21
un objeto de esa clase que lleva dentro 00:23:23
el criterio de comparación que lo lleva dentro 00:23:26
vale 00:23:28
pues entonces, ¿qué tiene que hacer 00:23:29
una clase para poder 00:23:31
ser criterio de comparación? 00:23:34
pues para poder 00:23:37
ejercer de algo, para poder 00:23:38
ejercer de cualquier cosa 00:23:40
tienes que implementar, adherirte 00:23:41
a la interfaz que te da 00:23:44
permiso a eso 00:23:46
bueno, pues nosotros queremos que 00:23:46
criterio en un matrícula 00:23:50
tenga la potestad de 00:23:51
ser criterio de comparación 00:23:53
pues para tener la potestad de ser 00:23:56
criterio de comparación tiene que 00:23:58
implementar una cosa que se llama 00:24:00
comparator 00:24:02
tiene que implementar esto 00:24:04
y ahora esto ya lo 00:24:09
importamos de java útil 00:24:11
también, vale 00:24:13
entonces para que esta clase pueda ser 00:24:17
pueda adherirse a eso 00:24:20
oye que yo soy criterio de comparación 00:24:22
yo soy criterio de comparar 00:24:24
pues si tú quieres ser criterio de comparación 00:24:26
implementa comparator, si quieres ser 00:24:28
criterio de comparación, vale 00:24:31
pues implemento comparator, estupendo 00:24:32
lo implemento 00:24:35
vale, comparator, esta es una clase 00:24:36
genérica, es decir 00:24:39
la podemos usar así en general 00:24:41
pero lo ideal, ahora que ya sabemos 00:24:43
lo que son las clases genéricas, es decir 00:24:44
vale, comparador es 00:24:46
un comparador genérico de cosas, pero tú que 00:24:48
estás comparando, yo estoy comparando 00:24:50
alumnos, venga pues dime 00:24:53
entonces que tú eres 00:24:54
un comparador de alumnos dime esto concreta me ya concreta me y dime que eres de alumno porque 00:24:56
si uno se va a esta clase esta es una interfaz genérica esta es la interfaz que tiene que 00:25:05
implementar cualquiera que quiera ser criterio de comparación de algo y este es el tipo genérico que 00:25:15
es el algo que tú vas a comparar entre sí sí sí sí a cualquier cosa sea clase interfaz que dependa 00:25:22
de un tipo abstracto 00:25:32
no, no tienes que pasarlo, pero si no se lo pasas 00:25:33
entonces tienes que trabajar con object 00:25:37
y si se lo pasas 00:25:39
entonces tienes mucho, no pasa nada 00:25:41
el compilador fenomenal 00:25:43
tú le pasas object, lo traga todo porque no has especificado 00:25:45
el tipo, el problema viene luego 00:25:47
en tiempo de ejecución, que va a tener que 00:25:49
hacer casting y vete 00:25:51
a saber los casting como salen 00:25:53
si tú dices, no, no, trabaja con alumnos 00:25:55
entonces el compilador te prohíbe y solo te deja 00:25:57
que metas alumnos, con lo cual el compilador 00:25:59
es el que te pone, se pone estricto 00:26:01
pero a cambio ya en la ejecución no tendrás problemas 00:26:03
porque ya el compilador se ha asegurado 00:26:06
de que solo metas alumnos 00:26:08
no sé si más o menos me explico 00:26:09
vale, pues entonces la idea es 00:26:11
cuando una clase es genérica, concretarle el tipo 00:26:14
concretarle, para que ya el compilador 00:26:16
te obligue y te diga, eh, que me has dicho alumno 00:26:18
pues alumno, no me metas cosas que no sean alumno 00:26:20
no me metas cualquier obvio, no, meteme alumno 00:26:22
es lo ideal 00:26:24
vale 00:26:26
pues aquí 00:26:28
esta de aquí 00:26:29
que implemente 00:26:31
un comparador pero de alumnos 00:26:34
que sea solo un comparador de alumnos 00:26:36
que no valga para comparar perro 00:26:37
con mesa, porque es que eso luego 00:26:40
no va a casar en tiempo de ejecución 00:26:41
va a tener que hacer un casting y no va a casar 00:26:44
vale, pues entonces 00:26:46
si queremos que esto sea un criterio que implemente 00:26:48
el comparador este de alumno 00:26:50
el compilador nos dice lo que ya no sabemos de toda la vida 00:26:51
ah, pues tienes que implementar los métodos 00:26:54
del comparador este, lo siento, tienes que implementarlo 00:26:56
no pasa nada 00:26:58
los implemento 00:27:00
ala 00:27:03
este es el método 00:27:04
que tenemos que implementar 00:27:06
y este método es en el que 00:27:07
tú ya pones lo que te dé la gana 00:27:10
pones como quieres 00:27:12
comparar a un alumno 00:27:14
con otro, comparar 00:27:16
significa decir cuál va antes y cuál va después 00:27:20
eso significa comparar, decir cuál va antes y cuál va 00:27:22
después, y el criterio es el mismo 00:27:24
que vimos con el comparable, que esto ya lo hemos 00:27:26
trabajado, y es 00:27:28
si esto es negativo 00:27:29
se sobreentiende que este va antes 00:27:31
si esto es positivo 00:27:33
se sobreentiende 00:27:36
que este va después 00:27:38
y si son iguales 00:27:39
y si es cero, perdón, si es cero 00:27:41
se sobreentiende que es que ni uno 00:27:43
no es mayor ni menor, que es que están en la misma 00:27:45
posición en cuanto a orden 00:27:48
¿vale? es como el 3 y el 5 00:27:49
el 3 es menor que el 5, el 3 y el 3 00:27:53
el 3 es igual que el 3 00:27:55
no es ni menor ni mayor 00:27:57
¿vale? pues aquí tenemos que con esas premisas 00:27:58
de funcionamiento 00:28:01
y a inventárnoslo, vale 00:28:02
entonces yo quiero que dé negativo 00:28:05
si el número de matrícula de O1 00:28:07
es menor que el número de matrícula 00:28:09
de O2 00:28:11
cero si el número de matrícula es igual 00:28:12
porque hemos dicho ordenar en orden ascendente 00:28:15
el número de matrícula 00:28:17
y positivo si el número de matrícula de O1 00:28:18
es mayor, hombre pues quizá 00:28:21
lo más fácil es devolver esto 00:28:23
O1 punto 00:28:24
get 00:28:27
num matrícula 00:28:29
menos o uno o dos, perdón. 00:28:30
Esto es lo más cómodo. 00:28:41
Si el número de matrícula de este está antes, 00:28:43
es un número más bajito que este, 00:28:47
esto me va a dar negativo. 00:28:50
Luego efectivamente el método interpreta que este alumno va antes. 00:28:52
Si este número es mayor que este otro, 00:28:57
la resta va a dar positiva, 00:29:01
la resta va a dar positiva, 00:29:02
luego esto va a dar positivo, 00:29:04
luego efectivamente el método 00:29:05
lo que nos devuelve es que este va después 00:29:07
y si 00:29:09
los números de matrícula son idénticos 00:29:11
la resta es cero, esto va a devolver cero 00:29:13
ni uno es mayor que el otro 00:29:15
ni otro es mayor que el uno 00:29:17
pues ahora tenemos un criterio de comparación ya 00:29:18
perfectísimamente implementado 00:29:22
con todos los requisitos que le hacen falta 00:29:24
implementar la capacidad 00:29:27
de ser criterio de comparación 00:29:29
que para eso tiene que implementar el comparator este 00:29:30
implementar esa capacidad 00:29:32
y implementar el método 00:29:34
poniendo yo aquí lo que me interese 00:29:37
lo que me interese 00:29:41
teniendo en cuenta que el valor de retorno 00:29:42
tendrá que ser negativo 00:29:45
si el primero va antes 00:29:46
positivo si el primero va después 00:29:48
o cero si van a la vez 00:29:51
¡ala! pues ya tenemos un criterio ahí de comparación 00:29:53
magnífico 00:29:57
pues estupendo 00:29:58
ya le puedo pasar a sort 00:29:59
un objeto de ese criterio 00:30:01
ya se lo puedo pasar 00:30:04
vale, pues vamos a ejecutar esto 00:30:05
pero pasándose los desordenados 00:30:11
para ver que efectivamente los ha ordenado 00:30:13
le paso el 3, le paso el 2 00:30:17
y luego en la posición 1 00:30:19
le paso el número de matrícula 00:30:22
vamos a mostrar 00:30:24
sin eliminar 00:30:27
antes y después de ordenar 00:30:29
vamos a mostrar 00:30:32
antes y después de ordenar 00:30:34
vale, pues 00:30:36
aquí están 00:30:48
tal y como los metí 00:30:51
primero el 3, luego el 2 00:30:55
y después de haberle hecho 00:30:57
el sort a la colección 00:30:59
después de haberle hecho esto 00:31:01
el sort, ahora ya 00:31:03
los ha ordenado 00:31:05
por el criterio que yo le he dicho 00:31:07
número de matrícula, por el criterio 00:31:09
que a mi me ha dado la gana decirle 00:31:11
luego las colecciones pues nos dan muchas 00:31:12
cosas ya hechas, que si tuviéramos 00:31:18
que programar son un rollo 00:31:20
Que a mí de repente me apetece 00:31:21
Cambiar el criterio de ordenación 00:31:23
Y quiero ordenar por 00:31:24
Edad 00:31:27
¿Me puedo hacer otra clase? 00:31:30
¿Otro criterio de comparación? 00:31:33
¿Me puedo hacer otro? 00:31:35
¿Eh? 00:31:38
¿Crit? 00:31:40
¿Eh? 00:31:41
A ver, era por no complicarlo, pero venga, sí 00:31:43
Por nombre 00:31:45
Venga, vamos a ordenar por nombre 00:31:45
Por orden alfabético de nombre 00:31:49
estoy usando otro criterio, llamo al mismo método 00:31:50
a sort, llamo al mismo método 00:31:53
pero le voy a pasar otro criterio 00:31:54
tengo que hacer la clase que recoge 00:31:56
ese criterio, tengo que hacerla 00:31:59
pues venga, hacemos esta clase 00:32:00
y esta clase 00:32:05
que implemente el comparator 00:32:10
este de alumno 00:32:11
vale, esta es otra clase con otro 00:32:12
criterio de comparación 00:32:17
vamos a ponerle el criterio 00:32:18
bueno, pues aquí se nos complica, ¿no? 00:32:21
porque tenemos que devolver 00:32:29
negativo si o1 00:32:30
está alfabéticamente 00:32:32
el nombre, perdón, está alfabética antes que o2 00:32:33
o sea, lo que hay que comparar son estas dos cosas 00:32:36
o1.getNombre 00:32:38
y o2.getNombre 00:32:41
esto es lo que hay que comparar 00:32:45
alfabéticamente 00:32:46
si este alfabéticamente 00:32:47
va antes que este otro, me devolverá negativo 00:32:50
si alfabéticamente 00:32:52
van a la vez, o sea, es el mismo nombre 00:32:54
me devolverá cero 00:32:56
y si alfabéticamente este va después que el otro 00:32:57
me devolverá positivo 00:33:00
es lo que yo tengo que hacer 00:33:01
pero comparar alfabéticamente dos cadenas es un rollo 00:33:03
por ahí comparar el primer carácter 00:33:05
si el primer carácter es igual tienes que pasar al segundo 00:33:07
si el segundo es igual 00:33:10
tienes que pasar al tercero 00:33:11
entonces eso lo podemos programar 00:33:13
con dos for estupendamente 00:33:15
uno hace un primer for que va 00:33:17
carácter por carácter y va 00:33:19
luego de forma recursiva 00:33:21
mucho más fácil, se programaría de forma recursiva 00:33:23
es un ejercicio de programación 00:33:26
maravilloso, dos cadenas 00:33:28
ordenalas alfabéticamente 00:33:29
pero bueno 00:33:31
no lo vamos a hacer, ya no estamos para esos trotes 00:33:33
pero sería un ejercicio magnífico 00:33:36
de programación 00:33:37
de pura y dura de toda la vida 00:33:39
¿por qué no lo vamos a hacer? 00:33:41
porque tanto esto como esto 00:33:42
pertenecen a qué clase 00:33:45
pertenecen a la clase string 00:33:46
y la clase string 00:33:49
afortunadamente tiene muchas cosas ya hechas 00:33:51
la clase string tiene 00:33:53
entre otros 00:33:56
un método por ahí 00:33:59
esto para buscar rápidamente 00:34:01
que era control 00:34:05
¿cuál era el atajo 00:34:06
para buscar aquí en el editor? 00:34:09
¿alguien lo... 00:34:11
control F? 00:34:12
si yo busco aquí 00:34:14
compare to 00:34:16
aquí me sale 00:34:19
vale 00:34:21
no, pero yo no quiero esta 00:34:22
compare to 00:34:27
aquí 00:34:31
este 00:34:36
vale, pues resulta 00:34:37
que la clase string tiene un montón de cosas hechas 00:34:40
que ya hemos usado, el length 00:34:41
el charat 00:34:43
vamos 00:34:46
el index of, tiene un montón de cosas ya hechas 00:34:49
bueno, pues tiene un método compareTo 00:34:52
que ya directamente 00:34:53
me devuelve 00:34:56
negativo si la cadena 00:34:57
que llama el compareTo va alfabéticamente 00:34:59
antes que esta 00:35:02
o sea, ya me hace todo el código de la ordenación alfabética 00:35:03
llamando aquí a 00:35:06
a estos compare tools 00:35:08
de las clases string UTF etc 00:35:10
ya me lo hace, me devuelve 00:35:11
negativo si el string que llama 00:35:14
a este método va antes 00:35:16
que este otro, 0 si son iguales 00:35:18
y positivo si el string 00:35:20
que llama a este método va después 00:35:22
que este otro, o sea el compare tool 00:35:24
ya me dice alfabéticamente cual va antes 00:35:25
el que llama al método o el otro 00:35:28
bueno pues hombre si ya tengo 00:35:30
el compare tool string 00:35:32
pues vamos a usarlo aquí 00:35:33
y no vamos a volvernos locos 00:35:35
y hacemos esto 00:35:37
y hacemos 00:35:40
retuno1.getNombre 00:35:45
.compareTu 00:35:47
este otro 00:35:51
o 2.getNombre 00:35:52
voy a bajar abajo esto 00:35:55
para 00:35:57
y ya tenemos el criterio hecho 00:35:57
porque el método compareTu 00:36:03
ya te devuelve negativo, cero 00:36:05
positivo en función del orden alfabético 00:36:08
Del string que llama al método 00:36:10
De este string 00:36:11
Y del string pasado por parámetro 00:36:13
Ya te lo hace 00:36:15
Te compara estos dos strings 00:36:16
El que llama al método 00:36:18
Y este otro 00:36:19
Y ya te devuelve menos uno, cero o uno 00:36:20
Pues aprovechémonos de eso 00:36:23
Llamemos directamente a esto 00:36:25
Y devolvamos eso que ha devuelto él 00:36:26
Pues ala, fenomenal 00:36:28
Ya tenemos otra clase comparator de esta 00:36:30
Que me devuelve el criterio alfabético de ordenación 00:36:33
Según el nombre de los alumnos 00:36:36
bueno, pues si yo ahora vuelvo 00:36:38
a ejecutar esto 00:36:43
ahora me los va a dar 00:36:44
ordenados por nombre 00:36:48
¿veis? aquí están 00:36:50
por número de matrícula, un, dos y tres 00:36:59
y aquí están 00:37:01
por orden alfabético de nombre 00:37:03
ahí están 00:37:05
¿vale? luego todo el trabajo que nos ahorramos 00:37:06
pues trabajando con colecciones 00:37:14
pero no podemos olvidar ninguna 00:37:15
otra cosa 00:37:18
¿vale? para entender lo que los métodos 00:37:18
hacen, para entender lo que nos ofrecen, tenemos 00:37:22
que tener claro, pues, todo el 00:37:24
tema de los interfaces, de implementar métodos, 00:37:26
de un montón de cosas. Tenemos que tener 00:37:28
claras. ¿Vale? 00:37:30
Bueno, hasta aquí más o menos. 00:37:34
¿O habéis desconectado muchos? 00:37:36
¿Cuántos habéis desconectado? 00:37:40
Con sinceridad. 00:37:42
¿Sólo Claudia es sincera? 00:37:44
¿Y su compañera? 00:37:46
El orden alfabético, 00:37:52
creo que se salta las mayúsculas y las minúsculas 00:37:53
no lo sé 00:37:56
no sé el compare to the string 00:37:58
cómo lo hace 00:38:00
ah, vale, pues 00:38:00
aquí en string 00:38:05
sí, habría que ver cómo 00:38:09
funciona 00:38:11
donde estoy en el criterio nombre 00:38:12
aquí, yo he usado el compare to 00:38:15
que si no las ignora 00:38:17
lo que hace es ponerte antes 00:38:20
todas las minúsculas y luego después de las mayúsculas 00:38:21
Y luego dices tú que en string hay otro 00:38:23
Que es el compare tú 00:38:26
Ignore este de aquí 00:38:28
Efectivamente que te ordena alfabéticamente 00:38:29
Ignorando mayúsculas, minúsculas 00:38:32
Vale, depende del criterio que queramos dar nosotros 00:38:34
Si queremos tenerlo en cuenta 00:38:36
O no tenerlo en cuenta 00:38:38
Bueno, ¿cuántos habían desconectado entonces? 00:38:39
No me lo creo 00:38:49
Que solo 00:38:50
Vale, venga 00:38:51
Vamos a parar un momentito 00:38:53
Para reconectar 00:38:54
Subido por:
Raquel G.
Licencia:
Todos los derechos reservados
Visualizaciones:
6
Fecha:
27 de febrero de 2024 - 18:31
Visibilidad:
Público
Centro:
IES ROSA CHACEL
Duración:
39′
Relación de aspecto:
1.78:1
Resolución:
1920x1080 píxeles
Tamaño:
187.83 MBytes

Del mismo autor…

Ver más del mismo autor

EducaMadrid, Plataforma Educativa de la Comunidad de Madrid

Plataforma Educativa EducaMadrid