Saltar navegación

Ficheros 1 - 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.

15 visualizaciones

Más información Transcripción

Descargar la transcripción

Vale, vamos a grabar la clase, por lo tanto si habláis me dais el consentimiento para que grabe vuestra voz, ¿vale? 00:00:00
Para hacer preguntas y cosas por esto. 00:00:06
Persistencia de datos, entonces vamos a ver ahora uno de los mecanismos que podemos hacer, utilizar en Java para que los datos persistan entre una ejecución y otra de un mismo programa, ¿vale? 00:00:09
Nosotros sabemos que una parte de nuestros programas ya se mantienen entre ejecuciones, ¿vale? 00:00:24
Que son el código, sustancialmente 00:00:30
El código se almacena y ha compilado en dispositivo de almacenamiento como disco duro, ¿vale? 00:00:32
Vosotros sabéis que vosotros escribís el código 00:00:37
Luego, al darle al Java C, sustancialmente, creáis bytecode 00:00:38
Que serían los puntos class 00:00:44
Los puntos class en vuestros proyectos se guardan en la carpeta bin, ¿vale? 00:00:45
La carpeta src contiene punto java 00:00:52
La carpeta bin contiene los puntos class 00:00:55
Y cuando se ejecuta, los puntos Java y el search no se miran 00:00:58
Todo se hace en BIM, ¿vale? 00:01:03
En la parte compilada 00:01:05
Porque la JavaScript Machine entiende los puntos class, ¿vale? 00:01:06
Sin embargo, el resto de los datos 00:01:11
Como son los objetos, las variables, etc. 00:01:14
Eso no se guarda en el disco duro 00:01:17
Eso se guarda en RAM al momento en que se ejecuta 00:01:20
Por lo tanto, existe mientras que la JavaScript Machine está funcionando 00:01:23
Y mientras que yo estoy utilizando mi programa 00:01:27
Cuando la director machine se apaga 00:01:29
Cuando el programa se acaba 00:01:31
Todos estos datos se pierden 00:01:32
¿Vale? 00:01:35
Justo para que os suene 00:01:40
¿Vale? 00:01:41
Los valores de atributos y objetos 00:01:42
No existen en el disco 00:01:45
Cuando se ejecuta una new 00:01:47
¿Vale? 00:01:50
Cuando se hace un nuevo objeto 00:01:50
Se reserva un espacio en la memoria RAM 00:01:52
Un espacio dentro del proceso que es todo el programa 00:01:55
Hay un espacio particular para los objetos que se llama el heap 00:02:00
Esta es la parte de la memoria donde se guardan los objetos 00:02:04
Es una zona especial donde se guardan los objetos 00:02:09
Sin embargo, los otros datos como variables locales, los parámetros de entradas 00:02:12
Los parámetros cuando hago una llamada, etc. 00:02:17
No se guardan en este espacio aquí 00:02:20
Si no se guardan en otra sección que es llamada la stack, la pila 00:02:23
Si os acordáis cuando vimos las pilas y cosas por el estilo 00:02:27
Hablamos de la pila de llamadas, de métodos, etc. 00:02:31
Pues esto funciona como pila porque si pensáis a las variables 00:02:36
Y donde existen las variables, el concepto de ámbito de una variable 00:02:41
Lo vimos al principio 00:02:46
Si os acordáis que una variable existe solo dentro del bloque en el que está declarada 00:02:47
Pues esto es una pila, ¿vale? Cada bloque es una capa nueva de la pila donde existe la información de ese bloque, ¿vale? Cuando yo salgo de ese bloque, pues la última capa se quita y las variables que existían allí desaparecen, ¿vale? 00:02:51
Por eso son locales a ese blog 00:03:10
Entonces, heap y stack son 00:03:13
Heap es como montón en español 00:03:15
Son simplemente dos formas de almacenar los datos 00:03:19
¿Vale? Por eso se llaman así 00:03:24
El stack lo conocemos, la pila 00:03:25
El heap no lo conocemos exactamente como funciona 00:03:27
Pero es, digamos, el tipo de colección 00:03:30
El tipo de estructura que se utiliza para almacenar 00:03:34
Los objetos 00:03:38
Vale 00:03:40
Cuando finaliza el programa 00:03:42
Los datos, los atributos 00:03:44
Etcétera, etcétera, no persisten 00:03:47
¿Vale? 00:03:49
Y los lenguajes orientados a objetos 00:03:50
No suelen prever ningún 00:03:52
Mecanismo automático 00:03:55
Para guardar estos objetos 00:03:57
De forma persistente 00:03:58
O sea, todos los lenguajes orientados a objetos 00:04:01
Por defecto, si yo no hago nada 00:04:03
Si yo no lo hago explícitamente 00:04:05
Lo que hacen es perderán todos los datos cuando se apaga 00:04:06
¿Vale? 00:04:09
Pero prácticamente todos los lenguajes de orientado a objetos 00:04:10
Tendrán sus mecanismos para intentar guardar estos ficheros 00:04:13
Y para que persistan de alguna forma 00:04:18
¿Vale? 00:04:20
Entonces, ¿cómo vamos a almacenar los datos? 00:04:21
¿Vale? 00:04:26
Para conservar estos datos tenemos que trabajar con un sistema de almacenamiento 00:04:26
Que no sea como la RAM, que cuando apaga, cuando ya pierde la corriente se va 00:04:32
Sino algo que pueda persistir, como por ejemplo un disco duro, ¿vale? 00:04:37
¿Cómo se hace esto? Pues, por ejemplo, se puede crear un archivo 00:04:41
Que es lo que aprenderemos a hacer hoy, ¿vale? 00:04:45
Nosotros podemos crear un fichero, dentro de este fichero, que es un trozo de memoria 00:04:48
Al fin y al cabo, podemos meter datos, ¿vale? 00:04:52
Los datos que metemos aquí pueden ser RAW, crudos 00:04:56
O sea, los datos tal y como los tengo 00:05:00
Pues los escribo allí, en bits y bytes 00:05:02
¿Vale? 00:05:05
O en modalidad texto 00:05:06
¿Vale? Si yo lo que estoy utilizando es guardar 00:05:08
Información que son string 00:05:10
Que son texto 00:05:12
O yo tengo otros tipos de datos 00:05:13
Pero los puedo representar 00:05:16
Como un string 00:05:18
Pues entonces lo puedo guardar en modalidad texto 00:05:19
¿Vale? 00:05:23
Entonces en vez de guardarlo byte a byte 00:05:23
En un cierto sentido lo estoy guardando en grupos de bytes 00:05:25
Que luego se corresponderán a carácteres 00:05:28
Y serán secuencias de carácteres 00:05:30
¿Os acordáis algún ejercicio 00:05:32
Que hemos hecho en nuestro 00:05:35
En el curso 00:05:37
En el que se decía 00:05:39
Oye, mira, tenéis que crear, no sé 00:05:40
Tres alumnos, cinco alumnos 00:05:42
Te voy a dar yo un string 00:05:43
¿Vale? 00:05:46
Que pone nombre, coma 00:05:47
O sea, Estefano, coma 00:05:49
Cuarenta, coma 00:05:53
Una dirección, ¿vale? 00:05:55
Punto y coma 00:05:56
Y luego estará paco, coma 00:05:57
37, coma 00:05:59
Y otra dirección, etc, etc 00:06:01
Y esto era una representación 00:06:03
De tipo texto 00:06:05
De los objetos 00:06:06
¿Vale? Entonces se puede hacer 00:06:08
Yo mis objetos los puedo pillar 00:06:11
Decir, vale, cada objeto se representará como 00:06:13
Concatenando de forma string 00:06:15
Una cosa a otra 00:06:18
Y eso me lo guardo como un line text 00:06:19
Está claro que aquí se podría complicar 00:06:21
Que 00:06:23
Pero 00:06:24
En qué sentido 00:06:28
Eso da igual 00:06:30
Eso lo decides tú 00:06:33
Puedes no poner espacio 00:06:34
Puedes ponerlo, puedes poner un asterisco 00:06:35
Eso lo decides tú 00:06:38
Como a ser formado en base a tus necesidades 00:06:40
Mi pregunta es más 00:06:43
A alto nivel, más abstracta 00:06:45
O sea, cuando yo tengo un objeto 00:06:47
Persona 00:06:49
Y lo quiero escribir en un fichero 00:06:50
Como una línea de texto 00:06:52
Si tengo el nombre de la persona 00:06:53
Fácil, es un string, lo pongo 00:06:56
Si tengo la edad de una persona, pues es un int 00:06:58
Vale, pero lo puedo convertir 00:07:01
A un string, poniéndole delante 00:07:02
Dos comillas, y lo puedo escribir tal y cual 00:07:04
Me tengo que acordar que 00:07:07
Cuando lo volveré a leer, ese es un string 00:07:08
Y yo tendré que hacer un integer.partseint 00:07:11
Para revocarlo 00:07:13
Vale, fenomenal 00:07:14
¿Dónde se puede complicar las cosas? 00:07:15
Exacto, cuando 00:07:27
Mis atributos no son primitivos 00:07:28
Definitivos. Porque nosotros sabemos que cuando los atributos de una clase son objetos también, pues no lo guardo directamente con su valor, sino guardo una referencia a otro objeto. 00:07:31
Y claro, si yo estoy haciendo una conversión de mi persona o mi alumno, y mi alumno tiene lista de materias, y lista de materias es una clase, ¿cómo hago la representación textual de esta lista de materias? 00:07:44
Puede ser complejo. Y más complejo todavía. ¿Qué pasa cuando hay referencias de distintos objetos al mismo objeto? O sea, que todos los alumnos de primeros tendrán la misma lista de materias. 00:08:01
Entonces, el objeto lista de materia es único, pero todos los objetos alumnos tienen que referenciarse a este objeto. Pues eso se complica en términos de tener que escribirlo como una cadena de texto. 00:08:16
Ya, pero tú 00:08:30
¿Qué haces? ¿Lo escribes en cada alumno? 00:08:32
¿Escribes toda la lista? 00:08:35
¿Cómo referencias un objeto 00:08:36
Pasándolo a string? 00:08:41
No es fácil 00:08:44
No es fácil 00:08:45
¿Vale? 00:08:47
Porque la referencia que te da 00:08:47
Es dinámica 00:08:49
Es que la puedes reutilizar más adelante 00:08:50
Entonces, esto complica un poco las cosas 00:08:53
No siempre se puede utilizar 00:08:56
Este mecanismo 00:08:57
Hay mecanismos más avanzados 00:08:58
Otro mecanismo 00:09:00
Que podemos utilizar es 00:09:03
Pidiéndole a la Java Virtual Machine 00:09:04
Oye mira hazlo tú 00:09:06
No me voy yo 00:09:07
A liar con los datos 00:09:09
Transformándolo a texto 00:09:11
Representando mis objetos 00:09:13
Como formato textual 00:09:16
Si no le digo a la Java Virtual Machine 00:09:17
Oye mira tengo este objeto 00:09:19
Guárdamelo en algún lado 00:09:21
Una vez que me lo has guardado allí 00:09:23
Cuando lo quiero te voy a pedir 00:09:24
Oye dámelo otra vez 00:09:26
¿Vale? Esto se suele hacer serializando el objeto 00:09:27
¿Vale? Existe una forma relativamente fácil para decirle que este objeto es serializable 00:09:32
Serializable es exactamente lo que se puede escribir en serie 00:09:38
Se puede transformar en una secuencia de bytes 00:09:41
Y una vez que se pueda transformar en una secuencia de bytes 00:09:44
Yo esto lo puedo dar a una clase, digamos así, ahora veremos cuál es 00:09:46
Que tiene unos métodos 00:09:54
Y estos métodos lo puede decir 00:09:55
Escribe esta serie de bytes 00:09:56
En un fichero 00:09:58
Y él lo escribirá 00:10:01
Además 00:10:02
Cuando un objeto es serializable 00:10:03
Si contiene solo objetos serializables 00:10:07
Pues en automático 00:10:10
La Java Store Machine se da cuenta 00:10:12
De las varias referencias 00:10:14
Y escribe lo que tiene que escribir 00:10:15
Para que luego más o menos funcione 00:10:17
Aún así 00:10:19
No es 00:10:20
Súper sencillo 00:10:22
¿Vale? 00:10:25
Hay que saber lo que estamos haciendo 00:10:26
Porque, sobre todo 00:10:28
O sea, para... 00:10:30
Yo tengo la clase alumno con sus datos 00:10:32
Y la guardo, guardo un objeto 00:10:34
Y lo vuelvo a pillar 00:10:36
Pues eso es muy fácil 00:10:37
Las cosas se complican cuando hay muchos objetos 00:10:38
Que se referencian a objetos compartidos 00:10:42
Y que haya esto... 00:10:45
Haya que hacer algo 00:10:47
Para que cuando yo vuelva a cargar estos objetos 00:10:48
Se cargue también el objeto compartido 00:10:51
Y que todos referencien a la misma instancia 00:10:53
Eso se complica 00:10:55
¿Vale? 00:10:56
Y si Java no lo entiende 00:10:57
No lo consigue hacer 00:11:00
Pues tendré que ser yo 00:11:01
En mi fase de leer el fichero 00:11:03
Y recuperar los datos 00:11:05
Que haga las cosas bien 00:11:06
Lo habré guardado de tal forma 00:11:08
Que cuando luego lo vuelva a recargar 00:11:09
Pues modifique lo que tenga que modificar 00:11:12
Para que funcione 00:11:15
¿Sí? 00:11:16
Más de eso más adelante 00:11:17
La tercera forma 00:11:18
Es utilizar una base de datos 00:11:20
¿Vale? 00:11:22
Para poder utilizar una base de datos 00:11:24
Que no es sencillo, tengo que encontrar algo 00:11:25
Que me haga un mapeado 00:11:28
Entre mis objetos y las tablas de la base de datos 00:11:30
Que se llama un ORM 00:11:32
Y utilizando estas dos cosas 00:11:34
Pues es una versión 00:11:35
Un poco más eficiente 00:11:38
Y un poco más 00:11:41
Elegante 00:11:42
De hacer esta cosa 00:11:43
Está claro que 00:11:45
Si mi programa es un programa muy sencillo 00:11:46
Montar un sistema de un gestor de base de datos 00:11:49
Con un ORM y todo esto 00:11:52
Pues me lleva más tiempo 00:11:53
Que programar mi programa 00:11:55
Lo que estamos haciendo nosotros es programar cosas muy sencillas 00:11:57
Y por lo tanto esto 00:12:00
Por ahora nos interesa poco o nada 00:12:01
¿Vale? 00:12:04
Está claro también que en un proyecto verdadero 00:12:05
Allá afuera, un sistema que tiene que funcionar 00:12:07
Entre producción 00:12:10
Pues probablemente esto es lo que queremos 00:12:11
También porque 00:12:14
Si hay muchos datos con los que trabajamos 00:12:15
Y cosas por el estilo 00:12:18
Trabajar con archivos es lento 00:12:19
Siempre trabajar con archivos es una cosa lenta 00:12:21
Los sistemas gestores de base de datos 00:12:24
Tienen todos los mecanismos que habéis aprendido 00:12:26
De indicización 00:12:28
De optimización 00:12:30
Para que el acceso a los datos sea mucho más rápido 00:12:31
Con respecto a leer un archivo entero 00:12:34
Y buscar allí algo 00:12:37
Para que no se 00:12:38
¿Vale? 00:12:40
Eso quiere decir que los archivos no se usan 00:12:42
Los archivos siguen allí 00:12:44
Son la base 00:12:46
Muchos datos 00:12:47
Que hay que cargar 00:12:49
O que te interesan todos 00:12:52
Que no hay tanto que buscar 00:12:54
Sino que son datos que tienen que almacenar 00:12:55
Y que cada vez que arrancas tu programa 00:12:57
Los tienes que cargar en memoria 00:12:59
Pues un archivo es una solución 00:13:01
Aceptable 00:13:03
¿Sí? 00:13:04
Entonces, cuando se habla de almacenamiento de datos 00:13:06
Tres opciones 00:13:10
O uso archivos directamente 00:13:11
Y soy yo que le digo 00:13:14
Cómo se escribe y cómo se lee 00:13:15
Tanto en modalidad directamente byte a byte 00:13:17
O en modalidad de cadenas de texto y mensajes 00:13:20
O uso la Java Vector Machine 00:13:24
Lo que me proporciona la Java Vector Machine 00:13:27
Para que sea ella que decida cómo almacenar los datos 00:13:29
Y ahí yo pierdo el control de cómo se almacena este objeto 00:13:32
Es ella que sabe almacenarlo y recuperarlo 00:13:35
O utilizo una base de datos 00:13:38
Estas son las tres opciones 00:13:41
Para utilizar los ficheros 00:13:42
Necesitamos una clase que represente los ficheros 00:13:47
Fijaos, esto no es 00:13:50
File, la clase file 00:13:51
De Java no es un fichero 00:13:54
Es un manejador 00:13:56
De fichero 00:13:58
Representa un fichero 00:13:59
Es una abstracción de un fichero 00:14:01
El handler, el manejador 00:14:05
Que yo puedo tener dentro de mi programa 00:14:08
Para luego trabajar con 00:14:10
El sistema 00:14:12
Con el sistema de ficheros 00:14:13
Y los ficheros de verdad 00:14:15
Tened en cuenta que aquí hay varios pasos 00:14:17
Si yo estoy en un programa 00:14:19
Mi programa está escrito en Java 00:14:20
Y está ahí en un ficherito 00:14:22
Está traducido al class 00:14:24
Nosotros no trabajamos 00:14:25
Directamente con ficheros nunca 00:14:28
Lo que hay en el medio 00:14:30
Hay al menos dos pasos 00:14:32
Por un lado está la Java Virtual Machine 00:14:34
Que interpreta mis comandos 00:14:36
Y que entonces puede ya hacer algo 00:14:38
Allí ella, y luego la Java Virtual Machine 00:14:40
Para poder trabajar sobre los ficheros 00:14:42
No puede ir a trabajar directamente 00:14:44
Necesita una interfaz 00:14:46
Con lo que es el sistema operativo 00:14:48
¿Vale? Entonces, la implementación 00:14:50
De la Java Vector Machine, implementará 00:14:52
Las llamadas de sistemas 00:14:54
Al sistema operativo correctas 00:14:56
Porque la Java Vector Machine, sabéis que si está instalada 00:14:58
En Windows, o en Linux, o en 00:15:00
OSX, o lo que sea 00:15:02
Por lo tanto, al instalar 00:15:04
La Java Vector Machine, ella tendrá 00:15:06
Los mecanismos dentro para poder 00:15:08
Solicitar al sistema operativo 00:15:10
Oye, píllame un trozo 00:15:12
De memoria, ese trozo de memoria 00:15:15
Lo referenciarás con este nombre 00:15:16
Y ahora este sería un fichero 00:15:18
Y yo quiero escribir allí 00:15:19
Entonces hay varios niveles 00:15:20
A nivel nuestro, que es el nivel más abstracto 00:15:23
De todos, nosotros no trabajamos 00:15:26
Directamente, no sabemos si por debajo 00:15:28
Hay un disco duro, si hay un pendrive 00:15:30
Si hay un 00:15:32
Un cd, que se yo 00:15:34
Me da igual 00:15:36
A mi lo que me interesa es 00:15:38
Llamar una entidad file 00:15:39
Y en este file luego podré hacer algo 00:15:41
Como crear un canal de escritura 00:15:44
O crear un canal de lectura 00:15:45
Para poder escribir o leer 00:15:47
¿Vale? 00:15:49
Entonces la clase File me representa este fichero 00:15:50
Normalmente se le da un nombre 00:15:53
De un archivo 00:15:56
¿Vale? 00:15:56
Datos.dat 00:15:58
No se que.txt 00:16:00
¿Vale? 00:16:02
Sabéis que al menos en el mundo de Windows 00:16:03
Las extensiones no sirven prácticamente de nada 00:16:05
La única cosa que sirven 00:16:08
Es para saber con que 00:16:10
Programa se abre en estos 00:16:12
Ficheros 00:16:14
¿Vale? Entonces si es .docx 00:16:16
Se abrirá con Word 00:16:18
Si es .pdf se abrirá con 00:16:19
Un lector de PDFs y cosas por el estilo 00:16:21
¿Vale? Entonces 00:16:24
Esto para decir que cuando me invento un nombre 00:16:25
Le tengo que dar una extensión, pero a lo mejor inventaré 00:16:28
La extensión que me da la gana, ¿vale? 00:16:30
Normalmente 00:16:33
A lo mejor nosotros pues 00:16:34
Utilizaremos un .txt 00:16:35
¿Por qué? Porque luego es fácil ir allí, abrirlo 00:16:37
Con doble clic y ver que hay dentro 00:16:39
Si lo llamo punto algo, pues funciona perfectamente 00:16:41
Pero cuando voy a darle doble clic me dice con qué programa lo tengo que abrir un punto algo 00:16:46
Para crear un fichero en Java se invoca un constructor de la clase File 00:16:50
Hago New File entre paréntesis del nombre y sostancialmente esto me crea un handler 00:16:56
A ese punto con este handler puedo preguntarme, ¿existe este fichero? 00:17:02
Si existe, lo puedo 00:17:06
Utilizar, si no existe 00:17:08
Se puede decir entonces crear 00:17:10
Vale 00:17:12
¿Cómo se leen los datos 00:17:17
Desde un fichero? 00:17:20
¿Vale? 00:17:22
Entonces, para eso existen 00:17:23
Varias clases 00:17:25
Nosotros veremos 00:17:27
Cuatro, cinco 00:17:28
Clases de este tipo, ¿vale? 00:17:31
Que me permiten crear 00:17:33
Un canal de comunicación con el fichero 00:17:34
¿Vale? 00:17:37
La input stream 00:17:37
Es la más genérica 00:17:40
¿Vale? De hecho no se puede crear 00:17:41
Un input stream como tal 00:17:43
¿Vale? 00:17:45
Es sustancialmente 00:17:46
Una idea abstracta 00:17:48
De como se puede 00:17:51
Recibir datos 00:17:53
Un flujo en input 00:17:54
Un flujo en entrada 00:17:56
De datos 00:17:57
Y sustancialmente me da unos métodos 00:17:59
Me proporciona unos métodos muy muy básicos 00:18:02
En plan a leer bytes 00:18:04
Esto sirve 00:18:06
Para sustancialmente 00:18:09
Poder leer byte a byte un fichero 00:18:11
Sin interpretarlo como 00:18:13
Carácteres, sin interpretarlo como 00:18:15
Objetos, sin interpretarlo 00:18:17
No lo interpreto 00:18:18
Voy a pillar un byte y lo leo 00:18:20
Voy a pillar otro byte 00:18:22
Está claro que yo a nivel de Java 00:18:23
Puedo leerme todos los bytes que quiero 00:18:27
Y luego esos bytes 00:18:29
Castearlos, transformarlos en otra cosa 00:18:30
¿Vale? Eso se puede hacer 00:18:33
Pero aquí estoy trabajando solo con bytes 00:18:35
¿Para qué puede servir cosas así? 00:18:38
Por ejemplo, cuando yo quiero copiar un fichero 00:18:41
Y este fichero no es un fichero de texto 00:18:44
Yo tengo un fichero ejecutable, lo quiero copiar 00:18:46
Entonces quiero leer este fichero ejecutable y escribirlo en otro lado 00:18:49
Pues para leerlo, como es un fichero ejecutable 00:18:53
¿Habéis abierto alguna vez un fichero ejecutable con un lector de texto? 00:18:57
No se entiende 00:19:05
Porque son bytes 00:19:06
Y el fichero de editor de texto 00:19:07
Intenta interpretarlo como caracteres 00:19:10
Pero no son caracteres, son bytes 00:19:13
Y por lo tanto no se ve nada 00:19:14
Pues lo mismo 00:19:16
En ficheros como el ejeutable por ejemplo 00:19:17
Si lo tengo que leer 00:19:20
Pues lo mejor es leerlos byte a byte 00:19:22
Porque no me representan caracteres 00:19:24
No me representan objetos, no me representan nada 00:19:26
Si quiero recuperar un mapa 00:19:28
Y se abre y solamente se ven los caracteres 00:19:29
¿Puedes hacer cosas para que 00:19:36
Es difícil, pero allí ya es otra cosa 00:19:38
Allí es porque un Word 00:19:41
En realidad por debajo es un lenguaje de marcas 00:19:42
¿Vale? Especial, lo habéis estudiado 00:19:45
Es un 00:19:47
What you get is what you see 00:19:47
Tipo de lenguaje de marcas 00:19:50
Tú lo ves, pero por debajo cuando se guarda 00:19:52
Le añade toda la marca que quiera él 00:19:54
Está claro que si se ha corrompido alguna de estas marcas 00:19:56
Pues como si en un XML 00:19:58
Tú te pones acá a borrar 00:19:59
Farentesis y borrar 00:20:02
Nodos 00:20:03
Y llega un momento que no te entiende 00:20:05
Pero no es 00:20:07
No son caracteres puros 00:20:10
Habría que ver como se guarda 00:20:12
En los pequeños 00:20:14
Vale 00:20:15
Ahora, yo puedo encapsular 00:20:17
Un input stream 00:20:20
Que es, hemos dicho, un canal de comunicación 00:20:21
Byte a byte 00:20:24
Y puedo decir, oye mira, pero yo no quiero leer byte a byte 00:20:25
Yo quiero 00:20:28
Trabajar con ficheros de texto 00:20:29
Vale 00:20:32
Entonces quiero que sostancialmente 00:20:33
Tú me leas como te da la gana 00:20:35
Pero interprétame lo que estás leyendo 00:20:37
Como char 00:20:40
¿Sí? Con el tamaño que incluye 00:20:41
Char y cosas por el estilo 00:20:43
¿Por qué? Porque el fichero de texto 00:20:44
Que yo estoy utilizando 00:20:46
El fichero que estoy utilizando es un fichero de texto 00:20:48
Guardaré allí dentro texto 00:20:50
Y leeré texto 00:20:52
Si estoy seguro de eso 00:20:54
En vez de utilizar un input stream 00:20:56
Voy a utilizar un input stream reader 00:20:58
Cuando está reader 00:21:00
O writer 00:21:02
Lo que estamos haciendo es no trabajar byte a byte 00:21:03
Sino interpretar los bytes como caracteres 00:21:07
Ahora estoy escribiendo caracteres, leyendo caracteres 00:21:11
¿Por qué se hace esto? 00:21:15
Porque sustancialmente esto me da algunas ventajas 00:21:17
Yo aquí, técnicamente, no puedo escribir un string 00:21:20
Puedo decir, hola, escríbemelo en un fichero 00:21:24
Le tengo que este hola transformarlo en un array de bytes 00:21:28
Porque aquí está transformando solo en byte en byte 00:21:32
¿Sí? 00:21:34
Sin embargo, aquí tendré algunos métodos adicionales 00:21:36
Además de los inputStream, porque están relacionados 00:21:40
Pero tendré algunos métodos especiales que me dirán 00:21:43
En vez de leer byte a byte, léeme un carácter 00:21:46
Entonces puedo leer directamente un carácter 00:21:49
O una red de caracteres, en vez de una red de byte 00:21:51
¿Sí? 00:21:54
En particular, cuando nosotros vamos a utilizar los ficheros 00:21:56
No vamos a crear ni input stream 00:22:01
Ni input stream reader 00:22:03
Pero está la clase file input stream 00:22:05
Para estos de aquí 00:22:08
Y file reader 00:22:09
Para estos de aquí 00:22:10
Tened en cuenta que tanto file input stream 00:22:12
Como file reader si se pueden crear 00:22:15
Pueden hacer una new 00:22:17
Una new de input stream reader directamente 00:22:18
De input stream no lo pueden hacer 00:22:20
Estos son para leer en ficheros 00:22:22
Es posible 00:22:27
Hay otros entornos donde se usan 00:22:30
Input stream, output stream 00:22:32
Y cosas por el estilo 00:22:34
Que es por ejemplo la comunicación entre ordenadores 00:22:35
¿Vale? 00:22:38
Si hacéis en segundo de DAM 00:22:40
Programación de procesos 00:22:41
Y servicios 00:22:44
Pues ahí hay una parte de comunicación 00:22:46
En internet 00:22:48
Donde se ven los sockets 00:22:49
Los sockets son canales de comunicación entre dos ordenadores 00:22:51
Para que dos aplicaciones que están en ordenadores distintos 00:22:54
Se hablen entre ellos 00:22:57
Y para mandarse información una a otra 00:22:58
Pues se usan 00:23:00
Input reader o input stream reader 00:23:01
O input stream 00:23:04
¿Vale? 00:23:05
Hasta que ahora no se usará el file input stream 00:23:06
Porque no estoy hablando con ficheros 00:23:09
Estoy hablando con sockets 00:23:12
Con canales de comunicación 00:23:13
Pero la idea es muy parecida 00:23:14
De hecho esto 00:23:17
Si se puede utilizar 00:23:18
Esta de aquí es una evolución 00:23:19
Todavía más 00:23:24
Hacia la abstracción 00:23:25
Del input del file reader 00:23:26
Que llega a ser 00:23:29
Buffered reader 00:23:32
Buffered reader es un reader 00:23:33
Por lo tanto estoy trabajando con carácteres 00:23:35
Que tiene un buffer 00:23:38
Tiene una memoria 00:23:40
Temporal 00:23:41
En que puede almacenar lo que está recibiendo 00:23:43
Entonces mientras un file reader 00:23:46
Te va leyendo carácter por carácter 00:23:48
Y tengo que hacer algo con estos carácteres 00:23:50
El buffered reader 00:23:52
Estos carácteres los lee 00:23:54
Y lo mete en una memoria 00:23:55
Y yo luego puedo acceder a esta memoria 00:23:57
¿Cuál es la ventaja? 00:23:59
Pues que ahora puedo hacer algunas operaciones 00:24:00
Que antes no podía hacer 00:24:03
Por ejemplo, leer una línea 00:24:05
FileReader 00:24:07
No tiene un método 00:24:10
Léeme una línea 00:24:11
Lo que tendré que hacer es 00:24:12
Léeme un carácter, léeme otro carácter 00:24:15
Y cuando encuentre uno de estos carácters 00:24:17
Que he leído, que es el retorno de carros 00:24:20
El intro 00:24:23
Pues entonces allí asumir 00:24:23
Oye, mira, he llegado al final de la línea 00:24:25
¿Vale? 00:24:28
Sin embargo, el BufferedReader 00:24:29
Me proporciona un método para decir 00:24:31
Lea una línea entera 00:24:33
Porque él se está guardando en un buffer 00:24:34
Todo lo que está leyendo 00:24:37
Y entonces luego puede trabajar con este buffer 00:24:38
¿Sí? 00:24:41
Puede trabajar en esta memoria 00:24:42
¿Sí? 00:24:43
¿Se entiende? 00:24:45
Entonces, la idea es simplemente que 00:24:46
Hacen todo lo mismo 00:24:48
Todo lo que puede hacer con un input stream 00:24:49
Lo puede hacer con un BufferedReader 00:24:51
Todo, ¿vale? 00:24:53
Lo que pasa es que el Buffered Reader 00:24:55
Ya me implementa algunas funciones 00:24:57
Más avanzadas 00:24:59
Que a lo mejor me hacen la vida más sencilla 00:25:00
En vez de tener que ir byte a byte leyéndolo 00:25:03
Pues lo que puedo decir es 00:25:05
Léeme una línea entera 00:25:06
Y voy trabajando en mi fichero diciendo 00:25:07
Por ejemplo, en el caso en que haya guardado 00:25:10
Los alumnos como texto 00:25:13
En mi fichero 00:25:15
Pues yo puedo decir que cada línea 00:25:16
Es un objeto 00:25:19
Entonces le digo al Buffered Reader 00:25:20
Léeme una línea, él me da una línea 00:25:22
Y con los datos que están allí 00:25:25
Con un string tokenizer 00:25:27
Cosa por el estilo, lo separo y creo un objeto 00:25:28
Léeme otra línea 00:25:31
Pillo esa línea de allí 00:25:32
La troceo como tengo que trocearla 00:25:34
La interpreto y creo un segundo objeto 00:25:36
Etcétera, etcétera 00:25:39
Sostancialmente están aquí 00:25:40
Para mejorar 00:25:42
Nuestra calidad de vida 00:25:44
Trabajar con input stream 00:25:46
Es más a bajo nivel 00:25:49
Más complejo 00:25:51
Pero más tienes tú el control 00:25:53
De lo que está pasando 00:25:56
Yendo hacia el Buffered Reader 00:25:57
Es más fácil de utilizar 00:25:59
Me tengo que olvidar 00:26:01
De varias cosas que hacía aquí 00:26:04
Me puedo olvidar tranquilamente 00:26:05
Pero tengo menos control 00:26:07
No voy leyendo carácter por carácter 00:26:09
Voy leyendo frase por frase 00:26:12
O lo que sea 00:26:14
¿Sí? Entonces 00:26:15
Normalmente nosotros tendremos a usar Buffered Reader 00:26:17
Nosotros 00:26:20
Para simplificarnos la vida, tendemos a ir a cosas más genéricas 00:26:21
Entonces vamos a ver un ejemplo de una lectura de un archivo de texto 00:26:28
Imaginaos que yo tengo un archivo de texto, pues ¿cómo lo hago? 00:26:32
Aquí se usan FileReader y BufferedReader 00:26:36
Creo un FileReader y un BufferedReader 00:26:40
Try y catch 00:26:46
Muchas de estas cosas 00:26:48
Tienen a que ver 00:26:50
O pueden lanzar 00:26:52
IO exception 00:26:54
Input output exception 00:26:55
Los estudiamos cuando vimos las excepciones 00:26:57
Porque vimos que había una categoría 00:27:00
Que eran las excepciones 00:27:02
Los problemas que pueden surgir en input output 00:27:04
Como aquí estamos trabajando de eso 00:27:06
De escribir y leer de un fichero 00:27:08
Pues aquí salen un montón de excepciones 00:27:10
De este tipo 00:27:13
¿Vale? 00:27:13
Os recuerdo que hacer una catch de Exception E 00:27:14
Como en el ejemplo aquí 00:27:17
Pues es desaconsejado 00:27:18
¿Vale? 00:27:21
Si yo me estoy focalizando en otra cosa 00:27:23
Pues hago esta de aquí para hacer mis pruebas 00:27:26
Pero en un programa serio 00:27:29
Pues aquí debería tener varios catch 00:27:31
Que si ha pasado esto, hace esto 00:27:32
Si has hecho esta otra cosa, vas a otra cosa 00:27:35
Tanto cuando haremos ejemplos veremos alguno 00:27:37
Y volveremos a ver 00:27:39
Entonces, ¿qué hago? 00:27:40
Pues, el file reader me puede crear un nuevo file reader de un cierto fichero, ¿vale? 00:27:42
Ruta archivo sería un fichero 00:27:51
Eh, nota 00:27:53
Puedo hacer dos formas para identificar mi archivo 00:27:55
Con rutas absolutas o rutas relativas 00:28:00
¿Sabéis qué son rutas absolutas o relativas? 00:28:04
¿Habéis trabajado con ellos? 00:28:08
Por lo tanto, no vuelvo a deciros 00:28:09
¿Vale? 00:28:11
La ruta relativa es desde la carpeta del programa, del proce, del, del, proyecto, ¿vale? 00:28:12
La carpeta del proyecto donde está search, donde está bin, pues allí es donde se guardan los ficheros. 00:28:27
Si yo creo un nuevo fichero, se crea allí, por defecto, ¿vale? 00:28:33
Si luego lo quiero guardar en otro lado 00:28:36
O le pongo una ruta 00:28:39
¿Cómo se dice? 00:28:40
Absoluta, desaconsejado 00:28:45
Poner rutas absolutas 00:28:47
Es siempre desaconsejado porque si cambias 00:28:48
De ordenador ya no te funciona 00:28:50
¿Vale? Pero puedo tener una ruta relativa 00:28:52
Para decir, oye mira, desde 00:28:55
La carpeta del proyecto 00:28:56
Pues entra en otra carpeta, salga 00:28:58
De esa carpeta o vete a buscar 00:29:00
¿Sí? 00:29:02
Vale, el Buffered Reader 00:29:03
Pilla como parámetro 00:29:07
Un File Reader 00:29:09
Entonces, para poder crear un Buffered Reader 00:29:10
En realidad un Input Stream Reader 00:29:13
Que esto es un Input Stream 00:29:15
Pero bueno, le tengo que pasar 00:29:17
Sostancialmente es como si estoy encapsulando 00:29:19
Esto es el que me permite leer 00:29:21
Carácteres, vale, fenomenal 00:29:23
Y esto lo encapsulo 00:29:25
En una cosa más 00:29:27
Poderosa, entre comillas, que me permiten 00:29:29
Leer carácteres y guardarlas 00:29:31
en una memoria para luego poder leer una línea 00:29:33
entera o hacer cosas un poquito más complejas 00:29:35
¿vale? entonces 00:29:37
esto es como 00:29:39
empezaría ¿vale? entonces 00:29:40
creo una línea, una string línea 00:29:42
una variable que me guardará una línea 00:29:45
y luego empiezo con un while 00:29:46
¿vale? ¿qué hace este while? 00:29:49
me dice, mientras 00:29:51
que tú haces 00:29:53
un br.redline 00:29:55
bufferedreader.redline 00:29:57
esto lee una línea 00:29:59
Esta línea la vas a guardar dentro de la variable línea 00:30:01
Y si esta cosa no es null 00:30:04
Es decir, si has leído algo 00:30:07
Si tú has hecho un readline 00:30:09
Y has leído algo 00:30:11
¿Vale? 00:30:13
Quiere decir que has leído una línea 00:30:13
Pues esa línea imprimirá en pantalla 00:30:15
¿Vale? 00:30:17
Este programa aquí 00:30:20
Me pilla lo que hay dentro de root archivo 00:30:21
Y me lo imprime en pantalla 00:30:25
Más o menos 00:30:26
¿Dudas? 00:30:31
Y con esto, antes de la escritura, nos paramos. 00:30:35
Subido por:
Stefano C.
Licencia:
Reconocimiento - No comercial
Visualizaciones:
15
Fecha:
20 de mayo de 2024 - 13:30
Visibilidad:
Clave
Centro:
IES ROSA CHACEL
Duración:
30′ 51″
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:
93.14 MBytes

Del mismo autor…

Ver más del mismo autor

EducaMadrid, Plataforma Educativa de la Comunidad de Madrid

Plataforma Educativa EducaMadrid