Saltar navegación

20250930-FicherosObjetos_1 - 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 30 de septiembre de 2025 por Raquel G.

9 visualizaciones

Más información Transcripción

Descargar la transcripción

Vale, pues entonces 00:00:00
Como a nadie se le ocurre más 00:00:03
A mí es que solo me vienen Bini y Entidad a la cabeza 00:00:05
Como a nadie se os ocurre más 00:00:07
Términos 00:00:10
Y nos da pereza preguntarle a esa gente 00:00:11
Que le tenemos agobiado de tantas preguntas 00:00:13
Ya tendremos tiempo de preguntarle 00:00:15
Pues vamos a llamar 00:00:18
A nuestro paquete, pues Bins, por ejemplo 00:00:19
Aunque le podríamos llamar Modelo 00:00:21
Modelo es un nombre o Model es un nombre 00:00:23
Vale 00:00:25
Vale, y no nos habíamos puesto 00:00:27
de acuerdo en que íbamos a gestionar 00:00:29
vamos a gestionar 00:00:31
venga 00:00:34
el alumno 00:00:37
y el alumno 00:00:41
va a tener 00:00:43
esto también 00:00:44
nos va a servir como recordatorio general de programación 00:00:47
pero ya va a ser el último recordatorio 00:00:50
que hagamos porque no hace falta recordar nada 00:00:52
en realidad 00:00:54
el alumno va a tener 00:00:54
nombre 00:00:59
Su NIF, su nombre y su lista de asignatura. 00:01:01
Como asignatura es una palabra muy larga, vamos a poner módulo. 00:01:12
Vale, lo que suele ocurrir es que si suspendéis este módulo mío, 00:01:22
No suele ser tanto por los contenidos 00:01:32
Propios suyos 00:01:35
Que ya veréis, que no tienen mayor dificultad 00:01:37
Sino 00:01:39
Por cuestiones en general de Java 00:01:41
De desarrollo y programación en Java 00:01:43
Entonces 00:01:45
Pues es importante que 00:01:47
¿Quién? 00:01:49
Es muy completo 00:01:52
Y muy estupendo 00:01:56
Y por eso no hay manera de echarle del mercado 00:01:58
Pese a lo rígido 00:02:00
Que es y lo puñetero 00:02:02
que tienes que tiparlo, todo que tienes 00:02:04
que no sé cuántos, etc. 00:02:06
Pero claro, eso le da 00:02:08
mucha robustez 00:02:10
y mucha flexibilidad. 00:02:11
Venga, pues a ver, tenemos esto, aquí 00:02:13
hacemos siempre 00:02:15
yo para los constructores, como ya sabéis 00:02:16
soy muy vaga y no los pongo a menos que 00:02:22
sea imprescindible. Dejo el por defecto y luego 00:02:24
seteo las propiedades y ya está. 00:02:26
Pero eso no significa 00:02:28
que sea lo habitual. 00:02:29
Luego, 00:02:33
si una vez que hago la aplicación 00:02:33
ya veo que 00:02:35
necesito un constructor, pues en ese momento lo creo 00:02:37
y listo 00:02:39
bueno, pues tendríamos 00:02:40
un bin básico, y tan básico 00:02:46
porque es que por tener no tiene ni 00:02:48
toString, ni tiene equals, ni tiene nada 00:02:49
pero ya sabemos 00:02:52
en qué situaciones puede hacer falta 00:02:53
el equals, en cuál es el toString 00:02:56
si aparecen 00:02:57
lo ponemos 00:03:00
si aparecen lo ponemos 00:03:01
aquí si hiciéramos un equals 00:03:03
si sobre escribiéramos equals, ese equals 00:03:05
sobre qué propiedad lo apoyaríais 00:03:08
sobre nil, claro, ¿verdad? porque un alumno será igual a otro 00:03:12
por su nil, no por su nombre, porque Adrián es Alonso, pues hay muchos 00:03:16
ni por su módulo, ¿vale? y ahora 00:03:20
el módulo este, pues la lista de módulos que tiene 00:03:24
pues le vamos a poner 00:03:28
el nombre del módulo 00:03:31
Y siempre es muy socorrida 00:03:34
La nota 00:03:37
Que este modelo de datos 00:03:38
Lo habremos hecho mil veces, seguro 00:03:41
Porque 00:03:43
Imaginación 00:03:43
Justo imaginación no es lo que nos sobra 00:03:45
A mí por lo menos 00:03:49
Vale 00:03:52
De nuevo 00:03:54
Pues un poco vago 00:03:59
El bin, ni equals, ni toString 00:04:01
Ni constructores, si nos va haciendo falta 00:04:03
Lo hacemos aparecer, vale 00:04:05
hala pues modelo de datos 00:04:07
de dos entidades y ya está 00:04:10
esta aplicación solo gestiona alumnos 00:04:12
con los módulos que tiene y sus notas 00:04:14
se acabó 00:04:15
entonces 00:04:16
como fruto del análisis de la aplicación 00:04:19
uno habrá sacado cuáles son los requisitos 00:04:21
funcionales de la aplicación 00:04:24
¿vale? los requisitos funcionales de la aplicación 00:04:26
es lo que 00:04:28
tiene que hacer 00:04:30
insertar un nuevo alumno 00:04:32
eliminar un alumno, recuperar un alumno 00:04:36
dado su NIF 00:04:39
agregar un módulo 00:04:40
a un alumno, quitarle un módulo 00:04:42
a un alumno, ver las notas 00:04:45
de un alumno en tal módulo 00:04:46
esas serían los requisitos funcionales 00:04:48
que después de habernos entrevistado ahí 00:04:50
todos juntos 00:04:52
hemos hecho un documento en el que dice 00:04:54
requisito funcional 1, tatatí 00:04:56
requisito funcional 2, tatatí, requisito funcional 3 00:04:58
tatatí, vale 00:05:00
entonces parte de esos requisitos funcionales que hemos dicho 00:05:01
aluden precisamente al hecho 00:05:04
de insertar alumno, 00:05:07
eliminar alumno. Claro, sale la pregunta 00:05:08
¿de dónde? ¿Dónde van a estar 00:05:10
esos alumnos guardaditos? 00:05:12
Bueno, pues hemos dicho 00:05:15
que ahora mismo los vamos a guardar en un 00:05:16
fichero, no en una base de datos, 00:05:18
sino en un fichero. 00:05:20
Luego, 00:05:23
de alguna manera, 00:05:25
tendremos que gestionar ese fichero. 00:05:28
¿Vale? 00:05:31
Entonces, 00:05:33
Podemos hacer 00:05:33
Por ejemplo 00:05:36
El paquete ya de lógica 00:05:37
¿Vale? 00:05:41
El paquete de lógica 00:05:44
Donde va nuestra aplicación 00:05:45
¡Hala! 00:05:47
Así a lo bestia 00:05:50
Entonces 00:05:51
El paquete de lógica 00:05:52
Donde va nuestra aplicación 00:05:54
Pues vamos a hacer 00:05:55
Nuestra 00:05:57
Aplicación 00:05:58
De gestión 00:06:01
De alumnos 00:06:02
Vale 00:06:04
Nuestra aplicación de gestión de alumnos 00:06:05
Se me ha olvidado 00:06:10
Ponerle esto 00:06:12
No lleva corchetes 00:06:13
¿El qué? 00:06:22
El stream 00:06:23
Ah, sí 00:06:24
Lleva corchetes o lleva esto 00:06:26
Que es más bonito 00:06:30
Pero bueno, de esto ya 00:06:32
Como no llegamos a hablar el año pasado 00:06:33
A ver esto 00:06:36
Por si alguien le inspira curiosidad 00:06:38
Esto permite 00:06:40
que un método tenga un número de parámetros variable 00:06:45
que es algo que no llegamos a mencionar el año pasado 00:06:49
porque es meter demasiadas cosas 00:06:52
y uno se lo puede estudiar en 10 minutos 00:06:54
entonces nosotros cuando hablamos de métodos el año pasado 00:06:57
dijimos que cuando uno declara un método 00:07:00
tiene que poner exactamente 00:07:03
todos los parámetros que va a recibir con su tipo 00:07:06
vale, eso está bien, no pasa nada 00:07:10
podemos vivir así el resto de nuestra vida 00:07:12
pero a veces a lo mejor nos da un poquito más de libertad 00:07:14
el que un método pueda recibir a veces un int 00:07:20
o a veces dos int o a veces tres int 00:07:23
o a veces una cantidad variable de int 00:07:25
y luego siempre un double 00:07:29
es decir una cantidad de parámetros variable 00:07:31
entonces estos tres puntos aquí en medio 00:07:34
significan este método puede recibir 00:07:38
un string o dos o tres 00:07:42
o cuatro, depende de la situación 00:07:45
no es igual que poner 00:07:47
unos corchetes, cuando pones unos 00:07:49
corchetes dices, este método recibe 00:07:51
un array, vale 00:07:53
este puede recibir un string suelto 00:07:54
o dos string sueltos o tres string sueltos 00:07:57
esa es la idea, y luego también podría 00:07:59
tener este método, bueno ya no sería el main 00:08:01
porque lo estoy convirtiendo en otro 00:08:03
pues podría recibir 00:08:04
vale 00:08:07
bueno, es que como le 00:08:08
Tiene que ser el 00:08:13
Vale, tendría que ser el último 00:08:21
Para que luego en la llamada no hubiera confusión 00:08:24
Sobre lo que tú le estás pasando 00:08:26
Por ejemplo, esta sería una declaración válida 00:08:28
Para el método 00:08:36
Siempre le tienes que pasar un entero 00:08:37
Siempre un entero 00:08:40
Y luego le puedes pasar un string solo 00:08:41
O también le podrías llamar 00:08:44
Pasándole dos strings o tres 00:08:45
Bueno, solo para que os suenen 00:08:47
Los tres puntitos 00:08:49
Vale, solo para que suenen 00:08:51
No es algo que nos importe a nosotros 00:09:01
Pero como ahora ya no suenan 00:09:03
Si alguien, sobre todo si alguien lo ve 00:09:05
Ya no se asusta 00:09:08
Y si alguien quiere los detalles 00:09:09
Pues ya se lo mira en 00:09:11
En 15 minutos 00:09:12
Y ya domina todo lo 00:09:15
Relacionado con esos tres puntitos 00:09:16
¿Con los tres puntitos le puedes enviar nada? 00:09:19
estoy, no lo sé 00:09:26
creo que le tienes 00:09:28
que, creo que le puedes enviar 00:09:31
nada, creo, pero no estoy segura 00:09:33
no estoy segura, habría, esa es la diferencia 00:09:35
entre si tú le pones un array, que tienes que poner null 00:09:37
en el caso de que no hayas enviado nada, null 00:09:39
o el array, un array vacío 00:09:41
ahí creo que puedes no enviar 00:09:43
nada 00:09:45
vale, pues entonces 00:09:46
aquí estamos gestionando 00:09:49
los alumnos estos 00:09:51
y en algún sitio 00:09:52
tenemos que decidir donde van nuestros alumnos 00:09:55
pues hemos dicho un fichero 00:09:57
entonces como solo tenemos un fichero 00:09:59
ese fichero 00:10:01
puede ser una variable estática que pongamos 00:10:03
aquí fuera, verdad 00:10:05
static pues 00:10:06
file fichero 00:10:09
alumnos 00:10:13
vale, este va a ser donde van 00:10:14
nuestros ficheros 00:10:17
y ahora nuestra aplicación lo primero que tendrá que 00:10:18
hacer es 00:10:25
dime el nombre fichero alumnos 00:10:26
para que la aplicación ya cargue los que hubiera 00:10:29
y ahora ya 00:10:37
pues puede instanciar 00:10:39
fichero alumnos 00:10:41
con new file 00:10:43
ahora ponemos 00:10:47
el scanner 00:10:53
que next 00:10:54
next line para 00:11:07
en el salto de línea 00:11:09
y next para en el token de separación 00:11:10
y ese token tú lo puedes cambiar 00:11:13
El token de separación por defecto es el espacio 00:11:15
Entonces con next 00:11:17
No puede ser una línea con espacios 00:11:19
A menos que previamente cambies el token de separación 00:11:20
Que habrá un método para cambiarlo 00:11:23
Hombre, como el fichero no tendrá espacios 00:11:24
Pues podríamos poner aquí 00:11:34
El next y ya está 00:11:36
El nombre del fichero no tendrá espacios 00:11:37
Perdón 00:11:40
Y ahora aquí ya nos podríamos plantear 00:11:41
Hacer la aplicación, vamos a hacer un menú 00:11:46
De dos opciones, porque si no nos estamos 00:11:48
Mil años, ¿vale? Solamente 00:11:49
Pues por ejemplo vamos a insertar alumno y recuperar alumno, para ver que verdaderamente el alumno se ha insertado y todo eso, insertar alumno y recuperar alumno, vale, esta sería la opción 1 por ejemplo y esta la opción 2 00:11:52
Y vamos a ponerle 00:12:26
La cero 00:12:31
Salir 00:12:32
Y ahora la opción 00:12:35
Para no tener problemas 00:12:38
Con el salto de línea y todo eso 00:12:42
La vamos a leer como string directamente 00:12:44
Porque si empezamos a mezclar 00:12:47
Next in con next line 00:12:49
Recordad que el next in deja el salto de línea 00:12:51
En el buffer 00:12:53
Luego el next line siguiente se va a comer el salto de línea 00:12:53
Y entonces habría que limpiar el buffer 00:12:57
Si hacemos todo next line 00:12:59
No hay ningún problema con eso 00:13:01
Entonces vamos a leer 00:13:02
Esto así 00:13:04
Y ahora ya pasemos rápidamente el switch 00:13:06
En el caso 00:13:13
De que 00:13:19
Tengamos una 00:13:20
Lo que sea 00:13:26
En el caso 00:13:31
Uy una A no, un 1 00:13:34
Un 1 00:13:36
A sacar errores y nos despertamos 00:13:37
¿Eh? 00:13:40
Pero 00:13:41
Luego habla de la verdad 00:13:41
Entonces ya y dormimos 00:13:46
El switch termina 00:13:48
Esto sería 00:13:58
Y aquí siempre poníamos 00:14:02
Un default, verdad 00:14:09
Con 00:14:10
Opción incorrecta 00:14:13
Joder 00:14:17
Este es el final del switch 00:14:18
Este es el final 00:14:29
Del do 00:14:31
Vale, con lo cual aquí lógicamente 00:14:32
Nos falta el while 00:14:35
mientras la opción 00:14:36
sea distinta 00:14:38
de la cero, vale 00:14:40
mientras la opción sea distinta de la cero 00:14:46
todo eso, este sería 00:14:48
el esqueleto de nuestra aplicación 00:14:52
solo tiene dos funcionalidades 00:14:54
vale 00:14:56
y ahora ya aquí 00:14:58
ahora ya aquí 00:15:04
para insertar alumno 00:15:06
pues tendríamos que 00:15:08
pedir los datos del alumno 00:15:09
para no engrosar un switch case que queda muy feo 00:15:12
vamos a hacerlo mediante un método de solicita datos 00:15:15
alumno igual a solicita 00:15:19
datos, vale, importamos 00:15:24
alumno, bueno, solicita datos 00:15:29
pues es este método que tendremos que hacer ahora 00:15:33
que me va a devolver un alumno, importamos la clase alumno 00:15:36
y ahora ya 00:15:41
alumno 00:15:44
pues tendríamos que meterlo 00:15:46
en nuestro fichero 00:15:48
tendríamos que meterlo en nuestro fichero 00:15:49
no es necesario 00:15:52
que recordemos mapas y nada de eso 00:15:58
porque podríamos 00:16:00
vamos a hacer una cosa, por si alguien tiene los 00:16:01
mapas olvidados 00:16:04
como esta es la versión patatera 00:16:05
luego en la versión buena podemos hacerlo 00:16:07
directamente con el fichero 00:16:10
vamos a hacer la versión vaga 00:16:12
que es 00:16:14
la aplicación cuando arranca 00:16:15
coge todos los alumnos 00:16:17
y los lleva a un map 00:16:20
si hago eso 00:16:21
esto de meter el alumno 00:16:23
recuperar el alumno, trabaja sobre el map 00:16:26
se hacen dos patadas en una línea 00:16:28
entonces 00:16:30
¿qué tendríamos que hacer aquí? 00:16:31
yo tengo mi fichero 00:16:36
y tengo 00:16:37
una estructura map 00:16:40
que es la que va a tener los datos 00:16:41
vale, mi estructura map 00:16:43
es un diccionario 00:16:45
y el diccionario ya sabéis que la utilidad 00:16:49
que tiene respecto a una colección normal 00:16:52
es que te saca la clave del objeto 00:16:55
te la saca aquí fuera 00:16:58
y al tener la clave del objeto fuera 00:17:00
puedes hacer las búsquedas, las modificaciones 00:17:02
los borrados mucho más fácil 00:17:05
sin tener que recorrer 00:17:07
Si tú tienes una colección con los objetos así 00:17:08
Para hacer cualquier cosa 00:17:12
Tienes que recorrer hasta que lo encuentres 00:17:13
En un mapa 00:17:15
La clave primaria de cada objeto 00:17:17
La has sacado fuera 00:17:19
Con lo cual puedes usar directamente 00:17:20
La clave para localizarlo 00:17:23
Sin tener que recorrer 00:17:25
Bueno, pues en este caso 00:17:26
Lo que vamos a guardar en el mapa 00:17:28
Son alumnos, ¿verdad? 00:17:29
Primero tenemos que pensar 00:17:32
¿Cuál es la clave de nuestros alumnos? 00:17:33
Pues nos vamos a nuestros alumnos 00:17:35
La clave es el NIF, que es un string 00:17:36
Luego nuestro map va a tener como clave string 00:17:38
Y como valor alumno 00:17:41
¿Verdad? 00:17:44
Entonces inicialmente 00:17:45
Esto va a ser 00:17:47
Un mapa vacío 00:17:48
Luego lo primero que tendremos que hacer 00:17:50
Una vez que nos han dado el nombre del fichero de alumnos 00:17:58
Es, bueno, ni lo he llamado 00:18:01
No le he dado ni nombre 00:18:03
Alumnos 00:18:05
Y vamos a importar tanto map como hashmap 00:18:06
Vale 00:18:10
Entonces 00:18:17
Recordad que había varias implementaciones 00:18:19
De diccionarios o mapas 00:18:25
Como lo queráis llamar, diccionario o mapa 00:18:27
HashMap, Trimap y LinkedHashMap 00:18:29
¿Cuál era la diferencia entre ellas? 00:18:34
La diferencia era en qué tipo de estructura 00:18:37
Se guardaba la clave 00:18:40
Esa era la diferencia entre ellas 00:18:41
En qué tipo de estructura 00:18:43
Se guardaban las claves 00:18:45
porque las claves son las que hay que manejar 00:18:47
de alguna manera, las que Java 00:18:50
tiene que manejar con más 00:18:52
soltura, porque son las que 00:18:54
usa para localizar los objetos 00:18:56
etcétera, entonces 00:18:57
si las claves se guardan en un hash set 00:18:59
entonces tenemos un hash map 00:19:02
si yo quiero que las claves se guarden 00:19:03
en un tree set, entonces tendremos 00:19:05
un tree map, vale, a su vez 00:19:07
cuál es la diferencia entre guardar en un 00:19:10
hash set y guardar 00:19:11
en un tree set, en un 00:19:13
HashSet se guardaban 00:19:18
los elementos 00:19:20
atendiendo 00:19:21
se generaba un código de hash 00:19:24
y se guardaban internamente, todo eso 00:19:26
luego nos era transparente a la hora de usarlo 00:19:28
pero si explicamos 00:19:30
como funcionaba por dentro 00:19:32
para poder elegir con criterio 00:19:33
una estructura u otra 00:19:35
vale, ambas son muy eficientes 00:19:37
sobre todo la HashSet 00:19:39
quizás es la que más se usa, entonces cuando 00:19:41
Java guarda internamente 00:19:44
en un hash set lo que hace 00:19:46
asociar un código de hash 00:19:48
a cada elemento, entonces ese código 00:19:51
de hash hace que luego 00:19:54
cuando tiene que localizarlo dentro del hash set 00:19:56
lo hace muy rápido, porque tú le das un objeto 00:19:57
saca el código de hash de ese objeto 00:19:59
con ese código de hash se va a su tabla hash 00:20:01
y dice, ah este código de hash es este 00:20:04
está aquí colocado 00:20:05
entonces es bastante rápido localizar 00:20:07
los elementos en un hash set porque a cada objeto 00:20:10
tiene un código de hash 00:20:12
te llega un objeto para localizarle 00:20:13
haces el hash, es este 00:20:15
pero eso implicaba que cada 00:20:16
que la clase esta de aquí 00:20:19
tiene que tener una función 00:20:21
para generar ese código, una función 00:20:23
esa función era la implementación 00:20:25
esta, vale 00:20:28
string ya la tiene, string ya tiene 00:20:30
su propia implementación de hashCode 00:20:33
no tenemos que hacerla nosotros 00:20:35
luego puedo usar 00:20:36
un hashMap que implica 00:20:38
a su vez que las claves van en un hashSet 00:20:41
sin preocuparme de nada más 00:20:43
porque string ya tiene una función de hash 00:20:44
para generar esos códigos de hash 00:20:47
que le van a permitir internamente a java 00:20:49
trabajar rápidamente con el conjunto 00:20:51
que repito 00:20:53
efectos de programar nosotros 00:20:55
es que eso no es transparente 00:20:56
ni vemos como genera los hash 00:20:58
como los usa para localizar 00:21:00
nosotros metemos en la colección 00:21:01
eliminamos y ya está 00:21:03
pero 00:21:05
si que tenemos que saber 00:21:06
que si una clave 00:21:09
es de una clase concreta 00:21:10
esa clase tiene que tener una implementación 00:21:12
de hashcode lo más 00:21:15
eficiente posible 00:21:17
string ya la tiene 00:21:17
¿vale? pero si yo pusiera como clave 00:21:20
una clase mía 00:21:22
cualquiera, una clase que yo 00:21:24
me he inventado clave 00:21:26
pues tengo que hacer una implementación 00:21:27
de hashcode 00:21:31
ahí 00:21:32
la tengo que hacer 00:21:34
que la hicimos el año pasado 00:21:35
pues la que te generaba el eclipse es suficiente 00:21:38
porque tampoco teníamos conocimientos 00:21:40
como para generar una óptima en función de 00:21:42
la estadística de mis datos, lo ideal 00:21:44
es que en función de la estadística 00:21:46
del uso de mis datos 00:21:48
yo generara una óptima, pero bueno 00:21:49
eso ya es pasarse 00:21:52
nadie hace eso, ¿vale? 00:21:54
con la implementación de Haskell de estándar 00:21:56
que te ofrece Eclipse ya es un compromiso 00:21:58
más o menos 00:22:00
porque si no implementamos esto 00:22:01
¿qué versión de Haskell usa? 00:22:04
la de Object, porque ya sabéis 00:22:08
que todas las clases eran de Object, todas 00:22:10
entonces si yo no sobrescribo 00:22:12
hashCode va a utilizar la implementación 00:22:14
de object y la implementación 00:22:16
de object 00:22:19
convierte el set en una lista 00:22:19
normal y corriente porque todos los elementos 00:22:23
devuelven el mismo hashCode, todos, con lo cual 00:22:24
¿de qué me serviría? 00:22:27
usar un hashSet si no sobrescribo 00:22:29
la implementación de object 00:22:31
de hashCode es que no 00:22:33
hace un código de hash distinto para cada elemento 00:22:35
con lo cual es como si estuvieran todos en una lista 00:22:37
bueno, todo esto es más o menos 00:22:39
del año pasado, lo repaso un poco por encima 00:22:41
pero lo que importa ahora 00:22:43
es que a la hora 00:22:44
de usarlo, la clase 00:22:47
que pongamos aquí, si es 00:22:49
que es un HashMap, tiene que tener 00:22:51
una implementación de hash, este 00:22:53
bien la tiene, porque ya está hecha 00:22:55
esa clase y la tiene, ¿vale? 00:22:57
Bueno 00:23:00
y si poníamos el trimap 00:23:00
esto se guardaba en un 00:23:03
triset, eso tenía una 00:23:07
implicación, en un triset 00:23:10
implica que internamente lo guarda en un árbol binario 00:23:12
donde es muy eficiente el árbol binario 00:23:16
porque se coloca según un criterio de orden 00:23:19
si es mayor hacia acá, este es mayor que este 00:23:24
este es menor que este, este es menor que este 00:23:28
este es mayor que este, este es menor que este 00:23:31
entonces al guardar según un criterio de orden 00:23:33
a la hora de localizar, localiza muy rápido 00:23:36
porque se va quitando punto a la mitad de los elementos 00:23:40
de golpe, se los va quitando entonces localiza 00:23:43
rápido, por eso el trimap es eficiente 00:23:45
¿vale? pero a la hora 00:23:46
ya nosotros de escribir el código 00:23:49
¿qué implicación 00:23:50
tenía si yo aquí 00:23:53
decido un trimap 00:23:55
en vez de un 00:23:57
hasmap, decido un trimap 00:23:59
ahora ya a la hora de escribir código 00:24:01
¿qué implicación tenía? ¿alguien la recuerda? 00:24:03
seguro que sí 00:24:05
claro 00:24:06
que esta clase 00:24:11
tenía que tener un criterio de orden. 00:24:12
¿Y cómo hacemos que una clase 00:24:15
tenga un criterio de orden? 00:24:16
Implementando comparable 00:24:19
e implementar comparable 00:24:20
implica implementar el método compare-tú. 00:24:23
Entonces le damos un criterio de orden. 00:24:25
Que no podemos... 00:24:28
String ya implementa comparable, 00:24:29
con lo cual podríamos usar 3Maps sin problema. 00:24:30
Que tenemos aquí una clase 00:24:32
que no implementa comparable, 00:24:34
pero no la hemos hecho nosotros. 00:24:37
Ni tenemos acceso a ella 00:24:39
y no podemos tocarla, con lo cual 00:24:41
yo no puedo de repente coger su código 00:24:43
fuente y decir, voy a añadirle que 00:24:45
implemente comparable y por el método que me dé la gana 00:24:47
no puedo, esa clase no la he hecho yo 00:24:49
como ocurre la mayoría de las veces y no puedo 00:24:50
eso implica que es imposible 00:24:53
usar un trimap 00:24:55
vale, pero bueno 00:24:56
implica que entonces aquí tienes que hacer una instancia 00:25:03
de la heredada, vale 00:25:05
sí, pero cambias el modelo de datos 00:25:07
un poquito, pero bueno, sería una solución 00:25:09
pero cambiándolo, hay una más fácil 00:25:11
que es 00:25:13
pasas aquí en el constructor 00:25:14
un objeto comparator 00:25:18
¿os acordáis? 00:25:21
entonces el comparator es un objeto 00:25:24
que es un criterio de orden concreto 00:25:27
para el uso del map 00:25:29
no es que ese criterio de orden 00:25:31
simplemente para siempre en esta clase 00:25:33
no, solamente el map lo va a usar 00:25:35
él solamente, su trimap 00:25:38
lo va a usar cuando necesite meter las cosas 00:25:40
Va a usar ese criterio de orden que yo ponga aquí 00:25:43
Y esta clase se queda inalterada 00:25:45
Ni comparable ni nada 00:25:47
¿Vale? 00:25:48
Bueno, pues aquí 00:25:51
No nos complicamos la vida 00:25:52
En realidad es que da igual cual pusiéramos 00:25:54
Como string, implementa comparable 00:25:56
Implementa hashcode 00:25:58
Es que da igual el que eligiera 00:26:00
Pero 00:26:02
Si hay una diferencia 00:26:04
Con esto ya paramos un segundito 00:26:07
De implementar hashback a implementar 00:26:09
trimap, hay una diferencia 00:26:11
visible que yo podría observar luego 00:26:13
trabajando. ¿La recordáis? 00:26:15
Que cuando yo itere, 00:26:17
que puede ser que yo tenga que 00:26:22
iterar para ver todos los alumnos, 00:26:23
para ver todo. Pues cuando 00:26:25
yo itere, cuando itero en un triset, 00:26:27
la iteración se va a hacer 00:26:31
en el orden 00:26:33
del criterio de orden. 00:26:34
Entonces, la iteración me va a sacar 00:26:37
los elementos siempre ordenaditos. 00:26:39
La iteración en un haset 00:26:41
no me lo saca siguiendo ningún criterio 00:26:43
de orden que yo haya definido 00:26:46
entonces, si mi aplicación 00:26:47
va a hacer iteraciones para mostrar listados 00:26:50
y lo que sea, pues estás cómoda 00:26:52
porque esa iteración 00:26:54
ya me va a dar los elementos ordenados 00:26:56
aquí quiero yo ordenar 00:26:58
los alumnos por NIF, si yo tuviera una 00:27:00
funcionalidad que fuera 00:27:02
dame la lista de alumnos ordenados 00:27:03
por NIF, pues hombre 00:27:06
ahí podría tener sentido elegir un trimap 00:27:08
porque cuando itere por el map van a salir 00:27:09
todos ordenados por la CLAR 00:27:11
que es el... si me da igual 00:27:13
pues entonces un HashMap 00:27:15
que siempre es más 00:27:17
más comodillo y esas cosas 00:27:19
vale, vamos a parar 00:27:22
un segundinito 00:27:23
Materias:
Programación
Niveles educativos:
▼ Mostrar / ocultar niveles
  • Formación Profesional
    • Ciclo formativo de grado superior
      • Primer Curso
Subido por:
Raquel G.
Licencia:
Todos los derechos reservados
Visualizaciones:
9
Fecha:
30 de septiembre de 2025 - 18:52
Visibilidad:
Clave
Centro:
IES ROSA CHACEL
Duración:
27′ 26″
Relación de aspecto:
1.78:1
Resolución:
1920x1080 píxeles
Tamaño:
525.04 MBytes

Del mismo autor…

Ver más del mismo autor

EducaMadrid, Plataforma Educativa de la Comunidad de Madrid

Plataforma Educativa EducaMadrid