Saltar navegación

20250401 ejemplo obj serializable - 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 1 de abril de 2025 por Stefano C.

13 visualizaciones

Más información Transcripción

Descargar la transcripción

entonces me he creado aquí una clase app que es una palabra está vacía vale me ha hecho una clase 00:00:00
alumno y ahora lo que vamos a hacer es intentar crear una pequeña clase que lo que hagan a crear 00:00:09
alumnos y pero me los guarde en un fichero como objetos y no como como tipo de texto 00:00:17
vale, esto es desde cero 00:00:28
por lo tanto vamos a repasar 00:00:34
también como se hace 00:00:36
todo, vale, entonces aquí 00:00:37
lo que vamos a 00:00:40
crear es una aplicación 00:00:42
hacemos dos 00:00:44
aplicaciones distintas, una aplicación 00:00:45
que simplemente es para guardar 00:00:48
los 00:00:50
los objetos, vale, los 00:00:51
alumnos, etc, etc 00:00:55
Y luego hacemos una aplicación distinta que en vez de lo que se encarga es de cargar los objetos y visualizarlos, ¿vale? Así, se podría hacer como hemos hecho la otra vez en dos tabs y luego cambio de tab a otro, pero más o menos da igual. 00:00:57
Entonces, esta de aquí será la app para crear alumnos. 00:01:13
La hago fea porque no tengo ganas de perder tiempo en esto. 00:01:17
Pero, bueno, ¿me entendéis? 00:01:20
Aquí tenemos TextField. 00:01:23
Antes del TextField, cambio este de aquí en un Absolute. 00:01:25
TextField. 00:01:36
Esto será el nombre. 00:01:37
Esto será el apellido. 00:01:44
aquí habrá un botón para añadir 00:01:47
vamos a intentar 00:02:01
para añadirlo a la 00:02:08
¿cómo se dice? 00:02:10
a la estructura dinámica que va a ir construyendo 00:02:13
y luego hacemos que 00:02:16
intentamos hacer que al cerrar 00:02:20
ayer lo hicimos y luego no lo hicimos 00:02:22
al cerrar esta aplicación 00:02:24
como última cosa que haga antes de cerrarse el todo 00:02:27
Intente guardar el fichero, o sea los datos que ha creado en un fichero 00:02:30
Y se apaga así, vale 00:02:38
Vamos a verlo, si lo conseguimos 00:02:39
Entonces este botón de aquí lo llamamos save o add 00:02:43
Y pondremos add 00:02:47
Este de aquí lo llamamos txt nombre 00:02:51
este de aquí 00:03:00
lo llamamos 00:03:03
txt 00:03:06
apellido 00:03:07
vale 00:03:09
aquí debería poner 00:03:14
una cosa más bonita 00:03:16
pero vamos a la funcionalidad 00:03:18
vale, no vamos a la 00:03:21
a la estética 00:03:22
ok, entonces 00:03:25
ahora tengo estas dos cosas 00:03:26
cuando le doy al botón add 00:03:28
tengo un action listener 00:03:30
que tiene que hacer algo, vale 00:03:32
primero de todo tengo que ponerme aquí donde guardo las cosas vale entonces tendré un arre 00:03:33
listo un linked listo una estructura de este tipo un set podría hacer un set para que si 00:03:46
intentas añadir dos veces el mismo alumno no te lo añade dos veces y que si lo añades una segunda 00:03:51
vez lo sobre escribe o algo por el estilo vale no lo sé se podría hacer una set para intentar 00:03:58
hacer que haya como clave un el identificador para que luego sea más fácil buscar un alumno 00:04:08
por identificador por ejemplo hay varias opciones está dejo vosotros a monset set alumnos es igual 00:04:16
al año más set luego si necesito algo más de asset lo pondré aquí también pero si lo hago 00:04:29
así, mañana si quiero cambiar 00:05:03
esto en una cosa distinta 00:05:05
como un trisecto o cosa por el estilo 00:05:07
no me importa porque ya 00:05:08
esto 00:05:10
lo cojo, ¿vale? por eso lo dejo más 00:05:13
con una super clase 00:05:15
en vez que una super clase, si ahora 00:05:17
cuando estoy haciendo trabajo me doy cuenta 00:05:19
que necesito algo más de esto 00:05:21
pues ya, ¿vale? 00:05:22
entonces, ahora 00:05:25
aquí, al botón 00:05:27
add, me crea un nuevo 00:05:29
alumno, alumno 00:05:31
A es igual a new alumno 00:05:32
Txt 00:05:36
Txt 00:05:41
Nombre punto get text 00:05:42
Coma 00:05:46
Txt apellido 00:05:48
Punto get text 00:05:51
Punto y coma 00:05:54
Vamos a hacer un paréntesis 00:05:58
Vale 00:06:00
Y con esto me crea un alumno 00:06:01
Y ahora lo que haré es que alumnos.ad, esta cosa aquí lo que me está haciendo es, cada vez que le doy al botón ad me añade en este set, este alumno. 00:06:03
Pregunta para vosotros, entrego esto, ¿cuánto saco? ¿Qué me falta? ¿Qué no he hecho que debería hacer y que suspenda automáticamente el RA7? 00:06:27
colecciones, el que habéis suspendido todos 00:06:48
ah bueno, entonces el RSI 00:06:56
colección 00:07:00
¿por qué he suspendido 00:07:03
las colecciones? 00:07:04
la idea es también que el lunes 00:07:09
lunes, o sea, no 00:07:12
dentro de seis meses, lunes 00:07:13
hacemos un examen 00:07:15
para que vosotros podáis recuperar 00:07:17
el 6 con el objetivo 00:07:20
que vosotros estudiéis algo 00:07:22
y recuperéis el 6 00:07:24
pero si no estudiáis 00:07:25
no lo vais a recuperar 00:07:27
la idea es que 00:07:28
en estas semanas vosotros habéis estado 00:07:31
haciendo ejercicios sobre clases 00:07:33
sobre 00:07:35
colecciones 00:07:37
¿no? el intento es bueno 00:07:38
pero lo que has dicho no 00:07:54
vuestro compañero ha dicho 00:07:55
hay que hacer el equals 00:08:01
porque es un hash 00:08:02
estabas allí, cuando has dicho 00:08:04
hay que definir el equals, has dicho, ah menos mal 00:08:11
porque es un hash 00:08:13
Claro, hay que hacer el equals porque es un set 00:08:14
Y el h porque es un hset 00:08:19
Pero acordaos que todas las veces que me tocáis un set o cosa por el estilo 00:08:25
Como el set se basa en que no puedo añadir dos veces el mismo alumno 00:08:32
Entonces necesito definir cuándo dos alumnos son iguales 00:08:36
Entonces tengo que tocar el equals. 00:08:45
Y cada vez que toco el equals tengo que tocar el hash, el hash code, ¿vale? 00:08:47
Sobre todo porque este es un hash set, entonces utilizará el hash code para guardar las cosas ahí dentro, organizar las cosas. 00:08:52
Pues entonces necesito toquetear los dos. 00:08:58
Y en alumno, como la otra vez estaba haciendo un, ¿cómo se llama esto? 00:09:01
Un relist, pues entonces no los he puesto. 00:09:07
Pero bueno, simplemente me voy aquí y le digo, 00:09:10
genérame un hash code y un equals. 00:09:18
Pregunta para vosotros, ¿el equals y el hash code sobre qué se tienen que basar? 00:09:20
Es decir, ¿cuándo dos alumnos son iguales? 00:09:26
Cuando tienen la misma idea. Por eso existe la idea. 00:09:40
No me interesa el nombre y el apellido. 00:09:43
Me interesa la idea. 00:09:47
¿Sí? 00:09:49
¿Sí? Técnicamente podría haber dos alumnos que se llamen exactamente igual. 00:09:50
Lo hecho es que si tienen también el mismo ID, pues son el mismo alumno. 00:09:56
Si tienen ID distintos, pues son dos alumnos que se llaman igual. 00:10:01
¿Sí? Entonces lo que me interesa de verdad es el ID. 00:10:06
Entonces aquí marco solo el ID. 00:10:09
Generate. 00:10:11
y aquí ahora tengo mi 00:10:12
equals y mi hashcode 00:10:14
¿vale? basados 00:10:16
sobre el identificador de este alumno 00:10:17
¿sí? vale 00:10:20
perfecto 00:10:22
lo hago aquí 00:10:23
y ya está, entonces este de aquí 00:10:25
me debería funcionar 00:10:28
ahora mismo añadiendo 00:10:30
la cosa, hagamos un 00:10:32
chiso 00:10:34
de alumnos 00:10:34
vamos a ver si hace algo 00:10:38
pongo el alumno A 00:10:43
y me ha añadido el alumno A 00:10:46
pongo el alumno B 00:10:51
y me ha añadido también B 00:10:55
fijaos que ahora mismo 00:10:58
el orden 00:11:01
no lo garantiza 00:11:03
¿vale? 00:11:07
entonces aquí 00:11:10
habrá que ver qué hacemos 00:11:11
a la hora de 00:11:13
¿qué? de recargarlo 00:11:15
De cuando cargo los ficheros, los alumnos. 00:11:20
Porque ayer los alumnos se guardaban ordenados y se escribían en el fichero ordenados. 00:11:28
Vale, perfecto. 00:11:35
Entonces cuando lo recargaba no tenía que hacer nada con el identificador 00:11:36
porque venían ordenados con el identificador correcto. 00:11:40
Entonces, perfecto. 00:11:43
Pero ahora no lo sé. 00:11:44
Porque si os fijáis, ya me los ha mezclado. 00:11:46
Lo escribiera con este orden de aquí 00:11:51
Cuando lo recargo 00:11:54
Si voy pillando del primero al último 00:11:56
Este de aquí se me transformaría 00:11:58
En el alumno cero 00:12:00
Este en el uno y este en el dos 00:12:01
Entonces tendré que tener cuidado 00:12:03
Con esto 00:12:06
Tendré que hacer algo con esto 00:12:07
¿Qué hago con esto? 00:12:10
Punto short no, punto short a lo mejor 00:12:15
Punto short 00:12:17
Es corto 00:12:20
Short es 00:12:21
Short 00:12:22
short, short, short 00:12:25
short no, short 00:12:27
¿qué hago? 00:12:29
¿qué hago? 00:12:41
comparable, vale 00:12:42
¿qué hago? 00:13:02
alumno A 00:13:17
es igual a alumno 00:13:19
ahí 00:13:21
aprenderé a escribir uno de estos años 00:13:25
porque esto tiene que ser un alumno 00:13:28
¿sí? 00:13:31
y si no es, que explote 00:13:34
¿sí? 00:13:36
¿Y ahora qué hago? 00:13:38
O punto id menos a punto id. 00:13:45
Bueno, dis. 00:13:52
Me he equivocado seis veces. 00:13:57
Dis aquí y a aquí. 00:13:59
Ahora sí. 00:14:01
Esto ordenado es por id. 00:14:04
Ahora, la duda que tengo es a ver si me lo ordena al revés, del último al primero, pero creo que no. 00:14:07
O sea, en teoría, si este es el alumno 0 y este es el alumno 3, 00:14:14
Me hará 3 menos 0 00:14:17
Y por lo tanto me dirá que esto es mayor que esto 00:14:19
O sea que no 00:14:22
Debería ser al revés 00:14:23
Luego lo probamos y si sale al revés 00:14:25
Lo cambiamos 00:14:28
Si ahora esto es 0 00:14:29
Y esto es 3 00:14:32
Sale un número negativo 00:14:33
Entonces me está diciendo que this viene antes que este 00:14:35
O sea que este debería ser correcto 00:14:38
Si son el mismo y de 00:14:41
Me dará 0 00:14:42
Si son este aquí es 3 y este es 0 00:14:43
pues me dirá que 3 viene antes de 0 00:14:46
porque me da un número positivo 00:14:49
¿os acordáis como funciona el compare? 00:14:50
no, pues miradlo 00:14:53
¿sí? 00:14:55
entonces con esto en teoría 00:14:57
ya se pueden comparar 00:14:59
y se pueden organizar 00:15:01
¿qué hago? vamos a ver 00:15:02
sí, pues ahora 00:15:32
me lo está poniendo bonitos 00:15:48
organizados 00:15:50
¿vale? 00:15:52
puede que esto no sea 00:15:57
la forma más guay de hacerlo 00:15:59
yo aquí estoy creando 00:16:01
como los voy dando ordenados 00:16:03
estoy creando un tree 00:16:05
que en realidad no es un árbol 00:16:07
en realidad está yendo todo a la derecha 00:16:09
¿sí? 00:16:11
porque le pongo el 0, lo pongo aquí 00:16:13
le pongo el 1, oh está a la derecha, le pongo el 2 00:16:15
oh está a la derecha del 0, está a la derecha 00:16:17
del 1, oh le pongo el 3, está a la derecha 00:16:19
del 0, está a la derecha del 1, está a la derecha 00:16:21
del 2, entonces sostancialmente 00:16:23
me está saliendo una relist 00:16:25
¿sí? pero es una 00:16:26
opción para lograr esto la otra opción es dejarlo con asset y luego hacer un short pero no sé cuánto 00:16:32
gano cada vez que añado uno a hacer un reorganización de todo el asset es útil y es 00:16:40
rápido cuando no te interesa la el orden pero si cada vez tu idea no me interesa el orden pero 00:16:48
ordena melo cada vez que pongo algo pues entonces las 7 también es la cosa más interesante si me 00:16:56
interesa el orden pues entonces tengo el tricet que me garantiza el orden garantiza que me lo 00:17:04
estaba ordenando es una opción la otra opción que nos queda es hacer el asset modificar el alumno 00:17:08
para que haya, por un lado, el constructor este de aquí, que me da el identificador definitivo, 00:17:19
y otro constructor donde acepto yo el identificador, pero me expongo a que luego haya problemas con los identificadores. 00:17:28
Entonces, es peligroso. 00:17:38
O sea, que alguien me meta el alumno 500 sin haber hecho el 499, 00:17:41
y que entonces se quede allí un código que no existe. 00:17:45
Y no lo sé, ¿vale? Por lo tanto, prefiero dejar esto que se haga así y organizar esto de esta forma. Vale, perfecto. Entonces, ahora lo que hemos hecho es, sí, tú ayer no estabas, ¿verdad? Haber estado ayer. 00:17:50
pues empieza desde cero 00:18:29
pero como tú nada más encenderlo 00:18:32
vas a cargar 00:18:34
los ficheros que tenías antes 00:18:36
los alumnos que tenías antes 00:18:38
pues técnicamente lo que estás haciendo 00:18:40
como se dice, creas el primero 00:18:43
y le darás cero, creas el segundo 00:18:47
y le darás uno y entonces 00:18:48
tu aplicación llegará a un momento que has creado 00:18:49
los, has dicho catorce 00:18:52
antes y entonces el próximo 00:18:54
que crearás será el conidentificador catorce 00:18:56
funcionaba, ¿vale? 00:18:58
hoy es un poquito más complejo 00:19:01
porque tenemos dos aplicaciones distintas 00:19:03
entonces habrá que ver qué hacemos 00:19:05
pero, por ahora 00:19:06
felices 00:19:11
¿sí? 00:19:13
es un problema 00:19:17
para 00:19:18
los alumnos de la 00:19:18
del después de recreo 00:19:21
probablemente, ¿sí? 00:19:23
entonces, ahora 00:19:26
nos queda esto de decir, vale 00:19:27
esto funciona todo pero no hemos usado todavía los ficheros ahora queremos guardar esto en un 00:19:29
archivo vale fenomenal entonces para guardar esto en un archivo tenemos que en un determinado 00:19:36
momento guardar una opción meto un botón aquí de pincho aquí el guardo pero hemos dicho intentamos 00:19:41
hacerlo de otra forma cuando yo he usado esta aplicación ya he creado lo que sea pues 00:19:48
simplemente la cierro y que él me lo guarde vale vamos a ver si conseguimos encontrar una forma de 00:19:52
hacer esto window closing aquí tengo un par de eventos que me pueden ser 00:19:58
útil que son cuando la ventana se está cerrando o cuando las ventanas está 00:20:15
cerrada vale entonces vamos a poner esto cuando la ventana ya está cerrada pues haz algo y lo 00:20:21
que hagamos es si eso adiós primera cosa es antes de desarrollar aquí el código miro si 00:20:33
efectivamente me funciona vale lo lanzo añado lo que tengo añadir ahora le doy a cerrar pues aquí 00:20:44
no me escribe adiós, ¿vale? 00:20:52
Por lo tanto, no me 00:20:54
vale como opción. 00:20:56
¿Sí? 00:20:59
Entonces esto lo puedo quitar. 00:21:00
Esto lo ha metido sobre frame. 00:21:02
Este de aquí, por alguna 00:21:07
razón, no me está valiendo. 00:21:08
¿Vale? Probamos el otro. 00:21:10
Probamos el window 00:21:13
closing. 00:21:14
Sí. 00:21:16
Window closing. 00:21:23
Venga. Mientras 00:21:26
se está cerrando que vea algo y lo probamos añado lo cierro pues ahora me ha escrito algo pues esto 00:21:27
me vale sí o los pruebas y o si no hago como hacen las personas humanas vale que es lo busco 00:21:39
internet en internet busco hoy quiero hacer un evento cuando se está cerrando la cosa donde lo 00:21:47
pongo y allí o viendo así que closet de no me ha funcionado el closing no me ha 00:21:54
funcionado abro chat gpt y le pregunto qué diferencia hay entre el evento 00:21:59
closing el evento a closet y él me lo explica y luego le digo mira estoy 00:22:04
intentando hacer esto pero si lo pongo en closet no aparece inclusive porque y 00:22:09
él me lo explica vale esto es el uso bueno de la inteligencia artificial 00:22:13
No, hazme código. Eso es feo. 00:22:19
Aún si parece ser que alguien ha dicho, el jefe de ChagPT, 00:22:24
hoy ha dicho que en un par de años ya seréis inútiles. 00:22:30
Sigo. Vale, entonces, hemos encontrado el evento que hace algo cuando se apaga. 00:22:53
Vale, entonces, en este evento de aquí, que ahora no me acuerdo dónde está. 00:23:02
closing 00:23:05
¿vale? vamos a hacer 00:23:11
lo que queremos hacer, que es al 00:23:14
cerrarse, antes de cerrarse 00:23:15
pues intenta escribir en un fichero 00:23:17
entonces creamos nosotros un fichero 00:23:19
por ahí, ¿vale? entonces file 00:23:21
f es igual a new 00:23:23
file de 00:23:25
objetos 00:23:27
.txt 00:23:30
fijaos, nos hará un texto 00:23:34
pero si le pongo .txt 00:23:36
luego lo puedo abrir fácilmente con el block 00:23:38
notes en realidad para ser más bonito así vale o gato aquí se enfada porque no tengo file aquí 00:23:40
podía preguntarme si existe ya o no pero ya lo hace él me creó un object output 3 am os vale 00:23:57
esto también siempre en vuestro programa 00:24:11
se llamará os, desde ahora 00:24:13
para siempre, es new 00:24:15
object 00:24:16
output 00:24:17
stream 00:24:21
si, si, soy todos fanáticos 00:24:23
del 00:24:25
karate veo 00:24:25
aquí le tengo que poner un new 00:24:28
file output 00:24:33
stream 00:24:35
supongo, df 00:24:39
este de aquí 00:24:41
lo cargo, este de aquí 00:24:45
lo pongo en un 00:24:47
try-catch 00:24:49
y ya está 00:24:49
entonces 00:24:55
si esto funciona 00:24:57
ahora puedo escribir mis objetos 00:24:59
¿qué hago? 00:25:01
pues recorro mi set 00:25:03
¿vale? y voy escribiendo 00:25:05
los ficheros, ¿cómo recorro un set? 00:25:07
set es alumnos 00:25:11
alumnos.literator 00:25:12
iterator 00:25:17
de alumno 00:25:22
es igual a esta cosa aquí 00:25:27
y ahora vile 00:25:30
it.asnext 00:25:39
punto 00:25:49
vrite 00:25:51
object 00:25:53
de it 00:25:54
punto 00:25:58
next 00:25:59
esta cosa aquí me debería recorrer 00:26:01
todos los objetos 00:26:08
Pilla un objeto y lo escribe en mi fichero 00:26:09
Entonces, si yo lanzo esto 00:26:13
Escribo el señor A 00:26:20
Escribo el señor B 00:26:24
Escribo el señor C 00:26:27
Y ahora lo cierro 00:26:31
Explota 00:26:33
¿Por qué ha explotado? 00:26:34
Efectivamente, ¿os acordáis que yo os he dicho 00:26:45
Y mira, para poder guardar un objeto, para poder trabajar con los objetos, los objetos tienen que ser, o sea, para poder utilizar Object Output Stream, los objetos tienen que ser serializables. 00:26:47
Y esto no es serializable. 00:26:59
Este es comparable de alumno. 00:27:01
Entonces, este es un alumno. 00:27:07
Y entonces, esto... 00:27:11
Pues entonces, aquí, además de implementar comparable, tengo que implementar también serializable. 00:27:14
Y no puede hacerlo porque solo se puede implementar 00:27:23
Una interfaz, ¿correcto? 00:27:26
¿Qué es que solo se puede hacer uno? 00:27:28
Extender 00:27:38
Solo puede heredar de una 00:27:39
Pero puedo implementar cuanta me da la gana 00:27:41
Por lo tanto, coma 00:27:42
Serializable 00:27:44
Él me pregunta, ¿qué es esto serializable? 00:27:46
Impórtalo 00:27:49
Vale, ya está 00:27:50
Pues no tengo que hacer nada más 00:27:51
Ahora eres serializable, fenomenal 00:27:53
Entonces 00:27:55
voy a buscar 00:27:58
este de aquí 00:27:59
que era permanencia objeto 00:28:02
veis que el objeto me lo ha creado 00:28:04
estará vacío, no, esta cosa rara 00:28:05
¿qué es esto? 00:28:08
ni idea, fuera 00:28:09
probablemente esta es la cabecera 00:28:11
o algo por el estilo, ¿vale? 00:28:14
vuelvo a rehacerlo, vamos a ver 00:28:16
si funciona, hago el A 00:28:18
hago el B 00:28:21
hago el C 00:28:24
y ahora cierro 00:28:26
Ahora ya no explota. Si me voy al ficherito este de aquí, dentro me encuentro esta cosa aquí. ¿Qué es? Ni idea. No es inteligible para el ser humano. 00:28:31
Bueno, veis que hay cosas que no son char, ¿vale? 00:28:51
Ahora, algo, algo lo veo. 00:28:54
Aquí debe de estar nombre por algún lado. 00:28:59
Luego aquí está A, está B, está C. 00:29:02
Pero si os fijáis, además de esto está cosas raras, que no entiendo. 00:29:08
¿Sí? Cuando esto se complica mucho, pues posiblemente no lo entiendo. 00:29:14
¿Sí? 00:29:18
Esto es, son datos escritos como bytes, que luego he abierto con un fichero de texto, con un blog de notas, 00:29:18
que entonces intenta pillarme los bytes y transformármelos en carácteres. 00:29:31
Entonces, aquellos bytes que sí representan carácteres, pues lo consigo leer. 00:29:35
Pero aquellos bytes que no son carácteres, pues salen cosas raras. 00:29:42
¿Sí? Entonces, esto no está pensado para que lo lea un ser humano 00:29:48
¿Ludas? Vale, entonces, tengo mis objetos guardados 00:29:54
¿Sí? Vale, fenomenal 00:30:02
Ahora me hago una segunda aplicación, que es la que quiere importar las cosas 00:30:04
¿Vale? Entonces, en el... ¿Dónde está? ¿Dónde está? 00:30:09
Objetos, permanencia, objetos, será esto, ¿no? 00:30:15
Me crea un nuevo 00:30:19
Aplicación 00:30:21
Que sea 00:30:23
App 2 00:30:26
O App 00:30:27
Show Data 00:30:28
Esta será una nueva aplicación 00:30:31
Donde aquí tendré que empezar 00:30:41
A hacer todo, vale 00:30:43
Lo que crearé es 00:30:45
Un panel aquí en el medio 00:30:47
Un botón 00:30:49
A la derecha 00:30:52
Un botón a la izquierda 00:30:53
no, no, esto no lo quiero 00:31:01
entonces, a ver, espera 00:31:03
metamos antes los botones 00:31:08
botón aquí 00:31:10
otro botón aquí 00:31:11
y en el medio 00:31:14
quiero un panel 00:31:17
en este panel 00:31:18
quiero poner 00:31:22
las 00:31:24
campos de texto 00:31:25
ah, pero espera, este panel 00:31:27
tiene que ser 00:31:30
absolute 00:31:33
Esto va aquí 00:31:35
Esto será el nombre 00:31:40
Esto será el nombre 00:31:42
Y este de aquí será 00:31:46
El apellido 00:31:51
Esto de aquí me permitirá 00:31:56
Me permitirá moverse 00:31:58
Este de aquí 00:31:59
Lo pondré así 00:32:06
Este de aquí lo pondré 00:32:07
Así 00:32:10
y estos tres 00:32:11
mira que bonito 00:32:15
terrible, pero 00:32:19
vale 00:32:22
entonces la idea es que ahora cuando me cargue 00:32:23
cuando se cargue, cuando inicie 00:32:27
este de aquí lo que haga es 00:32:29
leer desde el fichero 00:32:30
toda la información que tiene 00:32:33
y luego empezar a ponerlas aquí 00:32:35
por ahora antes de ponerme a hacer que funcione esto 00:32:36
voy a hablar de los ficheros 00:32:39
tengo que empezar y leerme las cosas 00:32:41
del fichero, vale, entonces 00:32:43
en la parte de inicialización 00:32:44
cuando este hace init 00:32:46
inicialize 00:32:48
aquí voy a 00:32:50
leer los datos, a cargarme los datos 00:32:52
entonces lo que haré aquí 00:32:55
es crearme 00:32:57
un set también 00:32:58
de alumno 00:33:00
alumnos 00:33:03
que es igual a new 00:33:06
3 set de alumno 00:33:09
como antes 00:33:15
vale 00:33:19
esto 00:33:21
y esto 00:33:23
y lo que intentaré hacer es que 00:33:25
al hacer initialize me haga 00:33:28
un cargar datos 00:33:30
por ejemplo 00:33:32
este programa de aquí 00:33:33
lo que tiene que hacer 00:33:38
este método es cargar los datos 00:33:41
desde el fichero y mirarlos 00:33:43
guardarlos 00:33:46
en esta cosa 00:33:46
aquí 00:33:49
entonces, ¿qué hago aquí? 00:33:50
object 00:33:52
file 00:33:57
file 00:33:58
ff es igual a new 00:33:59
file de 00:34:02
objetos 00:34:02
.txt 00:34:05
lo hemos llamado 00:34:07
no me acuerdo 00:34:08
pillo el fichero 00:34:09
aquí podría comprobar 00:34:15
si existe 00:34:16
venga lo hacemos 00:34:17
no quiere 00:34:17
no quiere 00:34:24
o no está dentro de 00:34:26
de otra cosa 00:34:32
no lo sé 00:34:33
import 00:34:33
java 00:34:34
.util 00:34:35
la fila 00:34:37
o a java.io 00:34:40
java.io 00:34:41
input output 00:34:44
aquí object 00:34:47
o input 00:34:50
stream 00:34:52
ois 00:34:53
es igual a new object 00:34:55
input stream 00:34:58
new 00:35:03
file 00:35:04
input stream 00:35:06
de f 00:35:08
ahora no lo haces 00:35:09
vale, esto se enfada 00:35:13
tiene que estar en un track edge 00:35:20
vale, y ahora 00:35:21
lo que voy a hacer es 00:35:25
leer objetos 00:35:28
vale, paso número 00:35:29
uno de prueba 00:35:31
alumno 00:35:33
a es igual 00:35:35
a ois punto 00:35:37
read object 00:35:39
esto se enfada 00:35:42
alumno 00:35:45
se enfada 00:35:48
add catch clause, vale 00:35:50
me añade un class not found exception 00:35:55
si, vale 00:35:57
si, so 00:35:59
vamos a ver si funciona 00:36:03
veis que al cargarse 00:36:09
me ha cargado el primer 00:36:11
alumno 00:36:13
vale, tenía tres alumnos 00:36:15
allí, pam 00:36:17
al cargarse, me ha cargado 00:36:28
los tres alumnos. Pregunta, ¿qué pasa 00:36:31
si leo una cuarta vez? Explosion. ¿Qué 00:36:35
explosion es? End of file exception. 00:36:51
¿Vale? Entonces, esto puede ser 00:36:57
dos opciones. O sé cuántos ficheros hay allí 00:36:59
de alguna forma, cuántos objetos hay allí de alguna forma, 00:37:02
o tendré que hacer algo 00:37:07
para decir, oye, mira 00:37:11
como se dice 00:37:15
cuando llegue 00:37:16
un end of file exception 00:37:19
recoge esta excepción y en vez de 00:37:20
explotar, simplemente ha acabado 00:37:23
la cosa 00:37:24
como el available, por ejemplo 00:37:26
return the number of bytes 00:37:45
that can be read without blocking 00:37:48
vamos a ver esto 00:37:50
vamos a verlo aquí 00:37:52
y vamos a verlo allí 00:38:15
vamos, pem 00:38:17
al principio me dice cero 00:38:19
y aquí me dice cero 00:38:25
entonces tampoco me sirve mucho 00:38:26
en realidad aquí yo me esperaría más 00:38:28
pero como me contesta siempre cero 00:38:30
esto no me vale 00:38:35
porque si yo le pusiera un 00:38:37
mientras los available no son cero 00:38:39
pues no me entraría 00:38:42
entonces esto no me vale 00:38:43
vamos a ver si hay otros 00:38:45
métodos de hoy 00:38:47
que me puedan valer 00:38:48
no lo veo, si 00:38:51
es lo que he dicho antes, pero 00:39:17
él me ha preguntado, no hay un método 00:39:24
para no hacerlo con el try catch 00:39:26
entonces estamos viendo si hay un método 00:39:27
para no hacerlo en un package 00:39:29
aquí, si no me equivoco 00:39:31
lo hacía con available 00:39:34
esta es lectura 00:39:35
de objetos realizables 00:39:45
aquí estaba utilizando el available 00:39:46
pero lo hace no sobre el object 00:39:48
más sobre el otro 00:39:50
entonces, vamos a ver si funciona así 00:39:52
esto es un file input stream 00:39:57
file input 00:40:08
stream 00:40:12
es igual a esta cosa 00:40:17
y aquí ponemos fs 00:40:19
y esto hace con 00:40:20
fs.available 00:40:23
vamos a ver si fs.available 00:40:25
me hace el juego 00:40:27
¡pem! 00:40:30
explota 00:40:31
veis que aquí si lee y aquí no 00:40:32
me ignora 00:40:39
Antes me hace la pregunta 00:40:41
Y luego me ignora 00:40:43
Alexander, hola 00:40:44
Estoy contestando a tu pregunta 00:40:47
Pero vosotros lo sabéis 00:40:49
Jugáis, seguro 00:40:52
En vez de utilizarlo 00:40:54
Sobre el output stream 00:40:57
Lo he utilizado sobre el file input stream 00:40:59
Que es luego el que usa 00:41:01
Entonces si te fijas, este sí me dice 00:41:02
Que al principio hay 142 00:41:05
Y cero 00:41:06
Entonces tengo dos formas de hacerlo 00:41:08
o hago un while 00:41:11
esto.available 00:41:12
no sea cero, o sea, mientras que hay 00:41:14
todavía datos, sigue leyendo 00:41:17
o la segunda opción 00:41:19
es halo, halo, halo 00:41:21
y cuando explotas con un endofile 00:41:23
exception, pues me recupero 00:41:25
y digo, has acabado el fichero y sigue adelante 00:41:27
una de las dos, lo puedes hacer tú 00:41:28
lo lees una vez 00:41:37
cuantos objetos hay, explotas y luego 00:41:38
pero, si 00:41:41
esto es otra cuestión 00:41:43
que, pero 00:41:49
vamos después 00:41:51
es una buena observación 00:41:52
es decir, vale, mas si yo necesito saber 00:41:56
cuantos objetos hay 00:41:58
pues lo que puedo hacer es escribirlo 00:42:00
hacer que 00:42:02
el primer elemento que guardo 00:42:03
no sean objetos 00:42:07
sino sea cuantos objetos voy a guardar 00:42:08
de esta forma cuando voy a leer 00:42:11
la primera cosa que leo 00:42:13
no es un objeto, mas es cuantos objetos 00:42:14
están guardados en este fichero 00:42:17
y luego sé que tengo que leer 14 objetos 00:42:18
son 20 objetos 00:42:21
make sense, lo hacemos después por otra 00:42:22
razón 00:42:25
vale, entonces, esto hemos dicho que 00:42:25
funciona, pues entonces mejoro 00:42:29
un poquito esta cosa de aquí y hago 00:42:31
un vile 00:42:33
fees.available 00:42:34
available 00:42:37
available 00:42:39
no es 0 00:42:41
¿qué hago? 00:42:43
alumnos.add 00:42:46
esto 00:42:52
he borrado también el oís 00:42:54
object 00:43:06
output 00:43:12
stream oís 00:43:14
es igual a new object 00:43:16
output 00:43:19
stream 00:43:20
stream 00:43:22
de fiss 00:43:23
input 00:43:25
input 00:43:29
Entonces, ahora tenemos este mecanismo aquí 00:43:31
Que lo que hace es guardar método 00:43:39
Cuando he hecho todo este while 00:43:40
Si hizo alumnos 00:43:42
Vamos a ver 00:43:45
Lanzo esto 00:43:48
Y veis que me ha guardado los alumnos 00:43:49
¿Vale? 00:43:53
O sea que 00:43:55
Técnicamente no ha explotado 00:43:56
Está bien 00:43:58
Ha cargado todos los alumnos 00:43:59
Con sus cosas, etc, etc 00:44:01
Entonces, ahora lo que puedo hacer, después de haber hecho el cargar datos, es cargar el primer elemento, este de aquí, entonces, ¿qué hago? Me lo guardo, lo hago aquí. 00:44:03
Cuando hagas el cargar dato 00:44:26
Cuando acarga el primer 00:44:28
Elemento 00:44:31
Bolean 00:44:33
Primero 00:44:37
Es igual a uno 00:44:39
Igual a true 00:44:41
Primero 00:44:43
Es igual a false 00:44:47
Y lo que hace es 00:44:49
Primero 00:44:54
Hago algo 00:44:58
Si no 00:45:01
hago esta cosa aquí 00:45:02
si es la primera vez, si es el primero 00:45:04
lo que hago es leerlo 00:45:11
alumno a es igual a esta cosa aquí 00:45:14
luego lo puedo añadir 00:45:21
alumnos.add a 00:45:25
y lo que quiero hacer es escribir los datos de este alumno 00:45:30
en los campos 00:45:35
que no me acuerdo como he llamado 00:45:37
no los he llamado, por lo tanto vamos a llamarlos 00:45:38
Este de aquí lo llamamos txt1, esto lo llamamos txtn de nombre, este de aquí lo llamamos id y este de aquí lo llamamos a, txta, vuelvo aquí, está abajo. 00:45:41
Entonces, lo que hace es guardar en txt.id.setText de a.id, txt.nombre.setText de a.nombre, 00:46:06
txt 00:46:45
de apellido 00:46:48
punto set text 00:46:50
de a punto 00:46:52
apellido 00:46:54
entonces ahora cuando lo lanzo 00:46:56
explota 00:47:00
null pointer exception 00:47:01
ah porque lo he hecho 00:47:07
el que 00:47:11
si son azules si 00:47:23
event dispatch 00:47:26
event queue 00:47:32
access control 00:47:33
donde esta 00:47:35
donde está app.showData 00:47:36
app.showData 00:47:39
inicialice cargar datos, el error es 00:47:40
aquí 00:47:43
app.id 00:47:43
se me enfada, ¿por qué? 00:47:45
tatara tatara 00:48:08
olé, ¿por qué se me enfada? 00:48:09
vamos a intentar 00:48:49
entender por qué se 00:48:50
enfada 00:48:52
¿queréis ir a la? 00:48:53
vale, el error que daba antes 00:48:57
es porque yo llamaba el 00:48:58
método este de aquí 00:49:00
de cargar datos 00:49:02
lo llamaba en vez que aquí 00:49:04
abajo, lo llamaba aquí 00:49:06
y como se llama aquí 00:49:08
y todavía no ha inicializado 00:49:10
los text fields 00:49:12
pues esto era null 00:49:14
entonces intentaba acceder a ese null y decía 00:49:16
que no había nada, entonces he movido 00:49:18
la llamada del cargar datos aquí 00:49:20
abajo y ahora cuando lo lanzo 00:49:22
funciona, me pone 00:49:24
el primero, ahora tengo que hacer los 00:49:28
botones, pero esto ya no es 00:49:30
ficheros, por ahora está cargando 00:49:32
todo, está cargando todos los 00:49:37
objetos, están ya cargadas aquí 00:49:40
y está cargando el primer 00:49:42
objeto en el visor 00:49:46
si queréis 00:49:47
por completar, hagamos los botones 00:49:55
cuando le doy al botón derecho 00:49:58
lo que tiene que hacer 00:50:01
es pillar el siguiente 00:50:03
para eso tendré que tener 00:50:06
son ordenados 00:50:09
pues 00:50:13
pongo por algún lado el id actual 00:50:13
vale 00:50:16
int id actual 00:50:16
es igual a 0 00:50:20
entonces al hacer 00:50:22
clic allí 00:50:28
es este no 00:50:29
es este 00:50:31
pues lo que hace 00:50:33
es idea actual 00:50:36
más más 00:50:37
y ahora tiene que buscar 00:50:39
dentro del set 00:50:44
el ordenador 00:50:46
el alumno 00:50:47
que tenga esta idea 00:50:51
y pillarlo 00:50:52
¿si? 00:50:53
una forma de hacerlo 00:50:56
teniendo en cuenta que si esto se pasa 00:50:58
debería volver a cero 00:51:00
entonces me pregunto que si 00:51:02
idea actual 00:51:04
es igual 00:51:07
a alumnos 00:51:08
.sice 00:51:10
pues entonces id actual 00:51:14
es igual a cero 00:51:20
¿sí? 00:51:22
y ahora lo que voy a hacer es 00:51:26
voy a hacer con un método o algo por el estilo 00:51:29
de actualizar 00:51:31
id actual 00:51:32
¿qué hace esto? 00:51:36
esto si lo pongo fuera me funciona 00:51:41
vamos a ponerlo aquí al azar 00:51:55
esto me lo llama 00:52:01
entonces si llama 00:52:02
este método de aquí 00:52:05
y actualizar lo que tiene que hacer 00:52:06
es sostancialmente 00:52:10
buscar el alumno correcto 00:52:12
y una vez que ha pillado 00:52:14
el alumno correcto 00:52:16
pues cambiar los datos 00:52:18
en la 00:52:20
en la 00:52:21
en los tres campos, vale 00:52:23
entonces 00:52:25
hacemos con un iterador 00:52:27
si esto fuera en vez que un set 00:52:29
un hash set o cosa por el estilo podría 00:52:33
o un hash map o algo por el estilo podría utilizar 00:52:35
directamente el id para obtener el objeto 00:52:38
¿vale? pero como lo hemos hecho como 00:52:40
un set, pues lo que tengo que hacer es 00:52:42
recorrer el set 00:52:44
iterator it es igual 00:52:45
a new iterator 00:52:48
de alumno 00:52:50
de... no 00:52:52
no, no, no, esto está equivocando 00:52:54
de alumnos 00:52:56
punto get iterator 00:52:58
de iterator 00:53:00
este, y este es 00:53:01
un iterador de alumno 00:53:04
wille it.asNext 00:53:06
alumno a es igual 00:53:16
bueno, alumno a lo hago fuera 00:53:29
lo voy a hacer nula aquí 00:53:32
a es igual a it.next 00:53:38
si a.id es igual a id actual 00:53:42
Entonces lo que hago es txtid.setText a a.id txt.dn.setText de a.nombre txtApellido.setText. 00:53:57
de a.apellido 00:54:37
y luego un break 00:54:42
para que salga ya del 00:54:45
while y se acabó 00:54:49
esto debería ser 00:54:50
más o menos, también 00:54:52
podría 00:54:54
hacer que esto 00:54:55
donde está 00:54:59
aquí, al fin y al cabo 00:55:03
esta cosa de aquí 00:55:05
en vez de hacer if primero 00:55:06
puede hacer que si primero me haga un actualizar texto de cero 00:55:12
todo esto esto lo tiene que hacer este de aquí podría hacer un actualizar de cero debería 00:55:21
funcionar y si no hace este otro cosas vale vamos a ver si funciona carga el primero lo 00:55:42
carga, se pincha aquí el 1, el 2 00:55:54
0, 1, 2, 0, 1, 2, 0, 1, 2 00:55:56
0, 1, 2 00:55:58
entonces ahora 00:55:58
tengo que hacer el otro botón 00:56:02
el otro botón funciona 00:56:03
con id actual 00:56:08
menos menos 00:56:10
id actual 00:56:14
menor que 0 00:56:18
id actual 00:56:20
es igual a 00:56:24
Alumnos.ic-1 00:56:26
Y después, actualizar 00:56:30
Y de actual 00:56:39
Entonces, ahora lanzo 00:56:41
Con esto voy por un lado, con esto voy por el otro 00:56:48
Y funcionan ya los dos 00:56:50
¿Sí? 00:56:53
Por lo tanto, con esto he acabado mi aplicación más o menos 00:56:56
¿Vale? Como base ya la tenemos 00:57:01
Ahora, errores que puedan surgir aquí y vamos a ver un poquito qué pasa, ¿vale? 00:57:03
Nosotros tenemos dos aplicaciones. 00:57:09
¿Qué pasa si yo ahora aquí lanzo otra vez la aplicación esta para cargar y escribo nuevos alumnos? 00:57:12
Y cierro. 00:57:26
Que ahora cuando cargo aquí, los alumnos de antes han desaparecido. 00:57:28
¿Sí? 00:57:35
queremos nosotros esto 00:57:36
entonces lo que queremos hacer nosotros 00:57:41
es que al guardar 00:57:44
nuevos alumnos 00:57:46
se añadan 00:57:48
detrás 00:57:50
de los viejos 00:57:51
vamos a probarlo 00:57:53
si esto funciona 00:57:56
spoiler no 00:57:57
entonces aquí 00:57:59
cuando nosotros creamos el 00:58:02
file output stream 00:58:04
que es el que debería escribir, probamos a ponerle true, ¿vale? 00:58:06
Entonces, fijaos que ahora el fichero es este de aquí, con dentro QEW, 00:58:11
lanzo esta cosa aquí, pongo dentro el señor A y el señor B, cierro, 00:58:20
Y si ahora voy a mirar, dentro aquí está Q, está W, está A y está B. 00:58:33
El problema es esto. 00:58:43
Si me fijo, se parece mucho a esto. 00:58:51
¿Veis? 00:58:58
Esta de aquí es la cabecera. 00:58:59
Os lo decía antes. 00:59:02
Él ha escrito un fichero, ha puesto la cabecera 00:59:04
Y luego ha empezado a poner los objetos 00:59:07
Cuando he cerrado y abierto otra vez 00:59:11
La segunda vez, cuando ha empezado a escribir 00:59:13
Pues ha vuelto a poner la cabecera 00:59:17
Y luego los objetos 00:59:20
Entonces, cuando ahora lo voy a leer 00:59:22
Este de aquí empezará aquí, encontrará la cabecera, perfecto 00:59:25
Luego se espera de encontrar los objetos 00:59:28
Leerá el primero, Q 00:59:30
Le verá el segundo, W 00:59:31
Y ahora aquí se espera el tercero 00:59:33
Sin embargo, encuentra otra vez la cabecera. 00:59:36
Y entonces explota. 00:59:39
¿Qué copias de un fichero a otro? 00:59:48
No entiendo. 00:59:59
Vamos por orden. 01:00:01
Este es el problema, ¿vale? 01:00:03
Me dice, oye, mira, que hay algo aquí 01:00:04
que no sé qué es y que no lo entiendo, ¿vale? 01:00:06
Stream corrupted exception. 01:00:10
¿Sí? 01:00:13
Repito, la causa de esto 01:00:14
es que he escrito en un fichero un objeto, 01:00:16
luego he cerrado todo 01:00:18
y he vuelto a escribir desde cero. 01:00:20
Porque fijaos que yo he escrito ya dos veces en el fichero 01:00:22
Porque cuando yo hago esto 01:00:26
WriteObject 01:00:29
Esto lo está haciendo dos veces 01:00:32
Justo 01:00:34
Aquí no he hecho flash, pero 01:00:37
O sea, que he escrito dos veces 01:00:38
Si yo abro el flujo de información 01:00:41
Escribo un objeto, luego otro, luego otro, luego otro 01:00:44
Funciona perfectamente 01:00:48
El problema es cuando cierro este flujo de información 01:00:49
y lo vuelvo a abrir otra vez la primera vez que escribe un object output stream escribe 01:00:52
una cabecera vale entonces si yo he apagado encendido otra vez y vuelvo a escribir en el 01:00:59
mismo en el mismo fichero pues tengo este problema una opción es esta vale es vale 01:01:06
entonces cuando yo enciendo pillo todos los leo el fichero me cargo como hace la otra todo el 01:01:30
fichero en la nueva cosa así a este punto añado los objetos que quiero y vuelvo a reescribir no 01:01:39
con la opción true más entero todo el fichero otra vez es una opción vale mientras que los 01:01:45
ficheros sean pequeños porque si yo tengo ya 7 millones de alumnos porque no es un alumno son 01:01:53
productos que se yo y ahora cada vez que tengo añadir un producto me tengo que cargar en memoria 01:02:01
7 millones de... 01:02:06
Añadir uno y reescribir 7 millones 01:02:07
pues puede ser un problema. 01:02:09
Copias lo que está escrito allí. 01:02:18
Hacerlo de uno en uno. 01:02:29
No ocupas la memoria RAM, pero ocupas tiempo. 01:02:31
Tienes que hacer... Cada vez que añades uno 01:02:34
tienes que hacer 7 millones de copias 01:02:35
de uno en uno, pero 7 millones de copias. 01:02:37
¿Sí? Entonces 01:02:40
la idea es 01:02:41
si yo pudiera 01:02:43
directamente escribir 01:02:46
en el 01:02:48
fichero 01:02:49
sería mejor si entonces hay una forma de hacer esto sí vale esto de aquí deriva desde ahora no 01:02:51
me acuerdo dónde está y te estará en el este de aquí probablemente file a punto y coma 01:03:04
File 01:03:30
Output 01:03:33
Stream 01:03:35
Es igual 01:03:40
Hay otra cosa aquí 01:03:41
Aquí pongo FOSS 01:03:42
Aquí está 01:03:43
Si no me equivoco 01:03:46
Vrite 01:03:47
No está aquí 01:03:49
API 01:03:50
A ver dónde está 01:03:56
Java 01:03:58
API 22 01:04:01
Esto es 01:04:03
hay un metodito 01:04:05
que usa 01:04:12
object output stream 01:04:13
que es el responsable de escribir 01:04:15
el header 01:04:18
y se llama como 01:04:20
write stream header 01:04:22
este señor de aquí 01:04:24
es el metodito que 01:04:28
al principio cuando el crea 01:04:30
dice vale voy a escribir 01:04:32
la primera escritura 01:04:34
se llama este writeStreamHeader 01:04:35
al llamar este 01:04:38
writeStreamHeader lo que hace 01:04:39
es copiar 01:04:42
la cabecera 01:04:43
y luego después a partir de ahí no se llama 01:04:45
entonces se ponen todos los métodos 01:04:47
cuando hago el writeObject o lo que sea 01:04:49
¿vale? entonces la idea 01:04:51
aquí es que este 01:04:53
señor no tiene 01:04:55
que hacer siempre su trabajo 01:04:57
gente duerme aquí, hay señores 01:04:59
entonces lo que vamos 01:05:07
hacer es lo siguiente me creo una versión parecida pero no igual de mi object output stream vale es 01:05:11
decir que aquí yo me creo una nuevo una nueva clase que se llama object output stream 2 por 01:05:21
ejemplo o mi objeto de sim o el concepto hay que hacer esto no hay que usar un rm con base 01:05:34
de datos vale pero si lo quieres hacer así una opción es la que ha dicho tú copio todo 01:05:49
desde principio otra opción es crear varios ficheros cada vez que eres un fichero nuevo 01:05:55
con un numerito serial entonces cuando luego cargarás en vez de cargar a uno solo te lees 01:06:01
todos y te lo vas a hacer otra opción es ésta entonces en este cosa aquí yo le digo que extens 01:06:06
object output stream a nosotros porque nos interesa esto no porque sea elegante o la 01:06:16
cosa más mejor del mundo porque usa en un cierto sentido cosas que nosotros 01:06:24
hemos visto vale entonces por qué no default constructor que anotando leo exception vale 01:06:31
entonces este de aquí habrá que crear una cosa este estilo vale no lo toco más de lo que tiene 01:06:44
que ser lo mínimo vale no quiero modificar nada lo único que quiero modificar es el bright stream 01:06:51
Header, ¿vale? Esta cosa aquí 01:06:59
¿Dónde está? 01:07:01
Aquí, este 01:07:05
WriteStreamHeader 01:07:06
Entonces, ProtectedVoid 01:07:07
Lo que hago yo es 01:07:10
Protected 01:07:15
Void 01:07:17
Esta cosa aquí 01:07:19
Esto está sobrescribiendo 01:07:20
El fichero 01:07:24
Está haciendo un overwriting 01:07:25
¿Vale? 01:07:27
Que si yo llamaré un objeto de ObjectStream2 01:07:29
Pues el 01:07:32
método writeStreamMeter se llamará 01:07:34
este de aquí, ¿vale? 01:07:36
y entonces aquí la idea es sencilla 01:07:37
es decir, la primera vez que yo 01:07:40
uso esto, si lo uso 01:07:42
o si en el fichero 01:07:43
en el que voy a escribir 01:07:45
ya he escrito algo 01:07:47
si el fichero ya 01:07:51
existe en un cierto sentido 01:07:54
pues esto no lo tendré que hacer 01:07:55
y si no, sí 01:07:57
tengo que encontrar un modo 01:07:59
para que 01:08:01
Esta cosa de aquí 01:08:02
Si lo tiene que hacer 01:08:07
Haga super.brit 01:08:09
Stream header 01:08:12
Esto se enfada porque 01:08:14
Lanza 01:08:17
Exception 01:08:18
Y si en vez, ya lo he hecho 01:08:21
Ya no lo tengo que volver a hacer 01:08:25
Ya hago algo por el estilo 01:08:27
Pues entonces, no lo tengo que hacer 01:08:28
Tengo que hacer nada 01:08:31
Ideas 01:08:32
¿De qué fichero? 01:08:34
O sea, aquí tengo dos opciones 01:08:58
Yo necesito saber si el fichero que estoy manejando 01:09:00
Tiene algo o no 01:09:05
¿Vale? 01:09:06
Entonces, una opción es hacerlo desde aquí 01:09:07
Desde la aplicación 01:09:10
Y es decir, voy a mirar el fichero 01:09:11
Si en el fichero hay algo 01:09:13
No hay nada, perdón, es un fichero nuevo 01:09:15
Uso el Object to Stream normal y corriente 01:09:17
Y si no, uso la versión 2 01:09:20
¿Puede tener? 01:09:23
Pero la cabecera es siempre esa 01:09:27
Y de todas formas 01:09:32
Si tú una vez ya la has usado 01:09:34
Ya habrás hecho esta cosa 01:09:36
Y ahora no tienes que hacer, tienes solo que añadir detrás 01:09:38
¿Vale? 01:09:40
Pero, la otra opción 01:09:41
Es en vez que mi object stream 2 01:09:44
En vez de recibir 01:09:47
Solo 01:09:50
La conexión 01:09:52
¿Vale? Reciba también 01:09:54
Algo más 01:09:56
O sea, que le pase, por ejemplo, el fichero o cosa por el estilo 01:09:57
Otra opción también es que yo esto lo recibo 01:10:02
¿Vale? 01:10:05
Entonces, a ver si con esto puedo hacer algo 01:10:07
Por ejemplo 01:10:10
OutputStreamOut 01:10:11
Y hacer que cuando el constructor 01:10:17
Hago que this.out 01:10:24
Es igual a out 01:10:27
O sea que ahora aquí puedo usar este out 01:10:28
Ahora el 01:10:34
Me sirve poco o nada 01:10:36
Necesito un int 01:10:39
Un int 01:10:40
Out punto 01:10:41
Vamos a ver que puedo sacar de aquí 01:10:47
Si desde aquí podía sacar el fichero 01:10:50
Al que está conectado 01:10:58
Pues no necesitaba que me pasara un fichero 01:11:00
¿Vale? 01:11:02
Pero bueno, como no puedo 01:11:03
pues entonces aquí por ejemplo 01:11:04
file f 01:11:08
esto ya no me sirve 01:11:10
prefiero poner un file f 01:11:14
y hacer que this.f es igual a f 01:11:20
ahora esto quiere decir 01:11:24
que cuando creo un autostream 01:11:26
de tipo 2, no lo puedo 01:11:28
construir así directamente 01:11:30
tendré que pasar también 01:11:31
el fichero 01:11:33
esto 01:11:34
un poco veucho 01:11:36
¿vale? porque estoy cambiando 01:11:39
como se crea un object stream 01:11:41
autostream 2 ¿vale? pero a ver 01:11:42
más o menos 01:11:45
entonces ahora 01:11:46
lo que haría aquí es vale 01:11:49
tengo el fichero entonces me 01:11:51
pregunto si el fichero por ejemplo 01:11:53
existe entonces 01:11:54
perdón si el fichero no existe 01:11:57
entonces llamo esta cosa 01:12:01
si en vez del fichero existe pues 01:12:02
no lo hago, o mejor 01:12:04
porque podría ser que el fichero sea 01:12:07
creado antes, vale 01:12:09
vamos a ver si hay algo dentro de este 01:12:10
fichero, entonces hago 01:12:13
un file input 01:12:15
stream f 01:12:17
fs, es igual a 01:12:19
new file input 01:12:21
stream f 01:12:23
y hemos visto 01:12:25
antes que podía preguntarme de si 01:12:30
fs.available 01:12:32
mayor que 0 01:12:35
si hay algo 01:12:38
entonces 01:12:41
o mejor, hagámoslo así 01:12:42
si no hay nada 01:12:45
allí, vale 01:12:47
si yo voy a mirar este de aquí 01:12:58
digo, intenta leerlo 01:13:01
y si al intentar leerlo 01:13:02
no hay nada 01:13:05
o sea, porque 01:13:06
es mayor que cero, no es mayor que cero 01:13:08
entonces quiere decir que hasta 01:13:11
si has sido creado, ahora mismo está vacío 01:13:13
no hay la cabecera, por lo tanto 01:13:15
escribo la cabecera 01:13:16
Si no, este programa no hace nada 01:13:18
Este método no hace nada 01:13:21
¿Sí? 01:13:22
Entonces 01:13:26
Vamos a ver 01:13:26
Esto podría explotar si esto no existe 01:13:28
Vamos a verlo 01:13:34
Entonces, lanzo 01:13:35
Esto lo lanzo de aquí 01:13:42
He creado con un impuesto en 2 01:13:43
Lanzo 01:13:46
Escribo a 01:13:47
Escribo b, b, b 01:13:50
Y cierro 01:13:53
explota porque explota null pointer excepción vamos a ver dónde está en el puente de excepción 01:13:56
y en it right streaming en esta cosa nueva que hemos hecho nosotros dice que esta cosa de aquí 01:14:04
me da un nulo porque probablemente efe no existe vale entonces podremos preguntarnos aquí si fish 01:14:17
is es null, o, a ver si esto funciona, o, o end, vamos a ver si esto funciona, entonces, a, add, b, b, b, add, cierro, sigue explotando, 01:14:26
siempre en un pointer excepción pero no debería vamos a verlo es aquí siempre 01:14:55
mismo punto pero porque el pointer excepción tiene que ser en otro lado 01:15:05
super punto superado pauso vale entonces hemos hecho algunos cambios hemos 01:15:15
cambiado que sustancialmente hemos creado un fichero nuevo en el que se 01:15:34
guardan cuántos alumnos se han creado en total de esta forma cuando la aplicación de creación 01:15:40
arranca lee cuántos cuantos alumnos se han creado hasta ahora y lo guarda en alumnos 01:15:48
creatividad así que los nuevos alumnos se crean con la id correcta vale y cada vez que se cierra 01:15:58
pues guarda este número 01:16:04
hasta donde ha llegado 01:16:05
y entonces con esto ya 01:16:07
debería más o menos funcionar 01:16:09
ahí es la hora 01:16:12
si, no, hacedlo vosotros 01:16:12
Materias:
Programación
Niveles educativos:
▼ Mostrar / ocultar niveles
  • Formación Profesional
    • Ciclo formativo de grado superior
      • Primer Curso
Autor/es:
Stefano Chiesa
Subido por:
Stefano C.
Licencia:
Reconocimiento - No comercial
Visualizaciones:
13
Fecha:
1 de abril de 2025 - 12:48
Visibilidad:
Clave
Centro:
IES ROSA CHACEL
Duración:
1h′ 16′ 19″
Relación de aspecto:
16:10 El estándar usado por los portátiles de 15,4" y algunos otros, es ancho como el 16:9.
Resolución:
1152x720 píxeles
Tamaño:
304.53 MBytes

Del mismo autor…

Ver más del mismo autor

EducaMadrid, Plataforma Educativa de la Comunidad de Madrid

Plataforma Educativa EducaMadrid