Saltar navegación

20250401 Permanencia objectos 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.

15 visualizaciones

Más información Transcripción

Descargar la transcripción

Voy a grabar esta clase, por lo tanto, si habláis, me dais consentimiento para que grabe esta voz. 00:00:00
Entonces, ayer empezamos, bueno, antes de ayer, hace unos días, empezamos con la persistencia de datos 00:00:06
y vimos la posibilidad de escribir en ficheros, ¿vale? 00:00:13
Ayer lo que empezamos es cómo puedo guardar un objeto, ¿vale? 00:00:16
Hasta antes, nosotros simplemente utilizamos o byte o carácter, 00:00:22
si trabajamos con texto, para grabar en un fichero o leer desde un fichero, línea por línea o carácter por carácter, byte por byte, 00:00:27
esto depende de las necesidades y de las exigencias que tengo en un determinado momento. 00:00:35
Sin embargo, sería útil, puesto que nosotros programamos orientado a objetos, guardar objetos. 00:00:41
Entonces, ayer hicimos un primer intento de esto, que es simplemente guardar los objetos como texto. 00:00:46
entonces nosotros en alumnos nos inventamos un metodito 00:00:55
que lo que hacía era representar los valores de este objeto 00:01:00
por ejemplo separados por un carácter especial 00:01:04
en nuestro caso eran dos puntos 00:01:08
entonces cuando yo quería guardar el objeto 00:01:10
lo que hacía es no guardar el objeto 00:01:13
sino guardar los valores de los atributos de este objeto 00:01:15
este es un método muy sencillo 00:01:19
muy poco práctico y muy poco eficiente 00:01:22
que se puede utilizar cuando los objetos que utilizo 00:01:26
son muy muy sencillos, como era el caso de nuestro alumno 00:01:30
que solo tenía valores, digamos, básicos 00:01:33
es verdad que string es un objeto, pero es verdad también que nosotros 00:01:38
lo hemos siempre casi utilizado como un tipo primitivo 00:01:42
el problema de este método es que se complica mucho a la hora 00:01:45
de utilizar objetos que contienen otros objetos dentro, ¿vale? 00:01:50
Porque cuando estamos trabajando con las referencias, ya esto se complica. 00:01:54
Si imaginamos el alumno que tenga asignado un profesor y luego tenga varios alumnos 00:01:58
que tiene que apuntar al mismo profesor, pues esta cosa hecha con el método de guardar los objetos 00:02:05
directamente como cadenas de caracteres al fin y al cabo, se puede complicar 00:02:12
Porque cuando recrearé ese profesor, cuando creo ese objeto profesor, tengo que acordarme que no lo tengo que recrear por cada alumno, sino lo tengo que crear una vez sola y cada alumno tendrá que apuntar al mismo objeto recreado, ¿vale? 00:02:17
Entonces, ¿se puede hacer? Sí se puede hacer, pero se complica mucho la gestión. Tengo que conocer muy bien dónde están los puntos críticos de mi aplicación para que cuando, por ejemplo, recargue mi aplicación, en este ejemplo que estamos haciendo, tendría más sentido crear antes todos los profesores y una vez que he creado todos los profesores empezar a crear los alumnos porque así tengo ya los profesores creados y si hay tres alumnos que apuntan al mismo profesor ya tengo el objeto. 00:02:31
le puedo decir, mira, oye, directamente este es el objeto al que te refieres, ¿sí? 00:02:59
Esto porque, ¿sabéis qué? Si cada alumno tuviera su propio profesor y modificara algo del profesor 00:03:05
o se modificara algo de ese profesor, pues solo se reflejaría en ese alumno, ¿vale? 00:03:12
Porque hay instancias distintas. Pero si el profesor es único y de repente cambia el horario de atención, 00:03:17
qué sé yo, de tutoría, pues se debería reflejar en todos sus alumnos. 00:03:23
Entonces debería ser una instancia única, compartida como referencia por todos los alumnos. Estas son cosas de programación básica. 00:03:27
Si en vez es como teníamos nosotros, que sostancialmente teníamos datos que son propios del alumno y no se comparten con ningún otro alumno, el nombre del alumno no lo compartiré entre varios alumnos, 00:03:37
Pues entonces sí que se puede hacer como hemos hecho ayer. Ayer hicimos un botón para guardar. Este botón de aquí, que sostancialmente tenía, cuando lo pinchaba, lo que hacía era crearse un printwriter y recorría a los alumnos. 00:03:50
y por cada alumno 00:04:22
encontrado en todos los alumnos 00:04:24
lo que hacía era escribirlo 00:04:25
en el fichero con el programita 00:04:27
uno por línea, con el método 00:04:29
y sostancialmente lo que 00:04:32
hacía era escribir 00:04:34
un pequeño 00:04:35
fichero 00:04:37
que lo tenemos por aquí 00:04:38
lo repaso porque ayer no grabamos 00:04:41
¿cuál era? 00:04:44
¿dónde está? 00:04:55
permanencia 00:04:55
esta aquí 00:04:56
donde estaba 00:05:00
¿Qué proyecto es esto? 00:05:03
¿Proc2? 00:05:06
No sé 00:05:07
No me acuerdo cuál es el proyecto 00:05:08
¿No se acuerda cuál es el proyecto? 00:05:10
¿Cómo mira el proyecto de aquí? 00:05:25
Bueno, da igual 00:05:34
Simplemente sale un 00:05:34
Un fichero con varias 00:05:36
Líneas, en cada línea pone 00:05:39
Lo que tiene que poner 00:05:41
¿Vale? Ahora no lo encuentro 00:05:44
Otras cosas 00:05:45
Que hemos hecho es 00:05:48
Que al iniciarse 00:05:50
programa, ¿vale? 00:05:52
cuando se llama el init 00:05:55
¿vale? que está por aquí 00:05:57
initialize, ¿vale? 00:05:59
pues se llamaba este 00:06:01
método de aquí, este método de aquí 00:06:03
carga los datos y sostancialmente 00:06:05
lo que va a ver es 00:06:07
va a buscar si 00:06:09
existe el fichero 00:06:10
con dentro los datos 00:06:13
de los alumnos 00:06:17
si existe este fichero lo va cargando 00:06:19
Y, sustancialmente, va reconstruyendo estos alumnos. De esta forma, cuando apago e enciendo otra vez este programa, pues me carga los alumnos que ya existían, ¿vale? Y, ¿vale? Esto funcionaba, repito, porque los alumnos eran bastante sencillos. 00:06:21
Ahora, ¿qué pasa si quiero hacer las cosas un poquito mejor y si tengo estas cosas de problemas de objetos referenciados y cosas por el estilo? 00:06:38
Tengo otra forma de guardar los ficheros que es utilizando, digamos, mecanismos que me proporciona la propia Java Virtual Machine 00:06:50
¿Vale? Entonces, en vez de transformar yo un objeto en una cadena de textos y guardarlo, le digo directamente a quien sea, ¿vale? Ahora lo veremos, de guardarme este objeto. Le paso un objeto y digo, guárdamelo. 00:07:01
Él claramente a este punto el objeto no será un objeto inteligible por el ser humano, si yo abro ese fichero no me encontraré allí algo que puedo entender, ¿vale? Será una representación en formato de byte como le da la gana a la Java Virtual Machine del objeto que yo tengo, ¿vale? 00:07:16
La ventaja que tengo con esto es que hasta un cierto nivel de complejidad sí que me mantiene las relaciones internas entre los varios objetos. Es decir, que cuando guardaré el profesor, pues el alumno con el profesor me guardará el alumno y me guardará también el profesor. 00:07:38
y que si luego lo recargaré, pues los varios alumnos tendrán el mismo profesor, porque el mismo en automático como que seta un identificador, un modo de entender que este objeto no son tres copias distintas, 00:07:55
si no tienen el mismo identificador, el mismo hashcode, lo que sea, 00:08:12
de esta forma, cuando lo va recargando y le dice, 00:08:19
oye, mira, este alumno tiene este profesor, 00:08:22
y él se da cuenta que este profesor ya ha salido creado, 00:08:24
ya tiene existencia en mi heap, 00:08:27
pues a ese punto dice, ah, vale, entonces no lo vuelvo a crear, 00:08:32
pero le asigno el mismo. 00:08:35
Y haremos una prueba nosotros ahora para ver que efectivamente funciona así. 00:08:37
¿Vale? 00:08:41
si el dato no es string 00:08:42
habrá que convertir la string en matización 00:08:47
de una matización, hemos dicho que ocurre con referencia 00:08:49
a objetos, estos son los problemas si intentamos 00:08:51
guardarlo como cosa, ¿vale? 00:08:53
entonces, las opciones 00:08:55
nosotros lo que hemos 00:08:58
bueno, para obviar 00:08:59
al problema que teníamos ayer 00:09:01
¿vale? existen 00:09:03
varias formas, la primera forma es la que veremos 00:09:05
ahora, que se llama la serialización 00:09:07
¿vale? utilizar objetos 00:09:09
serializable y hacer que ellos lo guarden 00:09:11
¿Vale? Veremos ahora. 00:09:13
Otras opciones son hacer una serialización textual. 00:09:15
¿Habéis visto XML? 00:09:19
Habéis visto que XML es como un lenguaje de marcas, ¿vale? 00:09:22
Donde yo me puedo inventar las etiquetas, ¿vale? 00:09:27
Entonces, si yo lo que puedo hacer es, en vez de hacer una definición muy sencilla de este tipo, 00:09:30
de una representación muy sencilla de este tipo de mi objeto, 00:09:38
pues yo podría crearme, por ejemplo, un lenguaje XML que represente a mi alumno. 00:09:42
Y en este lenguaje XML podría representar también al profesor. 00:09:48
Y entonces el profesor dentro podría tener una referencia, un atributo, 00:09:53
que sea un identificador, que sea único, 00:09:57
y entonces cuando yo construyo mi XML del alumno y le asigno a un profesor, 00:10:00
a este profesor le pondré un ID, 00:10:06
y entonces si dos de estos elementos XML tienen el mismo ID, 00:10:08
cuando lo reconstruyo tendré que 00:10:12
construir el mismo objeto para los dos 00:10:14
¿vale? o sea, podría, sabéis que 00:10:16
lenguaje de marcas al fin y al cabo es 00:10:18
texto plano, como este 00:10:19
aquí, al que se le añade 00:10:22
información, meta información 00:10:24
se le añade las etiquetas para 00:10:26
decirle algo más, cuando era html 00:10:27
todos los comandos, todas las 00:10:30
etiquetas que utilizaban 00:10:32
era para dar semántica 00:10:34
a la web o para dar formato a la web 00:10:36
cuando uso xml 00:10:38
sustancialmente no estoy hablando de una página web, 00:10:40
más estoy hablando de un cualquier contexto. 00:10:42
Me creo un lenguaje propio mío para representar lo que yo quiera representar. 00:10:44
Entonces, en este caso, sería representar mi contexto de mi aplicación 00:10:49
y decirle que un alumno tiene estas características, 00:10:55
luego tiene estos profesores, tiene estas asignaturas y cosas por el estilo. 00:10:58
Está claro que si yo lo hago de esta forma, tengo ventajas y desventajas. 00:11:01
La desventaja clara es que se vuelve complejo tanto guardar los objetos como recargarlos. Es una tarea relativamente compleja porque se requiere un algoritmo bastante complejo para que se dé cuenta de todas estas cosas de los identificadores, etc. Además de alguna forma de poder leer XML. 00:11:06
Hay clases en Java que permiten leerse un XML y transformarlo en un modelo 00:11:26
Para que luego yo pueda trabajar con un modelo como si fuera un objeto 00:11:33
Pero tengo que saber utilizar todas estas cosas 00:11:37
La ventaja que tengo con esto es que lo que se está guardando 00:11:41
Es un fichero de texto inteligible por el ser humano 00:11:45
Entonces yo lo estoy usando para mi aplicación 00:11:49
pero nadie me prohíbe que mañana con este mismo fichero XML lo pase a otro programa, a otro lector de XML, a otra cosa 00:11:52
y este pueda analizarlo y darme un esquema de lo que está escrito en ese fichero 00:12:02
que yo pueda entender sin tener mi aplicación y sin encender mi aplicación. 00:12:07
Así como si quiero modificarlo y quiero hacer otro programa que lo que hace es 00:12:12
Pilla un fichero de texto de alumnos y de profesores y lo convierte en este XML para que luego se pueda importar dentro de mi aplicación, lo puede hacer. Si en vez lo utilizo como objetos serializados, entonces no como XML, sino como cosas que no entiendo, hacer esta operación, o sea, crear un fichero que luego sea leíble por mi aplicación va a ser más complejo. 00:12:17
Sí. Y otra opción es utilizar cosas avanzadas, o sea, un object, R no me acuerdo qué es, mapping, relational mapping, no lo sé, y un sistema de base de datos, es decir, un sistema que pille los objetos, haga un mapeado de los objetos a tablas de base de datos, 00:12:43
Y luego se utiliza un sistema gestor de base de datos para guardar esas tablas, guardar esta información. Sustancialmente, guardar los objetos en una base de datos. Pero claro, hay que ver cómo hacerlo eso también. Si represento una tabla que cada campo de la tabla es un atributo de mi objeto, pero esto me funciona bien solo si los atributos son todos sencillos. 00:13:08
Si los atributos a su vez son objetos, pues la cosa se puede complicar. Siempre puedo hacer que sea una referencia, una clave a otra tabla donde se guardan los otros objetos. Entonces tendré la tabla alumnos y la tabla profesores y un campo de la tabla alumnos será una referencia, una clave a la tabla de profesores. Y así voy construyendo. 00:13:33
Pero claro, hay que hacer un mapeado entre mi estructura a nivel de objetos y mi estructura a nivel de base de datos, ¿sí? Vamos a ver qué son los objetos serializables, ¿vale? 00:13:56
en la idea pensarla así es la posibilidad de pillar un objeto y transformarlo y considerarlo 00:14:09
como una secuencia de bytes vale para que esto sea posible los objetos tienen que implementar 00:14:21
una clase que sea una interfaz que se llama la interfaz serializable vale y veremos que 00:14:31
la interfaz serializable no tiene métodos 00:14:37
¿vale? o sea que 00:14:39
directamente yo le pongo implementar serializable 00:14:40
y ya lo puedo serializar 00:14:43
¿vale? la idea es que 00:14:45
si un objeto no es serializable no puedo 00:14:47
hacerlo pasar por un stream 00:14:49
para un input stream o un output stream 00:14:51
si es serializable 00:14:53
la Javitor 00:14:54
Machine se encargará de alguna forma 00:14:57
de poderlo representar 00:14:59
en un formato que se pueda 00:15:01
enviar por un stream o 00:15:03
leer por un stream ¿vale? 00:15:05
Entonces, lo único que tenemos que hacer nosotros, sustancialmente, es serializar el objeto. Tiene que ser serializable el objeto y todos los objetos que son atributos de este objeto. Si yo tengo el objeto alumno y tengo el objeto profesor, el objeto alumno es serializable y el objeto profesor no, no puedo guardar el objeto alumno en un fichero con este método. También profesor tiene que ser serializable. 00:15:06
Existe una clase, que es la clase ObjectOutputStream y la clase ObjectInputStream 00:15:34
Que permiten leer o escribir un objeto directamente 00:15:42
Entonces, por ejemplo, aquí tengo un ObjectOutputStream 00:15:46
Que se conecta a un FileOutputStream de un fichero 00:15:51
Pues esto escribirá directamente a un fichero 00:15:55
Y tengo la clase WriteObject, o sea el método WriteObject de la clase ObjectOutputStream 00:15:57
Que me permite pillar un objeto serializable 00:16:03
y guardarlo en el fichero 00:16:05
¿vale? y después lo puedo cerrar 00:16:08
si quiero 00:16:10
para leerlo, está el object 00:16:10
input stream, que se conecta 00:16:13
igualmente con un file input stream 00:16:16
a un fichero 00:16:18
y tengo la 00:16:19
función read object 00:16:21
la función read object leerá un objeto 00:16:23
¿vale? entonces cuidado 00:16:26
porque si he guardado un alumno 00:16:27
cuando lo voy a leer, lo leeré como objeto 00:16:29
y tendré que hacer algún tipo 00:16:32
de casting 00:16:34
O mirar con InstanceOff si es una clase de alumno y luego hacerla, o intentar hacerla con un try-catch en el caso en que no sea de la clase que yo estaba intentando castear, lo que pasará es que saltará una PlasticShip. 00:16:34
Muy bien, entonces también se utiliza la serialización para transmitir objetos por una red 00:16:59
Lo mismo desde aquí se hace cuando en vez de escribir en ficheros se utilizan sockets 00:17:07
Que sustancialmente crean un punto de acceso entre varias aplicaciones que están en un ordenador distinto 00:17:13
Se comunican por red, más de esto en segundos de DAM en procesos y servicios 00:17:21
pues la cosa es la misma 00:17:26
en vez de escribir, siempre se usará 00:17:29
input stream y output stream 00:17:31
en vez de file output stream 00:17:33
se usará el output stream directamente 00:17:35
pero la idea es que yo tendré un objeto 00:17:37
lo transformaré en una secuencia 00:17:39
de bytes sustancialmente y lo paso 00:17:41
por un canal de comunicación, este canal 00:17:43
en vez de llegar al disco duro y escribirse 00:17:45
en el disco duro, llegará a otra aplicación 00:17:47
que estará allí con un input stream 00:17:49
y leerá la información 00:17:51
que se le envía 00:17:53
en ambos casos la Java Virtual Machine gestiona el formato de los datos de los objetos 00:17:54
y los objetos serializados 00:17:59
entonces es la Java Virtual Machine que me dice cómo se guardan 00:18:01
y cómo tengo que hacerlo 00:18:04
no tengo que hacerlo yo, como siempre 00:18:06
ventaja, es más sencillo porque me olvido de cómo se hace 00:18:08
le digo simplemente hazlo 00:18:13
desventaja, no tengo control directo sobre estas cosas 00:18:14
estoy cediendo el control a la Java Virtual Machine 00:18:17
entonces si luego hace algo que no me gusta 00:18:20
pues es un problema mío 00:18:23
hay inconvenientes de la serialización 00:18:29
la clase Object AutoStream 00:18:32
tiene algunos problemillas 00:18:34
se lía a veces 00:18:37
en particular en dos casos 00:18:39
el primer caso es cuando intentamos reutilizar 00:18:42
una misma referencia para serializar 00:18:45
objetos diferentes 00:18:48
tengo una referencia a un objeto 00:18:49
lo mando, lo serializo, lo escribo en fichero 00:18:52
ahora en esta referencia cambio el objeto y lo vuelvo a escribir 00:18:55
a veces puede dar problemas, o si tengo un objeto 00:18:58
lo escribo, ahora lo modifico usando setter y getter 00:19:02
y luego lo intento escribir otra vez, puede que funcione mal 00:19:06
esto deriva también de algunos problemas 00:19:11
de optimización que tiene, en el que por ejemplo 00:19:14
esto se ve mucho cuando se usan sockets 00:19:18
¿Vale? Como yo tengo que enviar objetos, cuando yo te envío un objeto, ¿vale? Tú lo guardas y le das un identificador tuyo de esta transferencia. Si te vuelven a mandar el mismo objeto y te lo han mandado antes, en vez de gastar recursos de red y volver a mandarlo, tú asumes que ya me lo has mandado este objeto, pues ya lo tengo, no lo vuelvo a recibir otra vez. 00:19:21
Lo pillo de una caché interna que tengo yo y te digo, mira, aquí lo tienes. El problema es que si yo he pillado el objeto, te lo he mandado, ahora lo modifico y te lo mando otra vez, como es la misma referencia, el mismo objeto, él cree que no ha cambiado, cree que ya lo tiene y va a pillar el objeto que tenía antes, sin la modificación que se ha hecho. 00:19:46
Entonces hay que saberlo para que en situación como esta, cuando guardo ficheros, a veces me está guardando ficheros sin las modificaciones y tendré que hacer algo para que se dé cuenta de eso y que me lo vuelva a guardar desde cero. 00:20:04
El segundo problema es la cabecera del fichero serializado. 00:20:18
Cuando yo guardo un fichero serializado, al principio no se guardan directamente los objetos como hemos hecho ayer, que simplemente se guardaban las filas, entonces ya la primera fila era un objeto, sino que este fichero tiene al principio una cabecera, tiene una serie de datos iniciales que sirven a Java Virtual Machine para decir, 00:20:22
oye, mira, soy un fichero de objetos, pues a partir de aquí empiezan los objetos de beta. 00:20:44
Ningún problema. Tú lo usas, escribes los ficheros, ningún problema. 00:20:50
El problema surge en el que si tú tienes un fichero, guardas algunos objetos, 00:20:54
luego apagas la aplicación, mañana enciendes la aplicación, creas objetos nuevos 00:20:59
y los quieres guardar en el mismo fichero de ayer, añadiendoselo a continuación, 00:21:05
Como él, hasta si le pones la append, pues va a escribir después, pues como piensa que sea una nueva escritura, vuelve a añadir la cabecera. Entonces tengo un fichero que tiene una cabecera, una serie de objetos, otra vez la cabecera y otra vez los objetos. 00:21:12
Y esto, cuando luego lo irá a leer, pues le causará un problema, porque él después de la cabecera se espera todos los objetos, de repente se encuentra otra vez la cabecera, lo intenta interpretar como objeto, no lo consigue, entonces me lanza un exceso, ¿vale? 00:21:29
Y este problema aquí sí que lo vamos a simular ahora, vamos a hacer algo que funcione todo bien, y luego después vamos a forzar que haya varios errores para ver cómo podemos un poquito gestionarlos, ¿vale? 00:21:43
Por esta razón, esto de la serialización directa pura, pues no se suele utilizar, ¿vale? 00:21:57
Es decir, en proyectitos básicos, en cosas sencillas, en cosas por estilo, sí se puede utilizar, es bastante fácil. 00:22:04
Si yo tengo un sistema de gestión de varios objetos mucho más complejos, con muchos objetos y gestionar muchas cosas, 00:22:11
pues lo más probable es que llegue un momento en que trabajar con este tipo de comunicación llega a demasiada complejidad, entonces me da demasiados errores, pues entonces compensa crearse un sistema de persistencia mejor basado sobre un ORM y un SGBD, o sea, un sistema gestor de datos, como por ejemplo Hibernate y cosas por el estilo. 00:22:19
Pero no es una cosa sencilla que hago, oye, mira, doy clic aquí y aquí y me funciona. Tengo que entender qué es Hibernate, tengo que entender qué son estas cosas y practicarlo. El próximo curso creo que lo veréis. 00:22:47
en DAM, aquí yo doy DAM 00:23:02
entonces me lo sé mejor las asignaturas 00:23:05
en DAM seguramente hay una asignatura 00:23:07
dedicada a eso que se llama 00:23:09
accesos a datos 00:23:10
eso va todo de 00:23:12
bases de datos y conexiones 00:23:14
de datos normales, no relacionales, etc 00:23:16
y como desde una aplicación 00:23:18
puedo conectarme a eso 00:23:21
pero estoy convencido a un 95% 00:23:22
que también en DAO 00:23:25
en la parte sobre todo de programación 00:23:26
lado servidor 00:23:29
si que hay una parte 00:23:30
de acceso a datos 00:23:32
y entonces 00:23:34
allí es cuando veréis estas cosas 00:23:36
más en profundidad 00:23:38
a partir de aquí, estos son ejemplos 00:23:39
de escritura y lectura 00:23:43
en ficheros y cosas por el estilo 00:23:44
lo tenéis como código para echarle un vistazo 00:23:46
¿vale? 00:23:49
algunos de estos ya los hemos hecho 00:23:49
por ahora no hemos trabajado mucho con binarios 00:23:51
pero ayer si que lo vimos un poquito en clase 00:23:54
cosas por el estilo, como se lee 00:23:56
se escribe un ejemplo ¿vale? 00:23:58
Podéis buscar también otras formas de hacer estas cosas. 00:23:59
Este es el ejemplo que nos interesa particularmente ahora, que es de escribir utilizando Object Output Stream, ¿vale? 00:24:04
Entonces, si os fijáis aquí, creo un Object Output Stream y luego escribo varios objetos, ¿vale? 00:24:13
En particular, está un objeto, está un método que es WriteObject, que me permite escribir cualquier tipo de objeto, 00:24:22
Pero luego, si yo quiero, en vez de escribir un objeto, escribir un entero, un booleano, un char, en general un tipo primitivo, tengo métodos que sostancialmente me converten el tipo primitivo en un objeto. 00:24:28
Sabéis que cada tipo primitivo tiene una clase wrapper que sostancialmente transforma en un objeto equivalente el tipo primitivo, pues lo que hace es que luego lo escribe. 00:24:45
también tenemos write to tf que es para poder escribir strings vale utilizando 00:24:58
esto para leerlo lo mismo tengo read boolean, read double, read char, read int y en 00:25:04
particular lo que nos interesa más a nosotros es para poder leer un objeto 00:25:10
que es el read object vale y esto te lee un objeto directamente este es un 00:25:15
ejemplo de cómo se realiza una clase aquí tenemos la clase persona que 00:25:20
normal y corriente una persona toda la vida vale lo que tenemos que hacer para 00:25:25
que pueda ser escrita en un fichero es implementar serializable ahora este 00:25:30
serializable no añade ningún método directamente es simplemente digamos como 00:25:36
un flag para decir a la java virtual machine que esta persona este 00:25:42
objeto si se puede guardar en un en un fichero o de toda forma utilizar con un 00:25:49
input stream y un output stream es serializable es transformable en un 00:25:57
stream vale entonces un objeto serializable como se escribe vale aquí 00:26:02
tengo las personas y veis que aquí lo que estoy haciendo es un bright object 00:26:07
de la persona bright object de la persona pues éstos me lo 00:26:11
escribirá en este fichero de aquí vale aquí se está utilizando una 00:26:15
una ruta absoluta pero mejor utilizar rutas 00:26:20
relativas y para leerlo lo mismo tened en cuenta que pero cuando lo leo vale 00:26:27
esto será un objeto entonces tendré que hacer un cast al tipo de objeto 00:26:33
Entonces aquí, por ejemplo, está utilizando para poder utilizarlo un available. Está diciendo que mientras que haya bytes disponibles para leer, pues leeme otra persona. Cuando este de aquí, el available, me dirá que no hay nada, entonces me dará cero, pues habré llegado al final de la lectura de los objetos. 00:26:42
Y ya está. Es un método de hacerlo. Hay otros. La última cosa que nos puede interesar un mínimo es la jerarquía de clases que hemos visto hasta ahora. 00:27:04
Entonces, nosotros sabemos que hay input stream y output stream. A partir de aquí hay clases que pillan este input stream, que es una secuencia de datos en entrada, 00:27:16
Y me añaden algunas funcionalidades más para que sea más fácil para mí utilizarla. Nosotros hemos utilizado, por ejemplo, el File Input Stream, que lo que hace es añadir el concepto de que no estoy leyendo desde cualquier sitio, sino desde un fichero. 00:27:28
Entonces me añadirá algunas ventajas, alguna posibilidad más para poder trabajar con ficheros. Hay más, ¿vale? Hay otras cosas que están por allí y también existen, por ejemplo, Buffered Input Stream y cosas por el estilo que mejoran todavía la posibilidad de leer de ficheros, etc. 00:27:45
Lo mismo para OutputStream, luego están los Reader y los Writer. Hemos dicho que estos trabajan con bytes, mientras que estos de aquí trabajan con caracteres. 00:28:09
fijaos que InputStream, ObjectInputStream 00:28:23
está en el lado de estoy trabajando como bytes 00:28:26
porque al fin y al cabo lo que se está guardando 00:28:29
y lo veremos ahora abriendo un fichero guardado 00:28:32
que sustancialmente no es 00:28:35
no se entiende 00:28:37
algunos trozos a lo mejor sí 00:28:43
pero algunos otros no 00:28:45
dudas 00:28:47
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:
15
Fecha:
1 de abril de 2025 - 12:47
Visibilidad:
Clave
Centro:
IES ROSA CHACEL
Duración:
28′ 56″
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:
80.82 MBytes

Del mismo autor…

Ver más del mismo autor

EducaMadrid, Plataforma Educativa de la Comunidad de Madrid

Plataforma Educativa EducaMadrid