Saltar navegación

Ejemplo Map: frecuencia palabras - 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 6 de marzo de 2026 por Stefano C.

1 visualizaciones

Más información Transcripción

Descargar la transcripción

Vale, entonces, vamos a grabar, por tanto si habláis me autorizáis a grabar vuestra voz, ¿vale? 00:00:00
Entonces vamos a hacer un ejercicio que se basa sobre, o sea, que hace un contador de frecuencia de palabras, ¿vale? 00:00:08
Entonces vamos a crear, no, aquí en map, vamos utilizando un map, entonces creamos un nuevo package, contador, 00:00:14
Palabras. Y aquí dentro ponemos nuestro... 00:00:23
Entonces ponemos, no sé, contador, frecuencia, qué sé yo. Contador, frecuencia. Palabras. 00:00:43
Supongo que hacemos directamente un main aquí, ¿no? 00:00:57
Sí, sí. 00:00:59
Porque tampoco... 00:01:00
Bueno, entonces tenemos este main. 00:01:03
Aquí nos dice que vamos a utilizar un hashMap de stringInteger, ¿vale? 00:01:05
No podemos usar un stringInt porque... 00:01:09
Hola, buenos días. 00:01:18
¿Eh? 00:01:21
Porque no es un objeto. 00:01:22
Entonces usamos integer porque... 00:01:24
Porque es exactamente lo que se llama una clase wrap, ¿eh? 00:01:33
Es una clase que engloba, envuelve el tipo primitivo y lo transforma en un objeto. 00:01:37
Además Java es suficientemente listo para que estos intercambios lo hace en automático, digamos así. 00:01:51
Entonces donde puedo poner un integer, puedo poner un integer, donde puedo poner un integer, puedo poner un integer. 00:01:58
Y él asume, hace la conversión automática entre uno y otro. 00:02:02
¿Vale? Entonces esta de aquí será frecuencia, es igual a new ashmap de string integer para acá, ¿vale? 00:02:05
Entonces vamos a usar un ashmap, podemos usar un map a la izquierda, da igual, y ¿qué vamos a hacer? 00:02:25
Vamos a tener una frase, ¿vale? 00:02:33
Vamos a hacer lo siguiente, si os parece bien. 00:02:38
¿Dónde queremos poner nuestras palabras? 00:02:44
¿En un list, en un array, en un set, en un qué? 00:02:50
En un array. 00:02:54
¿Un array? Never, una lista. 00:02:56
Array ya ha pasado, vamos a una lista. 00:02:59
List, string, palabras, o frase, o frase, es igual a new ArrayList de string, ¿vale? 00:03:01
Y vamos a hacer una cosa un poquito distinta, que es la siguiente. 00:03:17
Frase es igual a 00:03:24
frase split 00:03:31
de... 00:03:34
¿Eh? 00:03:37
No, esto no existe. 00:03:43
Esto es un método mío. 00:03:48
Si quisieras usar los splits sobre una string, pues sí. 00:03:50
Pero no estoy usando eso. Estoy creando un método mío. 00:03:55
sustancialmente lo que quiero hacer es lo siguiente 00:03:59
yo creo una lista 00:04:03
de palabras, que será mi frase 00:04:24
de cómo la hago con este método 00:04:27
¿qué hace este método? pues ahora mismo 00:04:30
nada, me pone cinco palabras que yo conozco 00:04:35
y que funcionen, cuando más adelante ya me funcione el programa 00:04:39
entonces me puedo poner aquí y decir 00:04:44
dame una frase 00:04:46
un poquito más 00:04:48
interesante y a partir de esta 00:04:50
frase interesante hago todo 00:04:52
lo que tengo que hacer para crear esta lista 00:04:54
o sea, sustancialmente 00:04:57
me invento que esta parte ya se ha hecho 00:04:58
y la haré después 00:05:00
porque no es esta la parte interesante 00:05:02
esta parte de aquí son ejercicios 00:05:05
que ya hemos hecho al principio del curso 00:05:06
dame una frase y divídela en palabras 00:05:08
pues ya la hemos hecho 00:05:10
entonces esto lo sé hacer 00:05:12
No me limito ahora a hacer esa parte de allí, porque es la parte menos interesante. 00:05:13
El ejercicio es sobre ashmat, entonces ahora hago como que este de aquí me hace la magia 00:05:19
y ya cuando paso de aquí ya tengo lo que me han dado originalmente, el texto, el artículo 00:05:26
y cosas por el estilo, dividido en frases, en palabras que componen una frase, ¿sí? 00:05:31
Luego cómo se hace, pues después, ahora lo ignoro. 00:05:38
Aquí simplemente lo que hago es frase, punto add, y añado unas cuantas palabras, que son 00:05:42
... hola, hola, ¿sí?, entonces, es más, yo luego cuando haré esto, asumo que esta 00:05:57
cosa de aquí me pilla una frase, un artículo, un lo que sea, me lo divide en palabras y 00:06:31
quita los puntos de arriba y de abajo y me lo pone todo en minúscula. 00:06:40
¿Sí? 00:06:44
¿Cómo se hace? 00:06:45
No lo sé, no me interesa, lo hace esto. 00:06:46
Después lo haré. 00:06:51
Entonces, aquí me estoy haciendo un método mock, un método falso, que me da lo que me 00:06:52
tiene que dar. 00:06:57
¿Vale? 00:06:59
Sin puntos, sin cosas raras, solo la palabra y todo en minúscula. 00:07:00
¿Sí? 00:07:06
paso aquí, yo tengo que recordarme que, como se dice, divide la frase en palabras sin puntuación, 00:07:07
todo en minúsculas regulares. Entonces yo paso esta cosa aquí, ahora esta cosa aquí 00:07:24
no la está haciendo, me está creando una frase. Yo me espero que de esta cosa aquí 00:07:32
me debería decir que es sustancialmente gato aparece tres veces o la aparece dos veces y 00:07:39
luego perro una delfina una y no más esto es lo que yo me espero de esta cosa aquí actualmente 00:07:50
Si me dará este resultado mi programa, pues funciona. 00:08:05
Asumo que funcione. 00:08:10
Luego puedo probar con otros ejemplos aquí para ver que funcione con datos, digamos, controlados. 00:08:11
Y a ese punto ya paso a implementar bien este método de aquí. 00:08:21
Teniendo en cuenta que si yo lo trabajara así, pues este método lo podría dar a un grupo de trabajo y este método a otro. 00:08:26
¿Vale? Entonces estoy paralelizando el desarrollo de mi sistema 00:08:31
¿Vale? Let's go 00:08:35
Entonces, asumamos que esto ha hecho la magia 00:08:39
Ahora tengo una lista con todas las palabras que es necesaria 00:08:42
Tengo que empezar a trabajar con este aquí 00:08:45
Tengo que recorrer esta lista, pillar las palabras 00:08:48
Y por cada palabra preguntarme 00:08:52
¿Está aquí dentro? Si está aquí dentro 00:08:54
Voy a pillar cuál es el valor actual 00:08:57
Y sumarle uno 00:09:00
Si en vez de no estar aquí dentro, es una cosa nueva y la pongo en él. 00:09:02
Entonces, lo hacemos de versión easy, versión básica, versión fea. 00:09:07
Pero requiere el menor conocimiento posible para que funcione. 00:09:13
Luego después, a lo mejor vemos si la hacemos un poquito mejor. 00:09:19
Entonces, pillo la primera frase. 00:09:24
Entonces, perdón, por todas las palabras de la frase. 00:09:25
vale entonces iterator de string palabra es igual a frase punto no perdón es un iterator 00:09:29
frase punto iterator no quiere trabajar importe que es ya va útil vale entonces vile it punto 00:09:40
as next 00:10:18
que hago es pillar una palabra 00:10:19
string palabra es igual 00:10:24
a it.next 00:10:27
y en este punto voy a preguntarme 00:10:29
si esta palabra existe o no 00:10:33
how se llama 00:10:36
frecuencia 00:10:40
frecuencia.contains 00:10:42
key 00:10:46
palabra 00:10:48
los dos casos, ¿vale? 00:10:51
la palabra ya existe 00:10:56
la palabra no existe 00:10:57
este es el caso fácil 00:11:00
la palabra no existe, la he buscado entre las claves 00:11:02
y la palabra no está 00:11:05
por lo tanto, frecuencia 00:11:06
punto put 00:11:09
palabra 00:11:11
uno 00:11:12
m1 es un 00:11:14
íntegro, yo quiero un íntegro 00:11:17
¿vale? 00:11:19
new integer de 1. 00:11:20
Y ahora te dice, pero ¿qué estás haciendo? 00:11:24
El constructor integer de int es deprecado. 00:11:27
Pues no lo hay, está adentro. 00:11:30
¿Sí? 00:11:34
Ahora, aquí en vez quiere decir que ya existe. 00:11:35
Entonces, ¿qué hago? 00:11:39
Pues primero le digo int f es igual a frecuencia.getPalabra. 00:11:40
Con esto usa la clave palabra para encontrar su correspondiente valor, que es un integer. 00:11:54
Entonces me lo puede guardar un int. 00:12:03
Ya lo tengo. 00:12:05
Como ya existía, ya lo tengo. 00:12:06
Que ya se había visto tres veces, me habrá dado tres. 00:12:07
que ya se ha visto 57 veces, me ha dado 57. Hago f++, porque ahora se ha visto una vez más, 00:12:10
y lo vuelvo a poner. Frecuencia, punto put, palabra, f. Cuando yo pongo put sobre algo que ya existe, 00:12:18
me sobrescribe el valor anterior. Por lo tanto, en este caso, lo que hace es que si había aquí dentro 00:12:31
que la palabra gato eran tres veces, ha leído un otro gato, ahora lee tres, pone cuatro y le pone 00:12:41
gato cuatro. Entonces ahora dentro de mi sistema está gato asociado con el intercuarto. Y ya está. 00:12:48
Una vez que ha hecho esto, no sé, vamos a ver si se hizo, frecuencia. Una maravilla. 00:12:55
Ahora, que queremos complicarlo un poco, que queremos decir, mira, pero esto pónmela ordenadas alfabéticamente, ordenada por número, se puede hacer. 00:13:15
Puedes hacer todo lo que queráis. 00:13:46
Probamos a completar esto 00:13:47
Yo os he dicho, usad frases 00:13:51
Inglesas, porque así quitamos 00:13:53
Del medio los acentos 00:13:55
Las señas y cosas así que son más complejas 00:13:57
De trabajar 00:13:59
¿Vale? Vamos a ver cómo lo hacemos 00:14:01
¿Vale? 00:14:05
Ahora, asumamos que no es así 00:14:06
Sino que me han dado 00:14:09
Una cadena 00:14:11
¿Vale? 00:14:13
Y mi cadena será 00:14:14
hola, gato, gato, perro, gato. 00:14:16
¿Sí? Fácil. 00:14:25
Por lo tanto, vamos a arreglar esta de aquí. 00:14:27
Entonces, ¿cómo lo hago? 00:14:29
Pues pillo la string que me han dado, 00:14:31
digo que string array splitted 00:14:34
es igual a string.split de espacio. Y luego, había una forma, raise.toList. 00:14:40
lo hago antes. string es igual a string.toLowerCase. Ahí, ya está, todo mismo. Y ahora lo que 00:15:02
quiero hacer es frase punto a doble de a raíz punto 00:15:19
no me acuerdo 00:15:27
había una forma para transformar 00:15:38
esto directamente en una 00:15:59
es una cosa 00:16:01
así no lo pilla 00:16:03
esto no le gusta, hay que transformar esto 00:16:05
en una colección 00:16:10
y no me acuerdo si estaba 00:16:11
collections punto 00:16:14
hay un método que te pilla directamente 00:16:16
un array 00:16:24
y te lo transforma 00:16:28
en una 00:16:30
en una lista 00:16:31
pero no me acuerdo como sea 00:16:34
list enumeration 00:16:35
no me acuerdo 00:16:42
array.list 00:16:48
Entonces, esto me lo transformo en una lista, lo añado aquí, de hecho, podría ser que 00:16:50
devuelve esto, de acuerdo, Arrays.asList, que devuelve, devuelve una, no leo, devuelve 00:17:08
entonces podría hacer directamente esto no 00:17:29
bueno una maravilla 00:17:50
vamos a ver si nuestro programa funciona click maravilla de una fenómena ahora el problema es 00:17:58
es que esta no es una frase real, porque no tiene comas, puntos y cosas por el estilo. 00:18:07
Entonces una frase real sería más como, me gustan mucho los gatos, porque de hecho 00:18:16
Los gatos son maravillosos, maravillosos, viva los gatos, entonces punto, son tres espacios. 00:18:28
Entonces ahora cuando yo hago esto, me salen cosas raras, entonces lo divide, ofreciendo 00:18:51
espacios pero ahora tengo que comprobar si al final de mi palabra están o no estas cosas aquí 00:19:03
vale entonces como lo hago me han separado por espacios entonces por cada palabra tengo que 00:19:10
hacer como un... Limpiarla. Entonces for string s dos puntos cliptender. Entonces pillo ese y lo 00:19:22
que hago es ese punto trim, le quito espacios a la derecha y a la izquierda. Tiene muchos espacios, 00:19:42
pues se lo quito, ¿vale? No creo que sea necesario porque como he utilizado esto, pues a lo mejor no lo hago, ¿vale? 00:19:52
Luego, voy a mirar... En teoría los signos podrían estar delante y detrás. ¿Hay signos delante? Sí, 00:19:58
porque, claro, en español, en inglés no, ¿no? A comillas a lo mejor, sí, a comillas podría ir. Entonces quito 00:20:08
cosas que no sean letras ni a la izquierda ni a la derecha. He puesto todo lo del case, entonces aquí 00:20:16
solo hay letras minúsculas, me interesan solo letras minúsculas, ¿vale? 00:20:20
Entonces, por ejemplo, quito la parte 00:20:24
la primera parte, ¿vale? Entonces digo 00:20:29
char c es igual 00:20:33
a ese punto char 00:20:40
0. Cuile c 00:20:44
mayor que 00:20:54
y c 00:20:59
menor que c, 00:21:02
está en minúsculos, ¿eh? Ah, esto lo haría así. 00:21:04
Y que 00:21:06
paga. 00:21:09
Mientras 00:21:12
no sea esta cosa aquí, 00:21:12
mientras no sea 00:21:17
una letra, yo he empezado desde el principio, 00:21:18
¿vale? Y mientras no sea una letra 00:21:21
lo que tengo que hacer es eliminar ese carácter. 00:21:23
¿Vale? Entonces 00:21:25
s es igual 00:21:26
ese punto, esto era substring, substring de 1. Esto lo voy a hacer, porque yo leo, no es una letra, 00:21:30
Pues entonces, transformo S en su substring, o sea, en una subcadena que empieza desde la primera posición. 00:21:58
Sostantialmente, quito la primera. 00:22:07
¿Entiendes? 00:22:11
Y lo vuelvo a hacer. 00:22:12
Ahora es una letra, he acabado. 00:22:14
Ahora es otro signo de interpulsión. 00:22:16
Siguiría adelante, adelante, adelante. 00:22:19
Este de aquí iría quitando todos los símbolos raros antes de la primera letra. 00:22:22
¿Sí? 00:22:28
Ok, he limpiado la parte izquierda 00:22:28
Ahora intento limpiar la parte derecha 00:22:34
Lo mismo, pero desde derecha hasta izquierda 00:22:36
O sea, pillo el último 00:22:38
P es igual 00:22:39
A S.charact 00:22:42
S.length 00:22:46
Menos uno 00:22:47
El último carácter 00:22:50
¿Vale? 00:22:55
Y digo que mientras este carácter 00:22:56
No sea 00:23:00
Una 00:23:00
una letra 00:23:02
pues lo que hago es 00:23:05
quitar la última 00:23:07
o sea, su string 00:23:10
desde el principio 00:23:12
hasta 00:23:13
esto 00:23:15
ahora, con un poco de suerte 00:23:18
esto funciona 00:23:27
hay que ver por qué string 00:23:28
siempre es especial 00:23:31
si esta cosa de aquí me lo hace bien 00:23:32
o no 00:23:35
porque si con esto lo hago por valor 00:23:35
no funcionará, si esto lo hace por referencia 00:23:39
si funciona 00:23:41
entonces vamos a ver 00:23:41
si lo hace 00:23:45
boom, explose 00:23:46
ancho 0 00:23:49
menos 1, out of bound 00:23:51
for length 0 00:23:53
vale, aquí 00:23:54
he intentado poner un 00:23:59
menos 1 aquí, porque me ha 00:24:02
dado una cadena 00:24:04
que es larga 0 00:24:06
entonces esto lo 00:24:07
hacemos, siempre 00:24:09
de cuando S tiene algo, pero hay algo, vamos a ver por qué lo hace, entonces aquí le 00:24:12
hacemos escribir schizo proceso dos puntos S, y luego después de este while veo que 00:24:28
quedado en S, limpio izquierda y después de esto limpio derecho. Vamos a ver donde explota. 00:24:41
¡Ah! Vale. Me ha ido bien. Gusto ha ido bien. La primera vez que encuentra gatos empieza a 00:24:56
limpiar a la izquierda y lo hace bien, pero cuando limpia a la derecha explota. ¿Por qué? 00:25:15
¿Por qué va de cero a ese punto lento y menos uno? 00:25:21
Porque se enfada porque intenta acceder... 00:25:44
¿Por qué? Porque la S es de lente cero. 00:25:54
Pero S no es de lente cero. 00:25:59
Que cuando lo escribe aquí, S es esto. 00:26:12
Entonces, debería estar bien. 00:26:15
cuando entra de aquí ese punto substring desde cero hasta la última que no pilla. 00:26:18
Este debería ser este, pero como si esta cosa de aquí me estuviera dando cero, en vez no debería ser cero. 00:26:27
y eso es el punto l 00:26:35
porque aquí me da menos 1 y 0 00:26:47
porque no cambio C aquí dentro entonces 00:27:10
y ya el punto empieza a ir a ir y nunca cambia el C. Esto lo tengo que volver a 00:27:15
hacer cada vez que hago esto. Y lo mismo aquí, porque lo quito, pero ahora tengo que actualizar 00:27:21
el carácter, que en este caso sería este. Ahora sí. ¿No entendéis? No. Si yo pillo, 00:27:31
si está así, aquí dentro el carácter no cambia nada, nunca. C no cambia nunca. Entonces, 00:27:43
aquí detectó que el último es un punto me dice aquí está el último pero no es cambiado entonces 00:27:49
sigue siendo un punto entonces me dice también quita el último y vuelve aquí dice es un punto 00:27:55
quita el último es un punto quita el último es exactamente me destruye todo si yo lo hago así 00:28:00
mira se escriba ese no me va a devolver todas las combinaciones de es y ya datos puntos quita 00:28:06
el punto pero como no he actualizado el carácter ahora cree que este es el punto entonces me quita 00:28:16
este es el punto, me lo quita 00:28:21
este es el punto, me lo quita 00:28:23
hasta llegar a vacío 00:28:24
y cuando hace vacío y le quita el punto 00:28:26
al menos uno explota 00:28:28
¿vale? sustancialmente he hecho un bucle infinito 00:28:30
porque 00:28:33
no actualizo 00:28:35
no actualizo 00:28:36
cuánto vale C aquí dentro 00:28:38
y como mi condición es sobre C 00:28:40
si entra allí dentro no saldrá nunca 00:28:42
siempre que yo aquí hago una condición 00:28:44
sobre una cierta 00:28:47
variable 00:28:48
esta variable tiene que cambiar aquí dentro 00:28:50
porque si no cambia nunca 00:28:53
entro en el while, me quedaré en el while 00:28:55
al infinito o no entro 00:28:57
en el while y no entraré nunca 00:28:59
¿Me explico? Entonces aquí hay que 00:29:00
decirle, vale, ok, si lo que 00:29:03
has encontrado no es una letra 00:29:05
quítala y ahora 00:29:07
actualiza de cuál es el último carácter 00:29:09
es decir, vuelve a escribir esto 00:29:11
actualiza 00:29:13
cuál es el último carácter 00:29:15
ahora el último carácter 00:29:17
podría ser otra vez un punto o podría ser una O. Si es una O, has acabado el byte. ¿Se entiende? 00:29:19
Ahora funciona perfectamente. Medianamente funciona perfectamente. Sigue habiendo cosas raras. 00:29:27
En principio lo procesa bien. Pero no lo está actualizando del otro lado. 00:29:45
No, porque es siempre la última. Se actualiza solo por la S. 00:29:53
Básicamente lo que se hace con ese método es coger las palabras y dividirlas de derecha a izquierda. 00:30:06
O sea, primero por la derecha y luego por la izquierda, dejando solo la palabra y dando puntos y tal. 00:30:15
El trim es una cosa que lo hace para quitar espacios a la derecha o a la izquierda. 00:30:20
Si lo que me ha pillado es espacios, espacios, espacios, espacios, gato, espacios, espacios, espacios, me deja gato. 00:30:29
Quita los espacios a la derecha o a la izquierda. 00:30:35
No debería pasar, porque si tengo espacios, espacios, espacios, me debería dar como 3 palabras. 00:30:43
Ahora, aquí está pasando una cosa rarita, que es uno de los problemas de trabajar con string. 00:30:47
Si os fijáis, yo tengo una red de string. 00:31:00
Entonces, con esto estoy accediendo a cada uno de los string, a los objetos string, y lo modifico. 00:31:05
entonces técnicamente debería modificar ese objeto 00:31:14
y en splitted 00:31:17
ahora debería haber todos los objetos modificados 00:31:19
sin embargo si os fijáis al final yo devuelvo splitted 00:31:23
y lo que llega aquí 00:31:27
debería ser el splitted con todas las palabras limpiado 00:31:29
sin embargo no ha limpiado nada 00:31:40
Y esto es porque string es un medio objeto, es entre objeto y no objeto. 00:31:43
Yo creo que hace, si esto fueran alumnos y yo hubiese hecho modificaciones en alumnos, lo habría hecho. 00:31:54
Pero como string, a veces string se pasa como referencia y a veces se pasa por valor. 00:32:00
Y aquí probablemente cuando hace esta cosa de aquí, no está pillando la referencia desde dentro del objeto diciendo es este de aquí. 00:32:06
me ha estado haciendo una copia y entonces cuando yo la modifico aquí, 00:32:17
porque la estoy modificando sobre S, no se modifica en Splitted. 00:32:21
Y cuando devuelvo Splitted, Splitted es igual. 00:32:28
Si yo aquí lo pongo, si hizo 00:32:31
Arrays.DrawString Splitted, veréis que es 00:32:34
como al principio. 00:32:44
Veis, no ha hecho la limpia. 00:32:47
lo ha hecho sobre como una copia que es una cosa extraña es la razón de cuando 00:32:52
hacéis vosotros ejemplos o pruebas sobre objetos no uséis string como prueba de 00:32:56
objeto porque string se porta como le da la gana 00:33:03
string es un objeto es un semi objeto entonces como lo solucionó pues que esto 00:33:07
no me vale, creo otro string limpiado igual a new string de splitted.length, un array 00:33:16
del mismo tamaño, vale, y a este punto me compensa hacerlo como int i es igual a cero 00:33:36
i menor que splitted punto length i más más, es decir que string s es igual a splitted 00:33:52
de ahí y cuando lo he limpiado, taca taca taca taca taca taca, aquí añado al limpiado 00:34:05
d y ss y al final no devuelvo splitter, más devuelvo limpiado. Esto en vez que con arrays 00:34:15
con listas 00:34:34
de alguna forma 00:34:37
entonces ahora 00:34:38
ha encontrado 00:34:39
tres gatos, no obstante 00:34:45
la frase original 00:34:47
tenga gatos raros 00:34:48
tiene gatos punto 00:34:50
tiene gatos 00:34:52
con tres excavaciones 00:34:54
vale 00:34:56
ahora, yo con esto 00:34:59
suficiente para mi 00:35:02
vale, estaba trabajando un poquito 00:35:04
Entonces, seguro que si os ponéis allí, hay algunas combinaciones de cosas raras que no funcionan, ¿vale? 00:35:06
Si yo, por ejemplo, pongo esto, ya no me funciona, ¿sí? 00:35:14
Porque no pilla esto como dos palabras. 00:35:20
Para él, una palabra es esta, una palabra es esta, pues esta es una palabra única. 00:35:24
¿Sí? Entonces, debería meterme letra por letra a encontrar si tiene un espacio o cosa por el estilo, 00:35:29
o hacer una regex, una expresión regular más compleja de esta y decirle si es espacio, 00:35:37
si es punto, si es coma, si es lo que quiera, pues considerarlo como uno nuevo. Pero si quiero hacer 00:35:48
esto, pues busco esto sí, para estas cosas de aquí, una vez que lo he entendido, pues me voy 00:35:57
a la inteligencia artificial y le digo, oye, hazme un programita, que lo que hace es que te doy una 00:36:02
frase y él me separa las palabras, teniendo en cuenta que pueden haber puntos, y eso trabaja 00:36:07
bien. Y más o menos. ¿Más dudas? 00:36:14
Podríamos seguir con, vale, cuando me lo escribe lo quiero ordenado por algún tipo, 00:36:25
Entonces, cuando lo escriba aquí, lo quiero ordenado por palabra. 00:36:54
Si lo quiero por palabra, una opción relativamente fácil podría ser esta, creo. 00:37:06
Me gato, gustan, echo, los maravillosos, me mucho, son, vivan. 00:37:11
Perfecto, ¿vale? 00:37:37
¿Por qué? Porque estoy aprovechando 00:37:39
de que el stream map 00:37:41
ordena las cosas 00:37:43
dentro por su clave. 00:37:46
La clave es un string. 00:37:48
Los strings vienen ordenados alfabéticamente. 00:37:49
Pues, que no da. 00:37:52
Si quisiera por 00:37:57
esto, 00:37:59
a lo mejor la cosa sería un poquito más compleja. 00:38:01
Voy a ver mi hash map 00:38:11
porque es más rápido. 00:38:12
Entonces, una vez que he obtenido 00:38:16
esto, esto sería un ordenado, entonces ahora pillo set, reset, set, vamos a decir, sí, 00:38:18
Preset de integer ord es igual a new preset de frecuencia.get, no, .values, que no es la key, son los valores. 00:38:36
Ah, sí, perdón. 00:39:11
¿Vale? 00:39:12
Que, pero, no me permite. 00:39:14
No es... 00:39:16
Ah, venga. 00:39:18
Reset lo importo... 00:39:24
¡Ay! 00:39:26
Entonces, con esto 00:39:28
me ha creado un 00:39:30
conjunto de valores... 00:39:32
Me he equivocado. 00:39:34
Si lo hago así... 00:39:36
¡Ah! ¡Uf! 00:39:39
Porque... 00:39:43
Sí, no me interesa. 00:39:45
no puede estar 00:39:47
tened en cuenta que el triset 00:39:50
no me permite duplicados 00:39:52
entonces si hay gato que aparece 00:39:55
tres veces y cocodrilo que aparece 00:39:57
tres veces, pongo una sola vez 00:39:59
tres 00:40:01
pero no me vale, porque yo simplemente lo que intentaré 00:40:01
hacer es pillar la frecuencia 00:40:05
menor e ir a recorrerme 00:40:06
todo el map 00:40:09
a la búsqueda de esa frecuencia allí 00:40:10
si aparece tres veces, tres veces 00:40:13
y pondré las palabras 00:40:14
Pones ahí. Luego empezaré otra vez. Vale, ahora pillo la segunda frecuencia. Es nueve. Vale, 00:40:16
voy a buscar toda la que... ¿Entiendes? La frecuencia, si lo hago así, iría de menor a mayor. 00:40:23
Desde menores... desde frecuencia menor a frecuencia mayor. Si lo quiero hacer al revés, 00:40:38
No sé si el org.getlast... Sí, lo tengo. Tengo getlast, por lo tanto puedo trabajar con getlast. 00:40:45
Vale, entonces, will.org.cj mayor que cero, lo que hago es pillar int frecuencia actual es igual a org.getLast, ¿sí? 00:41:08
Y ahora, con esta frecuencia actual, tengo que recorrerme toda la red y preguntar cada una de las keys. 00:41:42
Y si tengo esto como frecuencia, pues entonces la añado a lo que tengo que escribir. 00:41:50
Tengo que escribirse a una lista. 00:42:00
Lista de string ordenados. 00:42:14
por frecuencia es igual a new ArrayList de Spring, tiquetito, ¿vale? 00:42:23
Entonces, tengo la frecuencia actual que estoy buscando. 00:42:34
Voy a recorrerme el array entero. 00:42:37
Entonces, iterator.it de string it es igual a frecuencia.get, no, .kset.iterator. 00:42:40
¿Sí? 00:43:08
Will 00:43:13
it.next 00:43:13
int 00:43:16
comprobar 00:43:26
es igual 00:43:29
a it. 00:43:31
punto 00:43:33
a frecuencia 00:43:33
necesito los string 00:43:36
string 00:43:43
comprobar 00:43:45
es igual a 00:43:47
y t.next 00:43:49
frecuencia 00:43:52
.get 00:44:00
comp 00:44:02
es igual 00:44:03
a frecat 00:44:05
entonces la palabra que estoy 00:44:07
mirando ahora tiene como frecuencia 00:44:11
exactamente la que estoy buscando 00:44:14
por lo tanto lo añado a la lista 00:44:15
que mi lista era 00:44:17
ordenados 00:44:19
por freq. Ordenados por freq.add y añado la palabra con dos puntos, con freq.add. 00:44:22
Se puede optimizar, sí, se puede hacer cosas raras. Lo que queda es el parámetro it. Este 00:44:42
es it2. It2, it2, it2. Se podría mejorar la... porque esto está buscando siempre todo 00:44:47
las mapas siempre todo las mapas siempre todas las mapas hasta hasta frecuencias que ya ha 00:44:57
encontrado pero no quiero machacar el quiero destruir el asma si quiero cuando lo encuentro 00:45:02
destruyó de nuevo esa par esa es entrada en toda la siguiente vez eso no lo contará porque estará 00:45:08
más para más pequeño ahora lo que sí voy quitando es desde esto justo porque esos son los valores 00:45:15
Entonces, yo pillo la primera y la elimino. Bueno, no. Sí, porque le he puesto esto. Entonces, lo que hago aquí, ahora será, una vez que he hecho esto de aquí, he pillado todas las frecuencias, elimino la última. 00:45:24
a menos que no me la haya quitado, esperad, y el last lo remuevo, no, no vale, entonces ahora lo remuevo, remove, remove, entonces esto me va destruyendo org, vale, de organizar un ordenador, que es esto, 00:45:57
Son todos los valores, entonces me va pillando siempre el último, me pilla el último, hace 00:46:29
lo que tiene que hacer con el último y lo quita, me pilla el último, hace lo que tiene 00:46:39
que hacer con el último y lo quita, etc. 00:46:43
Hasta que llega un momento en que ya no habrá valores ahí dentro, entonces se ha acabado. 00:46:46
Al cabo, este de aquí, con un poco de suerte, aquí dentro las tengo ordenadas por frecuencia 00:46:53
3, 3, pero esta palabra no está ordenada por, si quisiera ordenarla ahora, antes de 00:47:06
Y este de aquí podría ser list.sort, no, list.sort, no, collection, collections.sort de ordenados por frecuencia. 00:47:28
No, me lo meto. 00:47:54
Sería demasiado, sería demasiado. 00:47:55
Aquí quieres ordenarlo tanto alfabéticamente como por cantidad de... 00:47:58
Sería bastante más complejo. O sea que dentro de la misma frecuencia, me lo debería organizar en una lista de listas y cada frecuencia ponerlo en una lista y luego ordenar eso y luego después combinarla. 00:48:04
Pero ahora no tengo el poder psicológico para hacer esa cosa. 00:48:20
Eso no tienes. 00:48:24
Lo hacéis vosotros para el lunes. 00:48:27
Exacto. 00:48:29
Entonces, esto lo puedo complicar cuantos da la gana, esto es lo que deberíais hacer 00:48:30
vosotros para jugar con estas cosas, es decir, hago el ejercicio, vale, el ejercicio son 00:48:37
cuatro líneas de códigos, lo hemos visto al principio, y luego ponéis a decir, y si 00:48:41
quiero esto, y si quiero esto, y claro, es que a veces una tontería se puede explotar 00:48:44
desde una perspectiva computacional en el sentido de que requiere de todo lo posible 00:48:55
que esta cosa aquí que hemos hecho nosotros haya una forma de hacerla mucho más ligera elegante 00:49:00
porque si nos interesa es en la primera parte que es aquí fija la cosa hay otros contenidos 00:49:08
aquí 00:49:24
esta 00:49:25
a lo mejor se puede hacer 00:49:27
de una forma un poquito mejor 00:49:30
¿vale? porque aquí sostancialmente 00:49:32
es uno de esos casos que te dice 00:49:36
si estás 00:49:38
una cosa, si no estás otra 00:49:40
¿vale? entonces 00:49:42
dentro de frecuencia 00:49:44
tengo un par de 00:49:46
métodos que son el 00:49:50
UTF-ABSENT 00:49:52
y el GET 00:49:55
por default 00:49:57
que puede 00:49:58
que podrían 00:50:00
ayudarme 00:50:03
por ejemplo podría 00:50:04
utilizar esto 00:50:07
entonces decir 00:50:08
int 00:50:18
s es igual a esta 00:50:19
cosa 00:50:23
y luego esto 00:50:24
y luego esto 00:50:28
entonces esto me lo va a 00:50:30
pillar, va a pillar palabra 00:50:41
si lo encuentra me dará 00:50:44
al asociado con cuarta palabra. Me da la 3, yo le pongo 4 y lo vuelvo a poner. Ya está. 00:50:46
Si en vez no lo encuentra, me devuelve un valor por defecto. Este. Entonces me devuelve 00:50:52
0, le sumo 1, 1 y lo pongo. Esto se queda mucho más elegante de nuestro if esta cosa, 00:50:58
if esta cosa. Mucho más legible, mucho más limpio. 00:51:06
A lo mejor la misma cosa se puede hacer con el otro, que sería, el otro es el frecuencia.put y fabsafe. 00:51:11
Para poner una palabra que no existe sí, pero si ya existe no me lo actualizaría, por lo tanto esto no. 00:51:35
Debería preguntarme que si esta cosa aquí es null, pues entonces quiere decir que no la he metido, entonces la meto yo, pero mejor así. 00:51:51
Esto es más bonito. 00:51:59
Sí, fijaos que he cambiado el método. Si os fijáis aquí yo hago tres cosas. 00:52:04
Hago lo splitting, hago el añadir, hago el organizar. 00:52:09
Estos deberían ser tres métodos para que el main me quede con split a la frase o crea el HashMap, organiza el HashMap, organiza un poquito el main y luego los varios programas lo podrías hasta separar a programadores. 00:52:15
Decirle, mira, tienes que hacer un programa que te dan esto y tienes que devolver esto. Ya está. Luego lo integro con una vaga. 00:52:37
¿Sí? Esto debería seguir funcionando. Madrilla de programa. ¿Dudas? ¿Preguntas? 00:52:44
¿Hay alguna forma de poder ordenar los timers? Diciendo, o sea, me ve por la clave, por igual, tenemos que, por ejemplo, decirle tal interior de mejor interior, me puede decir, por ejemplo. 00:52:59
No, porque como está hecho el map, el map depende de la clave. La cosa importante del 00:53:16
map es la clave. Cuando eliges la clave, entonces sí que con el trimap te organiza por clave. 00:53:28
Pero como valor, no porque tendría menos sentido. Es como si tú haces un índice de 00:53:34
un libro y en vez de ordenarlo por las palabras, pues lo ordenas por la página, pues sería 00:53:42
el primer libro. Pero es que entonces, tu índice serían los números. Normalmente los 00:53:52
HashMaps, si lo has hecho con la clave correcta, son una maravilla, siempre te queda la posibilidad 00:54:02
Es decir, cuando insertas gato y su frecuencia, creas también otro ashmap donde hace la revés. 00:54:16
Que será un ashmap de frecuencia, entonces un integer y una lista de string. 00:54:27
Y lo que haces tú es pillar su frecuencia. 00:54:35
Si ya existe esa frecuencia, lo añades así. 00:54:37
Pero es un... 00:54:40
Porque si lo encuentras otra vez, lo tienes que... 00:54:41
Imagínate, tú gato lo tienes tres veces. 00:54:43
Pues lo deberías añadir a la lista de palabras que se han encontrado tres veces. 00:54:45
Ahora, si lo encuentras otra vez, lo tienes que quitar desde la lista de tres y ponerlo en la lista de cuatro. 00:54:50
Por ejemplo, con cierto cuidado. 00:54:56
Pero lo podrías hacer y al final tendrías dos SashMap. 00:55:01
Uno que te permite buscar por palabra su frecuencia y uno que te permite, dada una frecuencia, buscar cuántas palabras tienen esa frecuencia. 00:55:04
El problemilla aquí es que en el caso de palabras, hay muchas palabras con frecuencia 00:55:16
la que sea, pero las palabras son distintas, entonces se diferencian. 00:55:23
En el otro caso, muchas palabras aparecen pocas veces, entonces a lo mejor tendrías 00:55:28
listas muy largas de 1, 2, 3, 4, entonces luego no sé cuánto... te volverías a recorrer 00:55:34
listas grandes, porque sí. 00:55:43
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:
1
Fecha:
6 de marzo de 2026 - 14:03
Visibilidad:
Clave
Centro:
IES ROSA CHACEL
Duración:
55′ 51″
Relación de aspecto:
1.78:1
Resolución:
1920x1080 píxeles
Tamaño:
468.57 MBytes

Del mismo autor…

Ver más del mismo autor

EducaMadrid, Plataforma Educativa de la Comunidad de Madrid

Plataforma Educativa EducaMadrid