Saltar navegación

Set - 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 2026 por Stefano C.

2 visualizaciones

Más información Transcripción

Descargar la transcripción

Voy a grabar esta clase, por lo tanto, si habláis, me dais vuestro consentimiento para que grabe vuestra voz. 00:00:00
Vale, entonces, el último, digamos, tipo de, como diría, de estructura dinámica, ¿vale? 00:00:07
De almacenamiento de datos, que vamos a ver, son, por ahora, son los sets, ¿vale? 00:00:20
El set es un conjunto. En inglés quiere decir conjunto. Si pensáis vosotros como está dicho un conjunto, un conjunto es una forma para almacenar datos, pero no estamos en un cierto sentido trabajando con instancias que representan una copia de un determinado objeto. 00:00:25
Más bien, el concepto de ese objeto en general. Me explico. Por ejemplo, de libros. Tú tienes un libro de programación y tú puedes ver este libro desde una perspectiva de una tienda que tiene seis copias de ese libro. 00:00:50
y entonces tiene que vender las seis copias y cada copia es un objeto distinto o lo puedes 00:01:10
ver desde una perspectiva de una biblioteca que es si tengo seis copias pero sustancialmente tengo 00:01:16
ese libro vale en como si fuera un catálogo vale entonces existe ese libro luego de ese libro se 00:01:22
pueden hacer 50 mil copias pero a mí me interesa gestionar o de una editorial gestionar el concepto 00:01:31
de que existe ese libro. Entonces, si estuviéramos en el ejemplo de que yo tengo varias copias, 00:01:39
pues podría utilizar una list, porque añado cada copia en la lista y cada copia es distinta 00:01:49
hasta si es el mismo libro, hasta si el equals diría true, pues añadiría varios objetos 00:01:55
dentro de la lista. Sin embargo, si yo quiero considerarlo como un editorial, entonces una 00:02:01
vez que ha añadido este libro pues no quiero volver a añadirlo porque ya está este libro 00:02:08
pues entonces usaría un set vale la cosa fundamental del set de la diferencia con 00:02:12
respecto a la lista es que no puede contener elementos duplicados eso es lo que tengo que 00:02:19
tener en mente yo cuando me acerco a estoy haciendo el diseño de mi programa de mi sistema 00:02:25
y tengo que decidir, ¿qué hago? ¿Uso una lista o uso un set? 00:02:35
La decisión allí es, ¿quiero que los elementos que estoy guardando puedan ser duplicados o no? 00:02:39
Si quiero que no se puedan duplicar, pues entonces el set probablemente es donde quiero ir. 00:02:46
La otra cuestión que tengo que tener en cuenta es si quiero mantener un orden o no de inserción. 00:02:53
las listas mantienen el orden de inserción 00:02:59
como siempre añaden al final con la alt 00:03:03
pues el último añadido estará al fondo de la lista 00:03:05
sin embargo en el set no 00:03:08
el set guarda las cosas allí dentro 00:03:11
como mejor le viene 00:03:14
para que sea más eficiente 00:03:16
y más rápido luego en poder buscar 00:03:18
o poder sacar el elemento 00:03:23
entonces mientras en una lista 00:03:25
si yo pongo el elemento a elemento b elemento c cuando luego lo voy a leer la lista me encontraré 00:03:28
a b y c en un set no en un set pongo a b y c y puede ser que cuando vaya a leerlo cuando vaya 00:03:34
a iterar sobre él o con un iterator pues que existe porque set deriva de collection que 00:03:42
deriva de iterable por lo tanto aquí también puede hacer un iterator exactamente como antes 00:03:51
vale, pero en vez de ir en el orden de inserción, pues será en el orden que prefiere el mismo set. 00:03:56
Dudas hasta aquí. La interfaz contiene únicamente los métodos del dado de collection, 00:04:06
añadiendo restricciones que los elementos duplicados están prohibidos. Porque si yo me 00:04:12
voy a mirar collection tiene estos métodos de aquí, vale, estos son los métodos que todas 00:04:17
las colecciones tienen que tener pues me voy a mirar set son los mismos métodos pero se añade 00:04:25
si no está ya vale o sea cuando ya añado algo cuando intento insertar un nuevo elemento sólo 00:04:32
lo inserto si no está anteriormente si éste ya está presente ahora como sé si un objeto está 00:04:39
presente está presente si el concepto está si en la lista yo añado el elemento a vale perfecto añade 00:04:49
otra vez el elemento a pues se me añade ningún problema porque puede ser puede haber elementos 00:05:02
duplicados en el séptimo dicho que no como detectó si un elemento es duplicado como comparó con otro 00:05:07
Entonces allí yo tengo que tomar una decisión, tengo que definir cuál es el concepto de 00:05:17
igualdad entre dos de mis objetos. El concepto de igualdad más básico es el que da object y ya 00:05:31
implementa object. Object tiene el método equals y dentro está implementado como dos objetos son 00:05:40
iguales si son el mismo jefe. Yo tengo dos referencias. Estas dos referencias 00:05:45
apuntan a la misma instancia, pues son iguales. Si no, no. Esa es la forma más 00:05:51
básica de decir que dos objetos son iguales. 00:05:57
Pero no siempre es la que quiero yo. Por ejemplo, en el caso del libro, 00:06:02
que decíamos antes de la editorial, pues no es tanto la instancia que me interesa 00:06:06
cuanto las características del libro. Yo podría crearme un libro que sea programación de Java de 00:06:13
una cierta editorial y luego crear otro objeto que sea programación de Java de esa misma editorial y 00:06:20
me gustaría que cuando comparo estos dos objetos, no obstante sean objetos distintos, sean instancias 00:06:29
distintas porque los he creado en momentos distintos, pues la respuesta de estos son el 00:06:34
mismo libro fuera así. Tengo que definir cuando dos objetos que he creado yo son iguales. Para 00:06:39
eso tengo que implementar el método equals. En el método equals vosotros estáis definiendo cuando 00:06:48
dos de los objetos que habéis creado vosotros se consideran iguales y cuando no. Y esto implicará 00:06:54
directamente si se puede insertar en un set o no. Si yo he definido que dos gatos son iguales cuando 00:07:02
pesan igual, pues si pongo dos gatos completamente distintos, de color distinto, con el 00:07:13
mismo peso en el set, me dirá no lo puedo insertar porque ya existe este gato. Porque para mí los 00:07:20
gatos son solos". Entonces, ¿qué hago? Si eso no me vale, modificaré la definición de igualdad 00:07:27
entre gatos. Si me doy cuenta, es siempre el mismo discurso que hacíamos antes a nivel de diseño. 00:07:39
Cuando yo creo mi clase alumno, mi clase profesor, mi clase coche o lo que sea, pues tengo que pensar 00:07:46
a nivel de este programa cuando dos profesores son el mismo profesor, cuando dos alumnos son 00:07:54
el mismo alumno, cuando dos coaches son el mismo coach. Y lo defino yo. Soy yo el designer, 00:08:00
en vuestro caso es que haréis estos ejercicios, y vosotros que definís cuando dos objetos son iguales. 00:08:06
Normalmente una persona, cuando el DNI es el mismo. Uno puede decir cuándo son los nombres 00:08:11
y apellidos distintos, iguales, pero a lo mejor hay dos personas que se llaman exactamente iguales, 00:08:17
son dos personas distintas. Eso lo tenéis que definir vosotros, repito, siempre en el marco del problema. 00:08:23
Por ejemplo, en nuestra escuela, el ejemplo que hacemos de escuela, pues podríamos utilizar un set, ¿vale? 00:08:31
Porque los alumnos que entran en la escuela son únicos. Entonces no quiero que se repita el mismo alumno. 00:08:38
Una vez que está en la escuela ya está dentro. Solo que tengo que definir una forma para identificar 00:08:45
dos alumnos que son el mismo alumno 00:08:51
y dos alumnos que son alumnos 00:08:53
distintos, pero con el mismo nombre, apellido, etc. 00:08:55
Como por ejemplo con el NIA, 00:08:58
el número de identificación de alumno, o con el DNI, 00:08:59
o con lo que queramos. 00:09:02
¿Sí? Un conjunto 00:09:04
de estos. O sea, no es que necesariamente 00:09:06
tienes que pillar un atributo y valorarlo 00:09:07
sobre el atributo. Pueden ser un conjunto de 00:09:09
atributos que sean iguales. 00:09:11
¿Sí? 00:09:14
Dudas hasta aquí. ¿Qué más? 00:09:15
Es importante destacar 00:09:22
para comprobar si los elementos son elementos duplicados o no lo son, es necesario que dichos 00:09:23
elementos tengan implementada de forma correcta los métodos Equals y Aschcode, ¿vale? 00:09:29
Tened en cuenta que Equals y Aschcode los encontramos en Objects, Aschcode e Equals, 00:09:35
lo que quiere decir que cualquier objeto que vosotros creáis tiene Equals y tiene Aschcode. 00:09:54
Los tiene, ya, ¿vale? Pero de una forma muy básica, de una forma muy elemental, que muchas veces hay que modificar, ¿sí? 00:10:02
Para comprobar si los sets son iguales, se comprobarán si todos los elementos que los componen son iguales, sin importar el orden en que ocupan dichos elementos, ¿vale? 00:10:16
Mientras que una lista, a lo mejor, con los mismos elementos, pero en orden distinto, 00:10:25
podrías decir que son dos listas distintas, dos sets, cuando los compruebas, 00:10:30
compruebas que todos los elementos de uno compaían en el otro, aparezcan en el otro, ¿vale? 00:10:35
No tanto el orden. El orden en los sets no tiene que ver, ¿vale? 00:10:42
Algunos sets sí, pero no el orden de inserción. Eso es importante. 00:10:47
EqualsHashCode, ¿vale? Ambos métodos son importantes para cuando necesito buscar objetos en colecciones, ¿vale? 00:10:51
Sobre todo el método de EqualsHashCode en colecciones, el HashCode es muy útil en los mapas, ¿vale? 00:11:01
Pero nosotros también veremos el HashSet que sí que usa el HashCode, ¿vale? Ahora hablaremos de eso. 00:11:08
Cuando se realiza una implementación de estos métodos, pues tenemos que toquetear los dos. 00:11:17
es parecido a lo que decíamos de comparables. 00:11:23
¿Vale? Hay una relación entre ellos. 00:11:25
Si dos 00:11:28
objetos dan true cuando 00:11:29
lo pones como equals, o sea, si 00:11:31
son iguales, tienen 00:11:33
que dar el mismo Shcode. 00:11:35
No puedo hacer 00:11:38
que dos objetos 00:11:39
distintos, dos instancias distintas, me den 00:11:40
como resultado al equals 00:11:43
true y como Shcode un número 00:11:45
distinto. ¿Vale? 00:11:47
Esto tiene las mismas implicaciones 00:11:49
que hacíamos antes. O sea, 00:11:51
Si equals es true, entonces mismo hashcode. 00:11:53
Si tienen el mismo hashcode, no necesariamente implica que equals sea true. 00:12:03
Pero lo tengo que comprobar. 00:12:16
Cada vez que vosotros loqueteáis el equals, deberíais estar seguros que esta propiedad de aquí se cumpla. 00:12:17
Y no puede dar problemas, sobre todo si usáis cosas que usan el hashcode, o usan, por ejemplo, el hashset. 00:12:26
Yo entonces no lo entiendo realmente por qué. Para comprobar si los objetos son iguales, se comproba con el e-book o con el hashcode. 00:12:34
¿Y el hashcode realmente qué hace entonces? 00:12:45
Ahora llegamos a eso. 00:12:47
Ah, vale. 00:12:48
El hashcode sabéis que existe, sabéis que tiene esta propiedad, pero no hemos entendido exactamente qué es el hashcode. 00:12:49
Hemos hablado una vez, pero muy en paz, ahora voy a hablar de eso, ¿vale? 00:12:55
Entonces, ¿dónde estoy? 00:13:04
Esta es la interfaz set, ¿vale? 00:13:09
Dentro de set, directamente hay hset y linkedhset, que son dos implementaciones de set, ¿vale? 00:13:11
Hset es una implementación bastante buena, bastante rápida, ¿vale? 00:13:18
Y esta de aquí es la misma, pero creo que esta se basa por debajo con una array, 00:13:22
esta de aquí de por debajo con 00:13:26
cosas alincadas, cada vez que es linked 00:13:28
son objetos enlazados 00:13:30
y luego está de set otra 00:13:31
interfaz que es sorted set 00:13:33
o sea un set ordenado 00:13:36
del que nosotros veremos la implementación 00:13:38
del triset, vale 00:13:40
que este es el árbol, os acordáis que al principio vimos 00:13:41
conjuntos 00:13:44
está también, vimos 00:13:46
lista, cola, pila y 00:13:48
árbol, vale 00:13:52
esta sería la implementación de árbol 00:13:54
Ahora, antes de meternos aquí en el LashSet y ver las tres clases, 00:13:56
sostancialmente aquí acabamos porque luego empieza el mapa, 00:14:02
tenemos que entender qué es una FuncionAge. 00:14:06
La FuncionAge es una función que se usa bastante en informática para varias cosas. 00:14:12
Se utiliza para seguridad, se utiliza para almacenamiento, 00:14:20
para mejorar la velocidad del almacenamiento y cosas por el estilo. 00:14:24
¿Y qué es? Sustancialmente es una función que categoriza objetos en un número, finito de números. 00:14:27
Por ejemplo, imaginémonos que yo hago una función de x que me dice, pon 0 si x es par o 1. 00:14:41
Si x es impar 00:14:58
Este es un funcionar 00:15:01
Fea 00:15:05
Pero es un funcionar 00:15:07
Porque tú me das cualquier número 00:15:08
Y yo te lo puedo categorizar 00:15:10
En la categoría 0 00:15:13
O en la categoría 1 00:15:14
¿Sí? 00:15:16
Una funcionar para que sea buena 00:15:19
Tiene que tener pocas colisiones 00:15:21
¿Vale? 00:15:25
Unas colisiones son cuando 00:15:26
Dos objetos distintos 00:15:27
caen en la misma categoría. En este caso, pésimo. ¿Vale? Porque había colisiones constantemente. 00:15:30
Mitad de los números caerían en el 0, mitad de los números caerían en el 1. Por lo tanto, 00:15:41
hay pocas categorías y muchas colisiones. ¿Sí? Vamos a ver otro ejemplo de esta función. 00:15:46
Imaginaos una función que pilla un string 00:15:53
Y genera una serie de categorías en base a la primera letra de este string 00:16:00
Entonces si la letra es A, cae en la categoría A 00:16:11
Si la primera letra es B, C, D, hasta Z 00:16:16
más una que pondremos 00:16:23
como asterisco, que es 00:16:25
cualquier símbolo que no sea 00:16:27
una letra. 00:16:29
Entonces, si yo os pongo 00:16:30
hola, ¿dónde se categoriza 00:16:32
este señor aquí? 00:16:37
En la H. 00:16:39
¿Sí? Como la primera 00:16:41
letra es la H, me voy a la 00:16:43
categoría H y lo pongo aquí. 00:16:44
Aquí está hola. 00:16:47
¿Sí? Ahora pongo 00:16:51
¿cómo no? 00:16:53
Gato. 00:16:55
¿Dónde va gato? 00:16:57
Empieza por G, me iría a H, G, H, I, G, y aquí se pondría gato. 00:16:59
Tú vas añadiendo palabras y las pones aquí. Aquí pones árbol, aquí pones banana, carro, etcétera, etcétera. 00:17:06
Ahora, si os fijáis, con este sistema de aquí, si yo tengo, aquí tengo una, dos, tres, cuatro, cinco palabras ya metidas, ¿cuánto tardo en encontrar una de estas palabras? 00:17:26
Imaginamos que busco DAT. ¿Cuánto tardo en encontrar DAT? 00:17:39
Claro, o sea, muy rápido. Porque me quito de encima mirar todas las otras palabras. 00:17:47
Ahora, si esto fuera una lista, yo debería recorrer toda la lista a la búsqueda de gato. 00:17:54
Ahora, en vez de no lo hago, ahora digo, oye, gato, ¿por qué estás buscando gato? 00:18:00
Vale, empieza por G. 00:18:04
Espérate que me voy a la categoría G a ver si ahí está gato. 00:18:05
Entonces, me quito de encima todos los otros. 00:18:11
Lo que, mientras que no haya colisiones, la velocidad es constante. 00:18:14
Es una operación. 00:18:24
Cuanto mejor sea mi funcionage, cuanto mejor, cuanto más, técnicamente, dispersa es mi funcionage, ¿vale? 00:18:26
Cuanto menos colisiones haya, mejor va lo que se basa sobre una función. 00:18:38
Ahora, ¿qué pasa si quiero añadir gatito? 00:18:45
Es que ahora iría en G, pero G ya está ocupado. 00:18:51
Entonces, ¿qué hago? 00:19:01
Y aquí depende, ¿vale? 00:19:03
Algunas implementaciones lo que hacen es crear aquí una lista. 00:19:05
Entonces, de gato voy a gatito. 00:19:09
Y si lo traje, pues se pondrá aquí. 00:19:15
¿Qué pasa ahora? 00:19:20
Que si busco esta palabra de aquí, pues me quito de encima todas las demás, 00:19:21
que ya es una... estoy ganando bastante, 00:19:27
pero ahora cuando llego a la G no hay un solo elemento, hay una lista. 00:19:30
Entonces tengo que entrar en esa lista y buscar allí. 00:19:33
Entonces cuantas más colisiones haya 00:19:35
Peor 00:19:40
¿Entienden? 00:19:41
Otra opción 00:19:44
Yo tengo aquí mi hash 00:19:45
Con mis categorías 00:19:50
Si la función 00:19:51
De lo que está insertando me mandaría 00:19:57
Aquí, pues lo inserta aquí 00:19:59
Si otra vez la función 00:20:01
De lo que estoy buscando 00:20:03
Otra vez, que no sé qué es 00:20:04
Pues me manda al mismo sitio 00:20:06
Y esto está ocupado 00:20:09
pues me pongo a recorrer 00:20:10
por abajo 00:20:13
hasta encontrar una celda libre 00:20:14
y lo pongo allí 00:20:16
como siempre de la lista aquí el lateral 00:20:17
pues usará esta misma estructura 00:20:24
esta sería una tabla 00:20:26
para intentar insertar las cosas 00:20:29
si tengo una colisión 00:20:32
pues busco el primer hueco libre 00:20:34
por debajo 00:20:36
entonces cuando luego los buscaré 00:20:37
yo me voy al sitio donde 00:20:42
tengo que... debería estar, y si no está allí, voy buscándolo en las siguientes celdas hasta llegar 00:20:44
a haberlo mirado todo y no haberlo encontrado. Pero si está, lo encuentro más rápidamente. 00:20:54
¿Entiendes? Entonces, una función hash, ¿qué es? Es una función que mapea objetos en números. 00:21:01
y yo me voy aquí 00:21:10
la función 00:21:15
hashCode 00:21:19
¿vale? lo que te hace 00:21:20
es pillarte el objeto porque tú harás 00:21:23
this.hashCode o 00:21:25
gato 00:21:27
x es igual a new gato y luego harás 00:21:28
x.hashCode, estás haciendo 00:21:31
el hashCode de este x, de este objeto 00:21:33
¿vale? y el resultado es 00:21:35
un entero, te doy un 00:21:37
objeto, haz algo con él 00:21:39
y dame un entero. 00:21:41
Ese entero será 00:21:44
el hash code, 00:21:46
el código hash, que representa 00:21:48
ese objeto. Teniendo en cuenta que 00:21:50
las categorías son finitas 00:21:52
y los objetos son infinitos. 00:21:53
Entonces, colisiones siempre habrá. 00:21:57
Cuanto más 00:22:01
mi función hash 00:22:03
sea buena y evite 00:22:06
esta cosa y sea dispersa, 00:22:08
mejor todo lo que se basa 00:22:10
sobre hash, todo lo que tiene hash 00:22:12
en el nombre, como los hash set 00:22:14
como los hash map 00:22:16
funcionará mejor, si mi 00:22:17
función hash es 00:22:20
pésima, pues también 00:22:22
lo que 00:22:24
voy a usar en el hash 00:22:26
por ejemplo, una función hash code 00:22:27
sería return 1 00:22:30
perfecto 00:22:32
todos van en la misma 00:22:34
categoría, por lo tanto será lenta 00:22:36
Ahora, hacer una función 00:22:38
hash buena 00:22:43
es complejo 00:22:45
Se requiere 00:22:47
conocimientos matemáticos, se requiere 00:22:48
capacidad de pensar 00:22:50
de cosas que 00:22:53
yo una función hash 00:22:55
buena no la sabría 00:22:57
¿Vale? 00:22:59
Necesitaría estudiarme 00:23:00
algunas cosas que son años que no estudio 00:23:02
¿Sí? 00:23:05
entonces nosotros 00:23:06
asumiendo que sabemos que existe 00:23:09
y que está aquí 00:23:11
pues lo que haremos es nos fiaremos 00:23:12
de nuestro mejor amigo 00:23:15
el señor Eclipse 00:23:16
¿vale? 00:23:19
y cuando vosotros tenéis un objeto 00:23:20
por ejemplo, yo tenía gato 00:23:23
pues yo le puedo decir 00:23:25
oye, me haces por favor 00:23:27
el hashcode de gato 00:23:29
y aquí surge 00:23:30
aquí me dice 00:23:33
genera asco del iguales y cuando él me lo crea me dice sobre qué quieres bajar el igual cuando 00:23:35
los gatos son iguales yo podría decir cuando tienen el mismo nombre o cuando tienen el mismo 00:23:43
peso o cuando tienen el mismo nombre y el mismo peso le doy a generate y él me crea por un lado 00:23:50
el igual basado sobre lo que le da yo lo hemos analizado la última vez no aquí primero comprueba 00:23:57
si estos son el mismo objeto entonces me da true 00:24:04
si el objeto 00:24:06
que le he pasado es null pues me dará 00:24:08
false, si no son 00:24:10
de la misma clase pues me dará false 00:24:12
y si no 00:24:14
hago un downcasting a gato 00:24:15
y compruebo nombre 00:24:17
con nombre y peso con peso 00:24:20
¿si? esto es el equal 00:24:22
pero al mismo tiempo 00:24:25
me ha dado esto 00:24:27
que es sustancialmente 00:24:29
beta la clase objects 00:24:33
que es una clase 00:24:35
de ayuda, ¿vale? Como 00:24:36
arrays para clase 00:24:39
de utilizar para los arrays, 00:24:41
como 00:24:43
aquí también 00:24:44
usaba float, por ejemplo, como clase 00:24:47
de la float. Pues, esto aquí son 00:24:49
cosas para los objetos. 00:24:51
Y te dice, me creas una función 00:24:53
hash basado 00:24:55
sobre el nombre y el peso. 00:24:57
Así 00:25:00
como tal y como me ha dado, 00:25:01
ya me asegura 00:25:04
que esta propiedad 00:25:05
de aquí 00:25:07
ha borrado. Que la propiedad 00:25:08
de que si el equal 00:25:11
se extruye, entonces en las cosas es lo mismo, 00:25:13
se cumple. Esto se encarga de él. 00:25:15
Si vosotros lo hacéis así y no lo 00:25:17
tocáis, pues esto ya se cumple. 00:25:19
Si vosotros 00:25:21
tenéis que hacerlo vosotros 00:25:22
a mano, no se os permite hacerlo 00:25:25
así, pues entonces 00:25:27
tendréis que tener cuidado vosotros. 00:25:29
¿Vale? Y buscar una 00:25:31
funcionar aceptado. ¿Dudas? Si, claro, también te muestra cómo está implementado el hash, está llegando a un object. 00:25:33
Si tú quieres saberlo, te vas a la clase Objects, te vas a hash y lees lo que está 00:25:45
escrito ahí. Es que aquí es cuando la informática se da la mano a la 00:25:52
matemática y salen cosas raras. Por eso muchas veces la gente que 00:26:00
estudia matemática, luego 00:26:07
se va a trabajar en informática. 00:26:09
Porque 00:26:12
nosotros se hablamos 00:26:12
de programación, ¿vale? Muy bien. 00:26:15
Pero cuando luego se va en algoritmica, 00:26:17
cuando luego se tiene que hacer los derivados eficientes, 00:26:20
cuando se tiene que hacer, pues por debajo 00:26:22
está siempre un sustrato de 00:26:23
matemática. 00:26:25
Y si no sabes la matemática 00:26:28
a alto nivel, pues allí 00:26:29
no haces nada. Allí te fías 00:26:31
de los que lo han hecho y dices 00:26:33
¡Hala! 00:26:36
Luego, en la otra versión, como siempre, esta es una forma de hacer las cosas genéricas, 00:26:37
entonces será buena, pero nunca tan buena como si tú te haces ad hoc para tu programa, 00:26:45
para tu sistema, la funciona correcta. Entonces, si tú entiendes, si tú tienes un equipo de 00:26:55
informáticos y matemáticos que trabajan juntos y que entienden del tema y que te sacan una 00:27:00
funcional que para tu sistema es más eficiente que la que te da llamar mejor en un 95 por 00:27:07
ciento de los casos no necesitas ese nivel de eficiencia pero y java o 00:27:16
Objetes. 00:27:27
A ver. 00:27:32
An objects esta 00:27:36
hash. Vale. 00:27:38
Generate an hash code for a sequence of input 00:27:40
values. 00:27:42
Generate an hash code for a sequence 00:27:45
of input values. The hash code is generated 00:27:47
as if all the input values 00:27:48
were placed into an array 00:27:51
and that array were 00:27:52
hashed by calling arrays.hashcode. 00:27:54
This method 00:28:00
is useful for implementing object.hashcode. 00:28:00
Vale, o sea que esto, tú le pasas una serie de valores, él te hace un Array con esos valores y una vez que haces estos Arrays se llama Arrays.score y que hace Array.code. 00:28:03
Array.code, el retorno de Arrays.code basado en los contextos de específicos Arrays. 00:28:14
Si el Array contiene otros elementos de Arrays, el Arrays.code está basado en las entidades y los contextos. 00:28:19
Pues me pierdo, ¿vale? Pues basados probablemente sobre la zona de memoria que tiene o cosas por el 00:28:28
estilo, ¿vale? También, por ejemplo, si tú te vas a string, pues string tendrá su forma de hacer su 00:28:39
hashcode, basado sobre los caracteres que tiene, cosas así. Cada clase tiene su forma. Entonces, 00:28:45
luego, lo que solemos hacer nosotros es basarnos sobre esas implementaciones para hacer nuestro 00:28:51
Yo tengo nombre que es un string, apellido que es un string, pillo nombre y apellido, 00:28:56
llamo el hashcode de estos dos, lo sumo y ese es el mismo. Como para string funciona, 00:29:01
pues funciona para mí también. Aún así, es demasiado alto nivel para nosotros de matemática 00:29:07
de meternos a entrar en cómo hacer una función hash, cómo implementarla bien y cosas así. A mí 00:29:21
lo que me interesa es que te entendáis este mecanismo de aquí, que es cómo funciona un 00:29:29
HashSet. El HashSet tiene esta función Hash, tú le dices inserta este elemento, él pilla este elemento, 00:29:35
lo va a llamar el HashCode de este elemento, recibe un número y este número es una categoría y él va 00:29:43
a meterte ese objeto en esa categoría. Si varios objetos coinciden en el mismo número, los pondrá 00:29:51
uno al lado del otro en una sorta de lista. Pero teniendo en cuenta que el hashCode es el 00:29:59
numerito que viene después del arroba. Cuando nosotros hacemos el toString de object y sale 00:30:06
la clase arroba y un numerito raro, pues ese es el hashCode. Entonces es un número bastante grande, 00:30:12
en hexadecimal puede haber muchos valores. Entonces la idea es que los objetos, a menos 00:30:20
que no sean millas o millones de objetos, pues sean bastante dispersos. Entonces, funciona bien. 00:30:26
¿Dudas? Bueno, entonces, nosotros tenemos H-Code. ¿Cuáles son las implementaciones de set? 00:30:33
La primera implementación es H-Set. Es la implementación de una tabla H, de esta cosa 00:30:43
aquí parecida. Una cosa así. Ahora no sé exactamente si luego los pone así o si luego 00:30:49
los pone así. Pero el concepto es esto. Tengo una serie de categorías, las pongo allí y allí dentro 00:30:55
asocio el valor. No permite tener elementos duplicados. Si voy a poner el mismo 00:31:01
objeto, él se irá a la categoría, pide el hashcode, va a la categoría, mira allí y ve que ya está 00:31:09
un objeto, hace un equals entre ellos, le da que es el mismo, te dice no lo añado. Ya está. 00:31:15
es la implementación con mejor rendimiento 00:31:21
de todas, pero no garantiza 00:31:25
ningún orden a la hora de realizar iteraciones 00:31:27
¿vale? o sea, esta de aquí 00:31:29
si a ti no te interesa el orden 00:31:32
de entrega, el orden de inserción 00:31:34
no te interesa el orden con el que 00:31:35
están metidos 00:31:38
dentro los objetos, no quieres 00:31:40
ordenarlo de ninguna forma 00:31:41
pues Hset es el que te da 00:31:43
mejor resultado 00:31:46
a nivel de rendimiento 00:31:48
es el más rápido 00:31:49
de todas las que hemos visto hasta ahora 00:31:52
es más rápido, está claro que si yo digo 00:31:53
no, pero yo quiero duplicar 00:31:56
objetos, quiero que los objetos puedan ser duplicados 00:31:58
pues ya la set no lo puedes usar 00:32:00
no, pero yo quiero mantener 00:32:01
un cierto orden, que sea un orden creciente 00:32:04
de los objetos, pues ya la set no lo puedes usar 00:32:06
la set, justo 00:32:08
porque hace esta cosa aquí 00:32:10
a lo mejor tú le das un objeto y te lo categoriza 00:32:11
en el número 37, lo pone en la posición 00:32:16
37, luego das otro objeto, lo categoriza 00:32:17
en el 3, pues te lo pone en el 3. 00:32:19
Luego otro objeto en el 94, 00:32:21
en el 94. No hay un orden. 00:32:23
Depende de su hash code 00:32:26
que el número da. ¿Se entiende? 00:32:27
Es la implementación más 00:32:34
empleada debido a su rendimiento, y a que 00:32:35
generalmente no nos importa 00:32:37
el orden que ocupen los elementos. 00:32:39
Yo tengo alumnos. No me 00:32:41
importa dónde se pongan los alumnos 00:32:43
siempre y cuando luego buscar 00:32:45
estos alumnos es rápido. 00:32:47
Entonces si me hago un hash set 00:32:50
de alumnos, eso que digo. 00:32:51
No puedo poner dos alumnos iguales, por lo tanto se queda la unicidad del alumno y cuando los vayan a buscar es el que con mejor rendimiento funcione. 00:32:53
Ahora, si dijera, me das por favor esta misma, o sea, una lista de alumnos por fecha de matriculación. 00:33:05
eso puede ser un infierno 00:33:17
con el hash set 00:33:19
porque no está allí dentro 00:33:22
o sea, debería ir 00:33:24
en cada 00:33:25
elemento y ordenarlo yo 00:33:27
esta implementación proporciona tiempos 00:33:30
constantes en las operaciones básicas 00:33:36
o sea, entrada y 00:33:38
añadir y clicar 00:33:39
siempre y cuando la función hash disperse 00:33:41
de forma correcta los elementos 00:33:44
dentro de la tabla h. Mientras que tú hagas una función h buena, los tiempos de insertar y quitar 00:33:46
son constantes, que es lo mejor que puede hacer. No depende del número de elementos que has insertado. 00:33:57
Si el tiempo fuera sobre n, si tú añades 100 elementos, pues el tiempo sería 100, n. Y cuando 00:34:06
vas a buscarte en este elemento pensado a una lista vale en el caso peor de la lista que yo 00:34:17
tengo que buscar un elemento pues debería recorrerme toda la lista encontrarlo el último 00:34:22
entonces tengo 100 elementos tardaré 100 operaciones si tengo mil elementos tardaré 00:34:27
mil operaciones en el caso peor este de aquí te da un tiempo de uno tú tienes mil elementos y esto 00:34:33
encuentras la primera. Le das 10.000 elementos y él te la encuentra la primera. Si mi funcionage 00:34:43
dispersa bien, pues con n elementos tú tardas siempre una operación. Mientras que al otro con 00:34:49
n elementos tardabas n operaciones. ¿Entiendes? O sea que esto debería ser la elección de default. 00:34:59
Ahora, si algo del HashSet no me vale, por ejemplo quiero duplicados o por ejemplo quiero un orden, 00:35:11
pues entonces ya no quiero utilizar el HashSet y busco otra cosa. Entonces, preset. Esta 00:35:21
implementación almacena los elementos ordenándolos en función de sus valores. Es bastante más lento 00:35:33
que HashSet en el proceso de inserción. El tiempo de acceso y recuperación es bastante rápido, 00:35:38
porque una vez que la ha ordenado 00:35:44
según la ordenación 00:35:46
que tiene que ordenarlo, pues luego 00:35:48
como hay un orden, cuando tú buscas 00:35:50
algo, pues él sabe más o menos dónde encontrarlo. 00:35:52
¿Vale? Porque buscar en una 00:35:55
cosa ordenada es más fácil 00:35:56
que buscar al azar. 00:35:58
¿Sí? 00:36:00
Los elementos 00:36:04
almacenados deben implementar la interfaz 00:36:05
comparable. ¿Vale? 00:36:07
Y esta implementación garantiza 00:36:09
siempre un rendimiento de 00:36:11
logDn. ¿Vale? 00:36:12
en las operaciones básicas, debido a la estructura de árboles 00:36:14
empleada para almacenar los elementos. 00:36:17
Logaritmo de N es bueno. 00:36:21
Si yo tengo 1000, tardo logaritmo 00:36:23
de 1000 operaciones, que suele ser 00:36:26
un número más bajo. 00:36:30
Es una... 00:36:34
Digamos que el rendimiento 00:36:38
logarítmico es bueno. En el orden 00:36:40
constante es el mejor. Logarítmico es bastante 00:36:43
bueno. Orden de n está bastante bien. Orden de n al cuadrado empieza a ser complejo. Es 00:36:46
cuando nosotros hacemos un for dentro de un for. Por cada elemento busco todos los otros 00:36:54
elementos. Primero elemento busco todo. Segundo elemento busco todo. Tercer elemento busco 00:37:00
todo. Pues esto es n al cuadrado. Si tengo 100 elementos, tardo 100% operaciones. Si 00:37:04
Tengo mil elementos, tardo mil por mil operación. 00:37:12
Y luego, lo peor que todo, es exponencial. 00:37:17
Donde la n está al exponente. 00:37:20
Operaciones o algoritmos que son del orden de la n exponencial, pues son de libre. 00:37:24
Dos a la n, pues libre. 00:37:32
Porque cuando tú tienes cien elementos, tardas dos a la cien operaciones. 00:37:33
Dos a la cien es un número de libre. 00:37:41
entonces el preset es el que está aquí abajo es este vale es el que me implementa el árbol 00:37:42
vale entonces cuando yo tengo un nodo en el nodo pongo un objeto ese es el nodo raíz cuando añado 00:38:05
un otro objeto lo comparo con este objeto si es menor lo pongo a la izquierda por ejemplo si es 00:38:13
es mayor lo pongo a la derecha inserto otro pues si es menor lo inserta aquí si es mayor bajo aquí 00:38:20
y miro esto si es menor que esto a la izquierda si es menor que esto a la derecha y voy construyendo 00:38:27
un árbol así entonces una vez que construir un árbol así siempre y cuando tú números desordenados 00:38:32
porque si me los das ya ordenados sale feo el árbol vale pues si tú me lo das al azar está 00:38:37
metiendo alumnos se les pones así pues al final el árbol se balancea más o menos entonces llegar 00:38:43
a la raíz del árbol, llegar al fondo del árbol, pues tardo logaritmo de n. O sea, tardo los niveles 00:38:49
del árbol. Cada vez que elijo una rama u otra, pues me estoy quitando de buscar en toda la rama 00:38:57
más cruda, ¿entiendes? Como un ejemplo. Como un ejemplo con números. Dame números de 1 a 100. 00:39:03
77, lo pongo aquí. Otro. 41, es menor, lo pongo aquí. Otro. 77, menor, 41, menor, aquí. 35, 00:39:15
Menor que 77, menor que 35, mayor que 2 00:39:36
Aquí, 80, mayor que esto 00:39:40
Aquí, 10 00:39:45
Es menor que esto, es menor que esto, es mayor que esto, es menor que esto 00:39:52
Iría aquí, digamos 78 00:39:58
Pues menor que esto, menor que esto, 78 00:40:07
95, pues mayor que esto, mayor que esto, 95 00:40:09
78 no era mayor que 75 00:40:14
78 es mayor que 77 00:40:19
78 es mayor que 77 00:40:26
Entonces, lo que estoy poniendo es este de aquí 00:40:30
¿Cómo? 00:40:33
Menos a la izquierda 00:40:35
Menos a la izquierda, mayor es a la derecha 00:40:37
Por lo tanto, 77 está aquí 00:40:39
Está allí, porque lo metí allí 00:40:41
Esta es 78, lo que hago es moverla aquí. 00:40:42
Entonces está el 80, es menor, 78. 00:40:46
Otro número, 49, 77, va aquí, 41, aquí, 49. 00:40:50
Luego están técnicas para rebalancear el árbol. 00:40:59
Si veo que este aquí está yendo demasiado abajo, 00:41:05
lo que puede hacer es pillar el 41 00:41:08
y transformarlo, tirarlo arriba 00:41:11
es decir, ahora el 41 00:41:13
es el 00:41:14
padre y 00:41:15
el 77 se vuelve su hijo derecho 00:41:18
y todos los demás, para evitar que una 00:41:20
rama se quede demasiado profunda 00:41:22
y que siempre sea el logaritmo 00:41:24
esto que es matemática 00:41:26
teoría de grafos 00:41:27
teoría de árboles, y cosas por el estilo 00:41:30
hay algoritmos 00:41:33
que te pillan un árbol 00:41:34
no balanceado 00:41:36
y te lo transforman en un árbol 00:41:38
equivalente pero balanceado 00:41:40
con un mínimo paso 00:41:42
con un mínimo trabajo 00:41:44
entonces cuando el triset 00:41:46
de vez en cuando se re-gestiona 00:41:48
el dedo para que sustancialmente 00:41:50
la profundidad sea baja 00:41:52
ahora, ¿cuántos elementos he puesto? 00:41:54
1, 2, 3, 4 00:41:57
5, 6, 7, 8 y 9 00:41:58
¿vale? 00:42:00
entonces en una lista 00:42:02
debería hacer 9 00:42:03
búsquedas para 00:42:05
encontrar en el caso peor 00:42:07
lo que yo quiero. Si lo que yo quiero está 00:42:09
al final, haría 9 operaciones. 00:42:11
Ahora el caso peor 00:42:14
es 1, 2, 3, 4 y 5. 00:42:15
O sea, el caso peor ahora 00:42:20
es buscar 10. 00:42:21
¿Sí? Pero aún así 00:42:23
son muchas menos operaciones, 00:42:25
casi la mitad, que la que haría en una 00:42:27
lista. En el caso peor. 00:42:29
¿Sí? 00:42:30
¿Y el 77 se le hará 00:42:34
a raíz del árbol? En este caso 00:42:36
sí porque la hemos metido al primer está claro que si yo uso un tricet y los doy ordenados y 00:42:38
pongo el 1 y luego el 2 está aquí el 3 está aquí el 4 está aquí el 5 está aquí donde se me está 00:42:47
saliendo la lista pero a este punto están estos sistemas que te digo que a un cierto momento como 00:42:56
esto es muy balanceado, lo que hace es 00:43:02
resetear, se pilla el 3, 00:43:04
lo mete aquí, aquí pone el 2 00:43:06
y el 1, y aquí pone el 4 00:43:08
y el 5. Y ya 00:43:10
esto funciona mejor que la lista. 00:43:12
¿En qué? En buscar. 00:43:17
Posiblemente en insertar 00:43:22
no, depende de cómo está hecho la lista. 00:43:23
Pero una vez insertado 00:43:27
como en orden, buscar es más 00:43:29
la lista es 00:43:31
orden de n operaciones 00:43:32
mientras que el árbol 00:43:35
es orden de logaritmo de n 00:43:37
esto es mucho mejor 00:43:39
que esto, porque esto en el caso 00:43:46
pésimo, tienes que 00:43:48
solo llegar a la profundidad del árbol 00:43:49
y si tú lo rebalanceas con estas técnicas 00:43:51
que hace, pues el árbol nunca 00:43:54
será tan profundo 00:43:56
como el número n 00:43:58
será profundo como logaritmo de n 00:43:59
pero estas son 00:44:02
todas las cosas matemáticas que si nos interesa 00:44:06
en la facultad 00:44:08
uno de los primeros 00:44:10
materias que estudiáis es 00:44:12
calculabilidad y complejidad. 00:44:14
¿Vale? Que os enseñan 00:44:17
a estimar la complejidad 00:44:18
de lo que hacéis. 00:44:20
Os enseño sustancialmente a no pongáis un for 00:44:22
dentro de un for, dentro de un for. 00:44:24
Y eso es muy interesante, muy... 00:44:30
Me gustó mucho. 00:44:32
Pero no es la cosa más sencilla. 00:44:34
¡Y ya está! 00:44:39
¿Vale? 00:44:41
Este es el 3-set. 00:44:41
Este de aquí. 00:44:44
Luego estaría la link 00:44:45
pero me interesa poco. Extiende Hset y contiene valores únicos, está implementada 00:44:47
en función del orden de inserción. Aquí mantiene el orden de inserción. 00:44:54
Permite elementos nulos. Es simplemente un poco más costosa que Hset. 00:45:00
Luego estarían los maps, que no extienden collection y son otra cosa. 00:45:08
cosas, son interfaz aparte, donde está el lashtable, lashmap, el trimap, pero nosotros 00:45:14
por ahora los aparcamos y llegamos a esto. Esto es mi esquema de qué uso y empiezo aquí 00:45:22
y digo lo que voy a guardar es valores, estoy guardando alumnos, estoy guardando gatos o 00:45:34
pares, es decir, una clave y un valor añadido. 00:45:44
Por ejemplo, yo quiero almacenar los DNI y que cada DNI se relacione con un alumno. 00:45:49
Estos son los map. 00:45:57
Por lo tanto, nosotros el lado izquierdo no lo miramos. 00:45:58
Estos serían los map. 00:46:02
Nosotros solo trabajamos con valores. 00:46:04
Vale, me voy aquí. 00:46:06
¿Contiene duplicados o no? 00:46:07
¿Puede tener complicado o no? 00:46:09
Si sí puede tener complicado, voy al revista. 00:46:11
Si no contiene duplicado, me voy aquí y me pregunto, ¿su tarea principal es buscar elementos? 00:46:14
Si no es buscar elementos, me voy a la lista igual. 00:46:24
Si es buscar elementos, me voy aquí y me pregunto, ¿es importante mantener un orden? 00:46:29
Si no es importante mantener un orden, me voy a ShSet y uso ShSet. 00:46:35
Si es importante mantener un orden, me voy aquí y digo, es el orden de inserción, o sea, quiero mantener el orden con que he insertado los valores, o un orden propio del elemento. 00:46:39
Si es de inserción, me voy al link de DashMap, a HSEP. 00:46:51
Si es de ordenación, que defino yo, me voy al TRISEP. 00:46:54
¿Sí? ¿Nuda? Más o menos. 00:47:05
Vale, en un 90% de las veces lo que vais a usar es o ARLIST o HSEP. 00:47:15
¿Criset también? Sí, 90% a relistarse. 00:47:22
Yo la linked list la usas si quieres algo específico como una stack, una fifo, lifo y cosas por el estilo, entonces sí. 00:47:29
Luego, se queda lo que os dije al principio. Si vuestro objetivo es recuperar datos, mejor una relista que una linked list. 00:47:44
Si vuestro objetivo es insertar y quitar mucho, mejor una linked list que una relista. 00:47:56
Pero normalmente, tú te creas un conjunto de datos y luego trabajas sobre esos datos. 00:48:02
Entonces, la re-lista es más utilizada que la re-lista. 00:48:08
Es más probable que un programa se cargue los datos y luego lo uses a que esté constantemente quitando, metiendo, quitando, quitando. 00:48:12
Es un caso de uso más común. 00:48:19
¿Sí? 00:48:23
Luego, esto no es definitivo. 00:48:24
Es decir, es un poquito para orientaros. 00:48:28
Pero no pilláis esto como, no, yo no voy a utilizar el LinkedIn List Map porque mi profesor me puso una vez una transparencia de PowerPoint. 00:48:31
el point que decía que no se usa, pues no, ¿vale? ¿Dudas? 00:48:38
O sea, es la tríceps o linker facet. ¿Cómo? 00:48:45
Que nos hemos creado como contenido tríceps o linker facet. 00:48:52
Linker facet que es igual a una facet solo que mantiene el orden de inserción, ¿vale? 00:48:58
Hasta ahí. Hasta ahí. Hasta la transparencia 29 es donde hemos visto. 00:49:06
a partir de la interfaz MAP, no. 00:49:11
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:
2
Fecha:
11 de febrero de 2026 - 12:44
Visibilidad:
Clave
Centro:
IES ROSA CHACEL
Duración:
49′ 16″
Relación de aspecto:
1.78:1
Resolución:
1920x1080 píxeles
Tamaño:
413.42 MBytes

Del mismo autor…

Ver más del mismo autor

EducaMadrid, Plataforma Educativa de la Comunidad de Madrid

Plataforma Educativa EducaMadrid