Saltar navegación

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

ProgramacionJavaEjercicio109910AsignacionTareas

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 mayo de 2020 por Andres R.

100 visualizaciones

Programacion Java Ejercicio 109910 Asignacion Tareas

Más información Transcripción

Descargar la transcripción

Ahí está. Vale, pues ya estamos grabando y vamos a iniciar la presentación, ¿vale? 00:00:00
Entonces, me imagino que se lo han mirado a todo el mundo, porque para eso lo he puesto, porque se lo miren y lo intenten. 00:00:04
He revisado hace un ratito y tenía dos entregas. Bueno, no sé, quiero pensar que lo han intentado y que se han quedado casi a punto de hacerlo y por eso no lo han subido el resto. 00:00:11
Hasta 80 usuarios que tenemos, dos entregas son muy poquitas, pero bueno, ahí está. 00:00:22
En mi caso vi la hora, creía que la hora era más tarde 00:00:28
La tengo hecha, pero ya se ha pasado 00:00:31
Ahora hay que mirarla en la tarea 00:00:33
Y es que es muy importante 00:00:34
Si uno... y así es 00:00:36
Entonces 00:00:46
Vale 00:00:47
Entonces 00:00:54
La tarea esta consiste en lo siguiente 00:00:57
La idea es tener dos ficheros 00:00:59
Uno es de nombres de usuarios 00:01:01
Y otro es de tareas que van a hacer los usuarios 00:01:03
Y la idea es 00:01:06
Distribuir de forma aleatoria 00:01:07
las tareas entre los usuarios 00:01:09
una serie de condicionantes 00:01:10
y bueno, que se los pone aquí 00:01:13
anunciado, ¿no? que por ejemplo 00:01:15
hay que tener un poco de precaución cuando se leamos 00:01:17
la primera lista 00:01:19
de usuarios, pues no repetir nombres 00:01:21
cuidadito con las líneas vacías que no nos la dan tal 00:01:22
y alguna cosita más que ir por ahí 00:01:25
¿vale? 00:01:27
¿qué más? 00:01:30
ah, bueno, sí, también pido 00:01:31
todo esto está hecho a posta para que 00:01:32
practiquen ustedes ciertas cosas 00:01:34
que sustituyan, por ejemplo, los caracteres 00:01:36
del alfabeto español, la A con acento, las diéresis, todas estas cosas, las que sustituyan. 00:01:38
Si pone Pepe Pérez y pone uno con acento y otro sin acento, pues que se consideren la misma persona. 00:01:45
Esto es importante, pues nos lo pide. 00:01:54
Y luego también pone que trabajemos para números aleatorios, saben que en informática los números son pseudoaleatorios, 00:01:57
y hay una forma de hacerlos un poquitín más aleatorios que es trabajando con semillas. 00:02:02
por ejemplo es investigar para que quería que ustedes investigaran un poco sobre esto de las semillas 00:02:06
las semillas son un numerito que lo que hacemos es que incrementamos la aleatoriedad de las funciones aleatorias 00:02:11
son un poquito más aleatorias, nunca son perfectas en computación 00:02:18
pero con las semillas se hacen un poquitín más interesantes 00:02:22
y quería que lo investigaran y que le dieran tres vueltas 00:02:26
el objetivo del curso también es investigar cosas 00:02:30
por supuesto, en ese puesto 00:02:32
prohibido usar ArrayList, yo no sé que manía 00:02:36
con los ArrayList, porque le gustan tanto a ustedes los ArrayList 00:02:38
no digo ustedes 00:02:40
como 00:02:41
ustedes los 80 de este año, sino en general 00:02:43
yo no sé por qué a los alumnos les gusta 00:02:46
tanto el ArrayList cuando hay otros tipos de colecciones 00:02:48
que hay siempre mucho más interesantes y adecuadas 00:02:50
para hacer las cosas, entonces 00:02:52
les prohíbe también usar ArrayList 00:02:53
para que usen las otras y se las miren 00:02:55
y que usen colecciones adecuadas 00:02:57
el día que hagamos el examen será muy importante 00:02:59
No vale usar cualquier colección para cualquier cosa. 00:03:02
Una cosa importante es usar la colección adecuada a las necesidades que tengamos. 00:03:05
Esto es importante. 00:03:10
Y luego, bueno, el tema de identificadores, comentarios, códigos, 00:03:11
un montón de códigos que expliquen las cosas, que lo hagan bien. 00:03:15
Y como siempre, programamos para que lo entiendan los demás, no para entenderlo yo. 00:03:18
Siempre ese programa para que lo entiendan los demás. 00:03:22
Para que los demás, cuando lean ese código, entiendan muy bien lo que se está haciendo ahí. 00:03:24
No usar unos identificadores que no hay quien se entere. 00:03:29
Pues poner una variable ij74, pues no da mucha información, pero si le pongo nombre de usuario plantilla, pues da muchísima más información. 00:03:32
Muy bien, pues vamos a empezar ya con esto. 00:03:41
Entonces, había que hacer este programita y también otra cosa que les he puesto para que practiquen es la ejecución de la recepción de parámetros por parte del programa. 00:03:44
Tenía dos ejecuciones, una si recibe dos parámetros, que son dos nombres de fichero, y otra muy interesante, si recibe solo un parámetro. 00:03:55
si recibes solo un parámetro supone que es el nombre del fichero de usuarios 00:04:00
y entonces en ese caso lo que hacemos es que a ese fichero de usuarios se le asigna de forma aleatoria 00:04:04
un numerito que va desde 1 hasta el número de usuarios que tenga 00:04:10
de forma que implícitamente nos genera un orden aleatorio de esos usuarios 00:04:13
por si lo quiero ordenar numéricamente, pues primero, segundo, tercero, cuarto, quinto 00:04:19
pues me lo hace pasándole solamente el nombre del fichero de usuarios, esta es la idea 00:04:22
entonces estos ficheros, pues el primero de ellos es un listado de nombres 00:04:27
les voy a poner el fichero para que lo vean, miren, todo esto se lo voy a subir 00:04:32
y ahora les comento una cosita, lo tienen todo, ya lo tienen subido, ahora se lo habilito 00:04:36
para que lo vean y se lo pueden descargar, con lo cual no se preocupen del código aquí de nada 00:04:40
si quieren tomar notas, perfecto, pero recuerden que todo este código lo van a tener 00:04:44
en cuanto termine la conferencia, la charla, la clase, donde quiera 00:04:48
pero primero los ficheros, fíjense, es un fichero de nombres y además está hecho a posta 00:04:52
ya, pues unas cuantas cosas, son nombres 00:04:57
en general, he puesto los nombres de una clase 00:04:58
de usuarios de una clase, alumnos 00:05:00
entonces fíjense que yo hago varias cosas a posta 00:05:02
la primera es que repito algunos de los nombres 00:05:05
no me acuerdo cuál exactamente, me parece que 00:05:07
este de Ávila, por ejemplo, lo repito 00:05:09
y fíjense que a este le he puesto Ávila Fernández 00:05:10
con acento en las mayúsculas, y miren que aquí 00:05:13
pone Ávila Fernández Pablo 00:05:15
la misma persona, pero sin acento 00:05:17
porque lo hago a posta, para verificar 00:05:18
que está bien la conversión de acentos 00:05:21
y demás, y que me los da como el mismo usuario 00:05:23
que eso es lo que me piden 00:05:25
Y luego, otra cosa de las que hago es que aposta, pongo una línea en blanco para que también el programita lo considere 00:05:26
y esta línea en blanco no la incorpore como un usuario. 00:05:34
Entonces ya pongo yo el fichero aposta para verificar que funcionan las cosas. 00:05:37
Y este segundo fichero, este es el de usuarios, y ahí incorpora a los usuarios y demás. 00:05:43
Y el de tareas, pues miren aquí, el de tareas, pues fíjense, lo voy a hacer un poco más grande, 00:05:47
Pues he puesto cuatro tareas chorradas 00:05:52
Pueden ser por ejemplo ejercicios de un examen 00:05:54
Una resolución de ecuaciones 00:05:56
El cálculo de Fibonacci 00:05:58
Al ser un programita 00:05:59
O el cálculo numérico 00:06:01
De unas integrales 00:06:05
O un cálculo aproximado al tipo de pi 00:06:06
Cosas de estas, pues tareas que hay que hacer 00:06:08
Para lo que fuera 00:06:10
Y yo quiero asignar aleatoriamente estas tareas 00:06:12
A todos los usuarios 00:06:14
Fíjense, muy importante 00:06:16
Es diferente el número de usuarios y de tareas 00:06:18
Si tengo menos usuarios no hay problema 00:06:20
Porque tengo tareas para todos, ya está 00:06:23
Pero ¿qué ocurre? Si tengo menos tareas 00:06:25
Tengo que repetir las tareas a los usuarios 00:06:26
Pero de forma aleatoria 00:06:29
Si yo quiero asignar aleatoriamente estas tareas a los usuarios 00:06:30
Y si tengo usuarios 00:06:33
Pues ir asignando las tareas 00:06:34
Cuando se me acaben, vuelvo a aleatorizarlas 00:06:36
Las vuelvo a asignar y así sucesivamente 00:06:38
Y todos los usuarios van a tener una tarea de forma aleatoria 00:06:40
¿Qué ocurre al ejecutarse? 00:06:43
Pues fíjense, ¿qué va a ocurrir? 00:06:46
Pues que si yo ejecuto con dos parámetros, el nombre de fechero de usuario y el nombre de fechero de tareas, 00:06:47
voy a tener una asignación de los usuarios o a los usuarios de tareas de forma aleatoria. 00:06:52
Pues al primero le toca el cálculo de pi, al segundo el teorema de Pitágoras, al tercero el cálculo tal, al cuarto, al quinto... 00:06:59
Y fíjense que a todos ellos le van tocando tareas de forma aleatoria. 00:07:04
¿Ven ahí? ¿Lo ven, no? 00:07:08
Vale, pues se lo van viendo como les toca a cada uno de ellos, todo esto. 00:07:11
¿Lo ven, no? 00:07:15
Vale, yo aparte en la ejecución pues he hecho alguna cosita más 00:07:15
Pues ya que estoy leyendo ficheros, pues aprovecho 00:07:18
Y a medida que voy leyendo hago un listado directo de la lectura 00:07:20
Es decir, que a medida que leo cada usuario 00:07:24
Voy sacando ese usuario 00:07:25
Lo separo por comas 00:07:28
Y los apellidos del nombre los separo por un punto y coma medio 00:07:29
Que ya veremos ahora cómo lo hago 00:07:31
Primer usuario, en el segundo saco un punto y coma 00:07:32
Tengo un usuario, voy leyendo, lo ven ahí, ¿no? 00:07:35
Este es el listado directo de la lectura 00:07:38
Luego, una vez sacado el usuario 00:07:40
Fíjense que lo que tengo aquí es el mismo listado 00:07:42
Pero ahora ya está ordenado por nombre 00:07:45
Altares va antes que Ávila 00:07:48
Que va antes que Bravo 00:07:50
Que va antes que Corregidor 00:07:51
Que va antes que Crejo 00:07:52
Este ya está ordenado por apellido 00:07:53
Que es como yo listo mis usuarios 00:07:57
Aunque los lea como los lea 00:08:00
Yo los listo ordenados por nombre 00:08:01
Y en el fichero de las tareas 00:08:03
Pues ya aprovecho de leerlo 00:08:05
Y lo voy visualizando 00:08:06
Como cada tarea es una línea 00:08:07
Pues visualizando las líneas y todas las tareas 00:08:08
Resolución de tal, cálculo de cual 00:08:10
Para ti, para ti, para ti, para ti 00:08:12
esto no me lo piden, pero yo lo quiero hacer 00:08:13
porque me apetece 00:08:16
y además en este proceso verifico 00:08:17
la correcta lectura de los ficheros 00:08:20
y demás y que todo está funcionando 00:08:22
porque a mí lo que me piden realmente 00:08:23
es esto de aquí 00:08:26
que es la asignación aleatoria 00:08:27
fíjense que aquí no tenemos ningún nombre repetido 00:08:29
el señor este que estaba hábil, fíjense 00:08:32
está solamente una vez, lo ven aquí 00:08:34
era un usuario repetido, pero 00:08:36
está salvado ese problema 00:08:38
y el otro problema que era que había una línea en blanco 00:08:39
pues como verán no aparece ningún usuario en blanco 00:08:41
como tiene que ser 00:08:44
¿vale? esto es la ejecución con dos parámetros 00:08:44
fichero de usuarios, fichero de tareas 00:08:47
teníamos la otra ejecución 00:08:50
que era con un solo parámetro, solamente 00:08:52
tenemos el fichero de usuarios y lo que hacemos es que asignamos 00:08:53
a cada usuario un numerito de forma aleatoria 00:08:55
entre uno y el número de usuarios que tengo 00:08:57
de forma que, fíjense 00:08:59
pues asignar al target local 17, a vilar 5 00:09:01
a pablo, tal, tal, tal, tal, tal, si lo ven 00:09:04
si yo hubiera ordenado por los números 00:09:05
pues saldría ordenado por números, pero esto 00:09:07
fíjense, pasando solo 00:09:09
un fichero que es el de usuarios 00:09:11
no paso el nombre de fichero de tareas 00:09:14
a cada número, a cada usuario 00:09:16
le asigno un número entre 1 y el número 00:09:18
total de usuarios que será el máximo de estos 00:09:20
que será por 27, por ahí 00:09:22
por lo que veo por aquí, y cada uno tiene un número 00:09:24
distinto asignado de forma aleatoria 00:09:26
bueno, vamos a ver como se consigue esto 00:09:28
de acuerdo 00:09:30
los ficheros, las tareas 00:09:31
que no tenemos, pues ya nos vamos a meter con este fichero 00:09:36
que nos han dicho más que sea único 00:09:38
un único fichero 00:09:39
o sea, todo lo que haga lo tengo que hacer 00:09:41
todo aquí 00:09:43
y eso es lo que hemos hecho, hacerlo todo aquí 00:09:44
vamos a abrir 00:09:47
y hacer un poquito más grande 00:09:48
¿lo ven ahí bien? 00:09:50
Sara, ¿me estás oyendo? 00:09:56
Sí, sí, perfecto, perfecto 00:09:58
tampoco te quiero cortar, va muy bien 00:09:59
con que digas de vez en cuando sí o algo 00:10:01
pues yo es que tengo una sensación de estar hablando para el cuello de mi camisa 00:10:03
no, no, vas muy bien 00:10:05
es que no sé si me lleno o no 00:10:07
no se corta ni nada 00:10:08
¿no? ¿todo bien? 00:10:11
bueno, pues vamos a continuar 00:10:13
un poquito, entonces este es el fichero único 00:10:15
este Java que nos han pedido, aquí tenemos el ficherito 00:10:17
entero, lo ven 00:10:19
este se comió un poco, ahora lo hacemos un poco más pequeño 00:10:20
estas líneas que son un poco más grandes 00:10:23
ahora las cortamos un poco 00:10:25
bueno 00:10:27
entonces, bueno, estas son las 00:10:31
importaciones de librería que nos piden a medida que vamos 00:10:34
programando, no tiene mucha importancia 00:10:36
y pues nada 00:10:38
el ejercicio, pues yo le he llamado 00:10:40
y miren lo primero que hacemos 00:10:42
lo primero que hacemos es esto que les digo 00:10:44
yo voy a estar leyendo estos usuarios de un fichero 00:10:46
entonces, en el enunciado este que les he puesto 00:10:48
a ustedes, no se lo pido 00:10:51
explícitamente, pero hombre, tiene sentido 00:10:52
¿verdad? que si voy a estar leyendo usuarios 00:10:55
pues de alguna forma los meta en algo 00:10:56
que los genere como entidades 00:10:58
y esas entidades van a ser objetos 00:11:00
entonces, este usuario 00:11:02
pues yo lo que hago es un usuario muy sencillo 00:11:05
fíjense, lo único que tiene aquí es el nombre 00:11:07
de usuario 00:11:08
que no le he separado ni siquiera en apellidos 00:11:09
porque es una cosa muy sencilla 00:11:12
Y sí que, muy importante, le hago el Implements Comparable. 00:11:13
¿Para qué? Para poder ordenar mis usuarios. 00:11:17
Ya que, claro, como implemento el Comparable de usuario, 00:11:22
este genérico Comparable de usuario, 00:11:26
quiere decir que esta clase implementa la comparación de elementos del tipo usuario. 00:11:28
Evidentemente se van a comparar a través del nombre, 00:11:33
que es el atributo que tiene el usuario y que lo va a identificar. 00:11:36
Fíjense cómo ha construido el constructor. 00:11:39
lo hago en línea porque es muy sencillito, no ocupo líneas para abajo 00:11:41
miren, otro constructor vacío, pues una cadena vacía 00:11:44
miren como hago el constructor de copia 00:11:48
para preservar la ocultación de código 00:11:51
fíjense como creo este usuario, fíjense lo que hago 00:11:56
yo quiero crear un usuario desde otro usuario 00:11:59
para no copiar este nombre, el espacio de memoria donde está este nombre 00:12:04
lo que hago es que creo un nuevo string 00:12:09
con el nombre de usuario que me han pasado como parámetro 00:12:11
entonces esto que me pasa es una referencia a un nombre 00:12:14
con ese getNombre que lo que me va a devolver es un string 00:12:18
creo un nuevo espacio de memoria 00:12:22
y ese nuevo espacio de memoria se lo asigno yo a mi 00:12:24
referencia privada de usuario 00:12:27
así tengo mi, de forma privativa 00:12:30
tengo esa zona de memoria para mí 00:12:32
para mi nombre, ¿vale? y nadie más va a poder acceder ahí 00:12:35
Entonces estamos preservando la ocultación 00:12:39
Ahí, el acceso y todo 00:12:41
Está muy bien hecho, ¿de acuerdo? 00:12:43
Sí 00:12:46
Gracias Sara por saber que me oyen 00:12:46
Nada, nada 00:12:49
Muy bien, gracias 00:12:50
Miren por ejemplo como devuelvo el nombre 00:12:52
No devuelvo directamente este 00:12:55
Este puntero 00:12:57
Referencia 00:13:01
No devuelvo el nombre 00:13:02
Devuelvo un new string de nombre 00:13:04
¿Para qué? Para preservar la ocultación 00:13:06
de este atributo, ¿vale? Jamás voy a devolver esto, ¿de acuerdo? Devuelvo un nuevo espacio 00:13:09
de memoria donde copio ese nombre, ¿eh? Y así preservo la ocultación 100%. Este está 00:13:16
muy bien hecho, aposta. Consume un poquito más de recursos, consume un poquito más 00:13:22
de tiempo, es verdad, pero preserva la ocultación de los datos. Los datos privados tienen que 00:13:27
estar siempre ocultos, súper importante. Vale, cuando establezco el nombre, pues aquí 00:13:33
sí que lo hago un poco a pelo marinero, porque ya que tengo todo lo demás preservado, pues 00:13:38
digo, bueno, pues esta me la salto. En principio ya me lo van a hacer. Pero bueno, podría 00:13:44
haber aquí sido un poquitín más exagerado y cuando quiero establecer el nombre a través 00:13:49
de un parámetro, pues igual le hago aquí un newString de nombre, voy a poner un igual 00:13:56
a nombre, newString de nombre y así genero un nuevo espacio de memoria para esta asignación 00:14:00
y asignárselo de esa manera 00:14:04
bueno, uno de los métodos que tengo en su momento 00:14:06
es el hash code, es el método que me devuelve el código 00:14:09
hash de cualquier información 00:14:11
¿vale? pues me genera 00:14:12
un número dependiente 00:14:15
del nombre, de los 00:14:17
atributos, ¿vale? que es un número aleatorio 00:14:19
este es en base a números primos y demás 00:14:21
matemáticamente hablando, pero siempre 00:14:23
me devuelve el mismo, ¿vale? 00:14:25
acuérdense del hash, lo hemos seguido en su 00:14:27
momento, equals me va a decir 00:14:29
si dos objetos son 00:14:31
iguales para el caso de este objeto usuario y el comparto es el método que necesariamente tengo que 00:14:33
implementar por qué escribir por qué recuerden que se implementa el comparable de usuarios 00:14:43
donde necesito como comparados como comparó dos usuarios a través de su nombre como el nombre es 00:14:52
un string y string ya tiene compareTo 00:14:57
pues uso el compareTo de string 00:14:59
porque el nombre es un string 00:15:01
entonces comparo mi nombre 00:15:02
con el nombre del parámetro, del nombre 00:15:05
comparo 00:15:06
voy a hacerlo así, a ver, ahí va 00:15:08
comparo, ¿vale? 00:15:10
mi nombre 00:15:13
con el nombre del 00:15:14
parámetro que me pasa 00:15:17
¿vale? y de esa comparación 00:15:19
este compareTo 00:15:21
el valor lo devuelvo yo como valor 00:15:23
Andrés, perdona 00:15:25
la sesión está bloqueada 00:15:26
y hay gente que está esperando para entrar 00:15:29
me están avisando por whatsapp 00:15:30
que no pueden entrar 00:15:32
en la configuración 00:15:35
de web he puesto que 00:15:37
a partir de los 10 o 15 minutos 00:15:39
no voy a dejar entrar a nadie más 00:15:41
entonces, bueno, le dejaré entrar si puedo 00:15:42
está esperando, pero otro día no dejo 00:15:45
porque es que si no están sonando pitiditos todas las sesiones 00:15:47
no voy a hacerlo más 00:15:49
pues otro día, si es que hacemos mal, no voy a dejar entrar 00:15:50
a ver si puedo 00:15:52
porque no me deja 00:15:55
Pues no sé cómo 00:15:55
Aquí me dice que Alberto no sé quién está 00:15:57
Pero no sé cómo habilitarle 00:15:59
No sé cómo 00:16:01
Si me dicen cómo 00:16:04
Yo encantado 00:16:05
Participantes, a ver 00:16:07
Dos participantes esperando 00:16:09
Admitir, vale, creo que los ha admitido 00:16:10
Me parece que sí 00:16:14
Sí, Alberto Jiménez, ¿no? 00:16:16
Señor Jiménez, ¿estaba usted esperando? 00:16:18
No, sí, ya estoy 00:16:21
Sí, llevaba un rato 00:16:22
Que no conseguía entrar 00:16:23
No, es que lo he bloqueado 00:16:25
Si lo he bloqueado yo hace 10 minutos 00:16:26
No quiero estar cada 00:16:28
N estando pitidito 00:16:29
Entonces cada vez que entra un usuario se van a pitir 00:16:32
Ah, vale 00:16:33
Me parece que ha dejado 10 o 15 minutos de margen 00:16:35
Vale, vale 00:16:39
Sí, sí, sí, pero es que creía que era las 8 y media 00:16:41
He visto el mensaje y ya me tiré 00:16:43
El próximo día 00:16:45
Pongo un tiempo 00:16:56
Prudente 00:17:00
Y ya está 00:17:01
vale, lo que, por donde andaba 00:17:02
entonces, ¿has quedado claro? 00:17:05
uso el compare to the string 00:17:07
para devolver un valor del compare to the usuarios 00:17:09
realmente yo comparo usuarios a través 00:17:11
del string nombre, entonces 00:17:13
el compare to the string me sirve 00:17:15
y el toString, pues nada 00:17:16
devuelvo el nombre con un formato 00:17:19
de 20 caracteres 00:17:21
y ya está 00:17:23
vale, joder 00:17:25
¿oyen ustedes el pitidito? 00:17:26
hola 00:17:32
¿hay alguien por ahí? 00:17:33
Nosotros no oímos pitidito 00:17:34
Yo creo que lo oyes solo tú 00:17:36
Madre mía, pues qué pesadilla esto 00:17:37
Cada vez que hay no sé qué 00:17:39
Un pitidito por ahí 00:17:41
Vale, bien 00:17:43
Continuamos 00:17:46
Entonces ya, visto esto 00:17:47
La declaración de la clase está usuario 00:17:50
Una clase extremadamente simple pero 00:17:51
A nivel conceptual nos sirve muy mucho 00:17:54
Para las clases que ustedes van a tener que desarrollar 00:17:56
Y luego ya nos metemos en el mail 00:17:58
¿Y qué hace el mail? Bueno, pues ya nos metemos un poco 00:18:00
con la chicha del código este de nuestro programa, ¿no? 00:18:02
Entonces, lo primero, pues fichero, nombre fichero usuarios y nombre fichero tareas. 00:18:05
Variables que vamos a utilizar para los nombres de los ficheros que vamos a utilizar. 00:18:10
Y aquí les voy a hacer una salvedad muy importante. 00:18:14
El código que yo les he pasado pone, en vez de nombre fichero usuarios, pone nombre fichero alumnos. 00:18:19
En muchos sitios que aquí vamos a ver que pone usuarios, en el código que yo les proporciono en el aula virtual pone alumnos, 00:18:25
pero que sepan que es lo mismo 00:18:30
una cosa de alumnos y esto es para usuarios en general 00:18:32
pero da igual, alumnos y usuarios 00:18:35
es lo mismo, a fin de cuentas 00:18:37
es lo mismo, que lo sepan 00:18:39
porque aquí van a haber usuarios 00:18:40
y cuando abran los ficheros en la aula virtual 00:18:42
van a haber alumnos 00:18:44
pero funciona exactamente igual 00:18:45
que lo sepan 00:18:48
entonces inicializamos estas dos variables donde vamos a almacenar estos nombres 00:18:49
y una variable línea 00:18:53
para ir leyendo 00:18:54
es una variable booleana 00:18:55
que dice si existen tareas 00:18:58
es para saber, todo esto 00:19:00
fíjense que el programa yo se lo he hecho muy comentado 00:19:02
para que se lo puedan estudiar 00:19:04
con ganas, tranquilamente 00:19:06
pues nada, simplemente sabemos con esta 00:19:07
variable si existe o no un fichero de tareas 00:19:10
¿vale? 00:19:12
entonces 00:19:13
si la longitud de 00:19:14
args es mayor que 1 00:19:18
¿vale? 00:19:19
es decir, si vamos a tener 00:19:22
dos o más parámetros 00:19:24
que nos da igual que haya más 00:19:26
nosotros vamos a usar dos 00:19:27
Y si hay más, pues se ignoran absolutamente 00:19:30
Pero los dos primeros parámetros 00:19:32
Van a ser los que usaremos como 00:19:34
Nombre de ficheros 00:19:36
Entonces, si hay dos parámetros, el nombre de fichero de usuario 00:19:37
Será el primero de ellos 00:19:40
Ars de 0 y el nombre de fichero 00:19:41
De tareas será Ars de 1 00:19:44
¿Vale? 00:19:46
El nombre de este 00:19:48
Hombre, pero bueno, no pasa nada 00:19:50
Y entonces, si tenías esos dos ficheros 00:19:52
Existe un fichero de tareas y es true 00:19:54
¿De acuerdo? 00:19:56
sin embargo, si la longitud en vez de ser mayor que 1 00:19:57
es exactamente 1, quiere decir que me han pasado 00:20:00
solo un parámetro 00:20:01
y si me han pasado solamente un parámetro 00:20:02
solo tengo usuarios 00:20:04
entonces, fichero de usuarios del parámetro que me han pasado 00:20:11
fichero de tareas no tengo 00:20:13
y existen tareas 00:20:15
no existen tareas, con lo que le hago false 00:20:17
y hace que no existen tareas 00:20:19
y si he pasado 00:20:21
ni siquiera un parámetro, pues mira 00:20:23
le damos un mensaje al usuario y le decimos 00:20:25
oye macho, que este para ejecutarlo 00:20:27
necesitas nombre de usuario de ficheros 00:20:29
y opcionalmente 00:20:31
el nombre de usuario de tareas 00:20:33
le pongo extension txt para que sepan que el formato 00:20:35
es de texto plano, no tiene por qué ser extension txt 00:20:38
vale 00:20:40
ya hemos solucionado el tema de leer los ficheros 00:20:42
ya sabemos si existen o no, se nos han pasado 00:20:44
los parámetros o no, a continuación 00:20:45
importantísimo 00:20:48
declaro las colecciones que voy a utilizar 00:20:50
para almacenar las cosas 00:20:51
La colección de usuarios que voy a utilizar 00:20:53
Un triset de usuarios 00:20:56
De forma que ya tenemos usuarios ordenaditos 00:20:58
¿Vale? 00:21:00
Y además hago un triset 00:21:02
¿Y por qué hago un triset y no hago un trilist? 00:21:04
A ver, Sara, ¿qué opina? 00:21:06
Yo estoy aquí para decir el sí 00:21:10
Ya, ya, pregunto 00:21:12
No, no, no 00:21:14
Yo paso palabra 00:21:15
Que responda otro 00:21:17
A ver, otro 00:21:18
A ver quién me contesta, un voluntario 00:21:21
¿Por qué uso un triset y no un linked list, por ejemplo? 00:21:23
O un sorted map 00:21:30
Esa es pregunta de examen 00:21:30
¿Puedo recorrerlo? 00:21:33
¿Eh? 00:21:37
Erlo, ¿eh? 00:21:40
Entendido, Erlo 00:21:41
Oiga 00:21:42
Sí, decía que sí es para poder recorrerlo 00:21:43
Hombre, cualquier colección se puede recorrer 00:21:46
Cualquiera 00:21:49
Pero las mapas 00:21:50
Para poderlo ordenar 00:21:52
¿Eh? 00:21:53
Para poderlo ordenar 00:21:55
Una de las razones es para poderlo ordenar muy bien 00:21:56
Y hay otra, muy importante 00:21:59
Esto es pregunta de examen, ¿eh? 00:22:01
Y estamos ya un poquito del examen 00:22:07
Hombre, las colecciones se las han estudiado a fondo, ¿no? 00:22:09
Ya, del capítulo anterior, ¿no? 00:22:12
A ver, ¿qué características tiene un set? 00:22:18
Súper importante 00:22:20
Hay una característica muy importante 00:22:21
De las colecciones de tipo set 00:22:23
¿Eh? 00:22:25
Tienen duplicados 00:22:30
Exacto, pero justo exactamente al contrario 00:22:31
No admiten duplicados 00:22:34
y es una de las cosas que me pedían en el enunciado 00:22:36
que no queríamos duplicados 00:22:40
pppere solo lo queremos una vez en mi conjunto 00:22:42
no puede estar dos veces pppere 00:22:45
por mucho que lo intente, no tiene doble existencia 00:22:46
solo existe una vez 00:22:49
entonces utilizo un set precisamente para evitar duplicados 00:22:49
y el hecho de que sea un triset o no 00:22:53
bueno, pues es interesante porque lo podríamos ordenar 00:22:56
de otra manera, pero bueno, si encima además 00:22:59
lo tengo ya ordenado, pues es que eso que gana 00:23:00
pero lo más importante es el que sea un set 00:23:02
es porque no admite duplicados 00:23:05
¿vale? y repito 00:23:07
como segunda opción elijo un tree 00:23:10
porque además ya los voy a tener ordenados 00:23:12
claro, y además voy a tener esos usuarios 00:23:13
ordenados por el nombre 00:23:16
jolín, pues que interesante, pues ya me lo han 00:23:18
vamos, blanco y en botella, pues ya 00:23:20
mejor imposible 00:23:22
yo directamente de la colección me ordeno las cosas 00:23:23
no me toque complicar la vida 00:23:26
y además le llamo 00:23:27
le doy un identificador a esto que me da información 00:23:28
acerca de lo que hace, es la colección 00:23:32
de usuarios 00:23:34
y es del tipo 00:23:34
triset de usuario 00:23:36
es el tipo que tiene 00:23:38
muy bien 00:23:40
y lo que hago es que la inicializo 00:23:42
la inicializo vacía, un new triset 00:23:44
no le paso 00:23:46
nada porque ya el orden 00:23:48
aquí le podría pasar el orden pero 00:23:50
los usuarios ya están ordenados por defecto 00:23:51
hay una ordenación por defecto 00:23:54
recuerda, implementa 00:23:55
comparable, ya tenemos una ordenación por defecto 00:23:58
que la hemos especificado 00:24:00
al hacer el compare to 00:24:02
Y entonces 00:24:03
Tenemos aquí nuestra colección de usuarios 00:24:13
Y luego tengo las tareas 00:24:15
Y fíjense 00:24:17
Vuelvo a usar un set, claro 00:24:19
No puedo tener dos tareas iguales 00:24:21
O no debería tener dos tareas iguales, ¿verdad? 00:24:23
Si hago el cálculo de pi, pues hago el cálculo de pi 00:24:25
Podría hacer el cálculo de pi por 00:24:27
Bueno, hay muchas formas de calcular pi 00:24:30
pero cálculo de pi 1 y cálculo de pi 2 00:24:33
ya son dos tareas diferentes 00:24:36
pero si tengo cálculo de pi 1 00:24:37
solo va a ser una vez 00:24:39
y en este caso hago un hash set 00:24:41
porque que estén ordenadas o no 00:24:43
la verdad es que me da un poco lo mismo 00:24:45
entonces hacemos las tareas 00:24:47
metidas en un hash set 00:24:49
necesitamos un orden dentro de las tareas 00:24:51
la verdad es que me da igual 00:24:54
de hecho no hemos declarado un orden en las tareas 00:24:55
porque no me interesa 00:24:57
de hecho las tareas si se fijan 00:24:59
las tareas realmente no las defino 00:25:01
ni siquiera como una clase 00:25:03
como tarea me sirve simplemente 00:25:05
el texto que define la clase me sirve 00:25:07
para la tarea 00:25:09
entonces utilizo el propio string y me ahorro 00:25:10
un montón de implementaciones 00:25:13
que no es que estarían mal pero no 00:25:14
voy a decir un poco inútiles pero 00:25:16
no son inútiles pero no 00:25:18
digamos que son un poco innecesarios 00:25:20
vale 00:25:22
a partir de ahí fíjense lo que tengo 00:25:24
súper importante un try catch 00:25:26
catch 00:25:28
y empiezo con un try 00:25:30
¿y por qué hago esto? 00:25:32
Sara, ¿está por ahí? 00:25:34
aquí estoy, aquí estoy 00:25:36
¿por qué hago un try? 00:25:37
porque puede dar un error 00:25:38
¿eh? 00:25:39
porque puede dar un error 00:25:40
¿y por qué puede dar un error? 00:25:41
las excepciones 00:25:42
¿por qué puede dar un error? 00:25:43
pues... 00:25:48
¿por qué lo metas? 00:25:49
¿eh? 00:25:50
al estar desordenado 00:25:50
porque no existe el fichero 00:25:52
bueno, pero eso ¿cómo se llama? 00:25:55
genérico 00:25:58
¿por qué? 00:25:58
por una excepción 00:26:00
no, la excepción es lo que se genera 00:26:01
Yo hago todo esto en un bucle try-catch que es un tratamiento de excepciones evidentemente porque tengo operaciones de entrada-salida y las operaciones que dan este tipo de errores capturados en excepciones son casi siempre, hay algunas también aritméticas, pero son casi siempre operaciones de entrada-salida y la lectura, escritura de ficheros son operaciones de entrada-salida que dan errores. 00:26:06
Estos son preguntas de examen, ¿eh? Todas. 00:26:28
Estas y otras 843.321 más que se me ocurren. 00:26:31
Pero todos estos son preguntas de examen, ¿eh? 00:26:36
Entonces, claro, como hay operaciones de entrada y salida, 00:26:39
yo tengo que envolver esto en un try-catch, ¿vale? 00:26:41
Para capturar esa excepción que se produce. 00:26:43
Y cuidado no confundan, la excepción es lo que se produce, 00:26:45
pero lo que produce el error es la operación de entrada y salida. 00:26:48
Cuidado no confundan los dos ejemplos, ¿eh? ¿Vale? 00:26:51
Entonces, fíjense lo que estoy haciendo aquí. 00:26:55
le asignó lector fichero de user de usuarios es aquí donde le meto el file reader el nombre de 00:26:56
fichero usuario que me ha pasado y luego le hago un buffer reader pues para que esté bufferizado 00:27:04
y con un buffer pues siempre las cosas funcionan muchísimo mejor vale y luego a continuación 00:27:09
si lo he abierto y no me ha dado errores si me da errores captura el try-catch y ya me olvido pero 00:27:17
si no tengo errores, pues quiere decir que lo he podido abrir bien 00:27:22
pues yo me pongo a leer los usuarios 00:27:24
entonces, ¿cómo leo los usuarios? 00:27:25
bueno, primero saco información para ver, fichero usuario 00:27:28
listado directo de lectura, le recuerdo que esto 00:27:30
es el resultado, este de aquí 00:27:32
fichero usuario 00:27:34
listado directo de lectura, lo ven aquí, ¿verdad? 00:27:36
fichero usuario 00:27:39
listado directo de lectura, y me pongo a leer líneas 00:27:40
entonces, ¿cómo leo las líneas? pues nada, del buffer 00:27:42
le hago un readline, ya está 00:27:44
un readline, me lee la línea completa 00:27:46
de texto, hasta el retorno de carro, pum, y me lo devuelve 00:27:48
En un string, que es este, se lo asigno a línea 00:27:50
Si eso es distinto de nulo 00:27:53
Quiere decir que hay información 00:27:55
Esa información la trato 00:27:56
¿Vale? 00:27:58
¿Qué línea es empty? Es decir, que había una de nada 00:27:59
Pues, continue, vuelvo a ver la siguiente línea 00:28:03
¿Vale? No añado líneas vacías 00:28:05
¿Vale? 00:28:07
¿Cómo me salto ya las líneas vacías? Con esto de aquí 00:28:08
¿Qué hace al continue? Recuerda, me vuelve 00:28:11
Al inicio del bucle 00:28:13
Entonces no hago lo demás, porque no tengo nada que hacer 00:28:14
Pues no hago lo demás 00:28:17
Si no, quiere decir que si tengo información la tengo que reemplazar 00:28:18
Y miren lo que hago aquí 00:28:22
Imprimo, ¿vale? 00:28:23
Por el dispositivo estándar de salida 00:28:26
Dispositivo estándar de salida 00:28:29
Imprimo la línea 00:28:32
Pero no la imprimo de cualquier manera, no 00:28:34
Fíjense lo que hago 00:28:36
Me agarro la línea y como yo he metido los nombres 00:28:37
Me dice enunciado el tipo 00:28:42
Pérez Jiménez, coma, Pepito 00:28:43
apellido, apellido, coma, nombre 00:28:45
reemplazo estas comas por puntos y comas, ¿vale? 00:28:50
para distinguirlos, los apellidos del nombre de los usuarios 00:28:53
se los separo por coma, ¿vale? entonces los apellidos del nombre los separo por punto y coma 00:28:57
y los usuarios en tesis los separo por comas, pero eso es solo en este listado 00:29:01
porque este replace es momentáneo de aquí 00:29:06
es al visualizarlo, ¿vale? ¿de acuerdo? 00:29:09
Y una vez que lo he reemplazado, miren lo que hago. Añado a mi usuario, Pere Jiménez Pepito, lo añado a la colección de usuarios. ¿Y cómo lo añado a la colección de usuarios? Pues nada, como es un nuevo usuario, creo ese nuevo objeto usuario a partir de la información de la línea de información. 00:29:13
Pero no de cualquier manera 00:29:40
Lo que pasa es que esa línea de información 00:29:41
Le limpia los acentos 00:29:43
Y limpia los acentos 00:29:45
Se hace a través del método limpia acentos 00:29:47
Que vamos a ver un poquito más adelante 00:29:49
Ahora no me voy a detener en él 00:29:51
Es un método que recoge 00:29:52
Un texto 00:29:55
Un string 00:29:57
Y lo limpia de acentos 00:29:58
Si tiene una A con acento la quita el acento y la deja como una A 00:30:01
Si tiene una Ñ la quita la Ñ 00:30:03
Y le pone una N en mi caso 00:30:05
Limpia estos caracteres propios 00:30:06
del alfabeto español como nos decía en el inicio, ¿vale? 00:30:09
pero fíjense lo que hago, yo aprovecho ya todo y lo hago todo de golpe 00:30:12
fíjense, lo hago todo de golpe 00:30:14
todo esto lo hago de golpe, me ahorro aquí 00:30:16
pues en vez de hacer esto en 5 o 6 líneas de código lo hago todo de golpe 00:30:19
a la línea limpio los acentos 00:30:22
ese string lo utilizo para inicializar un nuevo usuario 00:30:25
un nuevo objeto de la clase usuario 00:30:29
genero ese espacio y ese espacio generado por ese objeto 00:30:31
esa nueva instancia la añado 00:30:34
a la colección de usuarios 00:30:37
se añade la referencia de esta nueva instancia 00:30:39
y se gestiona la 00:30:41
que me da falso 00:30:43
es decir 00:30:47
que no me lo admite 00:30:48
si ya tengo texto y no me lo admite 00:30:50
la única razón por la que puede ser 00:30:52
es porque ya estaba ese usuario 00:30:54
¿vale? 00:30:57
y entonces si ya estaba ese usuario 00:31:00
evidentemente no se añade porque ya estaba 00:31:02
pero lo que hago yo es que saco 00:31:04
por el dispositivo 00:31:07
estándar de salida 00:31:08
visualizo una información 00:31:10
que la tengo aquí, que es esta de aquí 00:31:12
entrada repartida nos añade 00:31:14
y así yo sé 00:31:16
que lo que ha pasado es que había uno 00:31:18
para añadir pero como ya está de alta 00:31:20
como usuario no le vuelvo a añadir 00:31:22
es decir, si perejimenez, pepito 00:31:24
ya existía, no le añado 00:31:26
lo he leído, lo intento añadir pero no puedo 00:31:27
y lo visualizo que no lo añado 00:31:30
y ya está, eso lo hace el bucle 00:31:32
hasta que se termina el fichero 00:31:34
añado todos los usuarios a la colección 00:31:36
una vez hecho esto 00:31:38
bueno, este println de backslash 00:31:40
b, lo que hace es que imprime 00:31:42
un espacio atrás 00:31:44
un backspace, un espacio atrás 00:31:45
entonces me quita la última coma 00:31:47
que hemos ido añadiendo al usuario 00:31:50
la última coma del último usuario lo quita 00:31:52
el último no tiene esa coma 00:31:53
porque ya es el último, un truquito 00:31:55
una vez que he hecho esto 00:31:58
cierro el buffer 00:32:00
cierro el fichero y nada, pues ya está 00:32:02
y miren 00:32:04
la magia de las colecciones de Java 00:32:06
saco el listado ordenado 00:32:08
aquí lo tenemos, leído y a continuación 00:32:10
saco el listado ordenado, ¿y cómo saco el listado 00:32:12
ordenado? la magia de las 00:32:14
colecciones, tachán 00:32:17
a ver dónde está, aquí 00:32:18
saco el listado ordenado 00:32:20
mis usuarios los saco ordenados 00:32:22
¿qué hago para hacerlos 00:32:24
para tenerlos ordenados? nada 00:32:26
al ser un tree 00:32:28
set y estar bien implementado 00:32:30
el ordenamiento en la clase 00:32:33
de usuarios, automáticamente al 00:32:34
irlos introduciendo ellos se han ido ordenando 00:32:36
solos y lo que hago es que los visualizó esta colección tiene un plus string 00:32:38
este es lo activo porque hago que salga la colección de usuarios sumada concatenada con 00:32:46
una cadena vacía el sistema interpreta que quiero voy a querer transformar esta colección en un 00:32:52
string y él lo que hace 00:33:01
es que transforma la colección en un string 00:33:03
este de aquí, ¿está bien? 00:33:04
ese que está en azul 00:33:06
por ahí que le estoy pasando, ¿lo ven? 00:33:08
y es el listado ordenado 00:33:10
sale directamente ordenado 00:33:12
¿vale? muy bien 00:33:15
¿que existen tareas? pues nada 00:33:16
si existen tareas, ¿qué es lo que hacemos? 00:33:18
pues nos ponemos a leer el fichero de tareas, ¿no? habrá que leerlo 00:33:20
pues hacemos lo mismo que hemos hecho antes 00:33:23
lo abrimos, no sé qué, patatas 00:33:24
si está vacío, no sé cuántos 00:33:26
y si no está vacío, pues vamos añadiendo 00:33:28
las tareas, añadimos la línea que estamos leyendo 00:33:30
y aquí 00:33:32
ya está, con esto 00:33:34
hemos leído todas las tareas y las visualizamos 00:33:36
y ya está 00:33:38
y si no existen tareas 00:33:39
los que se ejecutasen, si no existen tareas 00:33:42
¿qué es lo que queríamos que hiciera? no teníamos el segundo 00:33:44
parámetro y queríamos que asignara 00:33:46
aleatoriamente los números entre uno 00:33:48
y el número de usuarios, es decir, un orden numérico 00:33:50
pues mire lo que hago 00:33:52
para hacer eso, le meto 00:33:54
las tareas, estoy añadiendo 00:33:56
tareas 00:33:59
pero que añado en las tareas, fíjense, añado 00:34:00
un contador que voy haciendo de número de usuarios 00:34:04
empieza siendo 0 y se va incrementando antes de añadirse 00:34:07
se incrementa para que el primero sea 1, se va incrementando y se pasa 00:34:12
en forma de value of del número, es decir, 1 00:34:16
pasado a string y se mete como tarea 00:34:20
la primera tarea se llama 1, más más, se hace un 2 00:34:23
Se transforma en un string 00:34:28
Y se mete ese string, la segunda tarea se llama 2 00:34:29
Y así va a suceder esto 00:34:32
Mientras que recorramos 00:34:34
Los elementos de usuario 00:34:36
De la colección de usuarios 00:34:38
Me recorro toda la colección de usuarios 00:34:40
Por cada usuario 00:34:41
Por cada elemento de usuario 00:34:43
De la colección de usuarios 00:34:45
Añado un numerito 00:34:47
Entonces añado tantos numeritos como usuarios tengan en la colección 00:34:48
Y ya está 00:34:52
Y esta es la parte del catch 00:34:53
Cuando tengo una excepción de estas 00:34:55
no he sido muy fino 00:34:57
con la recepción de extensiones 00:34:58
habría que haber sido un poco más fino 00:35:00
ahora que lo veo, creo que deberíamos 00:35:02
haber 00:35:05
analizado con un poquitín más de detalle 00:35:05
la lectura de un fichero 00:35:08
lo no sé qué, tal y que, habría que 00:35:11
afinar un poquito más 00:35:13
con esta captura de extensiones, porque aquí va a salir 00:35:14
la acepción de una revista, pero bueno 00:35:16
es suficiente y ya está 00:35:18
con esto finalizamos la lectura de fichero 00:35:20
al final se pone un comentario, se finaliza la lectura de fichero 00:35:23
y pasamos a lo siguiente que es la asignación 00:35:25
bueno, pues miren 00:35:27
¿qué es lo que voy a hacer? 00:35:29
voy a hacer uso de una lista de tareas 00:35:32
¿vale? una nueva variable 00:35:34
que como va a ser utilizada una lista 00:35:36
pero como las listas son abstractas 00:35:39
yo para cuando la inicializo 00:35:41
le hice una link en list 00:35:43
es decir, una lista que va 00:35:44
recuerden las listas 00:35:46
son listas dinámicas 00:35:47
¿vale? 00:35:52
enlazadas ¿vale? 00:35:54
Que va añadiendo la información a medida que se va introduciendo 00:35:54
Entonces, primero irá el primero de los que añadimos 00:35:58
Luego el siguiente, luego el siguiente, luego el siguiente 00:36:00
¿Vale? 00:36:02
Es un link en list 00:36:02
¿Y qué hacemos aquí? 00:36:03
Pues nada, empezamos a asignar a los usuarios 00:36:05
Le asignamos tareas 00:36:07
Y ya está 00:36:08
No hay problema 00:36:08
Entonces, fíjense 00:36:09
Me recorro todos los usuarios 00:36:11
Que le llamo elemento usuario a cada uno que va recogiendo 00:36:13
De mi colección de usuarios 00:36:14
Yo quiero asignarle a todos los usuarios una tarea 00:36:16
Pues me recorro todos los usuarios de mi colección de usuarios 00:36:18
¿Y qué hago? 00:36:21
Pues lo primero, digo 00:36:23
Oye, si lista de tareas está vacío, evidentemente la primera vez que yo me meto aquí, que acabo de crear mi lista de vacías como una nueva linked list vacía, la primera vez que me meto está vacía. 00:36:24
Si está vacía la lista de tareas, lo primero que hago es que le añado a mi lista de tareas, esta que voy a usar aquí, le añado todas las tareas que yo tengo. 00:36:37
Recuerden que tareas era un hash 00:36:46
Un hash set 00:36:49
¿Vale? Pero era un set, es una colección 00:36:55
¿Vale? Entonces pulsar el add all 00:36:57
¿Vale? Añado todas las 00:36:59
No tengo lista, lista, tareas en la lista 00:37:01
No pasa nada, toma, todas las tareas 00:37:04
¿Vale? Las añado todas 00:37:05
Y se lo paso 00:37:07
¿Lo ven aquí? 00:37:09
Se la metemos en la lista de tareas, ya deja de estar vacía 00:37:11
Porque le he metido todas las tareas que están 00:37:13
Y me pongo a generar un número 00:37:15
para generar la semilla 00:37:17
de esa aleatoriedad 00:37:19
la semilla de esa aleatoriedad 00:37:20
aquí lo he hecho 00:37:22
como lo he hecho 00:37:24
lo he hecho generando un número 00:37:24
a través de 00:37:28
bueno, pues utilizo aquí 00:37:29
una generación, esto es matemática pura y dura 00:37:36
saco los segundos, los minutos y alguna cosa más 00:37:38
por ahí y genero un numerito con eso 00:37:41
que eso depende del instante 00:37:42
en el que estoy ejecutando 00:37:44
Así tengo una semilla que depende del momento en el que ejecuto, cosa que ahora no va a ser lo mismo que dentro de un segundo, dentro de siete, que dentro de quince, que pasado mañana, que dentro de un mes, que dentro de una semana. 00:37:45
Se me dejará un numerito diferente dentro del instante de tiempo en el que estoy. 00:37:54
Y eso es lo que voy a utilizar de semilla en el Shuffle, este que es lo que se encarga de esbarajar o desorganizar, o desordenar, ¿no? 00:37:59
Yo quiero desordenar mi lista de tareas 00:38:11
Y miren que les meto 00:38:14
Nuevo 00:38:16
Número aleatorio 00:38:17
Utilizando esta semilla que es 00:38:20
Número aleatorio de tiempo, esta es la semilla 00:38:22
¿Vale? Que la he generado en este instante 00:38:23
Y depende de este instante 00:38:26
Hay alguna forma más sencilla de hacerlo 00:38:27
También 00:38:30
Con el kernel milisegundos y cosas así 00:38:30
Es otra opción 00:38:34
Pero bueno, hay varias maneras 00:38:34
Y nada, pues ya hemos generado esto 00:38:37
Pues me ha generado 00:38:40
Pues fíjense lo que le hago 00:38:40
Saco un elemento de usuario 00:38:43
Porque estoy recorriendo todos los usuarios 00:38:47
Y lo que hago es que saco una de las tareas 00:38:48
Extraigo 00:38:51
De la lista de tareas 00:38:53
La tarea remove 00:38:54
Extraigo la primera tarea de la lista 00:38:56
Y la saco de la lista 00:38:59
Y ya me queda una tarea 00:39:00
¿Lo ven? 00:39:02
Al usuario que le toque 00:39:04
Le extraigo la primera de las tareas 00:39:06
La primera de las tareas 00:39:09
Disponible en la lista 00:39:11
y ya está, y eso me genera 00:39:12
esto de aquí 00:39:14
tal, tal, cálculo de pi, patacín, teorema de Pizzagorassi 00:39:15
este es Fibonacci, el otro 00:39:18
este, tal, pim, pam, pim 00:39:20
ahí lo que es, ¿eh? 00:39:22
¿lo ven, no? 00:39:24
cuéntame 00:39:26
¿ahí al final lo estás ordenando? 00:39:27
¿ahí o allá? 00:39:30
en la visión, cuando salen los datos 00:39:32
cuando salen los datos 00:39:34
la salida de datos, ¿sí? 00:39:36
en la imagen anterior 00:39:37
Dices la visualización de la ejecución 00:39:39
Ahí 00:39:42
Cuéntame 00:39:43
Aquí los nombres están en orden alfabético 00:39:44
Sí 00:39:47
Y las tareas también están en orden 00:39:48
Calculo pi, teoría mapitágoras 00:39:52
Fibonacci 00:39:54
T, C, R 00:39:57
No, no está en orden 00:40:01
Por eso digo que 00:40:03
Es que es lo que yo quiero 00:40:05
yo quiero aleatoriamente 00:40:07
asignar a los usuarios que están ordenados 00:40:09
el desorden 00:40:11
de la lista de tareas, es que es exacta entre lo que quiero 00:40:13
yo no veo 00:40:15
el desorden 00:40:18
quiero decir, va, cálculo pi, teorema 00:40:18
la al va antes que 00:40:21
ab, que va antes que brr 00:40:24
que va antes que co, que va, esto está ordenado 00:40:26
a la derecha 00:40:27
k, t, k 00:40:29
esto no está ordenado 00:40:32
pero va siempre igual 00:40:33
se repite, ¿no? 00:40:34
Bueno, esto si está así es porque la aleatoriedad es un petardo, simplemente, porque teóricamente debería de hacerse un random cada vez que se gastan, esto cada vez que se termina, que lista de tareas termina de extraer todas las tareas, como lista de tareas está vacío se vuelven a copiar las tareas y se vuelven a desordenar, por esto se generan las semillas. 00:40:36
Para esto son las semillas 00:41:06
Claro, ¿qué ocurre? Miren 00:41:07
Si la ejecución es tan rápida que la semilla no pasa 00:41:08
Ni un segundo 00:41:12
Y esto es el problema 00:41:13
Como no ha pasado ni un segundo, la semilla es la misma 00:41:15
Y el aleatorio va a ser el mismo, seguramente 00:41:18
Seguramente tengamos que usar milisegundos 00:41:20
Para que esto funcione mejor 00:41:23
¿Entienden o no? 00:41:24
De acuerdo, sí, sí 00:41:27
Pero la idea es que esto fuera 00:41:28
Yo tengo otra versión de este programa que está con milisegundos 00:41:31
Y les aseguro que salen distintas 00:41:33
A ver, no me voy a fijar aquí 00:41:35
Pi, Pitágoras, Fibonacci, ecuaciones 00:41:36
Integrales, Pi, Pitágoras, Fibonacci, ecuaciones 00:41:39
Integrales, Pi, Pitágoras, Fibonacci, ecuaciones 00:41:41
Integrales, Pi, Pitágoras, Fibonacci, ecuaciones 00:41:43
Integrales, Pi, Pitágoras, Fibonacci, ecuaciones 00:41:45
Integrales, Pi, Pitágoras, pues tiene toda la pinta que se repite siempre lo mismo 00:41:47
Pero eso si se repite 00:41:50
Es porque está hecho en tan corto 00:41:51
Espacio de tiempo 00:41:53
Que el numerito que se genera aquí, el número de 00:41:54
Aterotiempo es el mismo, es el problema 00:41:57
¿De acuerdo? 00:42:01
Entonces seguramente haya que usar los milisegundos 00:42:02
Y ya está 00:42:04
en vez de con second 00:42:05
se usa minisecond 00:42:07
vale 00:42:08
si está claro o no 00:42:10
muy bien pues entonces ya está 00:42:13
sacamos el usuario, sacamos la lista de tareas 00:42:16
y se han sacado 00:42:18
más cosas 00:42:19
el programa ya está, nos queda revisar 00:42:22
el limpiacentos, el limpiacentos que hace 00:42:24
yo le paso un string como parámetro 00:42:26
y me devuelve 00:42:28
ese mismo string pero sin acentos 00:42:30
y como hago esto 00:42:33
pues de la forma más fácil posible, con un switch 00:42:34
voy pillando 00:42:37
carácter a carácter los caracteres 00:42:38
del parámetro, que me encuentre una A 00:42:41
de una forma, de otra 00:42:42
o de otra, de la que no quiero que me aparezca, le pongo 00:42:44
una minúscula, que me encuentre 00:42:47
la mayúscula, con el acento para un lado, con el acento para el otro 00:42:49
o con el acento circunflejo, le pongo 00:42:51
una mayúscula limpia, y así 00:42:52
eso es lo que hago con cada una de las vocales, lo ven aquí 00:42:54
a la Ñ le pongo 00:42:56
la N minúscula, y a la Ñ mayúscula 00:42:58
le pongo la N mayúscula 00:43:01
y una vez que he hecho esto 00:43:02
en el char at i 00:43:07
pues nada, una vez que he cambiado 00:43:09
todos los caracteres 00:43:11
por el que quiero 00:43:12
lo que hago, fíjense, si me encuentro este, reemplazo 00:43:14
en el parámetro, que es lo que le paso 00:43:17
le reemplazo el carácter este 00:43:19
que me acabo de encontrar en el char at i 00:43:21
que es este de aquí, que coincide con la 00:43:23
que yo quiero que incide 00:43:25
entonces lo estoy limpiando, estos caracteres 00:43:27
los limpio todos por sus caracteres 00:43:29
y el alfabeto inglés correspondiente 00:43:31
una vez hecho todo esto, devuelvo el parámetro 00:43:33
y se han cerrado 00:43:34
¿lo ven ahí, no? 00:43:36
¿y una vez hecho esto, lo que conseguimos? 00:43:41
pues lo que tenemos aquí, que a cada usuario 00:43:43
le ha asignado una tarea de forma 00:43:45
aleatoria, ¿vale? 00:43:47
o pseudo-aleatoria 00:43:48
¿eh? 00:43:51
sí, pues la otra versión es con milisegundos 00:43:53
y seguro, yo no sé por qué sale esta 00:43:54
pero bueno, da igual, no hay problema 00:43:59
no tiene medio problema 00:44:01
¿vale? 00:44:02
Bueno, ¿ha quedado claro esto? 00:44:08
Respondo por todos, sí 00:44:13
Sí, ¿no? Sí, vale 00:44:14
Muy bien, pues nada, esto era 00:44:16
Fíjense que hay un montón de conceptos implícitos en este programa 00:44:18
Por eso les quería mostrar este programa 00:44:21
Como tampoco sé si va a ser el último que veamos o no 00:44:23
Pues quería mostrar uno que tuviera bastante cositas 00:44:28
Para que se hagan un poco una idea de 00:44:30
De todo, un poquito en general 00:44:31
También es importante 00:44:35
Que se den cuenta de una cosa súper interesante 00:44:37
Utilizando colecciones con muy poco código 00:44:39
Se hace muchísimo 00:44:43
A esto si le quitan comentarios y alguna cosa más 00:44:43
Y están todas estas líneas en rojo 00:44:46
Si se fijan se quedan poquísimos 00:44:47
Hay muchas líneas en rojo pero porque hay muchos comentarios 00:44:49
Pues yo lo que quiero es que ustedes 00:44:52
Entiendan lo que se está haciendo aquí 00:44:54
Y bueno, lo comprendan y lo asimilen 00:44:55
Y lo entiendan muy bien, ¿de acuerdo? 00:44:59
Vale, pues yo por mi parte nada más 00:45:01
Intentaré la pesadilla hasta subir el vídeo 00:45:02
A la mediateca 00:45:05
Esta fantástica 00:45:07
y compartírsela, se lo comparto siempre donde está el ejercicio 00:45:08
aparte, les voy a habilitar 00:45:11
el ejercicio para que lo puedan ver 00:45:13
ya les digo que el código difiere 00:45:15
un poquitín, vale, pero nada 00:45:17
cosas sin relevancia 00:45:19
algún nombre, algún identificador 00:45:20
y ya está, vale 00:45:23
y nada, pues por mi parte ya está, si tienen alguna 00:45:24
duda me preguntan y les digo 00:45:27
y si no, pues 00:45:28
nos vamos a cenar o algo 00:45:30
ah, bueno, estamos en fase 0 00:45:32
no podemos tomar caña ni nada, entonces 00:45:35
Eso lo dejamos para otro día 00:45:37
¿Alguna duda, alguna cuestión o algo que quieran preguntar? 00:45:38
Yo sobre algo que no es del ejercicio, Andrés 00:45:44
Si es una duda general 00:45:46
Por favor en los foros 00:45:49
Porque así la tenemos todos 00:45:51
Era solo preguntar si la semana que viene habrá tutoría 00:45:52
No tengo ni idea 00:45:55
Porque es que 00:45:57
Si no recuerdo mal, esta era la última tutoría 00:45:58
Sí 00:46:03
Creo 00:46:03
De lo que pase de aquí en adelante es un auténtico misterio 00:46:04
Pero créanme 00:46:08
no lo sé yo, no lo sabe tampoco el coordinador 00:46:09
de distancia, no sabe nadie 00:46:12
lo que va a pasar de aquí en adelante 00:46:13
entramos en terreno 00:46:16
farragoso 00:46:17
desconocido 00:46:20
no sabemos si va a haber examen, si no, si va a ser presencial 00:46:22
telemático 00:46:25
cromático 00:46:26
sublimático, no tenemos ni idea de nada 00:46:29
pero nadie, no sabemos nadie nada 00:46:32
de hecho no lo saben ni los de arriba porque 00:46:33
tampoco saben cómo va a evolucionar tanto el tema este 00:46:35
entonces están esperando 00:46:37
un poco 00:46:39
acontecimientos 00:46:40
o alguna decisión. Dígame. 00:46:42
¿Se sabe 00:46:44
aproximadamente con cuánto tiempo se nos va a visitar 00:46:45
más o menos? 00:46:48
Sí, sí, sí. Sé exactamente que no sé nada. 00:46:49
Eso es lo único que sé con precisión. 00:46:54
Espero que más de una hora. 00:46:57
Pero yo también. 00:47:00
Claro, porque imagínese. 00:47:01
Hombre, yo lo que pasa es que la ventaja mía es que 00:47:04
yo les puedo tener el examen ya preparado. 00:47:06
Pero es que no les puedo decir nada. 00:47:09
No son los profesores. El problema es que para planificarte bien un examen... 00:47:11
Pero que me escuche, que no le puedo decir una cosa que no sé, si yo le doy la razón, pero no le puedo decir nada. 00:47:17
No le puedo decir qué va a ser con dos semanas, porque no tengo ni idea ni nada de nada, pero ni yo ni nadie lo sabe. 00:47:22
No, pero a lo mejor había comentado que con un mínimo de tiempo se iba a avisar o algo. 00:47:29
Que no, que no, que no tenemos ni idea de nada. Cero. 00:47:33
Porque para el tema de pedir permisos 00:47:37
De los trabajos y eso 00:47:41
Ante la nueva situación 00:47:43
Pero que entiéndanme 00:47:44
Que yo estaría encantado de todo 00:47:47
Pero es que no les puedo decir nada 00:47:49
Entiendo, entiendo 00:47:50
Me encantaría decirles 00:47:54
Con dos semanas, no se preocupen 00:47:56
Pues me encantaría, pero es que no les puedo decir nada 00:47:58
Así que 00:48:00
Esto es lo que 00:48:03
Uy, ¿qué pasa aquí? 00:48:06
A ver 00:48:07
Dejo ya grabar esto, ¿no? 00:48:08
Porque debe de tener un pauso 00:48:10
Que tengo 00:48:12
Idioma/s:
es
Autor/es:
Andrés Ramos González
Subido por:
Andres R.
Licencia:
Reconocimiento - Compartir igual
Visualizaciones:
100
Fecha:
11 de mayo de 2020 - 21:36
Visibilidad:
Público
Centro:
IES ALONSO DE AVELLANEDA
Duración:
48′ 13″
Relación de aspecto:
1.78:1
Resolución:
1920x1080 píxeles
Tamaño:
111.33 MBytes

Del mismo autor…

Ver más del mismo autor

EducaMadrid, Plataforma Educativa de la Comunidad de Madrid

Plataforma Educativa EducaMadrid