Saltar navegación

Examen Feb23 - 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 14 de febrero de 2023 por Stefano C.

13 visualizaciones

Más información Transcripción

Descargar la transcripción

segunda parte de la corrección del examen de febrero vale si habláis me 00:00:00
estáis autorizando a que yo grabé esta cosa vale entonces vamos a crear archivo 00:00:06
de documento todo el resto ya lo hemos creado anteriormente archivo de 00:00:12
documento y tiene un main no esto también es un 00:00:19
objeto es un archivo de documento luego podré hacer varios archivos de documentos 00:00:25
si yo quiero, ¿vale? 00:00:29
No, porque hemos dicho que hacemos 00:00:31
estático, por lo tanto existe un solo 00:00:33
archivo de documento general, ¿vale? 00:00:35
Entonces, 00:00:38
vale. 00:00:39
Dice, tendrá una única 00:00:41
propiedad static para guardar los documentos, 00:00:43
¿vale? Entonces, static 00:00:45
documento 00:00:48
array 00:00:52
.com 00:00:54
Se tendrá que llamar de alguna forma, 00:00:56
se llama docs. 00:01:01
Vale, esto será donde pongo todos los documentos que yo creo 00:01:03
Es estático, entonces no habrá objetos archivo de documentos 00:01:07
Utilizaré directamente archivo de documentos 00:01:11
Nunca haré new 00:01:14
Archivo de documentos x es igual a new archivo de documentos 00:01:17
Eso no se hace 00:01:21
Vale 00:01:21
Porque es estático, me pide que sea estático 00:01:23
Entonces, a partir de aquí 00:01:27
Pues vamos a rellenar documentos 00:01:29
¿Vale? 00:01:32
Esto lo pongo privado 00:01:33
Así, desde fuera 00:01:35
No acceden a mis documentos 00:01:40
Solo puedes acceder 00:01:41
Con métodos controlados 00:01:43
Y que he hecho yo de esta clase 00:01:45
¿Sí? 00:01:46
Primer método 00:01:48
Rellenamos algo 00:01:49
¿Vale? 00:01:50
Entonces, public 00:01:51
Void 00:01:52
Rellena 00:01:55
Para rellenar 00:01:57
¿Qué necesito? 00:01:59
Ah, no, nada 00:02:01
No necesito nada 00:02:02
Porque rellena lo que me habíamos dicho 00:02:03
Que hace dos cosas 00:02:05
Me pide los datos para un audio 00:02:06
Los datos para un texto 00:02:09
Y añade un audio a un texto 00:02:13
Siempre que se añade un audio 00:02:14
Se añade un texto 00:02:16
Claramente se añade un audio 00:02:16
Es la 00:02:18
¿Cómo se dice? 00:02:19
Es la transcripción 00:02:22
Muy bien 00:02:24
Y si se añade un texto es leído 00:02:25
Para los no vivientes 00:02:27
¿Vale? 00:02:29
Vamos a ver 00:02:30
Que hacemos 00:02:33
Entonces 00:02:34
Necesito dos espacios en Docks 00:02:35
Entonces aquí hay dos opciones 00:02:39
O Docks está vacío 00:02:41
O Docks no está vacío 00:02:43
Si Docks está vacío 00:02:45
Lo creo 00:02:48
Si Docks no está vacío 00:02:49
Tendré que pillar Docks 00:02:51
Añadirle dos espacios 00:02:53
Y añadirle las dos cosas 00:02:54
Si lo habéis hecho que al principio 00:02:56
Docs tiene 25 posiciones 00:02:58
Vacías 00:03:00
O sea, null 00:03:02
Y que una vez deberíais haber 00:03:03
Gestionado algo, aparte de gestionar 00:03:06
Todas las null que pueden aparecer 00:03:08
Y luego el concepto es que 00:03:10
Cuando haya metido al menos 25 00:03:12
O 50 00:03:14
O lo que habéis puesto 00:03:16
Documentos, debería haber hecho algo 00:03:17
Para añadir más documentos 00:03:20
Como doblar o hacer algo 00:03:21
Habría que gestionar algo sobre este 00:03:23
Array 00:03:26
¿Vale? 00:03:28
Dox 00:03:30
Es igual a 0 00:03:32
Si quiero ser específico 00:03:34
Esto 00:03:43
Nunca 00:03:45
Nunca, nunca 00:03:49
Esto 00:03:50
Mientras estáis trabajando en esta clase 00:03:52
Si, evitamos problemas 00:04:01
De hecho, el hecho de que me lo haya puesto en azulito 00:04:03
Y que esto sea azulito, me está diciendo que me está refiriendo a eso 00:04:05
¿Vale? 00:04:08
Mientras que no creé aquí dentro 00:04:08
Otro string 00:04:10
Docs 00:04:12
Y entonces ahora me está pillando 00:04:14
Este de aquí 00:04:17
Entonces si este es null 00:04:17
Entonces lo tengo que crear 00:04:22
Y como cada vez que llamo rellena 00:04:24
Pongo dos 00:04:26
Pues es fácil 00:04:27
Docs es igual a 00:04:28
New documentos 00:04:32
De dos 00:04:34
De esta forma he creado un espacio 00:04:36
De dos posiciones 00:04:45
Vale, si no 00:04:46
Pues ahora tengo 00:04:49
Un problemilla, tengo un array 00:04:54
Que técnicamente está lleno 00:04:56
Y necesito dos posiciones más 00:04:58
Entonces, ¿qué hago? 00:05:00
Documento 00:05:05
Aux 00:05:06
Es igual a new 00:05:13
Documento 00:05:14
¿De cuántas posiciones? 00:05:16
Docs 00:05:20
Punto length 00:05:21
Más 2 00:05:23
Pillo lo que tenía antes 00:05:32
Y le añado 2 00:05:35
¿Vale? 00:05:36
Fenomenal 00:05:39
¿Y luego qué hago? 00:05:39
Por 00:05:44
Intis igual a 0 00:05:45
Y más más 00:05:48
Y menor 00:05:49
Que 00:05:52
Docs 00:05:54
Punto leng 00:05:57
Y más más 00:05:59
Copio 00:06:02
Aux 00:06:05
De i 00:06:07
Es igual a dox 00:06:08
De i 00:06:11
Es copiado casi todo en dox 00:06:13
Entonces ahora 00:06:25
Que he hecho la copia 00:06:28
Le digo que dox 00:06:31
Es aux 00:06:33
No, pero no aquí 00:06:35
Y ya está 00:06:38
Ahora tengo el mismo que tenía antes 00:06:46
Con dos espacios vacíos al final 00:06:49
¿Eh? 00:06:51
Miles 00:06:58
No todas 00:06:59
Aceptables 00:07:03
Pero la mayoría 00:07:05
Muchas sí, ¿vale? 00:07:06
Hay objetos para... 00:07:08
Hay funciones de arrays, por ejemplo, para clonar un... 00:07:10
No sé si lo podéis utilizar 00:07:13
No lo sé 00:07:17
Si tenéis otras dudas 00:07:17
Yo lo he hecho de otra forma 00:07:20
Pues me lo preguntáis 00:07:21
¿Cómo lo has hecho? 00:07:23
Que podía crearme un método 00:07:40
Añadir 00:07:42
Fuera que hiciera eso 00:07:43
Lo hemos hecho en ejercicios de añadir un elemento 00:07:45
Y luego aquí crearme un audio 00:07:48
Añadir el audio, crearme un texto 00:07:50
Añadir el texto 00:07:52
Pero a lo mejor copiaba dos veces 00:07:52
Todo el array cada vez que llamaba rellena 00:07:57
Pues no lo sé, ¿vale? 00:08:00
Como también, ¿tiene sentido que me copie todo el archivo 00:08:02
Cada vez que añado algo? 00:08:05
Pues a lo mejor no 00:08:07
A lo mejor sería mejor decir 00:08:08
Pongo 20 posiciones y cada vez que relleno 00:08:09
Pues duplico, no lo sé 00:08:12
¿Vale? 00:08:14
En mi caso, la ventaja que tengo es que no hay elementos null 00:08:15
Porque 00:08:18
Y añado solo lo que me interesa 00:08:20
Claramente pierdo en performance 00:08:22
Es decir, que cuando haya un millón de documentos 00:08:23
He añadido dos más 00:08:26
Tengo que copiar un millón de documentos 00:08:27
Y lo que hay que añadir es más 00:08:30
En realidad no se copia el objeto, se copia la referencia 00:08:31
Entonces no debería ser tan lento 00:08:34
Tal, tal, tal 00:08:36
¿Vale? 00:08:36
Ok, cuando llego aquí 00:08:38
Tengo que crear los nuevos 00:08:41
Documentos y ponerlos 00:08:43
¿Vale? 00:08:46
Pero cuidado que si estoy aquí 00:08:46
Lo tengo que poner en 0 y 1 00:08:48
Si estoy aquí, o sea, si he pasado por aquí 00:08:51
No lo tengo que poner en 0 y 1 00:08:54
lo tendré que poner en no lo sé casi siempre esto podría solucionar son las 00:08:55
últimas dos posiciones entonces dos puntos lentes de menos 12 puntos 00:09:01
lentes menos dos otra opción es que yo y me lo presten a 00:09:07
aquí 00:09:15
true, me da razón 00:09:16
int i 00:09:22
me lo gestione 00:09:25
desde fuera, vale 00:09:26
si entro aquí, no lo toco 00:09:28
entonces empezaré en 0 y 1 00:09:30
si entro aquí, este 00:09:32
lo gestiono 00:09:37
directamente, vale 00:09:41
de esta forma, cuando salgo aquí 00:09:43
valdrá la siguiente 00:09:46
posición libre 00:09:49
Si he pasado por aquí, es 0 00:09:50
Si he pasado por aquí 00:09:53
Me habrá llegado hasta docs.length 00:09:55
Docs viejo 00:09:57
¿Vale? El que tenía menos posiciones 00:09:58
Por lo tanto, docs.length es la nueva 00:10:01
Posición libre 00:10:03
¿Sí? 00:10:05
Entonces puedo simplemente aquí decir 00:10:09
Vale, ahora me creo un audio 00:10:11
No, ya se lo he sumado aquí 00:10:13
Ha venido aquí 00:10:16
Esto es falso y por lo tanto ha salido 00:10:19
Ya estoy listo 00:10:21
Creo 00:10:22
¿Qué queréis crear antes? ¿Un audio? 00:10:29
Audio 00:10:33
Entonces 00:10:33
Ahora aquí hablo con el 00:10:34
Usuario 00:10:38
Que me tiene que dar los datos 00:10:40
Por lo tanto necesito unos scanners 00:10:41
Scanner es igual a 00:10:43
New scanner 00:10:45
De systeming 00:10:46
Y me importo este señor 00:10:48
Y ahora le digo 00:10:55
Vale, si esto 00:10:57
Creo un audio 00:10:59
Y le digo 00:11:07
Nivel 00:11:15
De confidencialidad 00:11:21
Y leo su nivel 00:11:24
De confidencialidad 00:11:26
Int, nivel de confidencialidad 00:11:27
Es igual a 00:11:30
Scan.nextint 00:11:32
Luego digo 00:11:36
Dame el contenido 00:11:38
Contenido 00:11:42
Y me leo 00:11:44
Que leo 00:11:48
A ver, aquí es el clásico 00:11:49
Problema de scanner 00:11:54
¿Vale? 00:11:56
Que 00:11:58
En algunos 00:11:58
En algunos 00:12:01
Ejercicios que hemos hecho 00:12:05
Que leemos estas cosas, a lo mejor lo habéis tirado fuera 00:12:10
¿Vale? De los viejos 00:12:12
de cuando utilizamos carnet que luego un rato que no lo utilizamos pero sabéis que si leo un 00:12:14
número y luego hago una scan next line no me funciona porque el intro que he dado aquí me 00:12:19
lo pilla aquí entonces hay dos opciones para esto o me gestionó esto haciendo un next line a vacío 00:12:29
Sabiendo que antes 00:12:38
He hecho un 00:12:40
Un nextint 00:12:43
Esto no hace nada 00:12:44
Y luego leo 00:12:46
La siguiente frase 00:12:47
Y esto me permite describir lo que me da la gana 00:12:49
O lo simplifico y digo 00:12:52
Oye mira, que me quito de líos 00:12:53
Leo solo una palabra 00:12:56
El contenido será una palabra sola 00:12:57
¿Vale? 00:13:00
Esto me da igual, no es parte de este examen 00:13:01
Concretamente 00:13:04
Con que hayáis encontrado una forma de hacerlo 00:13:05
fenomenal, dejámoslo 00:13:08
y finalmente 00:13:10
es un audio 00:13:15
por lo tanto la longitud 00:13:18
o duración 00:13:20
mejor duración 00:13:23
que es también un intro 00:13:27
porque en realidad para nosotros es longitud 00:13:34
¿vale? 00:13:37
con esta información ya puedo crear el audio 00:13:38
oye, cuidado, me falta algo, ¿qué me falta? 00:13:41
¿qué me falta 00:13:50
para lanzar 00:13:51
Este señor audio 00:13:53
Un ID 00:13:54
Pregunta de un millón de dólares 00:13:56
Se lo pregunto al usuario 00:14:00
El ID 00:14:02
Podrías no hacerlo, podrías preguntárselo 00:14:03
¿Qué implicaciones tienes 00:14:10
Preguntarla al usuario? 00:14:12
¿Qué sentido tiene 00:14:17
Un identificador que se puede repetir? 00:14:19
Ninguno 00:14:22
Entonces cuidado con lo que hacéis 00:14:22
Si la habéis puesto aquí 00:14:25
Que pedís al usuario 00:14:28
el nombre del fichero 00:14:29
luego tenéis que haber recorrido 00:14:31
todo docs a la búsqueda 00:14:33
de si ese nombre existe ya 00:14:35
y si existe ya decirle 00:14:37
este nombre no es válido 00:14:39
es a largo plazo 00:14:41
la otra opción cual es 00:14:46
que implícitamente con vuestro 00:14:48
poder deductivo 00:14:51
podíais deducir desde 00:14:52
el ejemplo que os he pasado yo 00:14:54
pregunta 00:14:56
Sherlock Holmes 00:15:03
número 1. No está en verde. Esto quiere decir que no lo ha escrito el usuario. Y fijaos, 00:15:05
audio 1, texto 2, audio 3, texto 4. ¿Qué os hace pensar esto? Que hay un numerito que 00:15:16
no va por audio o por texto, sino que va por documento, que me añade detrás un número 00:15:30
único. Y ese número único lo hago con static. ¿Es la única forma de hacerlo? No. Es una 00:15:38
forma de hacerlo. De hecho, porque soy magnánimo, en aquí, Sara, si no me equivoco, va a intentar 00:15:46
leer audio 2. Y no le dice, no tienes acceso a audio 2. Te dice, no existe este documento. 00:15:56
Cosa que es muy fea para un archivo de documentos secretos 00:16:09
Porque cuantas menos informaciones das 00:16:13
Mejor, mírame audio 2 00:16:15
No tienes acceso, no existe 00:16:17
Porque me estás diciendo que no existe este documento 00:16:20
De esa forma, si no me estás contestando eso, sé que existe 00:16:22
Muy malo 00:16:25
Pero independientemente de nuestras tramas conspiratorias 00:16:27
El concepto es que 00:16:30
La idea es que si es un identificador 00:16:32
Tiene que ser un identificador 00:16:38
Entonces lo deberíais 00:16:40
Haber hecho como identificador 00:16:42
Si habéis hecho 00:16:44
Que yo puedo poner tres 00:16:46
Cosas con el mismo nombre 00:16:47
Tenemos un pequeño problema 00:16:49
Vamos a ver 00:16:50
Como lo hacemos 00:16:54
Aquí entonces 00:16:56
Lo que voy a hacer 00:16:57
Yo es como lo había pensado 00:17:00
Acá 00:17:02
Que es 00:17:02
Static 00:17:04
private static 00:17:05
numdoc 00:17:08
igual a cero 00:17:10
tiene un valor numdoc 00:17:13
que es estático, vale por toda la clase 00:17:22
y cada vez que crearé un documento 00:17:25
se lo pego como 00:17:27
nombre 00:17:29
y además 00:17:31
lo sumo uno 00:17:32
vale, entonces cuando he llegado aquí 00:17:35
que tengo toda la información para este audio 00:17:36
me creo un nuevo audio 00:17:38
Entonces audio 00:17:40
Aud es igual a 00:17:42
New audio de 00:17:44
Nombre 00:17:45
Nombre lo llamo audio 00:17:47
Mas 00:17:50
Num, como lo he llamado 00:17:52
Un doc 00:17:54
Un doc 00:17:55
Coma, me lo debería dar ahora 00:18:03
Probablemente al punto de coma final me lo dirá 00:18:06
Luego le tengo que 00:18:11
dar, el siguiente es el nivel 00:18:13
de confidencialidad, NC, lo he leído 00:18:15
luego después el contenido 00:18:17
cont, lo he leído 00:18:19
y luego la longitud, L 00:18:20
punto y coma, y ya está 00:18:22
si no me gusta que ponga 00:18:24
audio 1, texto 2 00:18:29
pues lo que puede hacer 00:18:30
siempre aquí es llamarlo doc 00:18:32
entonces saldrá doc1, doc2, doc3 00:18:33
doc4, son documentos 00:18:36
os acordaos también que el 00:18:38
identificador no necesariamente es una palabra como se llama 00:18:40
Es un identificador interno 00:18:42
Podría ser AXFNP 00:18:44
Lo dejo como out 00:18:47
Porque así cuando me lo escribe 00:18:50
Si puedo le digo 00:18:52
Cuando es un audio me tendrá que escribir 00:18:54
Que lo escucha 00:18:57
Y cuando es un texto 00:18:59
Para ayudarme a mí en el debug 00:19:00
Y luego vuelvo a rehacer todo 00:19:01
Pero para el texto 00:19:06
Pero ahora en vez de crear un audio 00:19:09
Creo un texto 00:19:34
Podría haber sacado esto en un fichero externo 00:19:36
Y haber hecho algo para que me creara esta cosa 00:19:39
Probablemente toda la parte hasta la duración 00:19:44
O hasta el número de páginas es la misma 00:19:47
Entonces podría haber al menos parte de esto sacado 00:19:49
Creo un texto 00:19:53
Nivel de confianza lo pongo en cct 00:19:55
Lo pongo en cct 00:19:58
Lo pongo en 00:20:00
Y luego 00:20:03
Cuando lo creo no es un audio 00:20:07
Si no es un texto 00:20:09
Texto 00:20:10
Es un nuevo 00:20:14
Texto 00:20:17
Que ponga dentro texto 00:20:18
Que tenga dentro 00:20:20
Más este no 00:20:22
Esto es 00:20:23
Esto es nft 00:20:29
Y esto es content 00:20:31
Lo que he utilizado aquí 00:20:32
No he reutilizado las variables 00:20:33
Porque me daba gana 00:20:38
Lo podría haber reutilizado tranquilamente 00:20:40
Lo que pasa es que 00:20:42
Acordaos que este numdoc tiene que crecer 00:20:44
Numdoc 00:20:46
Más más 00:20:48
Ahora tengo 00:20:49
Perdón 00:21:01
Tengo 00:21:02
He hecho los dos objetos 00:21:04
Y ahora los dos objetos los tengo que poner 00:21:07
En docs 00:21:10
¿Vale? 00:21:12
Entonces en docs 00:21:13
De i 00:21:15
Pondré out 00:21:16
I++ 00:21:19
Docs 00:21:21
De i 00:21:23
Pondré xt 00:21:24
No hace falta hacer i++ 00:21:26
Porque ya i no la uso más 00:21:33
Porque 00:21:39
¿Te acuerdas que ahí la había 00:21:39
Metida de tal forma 00:21:41
Que cuando salía del primer punto 00:21:44
Y me apuntaba a la siguiente 00:21:45
Posición libre 00:21:48
Por tanto lo uso 00:21:49
Lo he hecho por esa razón 00:21:50
Para que ahora no tenga que ir a buscarme 00:21:53
¿Cuál es la primera libre? 00:21:55
No, sé que la primera es ahí 00:21:56
Y en realidad 00:21:57
Voy a hacer así 00:21:59
No, peligro 00:22:00
Porque Nundog crecerá 00:22:04
Crecerá Nundog 00:22:05
Bueno, entonces dices cuando hay... 00:22:08
Oye, pero estás mezclando ya muchas cosas. 00:22:10
Sí, pero considera que cuando llega aquí, NumDoc ya ha aumentado de dos. 00:22:19
O sea, lo deberías haber hecho esto aquí. 00:22:25
Sí, y cosa por eso. 00:22:29
Pero estás mezclando dos conceptos. 00:22:31
Uno es el identificador de cuántos documentos has creado por ahora 00:22:33
y otro es la posición en libre. 00:22:36
Yo lo dejaría separado. 00:22:40
Tanto, o sea, no lo ganas 00:22:41
Al nivel de, que aquí luego lo tienes que copiar 00:22:44
Igualmente, lo tienes que hacer, por lo tanto 00:22:46
Estás ganando una favor nada 00:22:47
No que esto sea un maravilloso sistema 00:22:49
Para hacer esto, eh 00:22:52
En nuestro examen 00:22:53
Vale, esto era rellena 00:22:55
Cada vez que llamo rellena 00:22:57
Me añade un documento, me pide la información 00:23:01
De un texto, eh, pues sostancialmente 00:23:04
Esto, vale, cuando yo llamo rellena 00:23:06
Aquí se está llamando rellena 00:23:08
Lo que me está haciendo es 00:23:11
Creo dos documentos 00:23:15
Audio 1 y me pide 00:23:17
Las varias cosas, texto 2 00:23:19
Y me pide las varias cosas y aquí ya la he creado 00:23:21
Y la he metido en el documento 00:23:23
Es la primera parte 00:23:24
Podría ya empezar con un 00:23:26
Main para probar rellena 00:23:29
Que sería esta parte aquí del main 00:23:31
¿Vale? 00:23:33
Esto, archivo de documentos punto rellena 00:23:34
Archivo de documentos punto rellena 00:23:36
Cuidado, no estoy haciendo ningún new 00:23:37
Porque es todo staff 00:23:40
Preguntas hasta aquí 00:23:42
Vale 00:23:44
Entonces paso al siguiente 00:23:50
Leer documentos 00:23:56
Lo que me hace es 00:23:57
Recibe un operador y un parámetro 00:23:59
El parámetro es un id 00:24:01
Perdón, recibe dos parámetros 00:24:02
Que son 00:24:05
Operador e id 00:24:07
Entonces leer 00:24:09
Public 00:24:11
Void 00:24:13
leer documento 00:24:15
es void 00:24:18
lo escribe, ¿no? 00:24:19
si es correcto 00:24:23
lo muestra, ¿vale? 00:24:25
leer documento 00:24:27
operador 00:24:29
string id 00:24:33
¿qué tiene que hacer este método? 00:24:39
pues sustancialmente 00:24:45
buscar un objeto 00:24:47
Vale, un documento 00:24:48
Una vez que haya encontrado este documento 00:24:51
Sobre este documento tengo que hacer 00:24:53
Llamar, su método mostrar 00:24:55
Al que le pasaré 00:24:59
Este señor de aquí 00:25:00
Y que sea él que haga las cosas que quiera 00:25:02
Entonces 00:25:04
Vamos a intentarlo 00:25:08
Busco el documento 00:25:10
Para el documento tengo que buscar la id 00:25:13
Por lo tanto 00:25:14
For 00:25:16
Documento 00:25:19
Dos puntos docs 00:25:22
Punto 00:25:32
Ide 00:25:33
Punto equals 00:25:35
Ide 00:25:38
Si os confunden 00:25:40
Los ides 00:25:45
Esto lo llamáis 00:25:46
Buscado 00:25:47
Buscado 00:25:49
Me estoy yendo a mirar 00:25:53
Todos los documentos en D 00:25:57
Si encuentro un documento 00:25:58
Cuyo ID 00:26:00
Sea buscado 00:26:01
Sean iguales 00:26:04
Entonces este documento D 00:26:05
Es el que quiero utilizar 00:26:07
Para hacer algo 00:26:10
¿Y qué hago? 00:26:12
D.mostrar 00:26:19
¿De qué? 00:26:21
¿Se acuerdan? 00:26:25
Hay que mostrar 00:26:27
Recibía un objeto 00:26:28
Que era 00:26:29
Solo puedo usar la O 00:26:31
Fijaos que luego 00:26:37
Él no me mirará si esto es un operador 00:26:41
Si es un operador 00:26:43
Autorizado 00:26:44
Me mirará si este objeto que te ha pasado 00:26:46
Esta instancia que te ha pasado 00:26:49
Implementa 00:26:51
Autorizado 00:26:53
Si implementa autorizado le puedo pedir la autorización 00:26:54
Y puedo ver si lo puedes leer o no 00:26:57
Entonces aquí yo le he puesto operador 00:26:59
En realidad le podría poner 00:27:01
Object y pasar lo que me da la gana 00:27:03
Porque luego aquí 00:27:05
Lo que necesita él es un objeto 00:27:06
¿Sí? 00:27:08
Podría ir aquí a puesto 00:27:13
Object, oper 00:27:14
Y esto me lo, me sigue funcionando 00:27:16
Porque mostrar recibe un objeto 00:27:19
Aquí, objeto cualquiera 00:27:21
¿Sí? 00:27:23
Y aquí, que no sé a quién 00:27:24
En la, no sé si está aquí 00:27:27
Me ha dicho, ah, ma aquí 00:27:28
Tengo que hacer lo que pone 00:27:31
Que dice 00:27:33
Se tratará de 00:27:34
No me acuerdo 00:27:35
Me pregunto, ¿tengo que comprobar 00:27:38
Si este operador lo puede leer? 00:27:41
Porque ya lo haces aquí 00:27:44
Ya lo has hecho eso 00:27:47
Si aquí te pones otra vez 00:27:49
A mirar si OPR es 00:27:51
Un autorizado 00:27:53
Y si su autorización 00:27:54
Es igual a la cosa 00:27:57
Estás volviendo a rehacer, mostrar 00:27:58
Que ya existe 00:28:00
Estás duplicando código para nada 00:28:01
¿Me entendéis? 00:28:04
UDAS 00:28:10
Pues si le contestas 00:28:10
Sí, pero no 00:28:13
Sí, lo tienes que hacer 00:28:15
Pero no aquí porque ya lo has hecho 00:28:20
Sí, pero no 00:28:22
Clarísimo 00:28:23
Implementa la interfaz 00:28:24
Clarable 00:28:28
Entonces 00:28:29
¿Qué más? 00:28:32
Y ya está 00:28:33
Se acabó 00:28:35
Vale, esto es feucho 00:28:38
Porque, eh 00:28:41
No te gusta 00:28:42
¿Cómo lo quieres? 00:28:46
Es foricho, para ir por colecciones 00:28:51
Es muy interesante 00:28:53
Ahora, el problema de este foricho 00:28:54
Es que 00:28:56
Cuando yo ya lo he encontrado 00:28:57
Sigo mirando todos los demás 00:29:00
Se utiliza un break 00:29:02
¿Vale? Aquí 00:29:11
Break 00:29:11
Probablemente 00:29:12
No lo hemos visto 00:29:14
¿Vale? 00:29:18
Pero el concepto es que hasta con el boolean no salgo 00:29:19
Porque aquí no hay una condición booleana que estamos comprobando 00:29:22
Entonces me queda aquí dentro 00:29:25
Con un boolean que dice 00:29:26
Cuando lo he encontrado le pongo el boolean a true 00:29:30
Eh, pero el if está dentro del for 00:29:32
A mí no me interesa 00:29:38
Pero entonces ya que tiene que hacer una comparación 00:29:39
Que me la haga 00:29:45
Porque técnicamente entrará en uno solo 00:29:46
Porque si yo he hecho que los IDs son únicos 00:29:49
Si no lo he hecho 00:29:51
Pues tenéis un problema 00:29:55
Desde esto 00:29:55
Pero sí 00:30:01
Yo creo que con esto 00:30:03
Funcionaría, vale 00:30:11
Aún así, lo habéis puesto así, vale 00:30:12
Perto un poco de tiempo 00:30:15
Miro más, no 00:30:16
La eficiencia es una tarea 00:30:17
Más bien de segundo 00:30:20
Este año aprendamos a hacer las cosas 00:30:21
Y hacerlas aceptablemente bien 00:30:24
Luego si lo sabéis también optimizar 00:30:27
Era pues mucho mejor 00:30:29
Y lo que me interesa es que lo tengáis en cuenta 00:30:30
Que os deis cuenta 00:30:33
Que esto está, si hay un millón de documentos 00:30:34
Y este es el primero 00:30:37
Al primero ya habría podido dejar 00:30:38
Y en vez hace un millón de if más 00:30:41
Esto a nivel de eficiencia es feo 00:30:43
¿Vale? 00:30:45
¿Cómo lo soluciono? 00:30:47
Pues o no hago el for each 00:30:48
Hago un for normal 00:30:50
Entonces allí sí que tengo la condición 00:30:52
Y puedo utilizar el que cuando he encontrado 00:30:53
Entonces sal 00:30:56
O si no, uso el break aquí 00:30:57
Vale 00:31:00
Esto debería estar suficiente 00:31:04
Listo, vale 00:31:07
Tened en cuenta que esto ya me escribe en pantalla 00:31:09
Entonces si lo he encontrado 00:31:11
Esto ya me escribirá en pantalla 00:31:12
No tienes acceso o si tienes acceso 00:31:14
¿Vale? 00:31:17
Problemillas aquí que puede haber 00:31:18
Esto 00:31:20
Pues es null 00:31:21
Es null explota 00:31:22
Técnicamente si habéis 00:31:26
Puesto private aquí 00:31:36
Entonces nadie puede acceder 00:31:38
Aquí dentro y modificar 00:31:40
Os docs directamente 00:31:42
La única forma actual para 00:31:43
Toquetear docs es 00:31:46
Con el rellena 00:31:48
Y el rellena lo habéis hecho vosotros 00:31:49
Y habéis puesto que no puede ser null 00:31:51
Porque no habéis dejado espacios libres 00:31:54
Pues entonces aquí os podéis 00:31:56
olvidar tranquilamente de nul 00:31:58
ahora si no habéis hecho estas dos 00:32:00
cosas, pues aquí teníais que comprobar 00:32:02
que era nul 00:32:04
¿pasaría algo si hay nul en el propio for? 00:32:05
no, porque tú pides 00:32:09
el nul, lo pones en D 00:32:10
y es una referencia a nul, tranquilamente 00:32:11
y cuando lo usas, que pum, nul pointer exception 00:32:14
vale, en el if, pues se pone antes de 00:32:16
y ya está 00:32:18
vale, aquí alguien me ha preguntado 00:32:19
más si yo he gestionado 00:32:24
todo 00:32:26
Sabiendo perfectamente 00:32:27
Que no hay null 00:32:30
¿Puedo evitar de poner el not null? 00:32:31
El if not null 00:32:34
Pero si lo has hecho bien 00:32:37
Si yo he hecho todo esto bien 00:32:38
Y mira sin ningún null 00:32:41
Y luego aquí no le he puesto private 00:32:42
Pues no lo has gestionado 00:32:44
Yo puedo acceder al doc 00:32:45
Acceder al docs de posición 3 00:32:48
Igual a null 00:32:50
Ya me he cargado 00:32:51
No puede haber null en doc 00:32:53
dudas 00:32:56
vale 00:32:59
no he sido yo 00:33:01
vamos a seguir adelante 00:33:06
tercero 00:33:11
obtener documentos 00:33:14
esto creo que son los de emergencia que hacen práctica con 00:33:15
obtener documentos 00:33:18
entonces los documentos 00:33:24
es decir a un nivel de 00:33:25
confidencialidad y devolverá como valor 00:33:28
de retorno un array con todos los 00:33:30
documentos con nivel de confidencialidad 00:33:32
inferior o igual a este parámetro 00:33:34
Parecido al que hemos visto ahora 00:33:36
Public 00:33:37
Void 00:33:39
Obtener 00:33:41
Documentos 00:33:46
Ah, y pilla 00:33:48
Nivel 00:33:52
Int nivel de confidencialidad 00:33:52
¿Qué tengo que hacer? A ver, no es void 00:33:58
Es documento 00:34:05
Allí 00:34:07
Vale, esta era la parte un poquito compleja de esto 00:34:09
Tengo que devolver una red de documentos 00:34:12
La pregunta es 00:34:15
¿Cómo lo devuelvo esta red de documentos? 00:34:16
Es decir, ¿cuántas posiciones 00:34:18
Tiene que tener este señor? 00:34:21
El número de 00:34:23
El número de documentos 00:34:24
Que tengan NC 00:34:26
Para NC o un menor 00:34:28
Lo sé 00:34:30
Entonces aquí tengo dos opciones 00:34:33
O voy buscando de un en uno 00:34:35
Y cada vez que encuentro uno 00:34:38
Lo añado a mi array 00:34:39
Y si mi array está lleno, aumento 00:34:41
Lo copio en uno más grande y aumento uno 00:34:44
Lo copio en uno más grande y aumento uno 00:34:48
O la segunda opción es 00:34:50
Recorro todo docs 00:34:52
Contando cuántos documentos me interesa 00:34:54
Allí me da el número de posiciones 00:34:58
Creo el array con ese número de posiciones 00:35:01
Y vuelvo a recorrerme todo docs 00:35:05
Pillándolos y poniéndolos así 00:35:07
hay una 00:35:10
que igual es peor, la peor de todas 00:35:12
es el mismo tamaño 00:35:14
que la red que vas a recorrer y luego lo acortas 00:35:16
pero claro, igual 00:35:18
si es un millón 00:35:20
no, no, es que 00:35:26
un gasto de hoy igual demasiado 00:35:29
no, no 00:35:33
yo creo que es simplemente más 00:35:34
retorcido para tu mente para entender 00:35:36
y de todas formas 00:35:39
por eso digo 00:35:41
gastas, o sea, no le veo una 00:35:43
ventaja directa 00:35:45
a hacerlo, entonces que lo vas añadiendo 00:35:47
de un mismo 00:35:49
no, no, si ventaja no hay, pero es la que se me ocurrió primero 00:35:49
acordaos también 00:35:52
la gestión de null, vale, si vosotros 00:35:56
lo hacéis de tal forma que no puede haber null 00:35:59
en lo que devolvéis fenomenal, si no 00:36:01
cuidado con lo que hacéis, vale 00:36:03
yo lo haré de la forma de leerlo dos veces 00:36:04
¿por qué? porque soy vago 00:36:07
entonces 00:36:09
copio esto 00:36:11
int num es igual a cero 00:36:15
voy a buscar 00:36:22
los documentos y si 00:36:23
el documento actual 00:36:26
punto 00:36:27
nivel 00:36:29
confidencialidad 00:36:32
es menor o igual 00:36:33
a nc 00:36:36
entonces lo junto 00:36:37
num++ 00:36:40
Cuando acabo este for 00:36:42
Aquí dentro 00:36:47
En num 00:36:49
Tengo cuantos documentos 00:36:50
Cumplen con esta condición 00:36:53
Por lo tanto me creo 00:36:55
Un documento 00:36:57
Subo 00:36:59
Documento 00:36:59
No se que 00:37:02
Res es igual a 00:37:04
New documento 00:37:06
De num 00:37:08
De ese número de posiciones 00:37:10
Y me vuelvo a hacer 00:37:12
Esta cosa de aquí 00:37:16
Los 00:37:17
Me da igual, mayor o menor 00:37:34
Pero el concepto es 00:37:36
No, a mi me interesa saber 00:37:37
Si te doy nivel 3 y tu me das los documentos 00:37:39
De nivel 3 o menor 00:37:41
3, 2, 1 00:37:43
Porque 00:37:47
Por eso me da igual que tu 00:37:50
Lo hayas interpretado de una forma o de otra 00:37:53
Si esto lo has hecho bien, lo que cambia 00:37:54
es que en vez que mayor o igual, has puesto menor o igual 00:37:57
o al revés 00:37:59
no es eso 00:38:00
que te hace perder 00:38:03
ni siquiera 0,5 00:38:04
oye, mira, que esto yo lo había 00:38:07
entendido otra vez, o si tú me dices 00:38:11
no, mira, que yo lo he interpretado de otra forma 00:38:13
y lo he interpretado así 00:38:15
no, no voy a mirar 00:38:16
esto, ¿vale? a lo mejor el concepto 00:38:20
es que como yo lo he interpretado así, aquí 00:38:23
me hace una cosa, que luego a ti te hace otra 00:38:24
¿no? si 00:38:26
El hecho es que yo te he dado un ejemplo 00:38:28
Entonces tú podrías ir a mirar mi ejemplo 00:38:30
Y ver que te estoy poniendo 00:38:33
Nivel 2, 1, 4 y 1 00:38:34
A nivel de confidencialidad 00:38:36
Y que cuando te pido el nivel 3 00:38:38
Te está devolviendo 3 00:38:39
Según el tuyo debería haber devuelto uno solo 00:38:41
El de nivel 4 00:38:44
Según tu definición 00:38:46
Si yo te pido nivel 3 00:38:51
Me das todos los documentos 00:38:52
De nivel 3, 4, 5, 6 00:38:53
Entonces eso 00:38:55
Ah, tú dices que esto no 00:38:59
Imagínate que tú has puesto 3 00:39:05
¿Vale? 00:39:08
Si mi documento de concluida ya vale 1 00:39:09
1 es menor o igual que 3 00:39:12
Por lo tanto me lo das 00:39:13
Vale, puedo seguir 00:39:14
Y ahora que hago 00:39:24
Vuelvo a rehacer esto 00:39:28
Num 00:39:30
Lo devuelvo a 0 00:39:35
Antes de empezar 00:39:37
Y cada vez que encuentro uno 00:39:38
Lo que le digo ahora es 00:39:40
Que en do 00:39:43
No, esto me vale 00:39:44
Que en dox 00:39:45
No, en res 00:39:47
De num 00:39:49
Me pones de 00:39:51
Fijaos que he vuelto 00:39:53
A reacerar cero 00:40:00
Es en num 00:40:02
Por lo tanto la primera vez que pongo aquí 00:40:03
En res de cero ponme el documento que has encontrado 00:40:05
Esto me encontrará 00:40:08
Me entrará aquí exactamente el mismo número de veces 00:40:09
que me ha entrado antes 00:40:12
por lo tanto tengo suficientes 00:40:13
y al final tengo un array 00:40:15
con exactamente esas posiciones 00:40:20
con dentro todos los documentos 00:40:22
que cumplen con esta característica 00:40:24
fijaos 00:40:26
que estos ejercicios de aquí 00:40:33
tampoco son una cosa terrible 00:40:35
este de aquí 00:40:38
tampoco mucho 00:40:43
al fin y al cabo es 00:40:45
pero este muro de texto 00:40:47
es para pedir 00:40:52
de código, ¿no? 00:40:53
esto dices, todo esto 00:40:58
sí, pero es mucho 00:40:59
porque tienes que hablar 00:41:02
con el usuario 00:41:04
eso sí, pero también 00:41:05
a ver, si tú has puesto audio 00:41:18
y texto y te has cargado 00:41:20
que no es un identificador 00:41:22
es un error, sí, porque es parte 00:41:23
del ejercicio, pero 00:41:26
tampoco es un error de, oye, mira 00:41:28
Con eso no pruebas en la vida 00:41:30
O sea, en una empresa sería un error grave 00:41:31
Aquí el examen es sobre otra cosa 00:41:34
¿Vale? 00:41:36
Sí, yo 00:41:41
Falta el último, ¿no? 00:41:41
Documentos, debería funcionar 00:41:51
Eh, nota también 00:41:53
Y yo estoy haciendo todo de... 00:41:55
Porque estoy grabando también 00:41:56
Pero técnicamente vosotros hacéis rellenar 00:41:57
Y probáis 20 veces rellenar 00:42:00
No se hace 00:42:02
Hago todo el examen en los últimos 5 minutos 00:42:04
Intento ver si lo he hecho bien 00:42:07
Porque allí es cuando sacáis un cero 00:42:08
Que no funciona nada 00:42:11
¿Sí? 00:42:13
O sea, esto se os da cuatro métodos 00:42:16
Independientes uno de otro 00:42:19
Además, el primero es para rellenar 00:42:21
Y los otros dependen de rellenar 00:42:23
Porque si no has rellenado, no puedes ni buscar, ni obtener, ni vaciar 00:42:25
Pues entonces, me hago rellenar 00:42:28
Y pruebo rellenar 00:42:30
¿Cómo lo pruebo? Pues lo llamo dos veces 00:42:31
Archivo documentos.rellena 00:42:33
Archivo documentos.rellena 00:42:36
Y luego me hago que me escriba 00:42:37
Lo que hay allí 00:42:39
Cuando he hecho esto allí 00:42:39
Pues me hago leer documento 00:42:44
Y pruebo leer documento 00:42:46
Vale 00:42:49
Ah, tengo que devolverle esta cosa 00:42:52
Horrible que he creado 00:42:57
Return res 00:42:59
Vale 00:43:02
Aquí hay problemas de null 00:43:05
No debería, vale 00:43:08
Pero si lo he hecho bien 00:43:09
L'ultimo 00:43:11
Que es el vaciar documento segreto 00:43:13
Vale, vaciar documento segreto 00:43:18
Public 00:43:22
Voy 00:43:28
Vaciar 00:43:29
Que es un método inútil 00:43:34
Solo para que vosotros lo practiquéis 00:43:37
Pero es 00:43:39
Búscame 00:43:40
El nivel 00:43:41
Los documentos con nivel más alto posible 00:43:42
Con nivel de confidencialidad más alto 00:43:46
¿Vale? 00:43:48
Entonces supongo que sean los que tienen cero 00:43:49
O uno 00:43:52
¿Sí? 00:43:53
De ellos 00:43:54
El primero me lo va a decir 00:43:57
El primero que has encontrado 00:43:59
¿Vale? 00:44:00
Ah, es eso 00:44:01
El primero que 00:44:01
El primer documento con nivel de confidencialidad más alto 00:44:02
Y luego está el ejemplo 00:44:07
Entonces si no lo entendíais 00:44:09
Podíais mirar el ejemplo de que hace 00:44:11
¿Vale? 00:44:12
La idea es que entonces 00:44:13
Esto también está en dos pasos 00:44:14
Primero tengo que saber cuál es el nivel de confidencialidad más alto que tengo 00:44:17
Que no necesariamente es uno 00:44:21
Podría tener solo documentos de nivel 20, 25 y 37 00:44:23
Por lo tanto me tendré que hacer un recorrido de todos los documentos 00:44:28
De todos los archivos buscando cuál es el nivel de documento más alto 00:44:35
El nivel de confidencialidad más bajo, más alto 00:44:41
más el número menor que representa el mayor nivel de confidencialidad. 00:44:44
Cuando tengo eso, vuelvo a empezar desde el principio, 00:44:50
pillo el primero que encuentre con ese nivel y este lo vacío. 00:44:54
Yo hice eso, pero yo había entendido que es el más alto, 00:44:59
si hay más iguales, pues borras todos, pero que te quites el que sea más, 00:45:20
pero como si hubiese varios. 00:45:24
Que podía haber uno o varios, no el primero que te encuentra, 00:45:26
si hay dos unos que todos los de nivel más alto si yo entendí eso pero ordenando lo que traemos 00:45:28
lo me gusta vale como idea como lo ordenamos vale me gusta es una buena solución porque también te 00:45:39
usar el comparto donde hay puesto el comparto donde lo habéis implementado el compare tú 00:45:54
documento vale implements mostrable como comparable vale entonces implementó aquí 00:46:01
Y public int compareto object o. 00:46:13
Justo. 00:46:27
¿No has usado comparable o no sabes que es comparable? 00:46:35
Sí, sí. 00:46:39
Lo puedes ordenar tú por tu cuenta. 00:46:40
Lo ordenas y ya está. 00:46:42
Como sabemos que existe una forma de ordenarlos fácil utilizando una interfaz, es un examen sobre interfaz. 00:46:44
si implementó el compare tú lo que tengo que hacer es devolver a menos 101 dependiendo de 00:46:51
cómo están que nunca me acuerdo como no me acuerdo o tenga acceso al api y lo miro o 00:47:00
si no lo hago de una forma y si luego veo que todo sale al revés por eso lo hago 00:47:10
si lo que tú tienes es menor 00:47:15
si dis es menor 00:47:23
es positivo 00:47:27
es lo raro, es como que es al revés 00:47:28
ahora me lo dices otra vez cuando llegamos 00:47:30
porque tanto se me olvida de aquí 00:47:32
esto tiene también 00:47:33
un pequeño 00:47:37
problemilla 00:47:38
tú los ordenas 00:47:40
vacías el primero 00:47:50
cuidado, vaciar el primero 00:47:52
quiere decir que no lo estás destruyendo 00:47:53
lo estás vaciando 00:47:55
entonces se te queda allí 00:47:56
Y luego lo tienes que volver a ordenar 00:47:58
Porque si no, si llamas otra vez vaciar 00:48:02
Te vuelve a vaciar eso si es el primero 00:48:04
Pero sobre qué lo ordenas 00:48:06
O sea, qué haces tú 00:48:14
Cuando vacías 00:48:16
Para que ese no se te quede primero 00:48:17
Estoy pensando 00:48:20
Porque si era ponerlo nulo era fácil 00:48:37
Pero si no pone nulo 00:48:40
Tienes que tener en cuenta eso 00:48:41
Una opción podría ser 00:48:43
Que tú te quites del medio 00:48:45
O sea, que le des un nivel de confidencialidad 00:48:47
Imposible de dar 00:48:50
Menos uno 00:48:52
Entonces, si es menos uno 00:48:53
Es lo mismo que tu concepto de 00:48:55
Esta vacía 00:48:58
Sí, pero luego lo puedes ignorar 00:49:00
Diciendo si es negativo o cero 00:49:07
Serán los primeros 00:49:10
Que a lo mejor no me gusta mucho 00:49:11
Pero lo que puedes hacer es luego siempre 00:49:13
Ordenar 00:49:16
Porque luego se te quedan allí 00:49:17
molestan y estarán siempre los primeros que vas a mirar lo pensaremos vamos a hacerlas 00:49:20
y simplemente por la curiosidad de utilizar convertir no por otra cuestión a lo mejor 00:49:33
otros métodos serían mejores qué más y dice punto nivel coincidencialidad no estamos comparando esto 00:49:38
Documento lo que estás comparando 00:50:03
Sí 00:50:05
Instance 00:50:07
¿Por qué O? 00:50:17
No sé qué objeto es 00:50:20
Tiene que ser 00:50:21
De mi mismo tipo 00:50:24
Para poderlo comparar 00:50:25
Documento 00:50:26
Documento 00:50:27
Entonces 00:50:28
Return 00:50:34
Punto 00:50:45
Nivel 00:50:46
Confidencial 00:50:47
Menos 00:50:48
Documento 00:50:49
De O 00:50:54
Punto nivel 00:50:55
Confidencialidad 00:50:59
¡Basta! 00:51:00
Eso es lo que me preocupa 00:51:07
Pero 00:51:09
Al ser el número menor es mayor 00:51:09
En confidencialidad 00:51:12
Tiene más confidencialidad 00:51:15
Si lo estás ordenando de mayor confidencialidad 00:51:16
Esa es 00:51:19
Eso es lo que tiene que dar 00:51:22
Menos uno más uno 00:51:24
Si esto tiene nivel uno 00:51:25
Y esto tiene nivel dos 00:51:27
Esto daría positivo 00:51:29
No, daría negativo 00:51:33
Que está mal 00:51:35
Según la definición 00:51:37
Por tanto, aparecería antes 00:51:38
Y está apareciendo antes el 84 00:51:40
Ponemos esto detrás 00:51:42
Ese era el tema que yo me quedé aquí 00:51:44
De rato 00:51:47
De todas formas, esto se hace fácil 00:51:48
Lo ponéis al azar 00:51:50
Miráis como os lo ha ordenado 00:51:52
Y luego cambiáis el orden 00:51:54
Fijaos, esto de los tres if 00:51:55
Si esto, si esto, si esto puede estar bien 00:51:59
Pero 00:52:01
Si tenéis números 00:52:01
Si ordenáis sobre la base de un número 00:52:04
¿Vale? Normalmente 00:52:07
Os compensa hacer 00:52:09
Algún tipo de operación 00:52:11
¿Vale? 00:52:13
Si son string no lo puede hacer 00:52:14
Pero si es un número probablemente 00:52:16
Lo puede hacer ¿Vale? Ya veremos si esto funciona 00:52:19
Tened en cuenta que 00:52:21
También este señor de aquí explota 00:52:22
Porque dice oye mira 00:52:25
Me tienes que dar un return 00:52:26
Y si esto no es verdad 00:52:28
No me estás dando nada 00:52:30
¿Vale? 00:52:31
Entonces 00:52:35
Esto sería un else 00:52:35
Explota 00:52:40
Pero todavía no sabemos explotar 00:52:44
¿Vale? 00:52:49
Sería un throw 00:52:51
Throw 00:52:53
A new 00:52:54
Exception 00:52:56
Algo 00:52:58
El próximo, por eso lo pongo 00:53:04
Algo parecido a esto 00:53:06
Vale, creo una nueva excepción 00:53:07
Lo lanzo 00:53:10
Y entonces explota 00:53:11
¿Vale? Pero bueno 00:53:12
Aquí hagamos 00:53:14
No lo sé 00:53:17
Si no, return 0 00:53:18
Tanto 00:53:22
En mi 00:53:25
En mi contexto 00:53:26
No debería dar problemas 00:53:29
Porque siempre son documentos los que comparo 00:53:30
¿Vale? Pero 00:53:32
Entonces, si yo consigo hacer el compare to 00:53:33
fenomenal me voy a vaciar vale y ahora puedo ordenar mi documento vale como lo 00:53:36
documento como lo rea como lo ordenó a raíz punto sorte de dos balas ordenado 00:53:46
una cosa probablemente porque intentará hacer un acceso a el comparable que hemos 00:53:55
se ha implementado ahora, accede 00:54:09
a algo, si este es null 00:54:11
explota 00:54:13
considera que para ordenarlo 00:54:13
lo que está haciendo es un compare to 00:54:17
entre los varios objetos de la red 00:54:18
por lo tanto, con que uno sea null, explota 00:54:20
claro, esto lo debería poner aquí 00:54:22
si, es not null 00:54:24
no, no, incluso poniéndolo 00:54:26
eso ya no lo sé, depende de que 00:54:29
llama, vale, pero bueno 00:54:32
con esto está ordenado 00:54:33
el array, vale, entonces 00:54:36
Si he ordenado la array 00:54:38
Ahora en primera posición 00:54:39
Encontraré el documento que yo quiero 00:54:41
¿Si? 00:54:44
Entonces 00:54:46
Podría hacer una cosa 00:54:47
Como esta 00:54:50
For int is igual a 00:54:51
0 y menor de 00:54:54
Docs.languette 00:54:55
Punto coma y 00:54:57
Más más 00:54:59
Lo que hago es 00:55:01
Docs 00:55:07
de i.contenido 00:55:09
.equals 00:55:13
Si ya has sido vaciado anteriormente 00:55:15
Siga adelante 00:55:18
Entonces, si not 00:55:21
Si esto no es verdad 00:55:28
Entonces lo vacío 00:55:30
Y si no, lo intento otra vez 00:55:31
Otra vez, otra vez 00:55:37
Además me meto una forma 00:55:38
De salir antes 00:55:41
bolean vaciado 00:55:43
igual a false 00:55:46
mientras que esto sea verdad 00:55:47
not vaciado 00:55:51
sigue haciendo 00:55:53
lo que tiene que hacer 00:55:58
cuando lo encuentres 00:55:59
el primero que encuentres puesto que son ordenados 00:56:01
entonces el primero será el primero más 00:56:04
de confidencialidad 00:56:06
más alta y el primero no vacío 00:56:08
que has encontrado 00:56:10
pues entonces vaciado 00:56:11
Saratrue 00:56:13
Así luego salgo 00:56:14
Y también vacío este documento 00:56:16
Entonces 00:56:20
Docs.di 00:56:20
Punto 00:56:22
Contenido 00:56:24
Es igual a nada 00:56:28
Si quiero le quito 00:56:32
El nivel de confidencialidad 00:56:35
Docs. 00:56:37
Punto 00:56:42
Que no puedo 00:56:42
Porque lo he puesto privado 00:56:45
Si no, para leer un documento 00:56:48
Lo acedo, le cambio el nivel de confianza 00:56:50
Y hago lo que me da la gana 00:56:51
¿Vale? No puedo 00:56:53
Sí 00:56:54
Probablemente con el break 00:56:59
Podrías utilizarlo también, ¿eh? 00:57:02
Pero 00:57:03
Contenido 00:57:03
Esto me puede servir 00:57:08
De cara a que cuando salgo del for 00:57:12
Sé si se ha hecho el vaciado o no 00:57:14
¿Vale? 00:57:16
Si esto sigue falso 00:57:17
Cuando salgo de aquí 00:57:18
Es que no me lo ha hecho 00:57:19
A lo mejor había un array 00:57:21
De documentos que ya han sido vaciados todos 00:57:24
Y entonces no me pilla ninguno 00:57:28
Y cuando sale aquí 00:57:30
Imaginaos que yo luego quiero hacer un programa 00:57:31
Que dice vacíame el archivo 00:57:33
Y me llame muchas veces vaciado, vaciado, vaciado 00:57:34
Hasta que esto 00:57:37
No se atreve 00:57:38
Por ejemplo 00:57:40
Contenido 00:57:42
Ahora tengo que borrar la longitud 00:57:46
O el 00:57:49
¿Cómo se llama? 00:57:51
El número de páginas dependiendo de que es 00:57:53
Entonces ¿Cómo lo hago eso? 00:57:55
Docs 00:58:02
Docs D 00:58:07
Instance 00:58:10
Texto 00:58:15
Entonces, esta cosa de aquí, de texto del punto numPag es igual a cero. 00:58:18
Si en vez es un audio, no, porque si luego después creo también vídeo, a ver si no me va. 00:58:42
pero crear un método en documento abstracto 00:58:57
vamos a hacerlo 00:59:20
si esto no me gusta 00:59:34
lo que puedo hacer es 00:59:36
ir al documento y crearme un método 00:59:39
public 00:59:42
y void vaciar 00:59:44
Que lo que hace es vaciarme 00:59:48
La parte que puedo vaciar 00:59:51
Cuidado que ahora estoy en documento 00:59:52
Puedo hasta borrarme el nivel de confidencialidad si quiero 00:59:53
¿Vale? 00:59:56
Entonces 00:59:58
Int 00:59:59
Is.contenido 00:59:59
Es igual a nada 01:00:05
Dis. 01:00:07
Dis. 01:00:08
Nivel de confidencialidad 01:00:12
Hagámoslo 01:00:14
Es igual a 01:00:19
No es verdad 01:00:21
Podría tener cosas más 01:00:29
Que está aquí, pero bueno, lo asumimos 01:00:31
Para hacerlo seguro 01:00:33
Podría ponerle menos uno 01:00:36
Porque lo dice por algún lado 01:00:37
Que el nivel más bajo es uno 01:00:40
Entonces 01:00:42
Hasta cero podría poner aquí 01:00:44
Solo que el problema es que luego cuando los ordeno 01:00:49
Me los pone todos delante 01:00:52
Y entonces cuando hago cualquier cosa sobre esta array 01:00:53
Antes me hace los vacíos 01:00:55
Que no me interesa 01:00:57
Lo hacemos así 01:00:58
Ahora, esta de aquí vacía un documento 01:01:02
Luego, en texto, por ejemplo 01:01:04
Lo que hago es implementar 01:01:07
Un public 01:01:09
Void 01:01:11
Vaciar, es lo que he llamado 01:01:13
Que lo que hace es 01:01:15
Super 01:01:18
Punto vaciar 01:01:19
Llámame 01:01:21
El vaciar de mi padre 01:01:28
Y luego vacía 01:01:30
Lo que yo quiero 01:01:32
O sea, this.numpatch es igual a 0 01:01:33
Este mismo lo hago en audio 01:01:39
Este es más elegante 01:01:44
¿Veis que es más elegante? 01:01:45
Y aquí en vez de longitud le pongo longitud 01:01:49
¿Por qué es más elegante? 01:01:57
Porque ahora desde aquí 01:02:01
En vez de hacer todas estas cosas de aquí 01:02:02
lo único que tengo que hacer es 01:02:05
docs.dei.vaciar 01:02:07
y por polimorfismo me llamará 01:02:12
el vaciar de audio o el vaciar de texto 01:02:19
correctamente 01:02:24
entonces esto de vaciar se vuelve 01:02:28
con estas dos aportaciones de ordenar los arrays 01:02:33
y luego después borrar el primero 01:02:36
Está claro que 01:02:40
Eso habría que verlo 01:02:42
Porque su documento 01:02:44
Es un archivo de un millón de documentos 01:02:47
No es lo mismo 01:02:49
Reordenar el millón 01:02:51
De cosas que 01:02:53
Pasar dos veces por ahí 01:02:55
Ordenar costa mucho más 01:02:57
Que simplemente hacer una palabra 01:03:01
Si ya está ordenado, tarda más que realmente reconocer 01:03:03
Tú no sabes si está ya ordenado 01:03:05
Está ordenado desde la última vez 01:03:07
que has vaciado. Otra cosa es que tú cada vez que hagas un rellenar, llames un ordenar 01:03:09
al final. Entonces, hasta no te serviría esto, porque cada vez que añades algo lo 01:03:18
ordenas. Pero es el mismo problema, cada vez que añades algo se te complica mucho la fase 01:03:24
de, en vez de añadirlo al final y ya está, pues, si queréis, esto. Probablemente, puesto 01:03:30
que lo tienes que hacer, no estaría 01:03:38
mal ponerlo aquí 01:03:40
después de haber añadido 01:03:40
en rellenar, lo ordeno 01:03:46
y así mi archivo está siempre ordenado 01:03:49
ahora 01:03:51
como estoy gastando 01:03:52
cosas en ordenarlo 01:03:54
a lo mejor leer documentos 01:03:56
estos de aquí que buscan un montón 01:03:58
que me han dado 01:04:00
un nivel de 01:04:01
no, esto no, aquí esto 01:04:03
sobre todo 01:04:06
este de aquí que se basa sobre el nivel 01:04:07
de confidencialidad en un array 01:04:10
ordenado, pues esto se puede 01:04:12
hacer mucho más eficiente, ahora que es 01:04:14
mi array ordenado. Voy 01:04:16
leyendo y el primero que encuentro 01:04:18
que está por encima de este de aquí 01:04:20
ya he acabado mi método, puedo salir. 01:04:22
No tengo que leerme el array 01:04:25
entero. No tengo ni siquiera que leer 01:04:26
sí, tengo que leer dos veces. 01:04:28
Pero no lo tengo que leer dos veces entero 01:04:30
sino que lo tengo que leer dos veces 01:04:32
solo la parte que me interesa. 01:04:34
¿Puedes empezar por la mitad y así batiendo? 01:04:36
Cuando estás buscando ese número, ¿no? 01:04:38
No, porque necesito, como estoy buscando todos los menores que esto, pues seguramente los menores que esto están al principio. 01:04:40
Ah, bueno, al principio sí, claro. 01:04:46
Sería, le échelo a todos hasta que llegue al primero que sea superior a este de aquí. 01:04:50
Claro, claro. 01:04:54
Y allí me paro, hasta aquí hemos llegado. Vale, este es el trozo que tengo que copiar. 01:04:55
O sea que invertir en ordenar, pues me puede mejorar algunos de los métodos que ya tenía. 01:05:02
Cuando he hecho este método aquí no era ordenado, por lo tanto he tenido que devolver los dos. 01:05:08
Lo que he hecho es que 01:05:13
Como la única forma 01:05:20
Para que estén desordenados es cuando se añaden 01:05:22
Cuando yo lo añado, añado cosas desordenadas 01:05:24
Al final, si los ordeno 01:05:26
Si me aseguro que cada vez 01:05:28
Que añado algo, lo estoy ordenando bien 01:05:30
Ya está 01:05:32
Mento 01:05:33
Lo debería hacer también abajo 01:05:35
Porque cuando le estoy poniendo 01:05:38
Que su nivel 01:05:42
Se vuelve 9999 01:05:44
9 y por lo tanto lo estoy desordenando. 01:05:46
Suponiendo que usted es eso, 01:05:49
a lo mejor hay otro método para... 01:05:50
Porque casi todos estos de aquí, 01:05:51
sobre todo, hay este de aquí, 01:06:01
esto, 01:06:04
esto, 01:06:05
lo está buscando. 01:06:07
Entonces, si tú estás acumulando 01:06:09
todos los vacíos 01:06:11
al principio de mi array, 01:06:13
cada vez que haces 01:06:16
esto, estás pasando por un montón 01:06:18
de documentos vacíos 01:06:19
que no te sirven de nada. 01:06:21
A ver, todo este sistema está mal hecho, ¿vale? 01:06:23
Es para que vosotros hagáis un examen, no para que efectivamente me llame la CIA 01:06:28
y me diga, no obstante, hay policía aquí, que me diga, oye, mira, qué bien, 01:06:33
qué trabajo maravilloso habéis hecho con vuestros, os queremos todos allí. 01:06:38
Bueno, no, eso todavía faltará un par de años. 01:06:43
Para esto... 01:06:46
Autor/es:
Stefano Cihiesa
Subido por:
Stefano C.
Licencia:
Reconocimiento - No comercial
Visualizaciones:
13
Fecha:
14 de febrero de 2023 - 14:07
Visibilidad:
Clave
Centro:
IES ROSA CHACEL
Duración:
1h′ 06′ 50″
Relación de aspecto:
1.78:1
Resolución:
1280x720 píxeles
Tamaño:
559.02 MBytes

Del mismo autor…

Ver más del mismo autor

EducaMadrid, Plataforma Educativa de la Comunidad de Madrid

Plataforma Educativa EducaMadrid