Saltar navegación

20250210 Maps y try-catch - 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.

11 visualizaciones

Más información Transcripción

Descargar la transcripción

Si habláis me autorizáis a que grabe vuestra voz. Hoy vamos a acabar la parte de colecciones hablando de maps. Existe una interfaz extra a la interfaz iterable collection que es la interfaz map. 00:00:00
Si os fijáis, la interfaz map no hereda de colecciones, es una interfaz distinta, aparte, pero es una interfaz que sostanzialmente se utiliza igualmente para guardar objetos y para guardar colecciones de objetos. 00:00:19
Por lo tanto, es parecida a las ideas que tenemos ahora mismo, ¿vale? 00:00:35
En particular, desde aquí, tenemos Ashtable, Ashmap y Trimap, que son tres implementaciones del concepto de mapa. 00:00:41
¿Qué es el concepto de mapa? 00:00:53
Sustancialmente es guardar un conjunto de objetos, pero en vez de guardarlos directamente como hemos hecho hasta ahora, 00:00:55
en una lista y que se pongan allí creo una clave vale es decir que los objetos en vez de guardarlos 00:01:01
simplemente en una colección lo que hago lo que hago es crear una pareja de una clave y el objeto 00:01:12
al que se refiere otra clave y el objeto al que se refiere un poco parecido a las claves que 00:01:19
utilizáis en bases de datos vale sabéis que cada registro en base de datos tiene que tener una 00:01:25
primary key y cosas por el estilo 00:01:31
que me permite identificar un determinado 00:01:34
elemento, un determinado record de la base de datos 00:01:37
pues esto en un cierto sentido va por allí 00:01:40
la idea es que yo tengo esta estructura 00:01:43
lo que voy a hacer es para buscar un objeto de esta estructura 00:01:45
en vez de buscar el objeto directamente busco su clave 00:01:49
busco algo que yo he establecido 00:01:52
ser una clave para poder encontrarlo 00:01:55
La clave puede ser o un propio atributo del objeto, ¿vale? 00:01:58
Si yo tengo la persona con dentro del campo nie, pues podría poner dentro de la propia persona, 00:02:04
o sea, usar el atributo de la propia persona como clave, ¿vale? 00:02:10
O podría ser algo externo. A lo mejor yo tengo personas, ¿vale? 00:02:15
Tengo conceptos de personas que no tienen un nie, 00:02:19
y yo puedo utilizar un mapa para, en un cierto sentido, añadir el concepto de NIE que sea único 00:02:23
para luego poder diferenciar las personas entre ellas. 00:02:31
Entonces yo tengo dos personas que a lo mejor la característica de persona, el nombre, la edad y la altura son las mismas, 00:02:35
pero luego las pongo en una estructura de mapa en la que digo, este NIE se refiere a este objeto, 00:02:42
este NIE se refiere a un objeto distinto 00:02:47
entonces es definido 00:02:49
dos distintos 00:02:51
dos distintas personas 00:02:52
identificables entre ellas 00:02:55
a través del 00:02:57
de la clave 00:02:58
la clave como en base a datos 00:03:02
y como en otro contexto debería ser única 00:03:05
no nos 00:03:07
permite el HMAP 00:03:09
introducir dos veces 00:03:11
objetos con la misma clave 00:03:12
no deberíamos poder 00:03:15
hacer cosas por el estilo entonces el primer la primera implementación de mapa podemos ir a ver 00:03:17
el java vale luego una cosa más o menos el java api map es este de aquí veis que tiene un clear 00:03:24
tiene un get para pillar fijaos que pilla una clave y que te devolverá te devolverá el objeto 00:03:39
asociado con esta clave, en nuestro ejemplo 00:03:54
si yo tengo como clave los nies 00:03:56
cuando yo pongo el nie de 00:03:57
Stefano, pues haré 00:03:59
un get del objeto 00:04:02
nie y él me devolverá 00:04:04
un objeto que es 00:04:06
el objeto que se había guardado 00:04:08
en la mapa, o sea 00:04:09
una persona que es Stefano en este caso 00:04:12
fijaos también 00:04:14
que cuando hago un add 00:04:16
no existe el add, existe el put 00:04:18
y el put 00:04:20
tiene una clave y un valor. 00:04:22
Siempre que añado una nueva cosa 00:04:24
a mi colección, pues la añado 00:04:26
como pareja de esta es su clave, 00:04:28
esta de aquí es el valor asociado 00:04:30
con esta clave. Luego buscaré 00:04:32
por claves y obtendré 00:04:34
valores. 00:04:36
¿Sí? ¿Dudas? 00:04:38
Fijaos 00:04:41
también 00:04:42
que este señor 00:04:43
trabaja con dos 00:04:46
tipos 00:04:48
genéricos. Un tipo genérico que representa la clave 00:04:50
y un tipo genérico que representa el valor. O sea, yo puedo usar como clave 00:04:54
strings y obtener como valores persona. Puedo utilizar 00:04:58
como variables gatos y tener como valores 00:05:02
casas. No lo sé. 00:05:06
Cuando yo defino un map, cuando creo un map, le tendré que 00:05:10
definir cuáles son los tipos de sus dos 00:05:14
tipos de las claves y los tipos de los valores 00:05:17
y luego los usaré 00:05:21
con los tipos apropiados 00:05:22
antes en la otra tenía 00:05:24
un solo valor genérico, un solo tipo 00:05:27
genérico, ahora tengo dos tipos genéricos 00:05:28
entonces 00:05:31
luego haremos ejemplos para ver 00:05:32
un poquito como se usa, una cosa 00:05:34
interesante es que 00:05:36
pregunta 00:05:38
para vosotros, a ver si me habéis seguido 00:05:41
¿existe 00:05:43
el método 00:05:44
iterator 00:05:47
en map 00:05:49
casi 00:05:51
no porque no extiende de iterable 00:05:59
este iterable no está en maps 00:06:02
entonces iterable 00:06:06
era el que me permite hacer 00:06:08
el comando iterator que me daba un iterador 00:06:09
que luego me permitía iterar 00:06:12
sobre el objeto 00:06:14
no puedo iterar sobre 00:06:15
un map 00:06:17
no puedo decir, mira tienes un mapa, sí 00:06:19
quiero que me des todos sus valores y me los das 00:06:22
¿vale? 00:06:24
no hay una forma de hacerlo 00:06:26
lo que se suele hacer en estos 00:06:28
contextos 00:06:30
es que tú puedes 00:06:31
transformar una de las 00:06:34
dos cosas del mapa 00:06:36
o sea, o las claves 00:06:38
o los valores en set 00:06:40
¿vale? 00:06:42
¿dónde estará? 00:06:44
esto, esto 00:06:46
y esto 00:06:47
no estos son la cosa no es el valor que hay 7 y valió varios varios vale entonces si yo quiero 00:06:49
yo tengo un mapa y quiero ver todas sus sus valores puedo hacer el método varios que me 00:06:59
devuelve una colección entonces sobre es así que puede tirar vale o si yo quiero puedo pillar todas 00:07:07
las claves transformarla en una red en un en un conjunto de claves vale porque conjunto en 00:07:14
la lista exacto porque hemos dicho que la clave es única vale entonces en el set no se repiten 00:07:22
valores muy bien me gusta cuando seguís el entonces luego una vez que tengo el set de 00:07:33
claves puedo iterar sobre el set de claves pillar la clave por cada clave buscar su valor utilizando 00:07:42
la get. 00:07:48
Entonces, tengo modos igualmente 00:07:52
para poder ir buscando 00:07:53
todos los valores de mi 00:07:55
mapa. Pero no el 00:07:58
iterator directamente. El iterator no está. 00:07:59
Entonces tengo que hacer este 00:08:02
truquillo. 00:08:03
Dudas hasta aquí. 00:08:05
Vamos a ver las implementaciones. 00:08:07
La primera 00:08:11
implementación es, hemos dicho, 00:08:11
esta de aquí, 00:08:14
¿dónde está? Interfaceset. 00:08:15
aquí, ashmap, ¿vale? 00:08:18
Es una implementación que almacena las claves en una tabla hash, ¿vale? 00:08:21
¿Os acordáis que era esto de la tabla hash? 00:08:26
Que yo pillo, tengo una serie de clúster, una serie de posibles categorías, 00:08:28
tú me das una clave, yo le hago una función y te digo que esta clave cae en la sección 3. 00:08:40
Por lo tanto, esta clave, la clave 1, la pongo aquí. 00:08:47
Ahora me das otra clave y la clave está aquí, le hago la función y me da como resultado 7 00:08:50
Pues el 7 va aquí, entonces la clave 2 va aquí 00:08:55
De esta forma, aquí yo insertaré otras claves, aquí va la 3, la 4 cae aquí también 00:08:58
Luego está la 5 que cae aquí, luego está la 6 que cae aquí también, etc, etc, etc 00:09:06
Ahora cuando por ejemplo busco una clave, como mucho tendré que hacer 3 comprobaciones 00:09:14
Porque el clúster más grande es este de aquí, que tiene solo tres comprobaciones. 00:09:20
Todas las claves que han caído en todos los otros clústeres, ni lo tomo en consideración. 00:09:25
Por lo tanto, es mucho más rápido para buscar. 00:09:31
Si mi función hash está bien hecha, este es muy disperso, o sea, hay muy pocos elementos por cada categoría, 00:09:34
y por lo tanto se mejora muchísimo la velocidad con el que encuentro la clave que está buscando. 00:09:42
Y luego a partir de esta clave tendrá referencia a los objetos valores que se refieren. 00:09:54
Entonces una vez que encuentro la clave de aquí podré saltar a los objetos valores que quería pillar de verdad. 00:10:04
Es una implementación con mejor rendimiento de todas, ¿vale? 00:10:13
Pero no garantiza ningún orden a la hora de realizar iteraciones. 00:10:17
Cuando yo, el orden de inserción con el que han metido las cosas, pues se mezcla todo, 00:10:20
porque yo inserto el primero y el primero, hemos dicho, que puede ir en cualquiera de esta categoría, 00:10:27
entonces me lo habría podido poner en la última categoría. 00:10:32
No lo sé dónde va a acabar. 00:10:35
Depende de la función y depende del valor de la clave que yo pongo, ¿vale? 00:10:36
Entonces, si yo quiero mantener un orden, pues esto no es la estructura que tengo que buscar. 00:10:41
Esta implementación proporciona tiempos constantes en las operaciones básicas, ¿vale? 00:10:50
Tiempo constante, tiempo constante es bueno, es más bajo que tiempo logarítmico, que ya es bueno, 00:10:54
que es mejor que tiempos lineares, que es de n, ¿vale? 00:11:00
Que es bueno, aceptable, que es peor de n al cuadrado, que es peor de x a la n, ¿sí? 00:11:05
Por lo tanto es bueno, es rápido. Es importante definir el tamaño inicial de la tabla porque este tamaño marcará el rendimiento de la implementación. Si yo hago una tabla hash demasiado pequeña con pocas categorías funciona peor, si la hago más grande funciona mejor, pero si la hago enorme me ocupa mucha memoria para nada. 00:11:14
Hemos que tener en cuenta un factor de carga 00:11:32
Cuando yo voy metiendo cosas en esta mapa 00:11:38
Y llega un momento en que hay demasiados elementos 00:11:41
El mapa se hace una operación 00:11:44
Y se dobla en tamaño 00:11:47
Para que no haya muchos clústeres pegados 00:11:50
Entonces yo cuando lo creo 00:11:54
Tengo que definir cuál es el tamaño inicial 00:11:56
y a qué nivel de riempimiento de la tabla yo decido hacerla más grande. 00:11:59
Por defecto, el tamaño es 16. 00:12:10
Empieza con 16 posibles claves que se puedan almacenar. 00:12:13
Y si llega al 75%, o sea, 12 llenadas, 00:12:18
pues entonces hace una operación de duplicar este de aquí, 00:12:24
tener 32 y ahora tengo 00:12:27
32 huecos y hasta que no haya 00:12:29
rellenado el 75% no pasaría 00:12:31
64, ¿vale? 00:12:33
Está claro que cada vez que hago esta operación 00:12:35
de duplicar, pues 00:12:37
es un trabajo 00:12:39
¿sí? A lo mejor las primeras veces 00:12:40
no, pero 00:12:43
imaginamos que yo tengo un millón de 00:12:45
entradas y de repente me añado 00:12:47
una y tengo que duplicar 00:12:49
pues es un buen trabajo hacer un millón 00:12:51
de operaciones ahí 00:12:53
moviendo cosas, ¿vale? 00:12:54
Probablemente es crear una nueva HMAP grande el doble y luego pilla iterar sobre el antiguo HMAP y volver a ponerlo en el nuevo. 00:12:57
Y en este punto tengo algo parecido a los arrays, pero lo hace en el automático por debajo. 00:13:07
Para evitar que esto pase, yo hago un estudio antes y digo, vale, ¿cuál es mi problema? 00:13:13
¿De qué voy a pagar? De alumnos, vale. 00:13:19
¿Cuántos alumnos voy a poner cada año? ¿Cuántos alumnos pueden estar en una escuela? 00:13:21
pues mil alumnos, pues haré una tabla que pueda tener 1.500 alumnos más o menos, ¿vale? 00:13:25
Ya sería una cosa de ese estilo. 00:13:33
Si en vez de alumnos estoy hablando de la población de Madrid, 00:13:35
pues no hago una tabla de 1.500, tendrá que ser mucho más grande. 00:13:40
¿Se entiende? 00:13:46
Vale, en realidad existía antes una cosa que se llama Stable, ¿vale? 00:13:50
Stable es más antigua, Ashmapa es más moderna. 00:13:53
Nosotros hoy en día se utiliza más HashMap que HashTable, HashTable deriva de lo que había antes, ¿vale? 00:13:56
Entonces, como algunos programas utilizaban HashTable antes, pues cuando se ha hecho HashMap, se ha dicho, vale, mantengamos también el HashTable para que, sustancialmente, los programas anteriores sigan funcionando. 00:14:03
Aquí hay una comparación, ¿vale? HashMap no está sincronizado a HashTable, sí, esto solo sirve si hacéis segundo de DAW y programación paralela. 00:14:15
HMAP permite una clave nula 00:14:23
Y múltiples valores nulos 00:14:26
Mientras HMAP 00:14:28
No permite ninguna clave 00:14:30
O valor nulo 00:14:32
Es decir, que hay una opción en la que yo puedo poner 00:14:33
Como clave nul 00:14:36
Y que luego, si tú buscas clave nul 00:14:37
Esto es el 00:14:41
Correspondiente valor 00:14:42
Que podría ser un valor por defecto 00:14:44
O yo puedo tener 00:14:45
Claves que apuntan a objetos nul 00:14:48
En HMAP lo puedo hacer 00:14:51
En Ashtable no 00:14:52
¿Vale? 00:14:53
Bueno, se ha introducido el juego hace mucho 00:14:56
En JDK 1.2 00:14:58
Pues viejo 00:15:00
Cuando estudié yo ya estaba en 2 00:15:01
Ashmap es rápido, Ashtable es mucho más lento 00:15:03
Podemos hacer que Ashmap 00:15:07
Este sincronizado llamando el método 00:15:09
Esta cosa aquí, collection.synchronizeMap 00:15:10
Entonces hay una forma 00:15:13
De transformar esto que no está 00:15:14
Sincronizado en sincronizado 00:15:17
Y entonces obviar el problema 00:15:18
Este de aquí 00:15:21
asMap es recorrido por iterator 00:15:21
se puede utilizar un iterator aquí 00:15:25
mientras que asMap es recorrido por 00:15:26
enumerator y iterator 00:15:28
dos cosas distintas 00:15:30
este asMap es a prueba de errores 00:15:31
este de aquí, el numerador 00:15:35
es muy lento, vale 00:15:36
usad asMap 00:15:38
sustancialmente, vale, esto es para que 00:15:41
sepáis un poquito la diferencia 00:15:42
entre los dos, no me interesa 00:15:44
mucho, muchísimo 00:15:46
trimap es siempre un mapa 00:15:47
Siempre estamos hablando de claves y objetos relacionados con esta clave 00:15:50
Que luego yo buscaré una clave y me da un objeto 00:15:54
Que es el objeto relacionado con esto 00:15:56
Pero lo organiza como un árbol 00:15:58
Como un tree 00:16:02
Entonces las claves están ordenadas en función de sus valores 00:16:03
Con orden ascendente 00:16:08
Entonces tendré que implementar la interfaz comparable de las claves 00:16:10
Las claves tienen que poder ser comparables entre ellas 00:16:15
Si no son comparables, no sé cómo ordenarlas. 00:16:18
Contiene solo elementos únicos, es bastante más lento que HMAP. 00:16:22
Esta implementación garantiza siempre un rendimiento de log n en las operaciones básicas. 00:16:27
Entonces, en casos en los que yo tengo, de todas formas, que mantener un determinado orden en las claves, 00:16:32
pues entonces este TRIMAP me puede servir de algo. 00:16:38
Si en vez de no me interesa el orden de las claves, el HMAP es seguramente mejor porque va más rápido. 00:16:41
está también en linkedashmap 00:16:45
¿vale? que es unashmap 00:16:48
hecho con esto de los nodos 00:16:50
enlazados uno con otro 00:16:52
pero bueno, que está por ahí 00:16:53
acabamos este tema 00:16:56
creo 00:16:58
con este maravilloso esquema 00:16:59
¿vale? que es 00:17:02
lo que debería hacer vuestra mente 00:17:04
cuando vosotros pensáis 00:17:06
tengo que hacer una colección de objetos 00:17:08
empezáis aquí, donde pone inicio 00:17:09
y preguntáis 00:17:11
¿Tienes pares de clave-valor o tienes solo valores? 00:17:12
Si tienes solo valores, pues te vas por aquí 00:17:18
Si tienes una clave que apunta un valor, pues entonces te vas por acá 00:17:21
Vamos para la derecha por ahora 00:17:27
Tengo solo valores, no me interesan claves 00:17:30
¿Contiene duplicado? 00:17:32
Si sí, usa la relist 00:17:35
Si no contiene duplicados, hazte otra pregunta 00:17:37
que es, su tarea principal es buscar 00:17:41
elementos, la contains 00:17:43
y la remove 00:17:45
si no, si la tarea 00:17:46
principal es otras cosas, vete a 00:17:49
relist, si sí 00:17:51
vete aquí y pregúntate, el orden 00:17:53
es importante, si no 00:17:55
quieres mantener el orden, hset 00:17:57
si quieres mantener el orden 00:17:59
pues vete aquí, orden de 00:18:01
inserción o orden de elemento 00:18:03
¿qué te interesa más? o sea, ¿te interesa 00:18:05
la orden con que has insertado 00:18:07
que se preserve o el orden de 00:18:09
un determinado valor que tienes 00:18:11
dentro de los objetos que tienen que ser 00:18:13
ordenados según este criterio. 00:18:15
Pues si es de inserción, usa una link 00:18:17
hset. Si en vez 00:18:19
es de ordenación, pues usa un 00:18:21
triset. Por otro lado, 00:18:23
¿qué eros pares en vez que valores? Vale. 00:18:27
¿Es importante el orden? Pues 00:18:30
si no es importante el orden, 00:18:31
usa una shmap. Ya está. Si en vez 00:18:33
el orden es importante, pues pregúntate 00:18:35
¿es el orden de inserción o 00:18:38
el orden de la clave? Que la clave tiene un 00:18:39
orden especial suyo y tienes que mantener 00:18:41
ordenada la clave según ese orden 00:18:43
si es de inserción usa un link dash map 00:18:45
si es de ordenación 00:18:47
de la clave pues entonces usa un trimap 00:18:49
entonces esto es 00:18:51
que voy a usar 00:18:55
en base a mis necesidades 00:18:57
estas son las preguntas 00:18:58
que deberíais 00:19:00
tener claras 00:19:02
a la hora de elegir 00:19:05
una de estas colecciones 00:19:07
y deberíais 00:19:09
entender después de toda esta 00:19:11
como se dice 00:19:13
teoría 00:19:14
por qué 00:19:16
la respuesta sí y no de cada una 00:19:18
de estas preguntas os lleva 00:19:21
a lo que os lleva. No. 00:19:23
LinkedList no es dicho 00:19:38
que es la más importante. Es dicho que es la más 00:19:39
flexible. Porque 00:19:41
LinkedList tú la puedes usar 00:19:43
de varias formas distintas. Ahora 00:19:45
si has mirado la cosa así 00:19:47
no es muy eficiente. 00:19:48
Entra a ser eficiente 00:19:52
en el momento en el que 00:19:53
tú lo que haces es muchas 00:19:55
remociones y cosas por el estilo 00:19:58
entonces estarías por aquí 00:19:59
¿vale? 00:20:01
¿contiene duplicados? 00:20:04
sí, o sea, aquí 00:20:06
faltaría él, si contiene duplicados 00:20:08
y su tarea principal es 00:20:10
contains remove, entonces sería una link allí 00:20:12
¿vale? faltaría aquí 00:20:14
él te manda hacia aquí 00:20:16
pero por aquí estaría pasando 00:20:18
por otra cosa 00:20:20
lo que yo dije es que 00:20:21
si tú no sabes, no tienes idea 00:20:23
pues pillar una linked list 00:20:26
te da la posibilidad en cierto momento de 00:20:28
usarla como 00:20:29
una cosa como otra, entonces a lo mejor 00:20:31
te da más 00:20:34
amplio espectro 00:20:35
dudas 00:20:37
vale 00:20:39
ahora haremos un 00:20:47
ejemplito de algo de esto 00:20:50
para ver como funciona y cosas por el estilo 00:20:52
pero quiero empezar por 00:20:54
otra cosa, vale 00:20:56
Vamos a ver, estamos en estructuras dinámicas 00:20:57
Pongámoslos aquí, venga 00:21:02
Hacemos otro ejemplo 00:21:03
Vale 00:21:06
Entonces 00:21:16
Las 00:21:18
¿Cómo se llaman? 00:21:22
Las estructuras que hemos visto ahora 00:21:25
Sostancialmente son versiones 00:21:27
Digo duda, nadie 00:21:30
Duda 00:21:32
Vale 00:21:33
Imagínate una rubrica telefónica 00:21:40
rubrica telefónica 00:21:44
se dice 00:21:46
sí, una cosa así 00:21:47
tú en casa tienes un cuaderno 00:21:54
donde pones Stefano y su número de teléfono 00:21:56
no sé qué 00:21:59
pues eso es una pareja, a ti no te interesa 00:21:59
Stefano, Stefano es una clave 00:22:02
¿vale? y cuando tú encuentras 00:22:04
Stefano ordenado por Stefano 00:22:06
porque tú no ordenas por 00:22:08
número de teléfono, porque si no te deberías 00:22:10
recordar el número de teléfono para poder encontrarlo 00:22:12
tú lo estás ordenando por una clave 00:22:14
Y cuando has encontrado la clave 00:22:16
No te interesa la clave 00:22:19
Te interesa el valor al que apunta 00:22:20
Y tienes mi número de teléfono 00:22:22
Eso es un ejemplo de 00:22:23
Cómo funciona un map 00:22:26
Mapea un cierto conjunto de valores 00:22:27
A otros valores 00:22:31
Donde tú sueles tener 00:22:32
O sueles buscar por 00:22:35
El valor clave 00:22:36
Pero lo que te interesa obtener 00:22:38
Es la parte valor 00:22:40
¿Cómo se dice en español rubrica? 00:22:41
Agenda 00:22:47
agenda telefónica la interfaz comparable la hemos visto bien en los apuntes y tiene que 00:22:48
tener sustancialmente comparable con perdú está por aquí está por aquí está por aquí 00:23:06
lo que tienes que hacer es implementar este método de aquí el único método que te permite 00:23:11
cuando se implementa 00:23:19
se implementa cuando 00:23:25
el objeto 00:23:26
la colección que vas a utilizar 00:23:28
hace uso del compare 00:23:31
para poder organizar 00:23:33
o sea ordenar los elementos 00:23:35
normalmente en lo que hemos visto 00:23:37
nosotros en los trialgo 00:23:39
en los triset 00:23:41
o en los trimap 00:23:42
como el árbol cuando tú 00:23:44
insertas un nuevo nodo tiene que decidir 00:23:47
si ponerlo a la izquierda o a la derecha de otro nodo, 00:23:49
tiene que poder comparar el nodo nuevo con el nodo actual. 00:23:51
Y si es mayor, bajará por la derecha y mirará. 00:23:55
Si no hay nada, lo pone allí. 00:23:59
Y si hay algo, volverá a comparar. 00:24:00
Si es menor, baja por la izquierda. 00:24:02
Entonces, se necesita un mecanismo para decidir, 00:24:04
oye, sí, vale, muy bien. 00:24:07
Mayor o menor, ¿de qué? 00:24:08
¿Cómo puedo comparar el nuevo nodo con el nuevo valor 00:24:09
con el valor viejo que estaba allí? 00:24:14
Pues eso dice, usa comparable. 00:24:16
tú implementas comparable él utilizará esa forma para hacerlo sí más dudas preguntas 00:24:18
luego sobre comparable también tenemos que decir algunas cosillas hoy tocan tres cosas vale hemos 00:24:29
acabado ahora las map y luego habrá que hacer ejemplos ejercicios y cosas y a lo mejor mañana 00:24:35
toca algo sobre 00:24:42
Compertú y sobre Comparator 00:24:45
que lo decimos el otro día, pero no hicimos 00:24:47
un ejemplo, ¿vale? A ver si encontramos un ejemplo 00:24:49
por ahí, si no, mañana 00:24:51
y luego la otra cosa que quiero enseñaros 00:24:52
pero es solo una pincelada, es sobre 00:24:55
excepciones, ¿vale? Pero muy poco 00:24:57
solo para cumplir el expediente 00:24:59
y era lo que quería enseñaros ahora 00:25:00
ejemplo 00:25:05
¿vale? 00:25:07
¿Os acordáis cuando éramos pequeños 00:25:09
y leíamos 00:25:11
de teclado 00:25:13
¿eh? 00:25:15
¿cómo se hacía esto? 00:25:17
que en segundo el otro día uno me ha dicho 00:25:19
no me acuerdo cómo se lee de teclado 00:25:20
scanner, scanner 00:25:22
igual a new, scanner 00:25:24
system.in 00:25:26
se os olvida de todo 00:25:28
¿sí? tenía scanner 00:25:29
y ahora 00:25:32
yo le digo 00:25:33
int 00:25:36
bueno, si hizo 00:25:38
dime tu edad 00:25:39
y ponía int 00:25:41
edad es igual 00:25:45
a scan.next 00:25:47
hola, que habláis mucho 00:25:49
luego nos enteráis 00:25:51
quién sabe por qué 00:25:53
int, ¿sí? ¿de acuerdo? 00:25:54
vale, y luego yo podría decir 00:26:00
si eso 00:26:01
tienes 00:26:02
más edad 00:26:04
años 00:26:06
esto es 00:26:08
ejercicio de septiembre 00:26:09
finales de septiembre si os acordáis yo lanzaba lanzaba esta cosa aquí ponía 19 00:26:15
tiene 19 años fenomenal yo lo lanzo pongo gato y explota porque explota claro input 00:26:23
match exception vale que está pasando aquí él se está dando cuenta que se 00:26:38
esperaba una cosa vale pero sin embargo tú le has dado otra él tiene un 00:26:44
metodito que es capaz de interpretar enteros, sin embargo, no puede interpretar los enteros 00:26:49
porque tú lo has puesto gato, no sabe cómo traducir gato a un entero y, por lo tanto, 00:26:56
explota, ¿vale? Ahora, las excepciones son muchas cosas y son cosas variadas y distintas, 00:27:02
¿vale? Pero a lo mejor lo profundizaremos un poquito más adelante sobre tipos de excepciones, 00:27:10
etc. Por ahora simplemente sepáis 00:27:15
que existen dos tipos de excepciones, dos tipos 00:27:18
de errores en un cierto sentido. 00:27:21
Las que pueden surgir, pero me da 00:27:23
igual, no tienes 00:27:27
obligatoriamente que gestionarlas, como 00:27:30
por ejemplo esta. Esta puede surgir, 00:27:33
puede explotar, pero no te pide que tú hagas 00:27:36
algo por este problema. 00:27:39
En vez hay otras excepciones, que cuando un método puede lanzar ese tipo de excepción, pues el programa, el mismo Eclipse, te dice, no, cuidado, si este método de aquí no me lo proteges de alguna forma, no te dejo utilizarlo. 00:27:42
Por ahora nosotros no hemos visto de esas. La veremos con los ficheros. Cuando usamos los ficheros, la IO exception, input output exception, pues requiere que tú la manejes siempre. Por eso damos una pincelada de cómo se maneja. 00:28:05
O sea, ¿es bonito que exploten los programas? No. ¿Gusta a los usuarios que exploten los programas? No. ¿Queremos nosotros que los usuarios no manden ticket? No. ¿Por qué? Somos vagos. Y si hacemos las cosas bien, trabajamos menos. 00:28:23
por lo tanto 00:28:47
esto es un sistema en el que te está 00:28:49
diciendo, dime tu edad, que claramente 00:28:51
es un entero, pero alguien podría decir 00:28:54
no mira, oye, en vez de un entero te pongo 00:28:55
mi fecha de nacimiento, pues eso no es 00:28:57
un entero, sería un string, y esto 00:28:59
explotaría, vale, entonces 00:29:01
existe una forma 00:29:03
de hacer las cosas, un comandito 00:29:06
que es el comandito 00:29:08
try-catch 00:29:09
¿qué es el try-catch? 00:29:10
es sustancialmente 00:29:13
Prueba a hacer esto 00:29:14
Tú inténtalo 00:29:18
¿Va todo bien? 00:29:21
Adelante, ningún problema 00:29:23
Pero si pasa algo raro 00:29:24
Pilla ese problema 00:29:27
Y en vez de explotar 00:29:41
Ejecuta este bloque 00:29:44
este bloque 00:29:47
en particular aquí le tengo que decir 00:29:49
¿qué pillo? 00:29:53
y aquí es una input mismatch 00:29:54
exception 00:29:57
input mismatch 00:29:57
exception 00:30:01
error 00:30:03
o problema, no importa 00:30:05
y ya lo tengo 00:30:14
entonces ¿qué pasa aquí? 00:30:16
él dice, intenta hacer esta 00:30:20
cosa 00:30:22
si por si acaso 00:30:23
aquí explota una excepción 00:30:25
se lanza una excepción 00:30:28
¿vale? se levanta una excepción 00:30:29
rise 00:30:31
pues entonces, si es 00:30:32
este tipo de excepción aquí 00:30:35
entra aquí dentro 00:30:37
ejecuta esta cosa aquí 00:30:39
ahora vamos a ver que ponemos 00:30:41
ahí, ¿vale? 00:30:43
tened en cuenta que aquí me da un error porque edad 00:30:44
la he generado aquí dentro y ahora estoy dentro 00:30:47
de este bloque y por lo tanto 00:30:49
no me funciona, ¿vale? podría 00:30:51
resolver esto o declarando 00:30:53
edad fuera o 00:30:55
metiendo esto dentro 00:30:57
si lo pongo aquí 00:30:58
ya está, todo dentro del block 00:31:01
que trae que he hecho 00:31:04
¿qué pasa ahora 00:31:05
si yo pongo 9? 00:31:08
porque tengo 9 años 00:31:11
¿qué pasa ahora si pongo gato? 00:31:12
porque me está diciendo 00:31:19
si explota algo 00:31:20
no hagas nada, ¿qué odia 00:31:22
más el usuario 00:31:29
Que le explote un programa 00:31:32
Que no haga nada 00:31:34
Que se quede allí y ni explote 00:31:37
Por lo tanto, no 00:31:39
¿Vale? 00:31:41
Pero no pasa nada 00:31:42
Y aquí dentro puedo hacer lo que me da la gana 00:31:43
Si hizo 00:31:44
Valor no válido 00:31:45
Pues ya está 00:31:48
Si tú le pones gato 00:31:50
Valor no válido 00:31:53
Pero ahora ya no explota 00:31:55
Ya está 00:31:57
El try catch 00:31:59
a proteger este bloque 00:32:00
para decir, tú inténtalo 00:32:02
si pasa algo 00:32:04
píllalo 00:32:06
¿cómo lo hacemos? 00:32:09
pues por ejemplo 00:32:20
bolean 00:32:21
repite 00:32:23
igual extrue 00:32:25
sin hacer 00:32:27
sin cosa 00:32:30
y ahora digo, vile 00:32:30
repite 00:32:35
si no repite, Dubai 00:32:38
Hacemos un 00:32:44
Esto lo ponemos a false 00:32:49
A ver, que ahora me lío 00:32:51
Esto es un 00:32:52
Esta cosa aquí 00:32:56
No, no, no, me estoy liando 00:33:00
Lo pongo fuera 00:33:09
Pongo el while aquí 00:33:10
Ahora sí 00:33:13
Y pongo un repite 00:33:14
A true 00:33:18
Me estoy liando, es un momento solo 00:33:19
Esto pasa a veces 00:33:21
esto lo ponga true 00:33:23
nada más entrar 00:33:25
lo acepto a false, ahora sí 00:33:28
aquí repite 00:33:30
y empiezo con este bloque aquí 00:33:31
¿vale? hasta aquí 00:33:34
entonces 00:33:38
en teoría todo este bloque 00:33:41
se repite una y otra vez 00:33:43
y otra vez y otra vez 00:33:46
mientras que repite sea true 00:33:47
pero yo lo ponga false 00:33:50
ahora, si yo entro aquí dentro 00:33:51
le digo, dime una tu edad 00:33:54
Y tú me das un valor que no me gusta 00:33:56
Entonces repite, se transformará en true 00:33:59
Cada vez que esto explotará porque me has dado un valor que no me gusta 00:34:11
Entonces al volver aquí 00:34:16
Entrará otra vez porque es true 00:34:18
Lo aceptará otra vez a false 00:34:23
Y lo intentará otra vez 00:34:25
Entonces se quedará dando ciclos aquí 00:34:26
Mientras que explote esta excepción 00:34:29
Si esta excepción no explota 00:34:33
no pasará por este repito igual a true y por lo tanto saldrá y seguirá adelante 00:34:36
después del while que sería aquí si so a ver si funciona 00:34:41
cedimetro de edad, bogato, cero en el examen, vamos a ver por qué 00:34:56
hay momentos de la vida en que la programación no es lo que deberías hacer 00:35:18
he cerrado esto antes, porque no relee, no vuelve a leer, donde lee, aquí lee, es como si hubiese leído 00:35:22
qué cosa rara, espera, entonces lo hemos solucionado 00:36:01
moviendo el escáner aquí dentro, antes estaba aquí fuera 00:36:06
y lo hemos pillado y lo hemos metido aquí dentro, sospecho porque 00:36:12
igualmente salta una excepción de algún tipo cuando cuando pasa por aquí pero no debería 00:36:18
ser una input mismas excepciones algo raro es algo raro es lo que pasa aquí pero ahora vamos 00:36:24
a explorar y luego lo decimos no sabemos exactamente por qué funcionaba así pero 00:36:31
poniendo el escáner dentro del try funciona pues probablemente se acuerda de las veces anteriores 00:36:37
que 00:36:43
sustancialmente 00:36:44
ha tenido un problema antes 00:36:47
y por lo tanto vuelve a lanzar el problema 00:36:49
hacemos otro ejemplo 00:36:51
siempre estas cosas 00:36:52
por ejemplo 00:36:55
os acordaréis vuestro amigo 00:36:56
el array 00:37:01
entonces me creo 00:37:03
un array de 10 posiciones 00:37:11
y ahora te digo 00:37:14
me escribes 00:37:15
la posición 00:37:17
O la posición 10, misma 00:37:23
¿Qué pasa? 00:37:25
Explota 00:37:30
¿Con qué explota? 00:37:31
Con una array index out of bounds exception 00:37:33
Pues, ¿cómo podría evitar esto? 00:37:35
Pues 00:37:38
Try, sí, también 00:37:39
Pero no siempre puedes 00:37:41
Ahora lo hacemos de otra forma 00:37:45
Vale, te dice programando bien 00:37:47
Entonces 00:37:49
Estos son 10 posiciones 00:37:51
Tú dices 00:37:52
escáner 00:37:56
escáner es igual a 00:37:58
newscanner 00:38:00
de system.in 00:38:01
si eso, dame una posición 00:38:03
tú dices 00:38:09
scan.nextSynth 00:38:14
y lo guardas 00:38:18
en una entera 00:38:21
en post 00:38:22
¿sí? 00:38:22
y ahora ¿qué hace de esa post? 00:38:24
¿sí? 00:38:29
entonces tú tienes esta cosa aquí 00:38:30
si yo le pongo 3 00:38:32
me dirá que dentro está 0 00:38:34
¿y está programado bien? 00:38:36
más o menos, no tiene errores 00:38:38
ahora si yo le doy 11 00:38:40
explota 00:38:42
entonces aquí 00:38:43
tenemos dos 00:38:45
posibilidades 00:38:47
la primera es 00:38:49
si pos mayor 00:38:51
que 0 00:38:54
mayor o igual que 0 00:38:55
pos menor 00:38:56
y dame que 10 00:38:59
o que R.lang 00:39:01
entonces 00:39:04
sí, R.com porque le he hecho 00:39:09
y si no 00:39:11
esto es lo que hacéis vosotros 00:39:15
deberíais hacer vosotros 00:39:22
sí 00:39:24
entonces esto funciona, sí 00:39:25
si yo le pongo 11, pues error 00:39:27
sí 00:39:29
ahora, ¿qué problema tiene esta cosa? 00:39:31
el problema de este tipo de programación 00:39:44
es que se llama programación 00:39:46
¿Cómo se llama? 00:39:48
Pesimista 00:39:53
En el sentido que estoy 00:39:54
Intentando comprobar 00:39:56
Que las cosas estén bien 00:39:59
Antes de hacerlas 00:40:00
Y se puede hacer, ningún problema 00:40:02
¿Vale? Bien hecho 00:40:03
Pero es pesimista porque tú te esperas 00:40:05
Que siempre las cosas irán mal 00:40:08
Ahora, el problema es que en informática 00:40:10
El 90% de las veces 00:40:12
Las cosas van bien 00:40:14
o el 99% de las veces 00:40:15
la gente que usará este array 00:40:19
lo usará bien, porque sabe que es 00:40:21
y luego 00:40:23
está un 1% que por alguna razón 00:40:25
pues lo ha hecho mal 00:40:27
y tú estás comprobando siempre 00:40:28
que esto funcione bien 00:40:31
hasta en los casos 00:40:32
en el que no haría falta porque todo iría bien 00:40:34
estás gastando recursos 00:40:37
si esto lo estoy haciendo un millón de veces 00:40:39
he hecho un millón de veces esta cosa aquí 00:40:40
a lo mejor no habría tenido que dar problema nunca 00:40:42
Entonces, una forma un poquito distinta de hacerlo 00:40:45
Es decir, tú hazlo 00:40:49
¿Me has dado la posición? Vale 00:41:00
Hazlo 00:41:03
Y en el caso 00:41:05
Arraindex 00:41:09
Out of bounds 00:41:15
Exception 00:41:19
Y en el caso en que explote una 00:41:21
error, pues entonces di error, o sea que esto es, tu intentalo y solo las veces que va mal 00:41:24
te encargarás de recuperar y hacer esta cosa aquí, entonces esta es optimista, estoy pensando 00:41:34
que las cosas funcionen y si van mal pues ya es el problema de alguien, esto funciona 00:41:41
prácticamente igual si yo pongo 9 funciona si yo pongo 11 explota no explota me dice error 00:41:48
si yo pongo gato flota porque esta excepción de aquí no la controla pero podría hacer esto y 00:42:01
entonces que le ponga 22 me da error que le ponga 00:42:22
claro sí porque está aquí más cifra fenomenal 00:42:49
ponemos aquí ahora sí y este tanto no es una es un wild 00:42:54
Claro, como esto estaba fuera del try, pues ya está, ¿vale? 00:43:01
Entonces ahora, ahora sí, ¿vale? 00:43:06
Pero cuidado, si yo uso esto, el problema que tengo es que estoy perdiendo granularidad. 00:43:10
O sea, no estoy sabiendo qué error ha habido. 00:43:18
Estoy diciendo, cualquier error, sea cual sea la causa, explota. 00:43:22
Pero, y a lo mejor, o sea, recógelo y hace esto. 00:43:27
Pero a lo mejor yo quiero hacer cosas distintas en excepciones distintas. 00:43:30
Por ejemplo, si te digo array index out of bounds exception, 00:43:36
entonces te digo no sabes usar los arrays. 00:43:44
Sin embargo, si el error que sale es un mismatch input era, mismatch format, mismatch input, exception, existe, lo hacemos explotar, a ver, que explote y a ver que pasa, se llama input mismatch. 00:43:51
entonces 00:44:24
si tengo un 00:44:26
input mismatch 00:44:28
exception 00:44:30
entonces 00:44:34
no sabes la 00:44:37
diferencia entre 00:44:40
números y letras 00:44:42
entonces ahora 00:44:45
dependiendo de lo que pasa aquí 00:44:48
si yo me equivoco 00:44:50
dando una posición equivocada 00:44:52
me dice que no se puede utilizar los arrays 00:44:54
si yo me equivoco porque no le doy un número 00:44:56
me dice la diferencia entre números 00:44:59
entonces, ahora yo puedo hacer 00:45:00
en base al error que ha salido 00:45:03
a los posibles errores que han salido 00:45:05
darle una respuesta a otra 00:45:07
estas excepciones 00:45:09
me las importa el 00:45:17
por ejemplo, esta me la reconoce directamente 00:45:20
pero esta otra la tengo que importar 00:45:23
entonces, esta cosa aquí 00:45:25
será más útil cuando empezaremos a utilizar 00:45:30
los ficheros 00:45:33
¿vale? porque en los ficheros cuando 00:45:35
yo intento leer de ficheros o escribir un fichero 00:45:37
al abrir el fichero 00:45:39
me puede salir una 00:45:40
file not found exception, me puede salir 00:45:42
una IO exception, me puede salir 00:45:45
una end of file exception 00:45:47
etcétera, etcétera y por lo tanto 00:45:49
tendré que mirar estas pequeñas 00:45:51
cosas, por ahora simplemente 00:45:53
que sepáis que exista una 00:45:55
posibilidad de ejecutar un código 00:45:57
y que si los errores que 00:45:59
estáis viendo, que habéis visto alguna vez, que son 00:46:01
pocos. ¿Cuál es otra excepción que hemos visto? 00:46:03
Null pointer exception. Entonces yo podría 00:46:09
en vez de preguntarme esto es null y luego utilizarlo 00:46:11
pues utilizarlo, pero poniéndolo dentro de un try catch 00:46:14
que si salta una null pointer exception pues 00:46:18
intente recuperarse. El objetivo 00:46:20
del catch es que 00:46:23
si es posible me recupere 00:46:26
del error. En vez de bloquearme y decir 00:46:29
mi programa no funciona, pues intente mandar 00:46:32
un mensaje al usuario 00:46:35
algo ha ido mal 00:46:36
ha pasado esto, has intentado hacer esto 00:46:38
te has equivocado en poner esta cosa 00:46:41
y en vez de decir, ya está, se ha acabado 00:46:43
pues volver a intentar hacerla 00:46:45
o acabar, pero acabar bien 00:46:47
porque no es 00:46:55
lo mismo acabar diciendo 00:46:57
los datos no son correctos 00:46:59
acabó el sistema 00:47:02
que pantallazo rojo de 00:47:03
error en el stack 00:47:05
en línea 24 00:47:07
el código si da una impresión distinta dudas 00:47:09
esto es un tema bastante más complejo que esto pero nosotros nos paramos aquí 00:47:15
simplemente puedo proteger un trozo de código poniendo un try y luego aquí 00:47:20
gestionar una posible solución al problema que sale 00:47:26
sí y nos quedaría ejemplos vale a este punto los ejemplos los dejamos a mañana 00:47:32
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:
11
Fecha:
11 de febrero de 2025 - 9:31
Visibilidad:
Clave
Centro:
IES ROSA CHACEL
Duración:
47′ 42″
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:
173.34 MBytes

Del mismo autor…

Ver más del mismo autor

EducaMadrid, Plataforma Educativa de la Comunidad de Madrid

Plataforma Educativa EducaMadrid