Saltar navegación

Ficheros 2 - 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 20 de mayo de 2024 por Stefano C.

25 visualizaciones

Más información Transcripción

Descargar la transcripción

Segunda parte de ficheros 00:00:00
Si habláis 00:00:02
Me dais consentimiento para que se grabe 00:00:03
¿Vale? Entonces 00:00:05
Estamos viendo como leer 00:00:06
Un archivo de texto ¿Vale? 00:00:08
Entonces tengo mi file reader 00:00:10
¿Vale? El hecho de que este reader por algún lado 00:00:13
Quiere decir que estoy trabajando con 00:00:15
Carácteres, con texto 00:00:16
¿Vale? En no byte a byte 00:00:19
Puede utilizar un buffer reader 00:00:22
Que obtiene dentro 00:00:25
Que pilla como parámetro 00:00:27
Un file reader 00:00:28
Pues esto me crea un objeto 00:00:30
BufferedReader 00:00:32
Que puede hacer lo que se llama el ReadLine 00:00:34
Y luego la idea de esta aquí 00:00:37
Es que voy leyendo filas, filas, filas 00:00:38
Líneas, líneas 00:00:41
Cuando lea una línea que es null 00:00:42
Porque ha llegado al final del fichero 00:00:45
Pues entonces saldré de este while 00:00:48
Y ya está 00:00:50
Fijaos también que 00:00:50
Si es null 00:00:54
Cierro 00:00:56
el canal de comunicación 00:00:58
¿vale? 00:01:02
la idea es que de vez en cuando 00:01:03
cuando ya ha utilizado 00:01:05
el acceso, el recurso 00:01:07
al fichero y 00:01:09
al canal de lectura 00:01:10
pues al final lo vaya a cerrar 00:01:13
¿vale? 00:01:16
esto de aquí quiere decir que sustancialmente ahora el canal está cerrado 00:01:17
no puedo volver a leer de ahí 00:01:20
¿vale? es como todo 00:01:21
en Java cuando utilizamos 00:01:23
un recurso lo mantenemos abierto 00:01:25
lo mantenemos activo hasta que lo necesitemos cuando ya no se necesita pues se hace esta 00:01:27
operación de aquí para evitar que java mantenga allí en memoria algunas informaciones necesarias 00:01:32
para poder leer cuando luego sé que no voy a leer nunca jamás sí y aparte de eso está en un 00:01:40
final y porque tanto que explote como no explote lo cierro vale entonces cómo se escribe en un 00:02:03
un fichero? Pues vamos a ver como se crea un fichero, en este caso por ejemplo utilizamos 00:02:12
la clase FileWriter para poder escribir en un file y la clase PrintWriter, vale? La clase 00:02:16
PrintWriter debería sonaros de algo, pero bueno, seguramente no. Entonces me creo un 00:02:24
FileWriter, un PrintWriter, creo un nuevo FileWriter con la ruta del archivo que yo 00:02:30
quiero vale fijaos que tengo la opción de utilizar un constructor que pilla dos 00:02:36
parámetros o sea el nombre del archivo coma un booleano y este booleano me dice 00:02:43
si al escribir en este fichero quiero que se añada al final del fichero lo que 00:02:51
voy a escribir o se sobreescriba lo que ya está me explico si esto es true 00:02:58
Cuando yo escribo 00:03:04
Él lo pone en el fichero 00:03:05
Y si escribo otra cosa 00:03:07
Lo pone detrás de lo que ya he escrito 00:03:08
Hace lo que se llama la función de append 00:03:10
Lo añade al final 00:03:12
Si yo en vez hago 00:03:14
El archivo, false 00:03:16
Quiere decir que cada vez que escribo 00:03:19
Machaca lo que ya estaba en el fichero 00:03:21
Y lo vuelve a escribir por encima 00:03:23
¿Vale? Eso depende de lo que yo quiera hacer 00:03:24
¿Si? 00:03:27
Este file writer 00:03:30
Se pasa como parámetro a un nuevo objeto 00:03:31
Print writer 00:03:33
vale, el printwriter 00:03:34
lo que me permite hacer es un método 00:03:36
que no habéis visto nunca que se llama 00:03:38
println 00:03:39
vale, pues si vosotros vais a mirar 00:03:40
que es system.out 00:03:44
pues veréis que system.out 00:03:46
es un printwriter 00:03:48
vale, solo que en vez 00:03:49
de su canal estar 00:03:52
pegado a un 00:03:53
fichero 00:03:55
lo que está pegado es a la salida 00:03:57
estándar de mi proceso, o sea 00:04:00
La consola, entonces lo que escribo 00:04:02
Allí llega a la consola 00:04:04
Del eclipse 00:04:05
¿Dudas? 00:04:07
Vale, entonces 00:04:10
Esto 00:04:12
Básicamente 00:04:13
Es lo que aprendemos a hacer 00:04:15
Repito que esto es con archivo de texto 00:04:17
Que quizás es la parte más fácil 00:04:19
Porque estoy usando letras 00:04:21
Estoy usando carácter, estoy usando frases 00:04:24
Y entonces es algo que entendemos 00:04:25
Bastante, luego está la parte 00:04:28
Más 00:04:30
A bajo nivel 00:04:30
Que es hacer lo mismo, pero byte a byte 00:04:32
Y la parte más a alto nivel 00:04:35
Que es hacer lo mismo, pero en vez de escribir 00:04:37
Un texto, escribo un objeto 00:04:39
Ejemplo 00:04:40
De programita que copia 00:04:45
Un fichero, vale 00:04:47
Este programita de aquí 00:04:49
Lo que hace es leer 00:04:51
Desde un fichero 00:04:53
Y escribir en otro fichero 00:04:55
Distinto, vale 00:04:57
Entonces se crea un input stream 00:04:58
Sobre el fichero 00:05:00
original, de donde va a leer 00:05:02
y lo mete 00:05:04
en un buffer de input stream 00:05:06
fijaos, esto no estoy haciendo copia 00:05:08
carácter a carácter, no estoy usando texto 00:05:10
estoy usando binario, vale, no está 00:05:12
el buffer reader o el 00:05:14
file reader, estoy usando file input 00:05:16
stream y buffer input stream 00:05:18
entonces estos no tienen 00:05:20
opción de leer una línea o escribir 00:05:22
una línea, bueno, escribir no porque es todo un input 00:05:24
pero, esto es 00:05:26
leo, ni siquiera un carácter, leo 00:05:28
byte a byte 00:05:30
Y a este buffer de input stream 00:05:32
Le paso el 00:05:36
File input stream que he creado antes 00:05:38
Por otro lado creo un file output stream 00:05:40
Y este file output stream 00:05:45
Tiene una ruta distinta 00:05:46
Del otro, es otro fichero 00:05:48
Este es el fichero origen.txt 00:05:50
Este es el fichero 00:05:52
Destino.txt 00:05:53
¿Se crea o lo tienes que crear tú y decirte la ruta? 00:05:55
Técnicamente 00:06:02
Debería ser 00:06:03
Para esto 00:06:04
Deberías comprobarlo 00:06:05
Deberías crear un objeto file 00:06:08
Verificar que existe 00:06:10
Si no existe, crearlo tú 00:06:12
Y seguir adelante 00:06:13
Aún así 00:06:14
Salvo excepciones raras 00:06:15
Alguna vez que explota 00:06:19
Pues normalmente si no existe lo creas 00:06:21
Cuando vas a escribir 00:06:23
vale, pero hay métodos que a lo mejor no lo hacen, entonces depende, depende también de qué clase usas, 00:06:25
a lo mejor si usas directamente float autostream no te lo hace, pero si usas el buffer de autostream si, 00:06:35
eso hay que leer y mirar en el API que tienes que hacer, aún así para ser buen programador pues yo me crearía un fichero, 00:06:40
Comprobaría si está, si no está 00:06:48
Creo un buffer 00:06:50
De output stream 00:06:54
Al que le paso esto aquí 00:06:55
¿Por qué estos dos pasos? 00:06:57
¿No se podría hacer directamente con file input stream y file output stream? 00:06:59
Sí, se podría hacer 00:07:02
Lo que pasa es que a lo mejor tendría 00:07:04
Menos funcionalidades 00:07:06
Que esto sí me ofrece 00:07:09
¿Vale? 00:07:10
A lo mejor estos son más suficientes 00:07:11
Porque en vez de escribir directamente en disco 00:07:13
Lo que hacen es escribir en una memoria temporal 00:07:15
Y cuando yo le digo, venga, ahora escríbelo 00:07:17
Pues escriben de golpe 00:07:20
Que es más rápido que escribir carácter a carácter 00:07:21
¿Sí? 00:07:25
Entonces, aquí no puedo utilizar string 00:07:26
No puedo utilizar carácter 00:07:28
Tengo que utilizar array de bytes 00:07:29
Me creo un array con 1000 bytes 00:07:31
¿Vale? 00:07:36
Esto quiere decir que sustancialmente lo que voy a hacer es 00:07:37
Leer 1000 bytes, escribir 1000 bytes 00:07:39
Leer 1000 bytes, escribir 1000 bytes 00:07:41
Hasta llegar a un momento en que he leído todo 00:07:43
Y acabo 00:07:46
Entonces, aquí no utilizo readline como utilizaba en el otro 00:07:47
Sino utilizo la función read 00:07:53
Que lo que brilla es un array de bytes 00:07:55
Y me lo rellena con los bytes que ha leído 00:07:59
Al final de esta operación 00:08:04
Me devuelve un entero que me dice cuántos bytes ha podido leer 00:08:06
Si he leído 3 bytes 00:08:11
Aquí tendré siempre un array de 1000 bytes 00:08:14
Pero solo los primeros 3 son interesantes 00:08:17
A este punto, mientras lo que he leído es mayor que 0 00:08:20
O sea, si he conseguido leer algún byte 00:08:27
Lo que voy a hacer es escribir con la operación write 00:08:29
Que pilla 3 parámetros 00:08:35
Pilla un array de bytes 00:08:37
Desde donde empiezo a escribir 00:08:40
Y hasta donde empieza a escribir 00:08:43
Eh, hasta donde 00:08:46
Acabo, escribo 00:08:47
¿Si? 00:08:49
Entonces, esto de aquí me está diciendo, pilla la RAID 00:08:51
Empieza desde el principio, siempre desde 0 00:08:53
Y si es 1000 00:08:56
Porque he leído 1000, pues me escribe la RAID entera 00:08:58
Si en vez 00:09:00
He leído solo 4 bytes 00:09:02
Porque al final he leído los últimos 4 bytes 00:09:04
Y no me reían al 1000, pues me escribirá 00:09:06
Solo del 0 al 4 00:09:08
Fijaos que 00:09:09
Esto es excluido 00:09:11
Esta posición de aquí es como la primera 00:09:13
Que no se pone 00:09:16
Si yo leo 1000, aquí va 1000 00:09:17
Y la posición 1000 no está en este array 00:09:19
La última posición es la 999 00:09:22
Pero 1000 es excluido 00:09:24
¿Sí? 00:09:26
¿Dudas? 00:09:29
Y ya está 00:09:31
Cuando he acabado esta cosa de aquí 00:09:32
Cierro el canal de entrada 00:09:34
Cierro el canal de salida 00:09:36
He acabado mi copia 00:09:38
Antes tenía un fichero, ahora tengo dos 00:09:39
Si todo esto funciona 00:09:42
¿Dudas? 00:09:43
Y tened en cuenta que este programita 00:09:46
Funciona con cualquier tipo de fichero 00:09:48
Me da igual que sea de texto 00:09:50
De un fichero de 00:09:51
Ejecutable 00:09:54
Un fichero de cualquier cosa 00:09:56
Pues este de aquí copia 00:09:58
Byte por byte 00:10:00
Entonces me da igual, copia los ceros y los unos 00:10:01
¿Dudas? 00:10:04
Vale 00:10:09
Entonces vamos ahora 00:10:10
a empezar a hablar de otro tema 00:10:12
que es, vale, muy bien, he visto como se trabaja 00:10:16
con los textos y he hecho un ejemplito de como se 00:10:20
trabaja con los bytes, vale, fenomenal, más o menos 00:10:24
eso es fácil de entender, vamos a ver la parte un poquito más compleja y por otro 00:10:28
lado más útil, vale, que son los objetos, nosotros todo esto lo estamos 00:10:32
enfocando a la persistencia de objetos, yo quiero que me echo mi escuela y cuando 00:10:36
apago, pues mi escuela se queda allí 00:10:40
lista para que mañana 00:10:42
la encienda otra vez, pues tengo todos mis alumnos 00:10:44
que he tardado una tarde 00:10:46
en meterlos en el sistema 00:10:48
entonces 00:10:49
el punto es 00:10:51
si yo tengo un objeto, lo importante 00:10:54
del objeto 00:10:56
son los atributos 00:10:57
lo que define el estado 00:11:00
de un objeto son los valores 00:11:02
del atributo 00:11:04
¿tenéis dudas? 00:11:05
Vale, entonces 00:11:08
Mi idea es 00:11:16
La parte de, o sea, la clase está definida 00:11:18
El comportamiento del objeto 00:11:21
Ya está definido en su clase 00:11:23
Entonces los métodos que puedo utilizar, etc 00:11:24
Lo que tengo, lo que quiero guardar 00:11:26
O sea, esa parte en un cierto sentido 00:11:29
El código lo tengo ya guardado porque está en un fichero 00:11:31
¿Vale? En un fichero .class 00:11:33
Pues lo que necesito es 00:11:35
Guardar los valores concretos 00:11:37
De un objeto 00:11:39
¿Vale? Entonces 00:11:41
¿Cómo puedo guardar los atributos de un objeto? 00:11:42
Una primera aproximación es hacer ficheros de textos 00:11:47
¿Qué quiere decir? 00:11:50
Tengo un archivo por clase 00:11:51
Por ejemplo, alumnos.txt tendrá dentro todos los alumnos 00:11:53
Materias.txt tendrá todas las materias, etc. 00:11:58
Y tengo una línea por objeto 00:12:02
Cada objeto tiene su línea 00:12:05
Y dentro de cada línea tengo una cadena de caracteres 00:12:07
Que pone cada atributo 00:12:11
Los valores de los atributos 00:12:13
No hay que decir nombre igual a 00:12:14
Pago 00:12:17
Aquí lo que pone es simplemente pago 00:12:18
Yo sé que el primero es el nombre 00:12:20
El segundo es el número 00:12:22
El tercero es, no lo sé 00:12:24
Estos valores 00:12:28
Estarán separados 00:12:30
Por un cierto 00:12:33
Carácter 00:12:34
Aquí por ejemplo uso dos puntos 00:12:36
A lo mejor 00:12:38
No me hace falta un separador final 00:12:39
Porque hemos dicho que cada objeto está en una línea 00:12:43
Entonces yo le doy a la línea y esto ya sé que es un objeto 00:12:45
Si quisiera poner todo en la misma línea 00:12:48
Pues debería tener un separador que separa los valores de los atributos 00:12:50
Y un separador que separa un objeto de otro 00:12:54
¿Vale? 00:12:57
Está claro que esto puede causar problemas 00:12:59
Si yo mi nombre lo pongo como 00:13:01
Sara dos puntos cocodrilo 00:13:04
Pues este dos puntos 00:13:08
Él lo interpretará como un separador 00:13:10
¿Sí? 00:13:12
Y entonces, cuidado 00:13:15
Pero, bueno 00:13:16
Eso es otro tipo de problema 00:13:17
Esta es una forma de hacerlo 00:13:19
Se puede hacer con programas 00:13:21
Y con objetos muy sencillos 00:13:24
Esto puede ser una solución 00:13:26
¿Vale? 00:13:28
¿Cuáles problemas surgen 00:13:29
Con este tipo de solución? 00:13:32
Primero, si el dato no es un string 00:13:34
Si no es un string 00:13:36
Ya lo tengo que convertir 00:13:37
¿Vale? 00:13:40
Durante el proceso de materialización 00:13:41
Y desmaterialización del objeto 00:13:44
O sea, cuando lo guardo 00:13:46
Y cuando lo vuelvo a crear 00:13:48
Pues si no tengo 00:13:49
Un string, pero tengo un entero 00:13:51
Tengo un booleano, tengo otra cosa 00:13:54
Pues tengo que ver como 00:13:56
Transformo esto 00:13:58
En el correspondiente 00:14:00
Formato textual 00:14:03
Hacer como un pseudo toString 00:14:06
De cada uno de estos 00:14:08
Y cuando lo materializo, cuando vuelvo 00:14:09
A guardarlo, pues tendré que interpretar 00:14:12
Que está escrito falso 00:14:14
No es la string falso 00:14:16
Es un booleano que vale false 00:14:18
Que esto 22 no es 00:14:19
El carácter 2 seguido del carácter 2 00:14:22
Sino que es el número 22, es un int 00:14:24
Entonces tendré que hacer todo el proceso inverso 00:14:25
¿Sí? 00:14:28
Y el otro problema que tenemos allí es 00:14:29
¿Qué ocurre con las referencias a otro objeto? 00:14:31
Aquí tengo una lista 00:14:34
Vale, tengo mi alumno que tiene string, tiene nota, tiene bovedad 00:14:35
Y luego tiene una red de notas 00:14:45
Luego tiene, qué sé yo, un objeto dirección 00:14:48
Que es otro objeto que tiene dentro calle, número y no sé qué 00:14:54
Pues, ¿cómo hago esta referencia a este otro objeto? 00:14:59
No es fácil, ¿vale? 00:15:05
Imaginaos, dos alumnos, son hermanos, viven en la misma dirección 00:15:10
En mi sistema, el primer alumno apunta a un objeto de dirección 00:15:15
Y el segundo alumno apunta al mismo objeto de dirección 00:15:20
Ahora lo voy a escribir de esta forma 00:15:23
Vale, el primero es alumno 1, su edad 00:15:26
Y la dirección, ¿cómo lo hago? 00:15:30
Escribo allí la dirección entera 00:15:32
Pongamos que escribo la dirección entera 00:15:35
Hago como, como he hecho con alumno 00:15:37
Hago lo mismo con direcciones 00:15:40
Le escribo allí tres campos 00:15:41
Que son la calle, el número y el código postal 00:15:43
Ahora, a su hermano hago lo mismo 00:15:48
Cuando los voy a recargar 00:15:51
¿Cómo hago a saber que estos dos objetos 00:15:53
Que vuelvo a materializar, estas dos direcciones 00:15:57
En realidad son la misma? 00:16:00
Se complica la cosa 00:16:02
Sí, pero lo debes comprobar 00:16:03
Con todo lo que existe ya 00:16:08
Ver si existe ya 00:16:10
No es trivial 00:16:12
¿Vale? 00:16:14
Además en el ejemplo que he hecho yo 00:16:15
No estaría mal hecho 00:16:17
Podría haber gente que vive en la misma calle 00:16:19
Cosa por el estilo 00:16:23
Y no sabe si son dos objetos distintos 00:16:24
O un objeto solo 00:16:27
Se complica, ¿vale? 00:16:27
Porque cuando trabajamos con referencias es un poquito más complejo 00:16:29
Entonces, ¿qué soluciones hay por aquí? 00:16:33
Pues, la serialización RAW, ¿vale? 00:16:37
Que es la serialización, lo que intentaremos hacer nosotros después, ¿vale? 00:16:40
Hay serialización textual, ¿vale? 00:16:47
O sea, que hay algunas librerías, como por ejemplo XStream 00:16:49
Que lo que hace es guardarte el objeto en formato textual 00:16:54
Pero usando, por ejemplo, bicheros.xml 00:16:59
Entonces te crea, no una cosa sencilla 00:17:02
Sino un xml donde te marcará que esta dirección 00:17:06
Tiene un determinado identificador 00:17:10
Que será el mismo identificador del objeto de su hermano 00:17:12
Entonces allí tú puedes saber, gracias a las etiquetas xml añadidas 00:17:17
Que estos son efectivamente el mismo objeto 00:17:22
Y cuando lo vas a reconstruir, uno lo crearás la primera vez 00:17:24
Y el segundo ya sabes que está ya creado 00:17:27
Y vas a apuntar al mismo objeto 00:17:29
¿Si? 00:17:31
Este es un poquito más avanzado 00:17:33
Y si no, usar un software 00:17:36
Que tenga un ORM 00:17:37
Más SGB 00:17:39
O sea, una base de datos 00:17:41
Una base de datos 00:17:42
Junto con un 00:17:46
Object Relational Mapping 00:17:47
O sea, un 00:17:50
Mecanismo que me diga 00:17:51
Cuando tienes un objeto con esta forma 00:17:53
Se relaciona a un sistema 00:17:54
Relacional con esta cosa 00:17:57
Se mapea a la tabla relacional 00:17:59
De esta forma 00:18:01
Entonces él en automático 00:18:02
Me materializa y me desmaterializa 00:18:04
Las cosas sin que sea yo 00:18:07
El que mete las manos allí 00:18:09
Y al máximo le doy algunas indicaciones 00:18:10
Iniciales de cómo tiene que hacer las cosas 00:18:13
Y una vez que lo sabe, pues lo hace 00:18:15
¿Sí? 00:18:17
Y esto es, digamos, desde más sencillo 00:18:18
Hasta más complejo 00:18:22
¿Sí? 00:18:23
A nivel de implementación 00:18:25
A nivel de gestión 00:18:26
Está claro que esto, una vez implementado 00:18:28
El último 00:18:31
El ORM más 00:18:32
Base de datos 00:18:34
Una vez que está implementado toda la interfaz 00:18:36
Todo el sistema 00:18:39
Pues lo uso 00:18:41
Más fácilmente 00:18:43
Más potente que este de aquí 00:18:44
Este me da más problemas a mi de programación 00:18:46
Porque soy yo, al fin y al cabo 00:18:49
El que tiene que hacer todo lo que después 00:18:51
Haría un segundo el ORM 00:18:53
¿Sí? 00:18:55
Entonces, son estas cosas de segundo 00:18:56
Vale, entonces 00:18:59
¿Cómo hago la serialización? 00:19:01
Se pueden 00:19:04
Escribir en un fichero 00:19:05
Solo los objetos 00:19:08
Serializables 00:19:09
Un objeto serializable 00:19:11
Es el que implementa 00:19:14
La interfaz serializable 00:19:15
Que tiene 00:19:17
Nada 00:19:19
Tú le escribes 00:19:20
Implemente serializable 00:19:23
Y ya es serializable 00:19:26
Listo 00:19:28
¿Sí? 00:19:30
Esa es la cosa buena 00:19:32
Ahora, para que sea serializable 00:19:33
Sus atributos 00:19:37
Tienen que ser 00:19:39
O tipos simples 00:19:40
O otros objetos que también 00:19:41
Son serializables 00:19:44
Si alguno de los objetos que uso dentro 00:19:45
No es serializable 00:19:49
O yo se me olvida ponerle implementos serializables 00:19:50
Pues me va a decir 00:19:53
Esto no se puede guardar 00:19:54
Porque hay una parte que no es escribible en un fichero 00:19:55
¿Qué es lo que hace? 00:19:58
Magia 00:20:02
Serializable es, sustancialmente, en un cierto sentido, marcar que este objeto se puede escribir byte por byte 00:20:03
Y, sustancialmente, lo que va a hacer es ponerte un método dentro 00:20:11
Que es un método para poder irte a leer tu objeto y leerlo byte por byte 00:20:16
Entonces, luego, cuando tú lo tienes que guardar, lo pillas byte por byte y lo escribes 00:20:22
Y cuando tienes que sacar otra vez 00:20:26
Lo lees byte por byte 00:20:27
¿Vale? 00:20:29
Solo que, por ejemplo, en el API 00:20:31
Muchos objetos son serializables 00:20:33
Pero hay algunos objetos 00:20:37
Que no son serializables 00:20:38
Esos objetos ni se pueden escribir en fichero 00:20:40
Ni se pueden mandar 00:20:42
Por ejemplo 00:20:43
Por sockets 00:20:45
A otras aplicaciones 00:20:47
Entonces, a lo mejor eso 00:20:49
Me condiciona también 00:20:51
A la hora de elegir 00:20:53
Que clases utilizar, que colecciones utilizar 00:20:55
O cosas por el estilo 00:20:57
De saber si las tengo que escribir en un fichero 00:20:58
Pues elegiré una colección que también sea real 00:21:01
La tengo que ir a comprobar 00:21:03
O si me la estoy haciendo yo la implementación 00:21:05
Pues todo lo que estoy utilizando tendrá que ser 00:21:07
Las clases que me creo tendrán que ser 00:21:09
Serializable, porque si no 00:21:11
No le puedo 00:21:12
No le puedo guardar, ¿vale? 00:21:13
Entonces, ¿cómo se escriben objetos 00:21:17
En disco? ¿vale? 00:21:19
O sea, materializar y desmaterializar 00:21:21
Pues existe una clase 00:21:23
Que es la object output stream 00:21:25
¿Vale? El output stream 00:21:27
De objetos 00:21:29
¿Vale? Que, sustantivamente, cuando lo creas 00:21:31
Dentro le pones 00:21:34
Un file output stream 00:21:35
De un fichero 00:21:36
Entonces, esto 00:21:38
La object output stream tiene un método 00:21:41
De escribirme un objeto 00:21:44
Tú le pasas un objeto 00:21:46
Y él lo escribe 00:21:47
Siempre y cuando este objeto sea un objeto serializable 00:21:48
Y con os.writeObject 00:21:52
Este es el método que se usa 00:21:59
De un objeto serializable 00:22:03
Y luego lo cierro 00:22:05
Esto me escribe, ya está 00:22:06
Para leer, pues tengo un object input stream 00:22:09
Al que le pongo dentro un file input stream 00:22:15
De un fichero 00:22:19
Y sustancialmente para leerlo 00:22:19
Tengo la función, leo un objeto 00:22:22
Vale, tened en cuenta que esto 00:22:24
Normalmente funciona 00:22:26
Para iniciar o acabar 00:22:27
O sea, los programas no pueden 00:22:30
Constantemente estar trabajando con ficheros 00:22:32
Los ficheros son lentos 00:22:35
Aquí hago una modificación y la esquivo en el fichero 00:22:36
La otra modificación, la leo en el fichero 00:22:38
Pues, yo trabajo 00:22:41
Con los objetos 00:22:42
En memoria normal, lo que hemos hecho hasta ahora 00:22:44
Esto será un botón 00:22:46
Guardar o un botón importar 00:22:48
Que yo pincho al principio 00:22:50
Para que importe todos los datos que están guardados 00:22:52
Y guardar al final de mi operación 00:22:55
Cuando voy a apagar la cosa 00:22:57
Pues antes de cerrar todo 00:22:59
Pues guardo 00:23:01
¿Sí? 00:23:03
Leo un objeto 00:23:08
Si este objeto no es null 00:23:09
¿Vale? Entonces lo proceso 00:23:11
Hago lo que sea allí 00:23:13
Para poder leer todos los objetos 00:23:14
Que están allí, cuando leeré el último 00:23:17
Pues o explota con un end of file 00:23:19
O explota dándome un o igual a 0 00:23:21
Entonces salgo, pues eso ya 00:23:23
Haremos pruebas y veremos un poco que pasa 00:23:25
¿Sí? 00:23:27
También se suele utilizar la serialización para transmitir objetos 00:23:29
Por una red, ¿vale? 00:23:31
Los sockets, repito que algunos de vosotros se lo verán antes o después 00:23:32
En ambos casos 00:23:35
La Java Desktop Machine gestiona el formato 00:23:37
De los datos de objetos o objetos serializados 00:23:39
O sea que aquí yo estoy perdiendo 00:23:41
¿Cómo se guardan dentro estos objetos? 00:23:43
No tengo ni idea 00:23:45
Que decide como guardar los varios 00:23:46
Atributos, compactarlos 00:23:49
Ponerles separadores, poner lo que sea 00:23:51
Me da igual, porque tanto yo 00:23:53
Lo que escribo, luego lo leeré 00:23:55
Con este método de aquí 00:23:58
Y entonces son métodos 00:23:59
Digamos duales 00:24:01
Bien, funciona 00:24:03
Nota y consejo 00:24:05
Aquí estamos viendo 00:24:08
Parejas de input y output 00:24:09
¿Vale? Desde input stream a output stream 00:24:12
File input stream, file output stream 00:24:14
FileReader o FileWriter 00:24:16
ObjectAutoStream o InputStream 00:24:18
Intentad en la medida de lo posible 00:24:21
Utilizar siempre las mismas parejas 00:24:24
No escribáis con ObjectAutoStream 00:24:26
Y luego leéis con un FileReader 00:24:30
Porque os buscáis problemas 00:24:33
¿Sí? 00:24:36
¿Dudas? 00:24:39
Pero la selección no es tan bonita como parece 00:24:43
Hay problemas con la serialización 00:24:46
¿Vale? 00:24:48
La clase Object-AutoStreamer 00:24:49
No funciona bien del todo, ¿cuándo? 00:24:52
Primero 00:24:54
Intentamos reutilizar la misma 00:24:55
Referencia para 00:24:57
Serializar objetos diferentes 00:24:59
Incluso utilizando 00:25:02
Setters para un mismo objeto 00:25:03
O sea, esto funciona cuando yo tengo 00:25:05
Mi persona P 00:25:08
Que le he puesto una persona y digo 00:25:09
¿Me la escribes a esa persona? Sí, fenomenal 00:25:11
Ahora, si yo he escrito la persona P 00:25:13
Ahora cambio la persona P 00:25:15
Le cambio el nombre, lo que sea 00:25:18
Y digo, me la vuelves a escribir 00:25:19
Eso le molesta 00:25:21
Hasta si yo tengo persona P 00:25:23
Y le digo new persona 00:25:26
O sea, estoy usando la misma referencia 00:25:28
Pero a un nuevo objeto 00:25:31
Pues eso le puede molestar 00:25:33
Por cómo está hecho dentro 00:25:34
La serialización 00:25:36
Entonces cuidado con eso 00:25:38
También, cuando yo guardo en un fichero 00:25:40
Él en automático crea una cabecera 00:25:45
¿Vale? 00:25:47
Crea una parte de datos que me dice 00:25:48
Más o menos lo que me voy a encontrar en este fichero 00:25:51
¿Vale? 00:25:53
Ahora, si yo, por ejemplo 00:25:55
Añado objetos personas 00:25:57
A un fichero, ¿vale? 00:25:59
Luego lo cierro, me voy a hacer otras cosas 00:26:00
Y después de un rato, abro el mismo fichero 00:26:02
E intento ponerle al final 00:26:05
Otras personas 00:26:08
Explota 00:26:09
Porque la segunda vez 00:26:11
Que voy a añadir personas 00:26:14
Intenta poner otra vez 00:26:15
Una cabecera allí 00:26:17
Entonces en vez de tener una cabecera 00:26:18
Y luego los datos, tengo cabecera, un poco de datos 00:26:20
Otra cabecera y otros datos 00:26:23
Y esto le lía 00:26:25
Y explota 00:26:26
¿Sí? 00:26:27
Entonces, para poder utilizar estas cosas 00:26:30
Tengo que saber 00:26:32
Qué estoy haciendo 00:26:34
Y hacerlo bien 00:26:35
¿Sí? 00:26:37
Y por esas razones 00:26:39
Utilizar los ficheros a veces es un poco 00:26:41
Complejo 00:26:44
Es un poco ineficiente 00:26:46
Y entonces se usan otros métodos 00:26:48
Para ver el sistema 00:26:50
¿Sí? 00:26:51
¿Trucos para solucionar estos problemas? 00:26:53
Es que siempre escriba de golpe 00:26:56
Yo pillo los ficheros 00:26:58
Los objetos 00:27:02
Escribo todos los objetos 00:27:03
Y dejo allí el fichero 00:27:05
Ya está 00:27:07
Si llega un momento en que tengo que escribir algo más 00:27:07
Lo que debería hacer es 00:27:11
Me leo el fichero 00:27:12
Sacando todos los objetos que están allí 00:27:14
Y luego me creo otro objeto 00:27:16
O el mismo objeto, lo borro 00:27:18
Y vuelvo, el mismo file, perdón 00:27:20
O un nuevo file 00:27:22
Y vuelvo a reescribir lo que estaba antes 00:27:24
Más las cosas nuevas, de golpe 00:27:27
Otra opción 00:27:28
Empaqueto todos los objetos 00:27:30
En una colección 00:27:33
Pongo todo en un array 00:27:35
Y cuando voy a escribir 00:27:37
Escribo el array 00:27:39
Entonces cuando me lo voy a cargar 00:27:40
No cargo una sola persona 00:27:43
Mas cargo un array de personas 00:27:45
Lo cargo entero, ahora tengo todas las personas 00:27:46
Hago lo que tengo que hacer, le añado las cosas así 00:27:49
Y cuando voy a escribir 00:27:51
Borro lo que está dentro y vuelvo a escribir 00:27:52
El array en bloque 00:27:54
O... 00:27:56
La shmap o lo que sea 00:27:58
¿Si? 00:28:00
Teniendo en cuenta que, repito 00:28:02
Estas operaciones son costosas 00:28:03
Trabajar con el disco duro es lento 00:28:06
Entonces no es una cosa que debería estar constantemente haciendo 00:28:08
Cambio algo, lo escribo en Word 00:28:11
De hecho, nuestros programas no lo hacen 00:28:12
Vosotros escribís en Word 00:28:15
No es que cada vez que tecleáis algo 00:28:16
Lo escriben en el fichero directamente 00:28:18
Espera que vosotros le deis a guardar 00:28:20
Para que escriba 00:28:24
¿Sí? 00:28:25
A lo mejor, si el sistema está en idle 00:28:26
Algunos sistemas avanzados 00:28:28
Escriben lo que estáis haciendo 00:28:29
En un fichero temporal 00:28:32
Que si tú le das a guardar 00:28:33
Copian eso en Word 00:28:35
Y si tú no le das a guardar 00:28:36
Pues te lo dejan allí por si acaso te has equivocado 00:28:38
Y se ha ido la luz 00:28:40
Pero bueno 00:28:40
Tiene un coste 00:28:43
Entonces 00:28:46
La última parte de esta 00:28:47
De esta 00:28:50
¿Cómo se llama? De esta presentación 00:28:51
Son una serie de códigos 00:28:53
Para hacer varias cosas 00:28:56
¿Vale? Como por ejemplo 00:28:58
Esto es un escribir 00:29:00
Texto en un fichero 00:29:02
¿Vale? Entonces os viene aquí 00:29:03
Como se hace, luego está 00:29:05
Leer un fichero 00:29:07
Pues aquí viene un ejemplo 00:29:09
Escritura en ficheros binarios 00:29:11
Es lectura 00:29:14
En ficheros binarios 00:29:17
Lectura 00:29:19
Perdón, ¿esto qué es? 00:29:21
Escritura de un objeto 00:29:23
A lo mejor ahora esto lo miramos con un poco más de detalle 00:29:25
Lectura de un objeto 00:29:27
Y un ejemplo de una clase 00:29:29
Serializable, ¿vale? 00:29:33
Una clase serializable es que, sustancialmente, la clase de persona implementa el serializable. 00:29:35
Con esto ya esta cosa es serializable. 00:29:40
Y dentro tiene las cosas que tiene que tener. 00:29:42
¿Vale? 00:29:46
Y entonces esto de aquí es siempre una escritura con un objeto serializable. 00:29:48
¿Vale? 00:29:55
Y lectura de un objeto serializable. 00:29:56
Y esta es un poco la jerarquía de clases que tenemos. 00:29:59
Nosotros hemos visto 00:30:04
Esto, FileInputStream 00:30:05
BufferInputStream 00:30:08
Esto puede ser interesante 00:30:11
DataInputStream 00:30:12
DataInputStream os permite 00:30:13
Leer 00:30:16
Ojetos, o sea leer 00:30:19
Cosas de un determinado tipo 00:30:22
Puedo leer un double 00:30:23
Leer un char 00:30:25
Leer un entero 00:30:28
Mientras 00:30:29
un input stream lee 00:30:31
byte por byte 00:30:34
esto ya te da un formato al dato 00:30:35
que estás leyendo 00:30:38
buffer de input stream lo hemos visto 00:30:39
file input stream lo hemos visto 00:30:42
object input stream 00:30:44
lo hemos visto 00:30:47
del output los mismos 00:30:48
hay otros 00:30:50
a lo mejor en determinadas situaciones pueden ser 00:30:51
estos son 00:30:54
a nivel de byte a byte 00:30:56
estos son a nivel de caracteres 00:30:58
Entonces si uso cosas textuales 00:31:00
Me voy a este lado con los readers 00:31:02
Buffered reader en particular 00:31:04
File reader 00:31:06
Y cosas por el estilo 00:31:07
¿Si? 00:31:08
Vale, vamos a ver 00:31:12
O este o este 00:31:14
Que diferencia hay 00:31:17
Si os fijáis aquí voy a escribir 00:31:18
Objetos, vale 00:31:20
Con el object 00:31:21
Object output stream 00:31:23
Puedo escribir cosas como estas 00:31:25
Un booleano, un double 00:31:27
Un char, un int, un string 00:31:29
¿Vale? 00:31:32
Sostancialmente los tipos 00:31:34
Básicos, los tipos primitivos 00:31:36
Transformados 00:31:38
En su clase wrapper, en su clase 00:31:40
Contenedor, que es un 00:31:41
Objeto, ¿vale? Como int tiene 00:31:44
Integer o double tiene double 00:31:45
Con la D mayúscula y cosas por el estilo 00:31:48
Y luego este objeto se escribe 00:31:49
¿Vale? Y tienen 00:31:51
Las operaciones para escribir 00:31:53
Cada uno de estos tipos 00:31:55
Lo que puedo hacer luego es 00:31:57
Leerlos, tengo el read boolean 00:31:59
Para leer un booleano, un read double 00:32:01
Para leer el double y cosas por el estilo 00:32:03
Todo esto en object input string 00:32:05
¿Vale? 00:32:07
Si en vez quiero escribir un objeto de verdad 00:32:08
¿Vale? 00:32:11
Tengo mi 00:32:13
Objeto 00:32:14
Que es objeto persona 00:32:16
Persona tendrá que ser serializable 00:32:18
¿Vale? Aquí tengo cuatro personas 00:32:21
Y lo que puedo hacer es un write object 00:32:23
Del objeto 00:32:26
Entonces, he abierto el fichero 00:32:27
Escribo los cuatro 00:32:30
Objetos uno seguido al otro 00:32:32
No pasa nada, ¿vale? 00:32:36
Esto lo puede hacer 00:32:37
Al final cierro el 00:32:38
El fichero, ¿vale? 00:32:41
El canal de comunicación 00:32:45
Cuidado que si ahora lo vuelvo a abrir 00:32:46
Y vuelvo a poner otro objeto 00:32:48
Allí es donde me puede dar problema 00:32:50
¿Sí? 00:32:52
o te creas 00:32:55
una serie de ficheros distintos 00:33:05
y luego cuando 00:33:07
cada vez que añades algo 00:33:09
añades, si esto es alumnos 00:33:11
añade alumno 2 y los añade allí 00:33:13
alumno 3 y cuando luego lo vas a leer 00:33:15
te vas a mirar 00:33:17
hasta que número has llegado 00:33:18
y te importa todos los alumnos 00:33:20
todos los ficheros dentro de esa carpeta 00:33:22
y te lo vas a ir añadiendo uno y otro 00:33:25
pero eso te puede llegar al momento que tienes 00:33:27
50.000 00:33:29
alumnos 00:33:30
pero repito 00:33:31
si son pocos datos 00:33:35
es viable, si son muchos datos 00:33:37
estamos hablando de 50.000 datos 00:33:39
no lo haces con ficheros, lo haces con una base de datos 00:33:40
esto es para leer 00:33:45
entonces acordaos que cuando voy a leer 00:33:48
read object 00:33:51
el resultado de esta cosa 00:33:53
aquí es un objeto 00:33:55
entonces lo tendré que castear 00:33:57
A persona 00:33:59
O leerlo como objeto 00:34:00
Comprobar que es una instancia de persona 00:34:02
Y a ese punto 00:34:05
Guardarlo en la persona 00:34:06
¿Se pueden mezclar 00:34:08
Entre ellos 00:34:13
Objetos raros 00:34:14
Se podrá 00:34:16
Es aconsejable 00:34:18
Cuidado 00:34:20
Con lo que no sabes 00:34:21
Que estás leyendo 00:34:25
Y esto más o menos 00:34:26
lo que tenéis que saber de ficheros 00:34:30
Subido por:
Stefano C.
Licencia:
Reconocimiento - No comercial
Visualizaciones:
25
Fecha:
20 de mayo de 2024 - 13:32
Visibilidad:
Clave
Centro:
IES ROSA CHACEL
Duración:
34′ 35″
Relación de aspecto:
4:3 Hasta 2009 fue el estándar utilizado en la televisión PAL; muchas pantallas de ordenador y televisores usan este estándar, erróneamente llamado cuadrado, cuando en la realidad es rectangular o wide.
Resolución:
960x720 píxeles
Tamaño:
104.60 MBytes

Del mismo autor…

Ver más del mismo autor

EducaMadrid, Plataforma Educativa de la Comunidad de Madrid

Plataforma Educativa EducaMadrid