Saltar navegación

Persistencia de datos 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 5 de mayo de 2023 por Stefano C.

9 visualizaciones

Más información Transcripción

Descargar la transcripción

Vale, si habláis durante esta grabación, me estáis dando implícitamente el consentimiento para que os grabe, ¿vale? 00:00:00
Si no, me levantáis la mano y me decís paro, ¿vale? 00:00:11
Lo que vamos a empezar a ver hoy es el concepto de persistencia de datos 00:00:14
La idea es que quiero que los datos persistan en memoria entre una ejecución y otra, ¿vale? 00:00:19
Esto es fundamental para todos los programas que tenemos, ¿vale? 00:00:27
¿Hay una parte de los datos de un programa que se queda persistente entre una ejecución y otra? 00:00:30
De los que habéis dicho vosotros 00:00:41
El propio código, ¿vale? 00:00:44
En otro sentido, el código es parte de los datos de un programa 00:00:45
Es la secuencia, las instrucciones y por ahí dentro está codificado también el concepto de algoritmo 00:00:50
Los pasos que tiene que hacer, el modo de funcionalidad y todas las funciones que tiene vuestro programa 00:00:56
Y eso cuando yo lo apago y lo enciendo otra vez, se queda allí 00:01:04
De hecho se crea un fichero, fichero.java que luego se compila .class y se queda allí ejecutable por una Java Virtual Machine 00:01:07
La misma Java Virtual Machine que es un intérprete, pues son códigos 00:01:15
Es el código que está guardado por allí 00:01:20
Cuando yo lanzo la Java Virtual Machine se carga ese código en memoria principal, en la RAM 00:01:22
Y a partir de allí se empieza a interpretar vuestro ficherito .class que tiene dentro bytecode que se ha hecho 00:01:27
Esta es una primera parte de mi programa que queda guardado en el disco duro, en la memoria secundaria 00:01:35
La memoria que no necesita energía cuando funciona y por lo tanto si le quito la energía sigue allí la información 00:01:47
Los objetos, que son los que utilizamos nosotros, dicen que se componen de atributos, datos y métodos 00:01:58
Código ejecutable 00:02:05
Este código se almacena en dispositivos como discos duros, lo que decimos ahora 00:02:07
Nosotros tenemos, cuando hacemos una clase, que es una abstracción de los objetos, una idea más general 00:02:13
Al que luego yo instancio en varios objetos concretos, tengo la clase cuadrado, son todos los cuadrados del mundo 00:02:20
Y luego creo el cuadrado del lado 3, que es un cuadrado concreto 00:02:26
Todo está almacenado, la parte de métodos está seguramente en el disco duro 00:02:31
Los atributos, si no, en el sentido de la definición de la existencia de estos atributos es parte del código 00:02:38
Pero el valor actual, el valor que he metido dentro del atributo lado de una clase cuadrado 00:02:48
No es real hasta que yo cree un objeto 00:02:58
Al momento que creo el objeto, este objeto tiene asociado un determinado valor 00:03:07
Y esto normalmente, cuando se crean los objetos, en tiempo de ejecución, o en tiempo de compilación, o en tiempo WAN 00:03:12
Cuando ejecuto, al ejecutar el programa, yo tendré las new que se ejecutan y allí es donde creo los objetos 00:03:23
Los objetos donde se guardan 00:03:31
¿Dónde se crean los objetos? ¿En qué memoria se crean los objetos? 00:03:38
¿Se crean en alguna memoria? 00:03:41
¿En la RAM? 00:03:43
En una parte de la RAM especial 00:03:45
Entonces, cuando ejecutamos un programa sobre una Java Editor Machine, el código compilado se carga en memoria RAM y se ejecuta 00:03:48
Entonces, todo se trabaja desde la RAM 00:03:56
¿Por qué la RAM? 00:03:58
¿Se ejecuta desde la RAM directamente? 00:04:03
No, ¿por qué? 00:04:09
El que ejecuta es el procesador, ¿no? 00:04:12
Sí, bueno, el que ejecuta es el procesador, ok 00:04:14
¿Pero lee los datos directamente en RAM? 00:04:18
¿Y dónde los almace? 00:04:25
¿Pero entonces lo lee y lo escribe en la RAM? 00:04:29
Es decir, estas son las memorias que tenemos, memoria secundaria y memoria principal 00:04:33
La RAM y el disco duro 00:04:39
Ya está, V o F, verdadero o falso 00:04:41
¿Cuál hay? 00:04:46
Caché 00:04:47
¿Qué es la caché? 00:04:48
El concepto de caché es que una parte de la RAM me la copio en una memoria más pequeña y más rápida 00:04:51
¿Vale? 00:05:01
¿Hay sólo una memoria caché? 00:05:02
Hay varias 00:05:06
¿Vale? 00:05:08
Memoria nivel 2, memoria nivel 3 00:05:09
Entonces se crea una pirámide de memorias 00:05:13
Cuanto más pequeñas, más rápidas y más cercanas, entre comillas, al procesador 00:05:15
La memoria más rápida de todos y más pequeña de todos son 00:05:23
Los registros 00:05:28
¿Suenan registros? 00:05:29
No suenan 00:05:30
Son memorias, son celdas de memorias que están en el mismo procesador 00:05:31
¿Vale? 00:05:37
Al fin y al cabo el procesador las operaciones las hace siempre entre registros 00:05:39
Lee los datos entre los registros y el resultado lo guarda en un registro 00:05:43
Y luego desde allí hay toda una operación de mover estos datos desde los registros hacia afuera 00:05:49
A los varios niveles de caché o hacia adentro si quiere ejecutar 00:05:57
¿Vale? 00:06:00
La idea es, si yo tengo un programa que son gigas y gigas de datos, algo para decir 00:06:01
No puedo tener todo eso directamente en el procesador 00:06:08
Entonces pillo sólo la parte que se está ejecutando ahora y lo pongo en nivel 3 00:06:12
De esta parte que he puesto en nivel 3 una parte, la que se está ejecutando ahora, la pongo en nivel 2 00:06:17
De esta parte la ejecución de la sentencia que se está ejecutando ahora la pongo a nivel de registros 00:06:23
Y allí trabajo 00:06:30
¿Vale? Entonces hay toda esta cosa 00:06:32
Esto, para los afortunados que acabaran en DAMA, en Programación de Procesos y Servicios 00:06:34
Tiene problemas 00:06:39
¿Vale? Pero lo veremos en segundo 00:06:41
¿Si? 00:06:44
El concepto es que cuando la electricidad se apaga, ¿Vale? 00:06:46
Todo lo que es del programa se pierde 00:06:49
¿Vale? 00:06:53
La parte del disco duro se queda allí 00:06:54
Pero todos los programas que hemos hecho hasta ahora 00:06:57
La única cosa que hacían era cargarse el RAM, el código 00:07:00
Pero todos los objetos que creaban, todas las variables 00:07:04
Todo eso estaba en la memoria no persistente, en la RAM 00:07:07
Y por lo tanto si yo apago el ordenador, pues todos los datos que están allí, perdidos 00:07:11
¿Vale? 00:07:16
Los valores de atributos de los objetos no existen previamente en el disco 00:07:20
¿Vale? 00:07:24
Lo que decíamos antes, cuando yo creo un objeto 00:07:25
Lo ideo, le pongo las cosas, le puedo poner valores en el código 00:07:28
Pero es cuando lo ejecuto que creo un objeto por algún lado 00:07:33
Y le asigno los valores que tiene que tener 00:07:36
¿Vale? 00:07:38
O sea que la memoria relacionada con este objeto 00:07:39
Y la dirección de memoria donde está 00:07:42
A nivel de disco duro no existe 00:07:44
Existe en el momento de ejecución dentro de la RAM 00:07:47
¿Si? 00:07:50
En particular, cuando creamos una new 00:07:52
Y creamos un nuevo objeto 00:07:55
Hay una parte, un espacio de la memoria RAM 00:07:58
Que se llama el heap 00:08:02
Heap es como montón 00:08:04
En español, si no me equivoco 00:08:06
¿Vale? 00:08:09
Es un trozo de memoria 00:08:10
Y en realidad esta es una estructura de datos 00:08:11
Como puede ser una lista, como puede ser un árbol 00:08:14
Como puede ser otra cosa que hemos visto 00:08:17
Pero se llama heap 00:08:19
Y tiene características distintas 00:08:20
Yo puedo pensarlo como 00:08:23
En la memoria RAM asigno un trozo 00:08:24
Donde aquí es donde creo los objetos 00:08:26
¿Vale? 00:08:29
Los objetos que creará la JavaScript Machine 00:08:30
Interpretando mis programas 00:08:32
Se crean todos en esta estructura de datos 00:08:34
Que es un heap 00:08:36
¿Vale? 00:08:37
Y allí dentro, como construyo los objetos 00:08:38
Puedo guardar los valores relacionados 00:08:41
Con cada instancia de cada objeto 00:08:44
¿Dudas? 00:08:47
Otros datos 00:08:53
Lo que no son objetos por sí mismos 00:08:54
Como por ejemplo variables locales 00:08:58
O parámetros de entrada 00:09:00
Cuando llamo un método y cosas por el estilo 00:09:03
No van en el heap 00:09:05
El heap es algo un poquito más persistente 00:09:07
Entre comillas 00:09:11
Porque esta RAM es lo que más persistente 00:09:12
Pero dentro de la ejecución del mismo programa 00:09:14
Mientras el programa está en ejecución 00:09:17
Mi heap es donde almaceno los objetos 00:09:19
Que estoy utilizando 00:09:22
Teniendo en cuenta que si vosotros hacéis un for 00:09:24
int i igual a 1 00:09:26
Este int i es una variable 00:09:29
Pero esta variable ¿Dónde se guarda? 00:09:32
¿Es un objeto? 00:09:33
¿Es un atributo de un objeto? 00:09:39
No, es una variable local 00:09:42
¿Local a qué? 00:09:45
¿Dónde existe esta i? 00:09:48
Si yo hago for int i igual a 1 00:09:57
y mayor a i más más 00:10:01
Y fuera de este for pregunto 00:10:03
¿Si está puntuado tu punto principal del ni? 00:10:05
¿Funciona? 00:10:07
Es local al medio 00:10:09
Es local al bloque de for 00:10:10
Porque lo está declarando ahí dentro 00:10:13
Si quiero que se lea afuera 00:10:16
¿Qué hago? 00:10:18
La declaro antes del for 00:10:19
int i es igual a 0 punto y coma 00:10:20
for i igual a 0 00:10:22
Entonces luego se puede leer el for 00:10:24
¿Vale? 00:10:26
Es local al bloque en el que se define 00:10:27
¿Vale? 00:10:31
Pero no es algo que va asociado a un objeto 00:10:32
O cosa por el estilo 00:10:35
Es una cosa que va asociada localmente 00:10:36
a ese bloque de código 00:10:39
Si yo ejecuto 10 veces ese método 00:10:42
con dentro el for 00:10:45
Por 10 veces crearé la variable i 00:10:47
La usaré 00:10:49
Y cuando salgo de este método 00:10:50
se destruye 00:10:52
Ya no me interesa 00:10:53
La vez siguiente que vuelva a llamar ese método 00:10:54
Es una nueva i 00:10:57
No es la misma i de la última vez 00:11:00
No tiene memoria de lo que ha pasado 00:11:02
con la i de la última vez 00:11:04
Si quiero que esto funcione 00:11:06
La tengo que sacar afuera 00:11:07
Ponerla como atributo 00:11:08
O ponerla estática 00:11:10
O encontrar un método distinto 00:11:11
Pero si es una variable local, no 00:11:13
Este tipo de datos como variables locales 00:11:15
Parámetros de entrada, etc, etc 00:11:18
Estos que tienen una vida relativamente breve 00:11:20
Se guardan en otra zona de memoria 00:11:23
Que es llamada stack 00:11:26
¿Qué es stack? 00:11:28
Fila 00:11:31
¿A qué se refiere con esta pila? 00:11:32
¿Pila de qué? 00:11:36
De procesos, ¿no? 00:11:38
Normalmente tiene que ver con el concepto 00:11:46
de pila de llamadas de métodos 00:11:49
¿Sí? 00:11:52
Proceso, cuando yo lanzo el programa 00:11:53
Este es un proceso, un programa en ejecución 00:11:55
Nosotros todavía no tenemos varios procesos 00:11:57
que interaccionan entre ellos 00:11:59
Entonces es uno solo 00:12:01
En los que hacemos nosotros por ahora 00:12:02
Pero sí que llamamos muchos métodos 00:12:04
Y un método puede llamar otro método 00:12:06
Y un método puede llamar otro método 00:12:08
Y un método puede llamar otro método 00:12:09
Y hemos dicho antes 00:12:10
Que si yo declaro una variable int i 00:12:11
Dentro de un método 00:12:13
Esta es local a ese método, a ese bloque 00:12:14
Y cuando se acaba el método 00:12:16
Esa se destruye 00:12:18
¿Y cómo hago a darme cuenta 00:12:19
Si esta i es en este método o no? 00:12:21
Pues lo añado a la stack 00:12:23
A esta pila 00:12:25
¿Llamo un nuevo método? 00:12:27
Añado un nuevo bloque encima de la pila 00:12:28
Y aquí creo sus variables 00:12:30
¿Llamo un otro método? 00:12:32
Añado otro bloque encima de la pila 00:12:34
Y allí añado sus variables locales 00:12:36
Cuando acabo el método 00:12:38
Y por lo tanto 00:12:40
En vez de apilar 00:12:42
Desapilo, quito un bloque 00:12:44
Con él me llevo también 00:12:46
Todas sus variables locales 00:12:48
Por eso no son ya accesibles desde fuera 00:12:50
Estudad 00:12:54
¿Me seguís o no? 00:12:56
Vale 00:13:02
Entonces, al fin y al cabo 00:13:04
Dentro del concepto de Java 00:13:06
Estamos trabajando con dos zonas 00:13:08
De memoria temporal 00:13:10
Memoria no persistente 00:13:12
¿Vale? 00:13:14
El heap que es la que gestiona 00:13:16
Todo lo que es relacionado con los objetos 00:13:18
Y el stack que es lo que relaciona 00:13:20
Los otros tipos de variables 00:13:22
Los variables locales 00:13:24
Son parámetros, etc. 00:13:26
También pensado un parámetro 00:13:28
Una llamada de método con parámetros 00:13:30
Cuando yo llamo cálculo área de 3 00:13:32
Pues este parámetro 3 00:13:36
Tiene que estar guardado por algún lado 00:13:38
Pero cuando yo acabo este método 00:13:40
Este parámetro 3 ya no me sirve de nada 00:13:42
Entonces lo quito 00:13:44
Es algo local también 00:13:46
Dentro del método 00:13:48
Este parámetro me sirve de algo 00:13:50
Lo vimos en primera relación 00:13:52
Si no me equivoco 00:13:54
El concepto de parámetros formales y parámetros actuales 00:13:56
Cuando yo pongo 00:13:58
Método, método 1 00:14:00
Que recibe int x 00:14:02
Y luego aquí hago cosas con x 00:14:04
Ese es un parámetro formal 00:14:06
El parámetro actual es cuando yo llamo 00:14:08
Mi método de 3 00:14:10
Ese es el parámetro actual 00:14:12
Ahora el x que es formal 00:14:14
Ahora actualmente vale 3 00:14:16
Atributos en la programación de objetos 00:14:22
Cuando finaliza el programa 00:14:24
Los datos de los atributos del IP 00:14:26
No persisten 00:14:28
Es decir 00:14:30
Me he quedado todos los objetos del mundo 00:14:32
Acaba el programa 00:14:34
Todo lo que está en el IP lo borro 00:14:36
Pero muchas veces 00:14:38
En un 60% 00:14:40
De los ejercicios un poquito más serios 00:14:42
Que nosotros hemos hecho 00:14:44
Pues me habría gustado que todo lo que he hecho 00:14:46
Se guardara por algún lado 00:14:48
¿Sinceramente por qué? 00:14:50
Porque la vez siguiente que voy a probarlo 00:14:52
Esos datos han desaparecido 00:14:54
Y tengo que volver a ponerlo 00:14:56
En uno de los problemas de examen 00:14:58
Que tengo poco tiempo 00:15:00
Y me pongo allí y digo 00:15:02
Pruebo mi programa a ver si funciona 00:15:04
Le tengo que añadir 3 alumnos 00:15:06
El nombre del alumno, la idea del alumno 00:15:08
Espera me he equivocado 00:15:10
Si yo estos 3 alumnos 00:15:12
Los tuviera ya allí 00:15:14
Que cada vez que lo arranco 00:15:16
Entonces ¿Qué hacéis vosotros? 00:15:18
Lo que habéis hecho hasta ahora 00:15:20
Pues los incrustáis en el código 00:15:22
El código empieza, crea 3 alumnos 00:15:24
Siempre los mismos 3 00:15:26
Y juego con ellos 00:15:28
Y me ahorro de tener que escribirlo yo 3 veces 00:15:30
Pero es una forma un poquito fea de hacer 00:15:32
¿Vale? 00:15:34
La idea es que como no persisten 00:15:36
Pues vamos a ver como podemos hacerlo persistir 00:15:38
Los lenguajes orientados a objetos 00:15:40
No provienen de ningún 00:15:42
Mecanismo automático de persistencia 00:15:44
¿Vale? 00:15:46
O sea que no hay una forma mágica de decir 00:15:48
Y ahora guárdame todo en el disco duro 00:15:50
¿Si? 00:15:52
Y esto esencialmente 00:15:54
Porque 00:15:56
Puede ser 00:15:58
Delicado 00:16:00
Guardar 00:16:02
Los objetos 00:16:04
Si vosotros pensáis en el objeto 00:16:06
Alumno 00:16:08
Que tiene nombre, edad 00:16:10
Guardarlo 00:16:12
Relativamente sencillo 00:16:14
No tiene gran problema 00:16:16
Si, pero pensáis 00:16:18
Al objeto 00:16:22
Escuela 00:16:24
Que dentro tiene una lista 00:16:26
De materia 00:16:28
Que son objetos 00:16:30
Y dentro de materia tenéis 00:16:32
Luego tiene una 00:16:34
Rey de profesores 00:16:36
Y luego tiene un 00:16:38
Set de alumnos 00:16:40
Y ahora 00:16:42
Esta escuela la queréis 00:16:44
Guardar 00:16:46
Ya es un poquito más complicado 00:16:48
Porque no estáis guardando solo escuela 00:16:50
Deberíais guardar también todos los objetos 00:16:52
Dentro de escuela 00:16:54
Y las referencias 00:16:56
Hacia este objeto 00:16:58
Entonces esto se complica 00:17:00
Justo 00:17:02
Vale 00:17:04
Entonces 00:17:06
Digamos que nosotros programadores 00:17:08
Vamos un poquito detrás de cual es la forma 00:17:10
Correcta de mi sistema 00:17:12
Guardar la información 00:17:14
Que quiero guardar 00:17:16
Entonces como se almacenan los datos 00:17:18
Para conservar el valor de un dato 00:17:20
En un dispositivo de almacenamiento como un disco duro 00:17:22
Se puede hacer 00:17:24
De varias maneras 00:17:26
Nosotros 00:17:28
Echaremos un vistazo principalmente 00:17:30
A dos 00:17:32
Luego ya veremos la tercera 00:17:34
Primero es creando un archivo 00:17:36
Escribiendo en él datos en modo row 00:17:38
Es decir 00:17:40
Guardo los datos 00:17:42
Tal y como son 00:17:44
Hay el nombre del alumno 00:17:46
Escribo el nombre del alumno 00:17:48
Estefano 00:17:50
Luego la edad del alumno 00:17:52
Pues le pongo 37 detrás 00:17:54
Voy escribiendo yo los datos 00:18:02
De forma por ejemplo de texto 00:18:04
Entonces me creo 00:18:06
Una cadena 00:18:08
Hicimos un ejercicio hace mucho tiempo 00:18:10
En que se daba una cadena 00:18:12
Y desde esta cadena se sacaban los datos 00:18:14
Cuando trabajábamos todavía 00:18:16
Eramos pequeños 00:18:18
Y trabajábamos con las strings 00:18:20
Tú por ejemplo 00:18:22
Pones todos los datos de tu objeto 00:18:24
Separados por dos puntos 00:18:26
El último 00:18:28
Cuando hayas acabado el objeto 00:18:30
Le pones un punto para decir 00:18:32
Y lo que harás es que cuando luego 00:18:34
Este string 00:18:36
La guardas en un fichero 00:18:38
Que si tú abres el fichero 00:18:40
Lo puedes leer 00:18:42
Y cuando tú quieres 00:18:44
Volver a cargar 00:18:46
Ese objeto 00:18:48
Lo que haces es leerte el string 00:18:50
Dividirlo cada vez que encuentras dos puntos 00:18:52
Este era un dato, este es otro dato 00:18:54
Cuando encuentras el punto 00:18:56
Has acabado de sacar 00:18:58
Los datos distintos 00:19:00
Tienes los datos con un determinado formado 00:19:02
Antes el nombre, luego la edad 00:19:04
Luego no sé qué, luego no sé cuánto 00:19:06
Y eso creas un nuevo objeto con una new 00:19:08
Pasándole los datos que estaban escritos ahí 00:19:10
¿Se entiende la idea? 00:19:12
Es un cierto sentido 00:19:18
Hacer un toString 00:19:20
¿Vale? 00:19:22
Donde en vez de imprimir 00:19:24
Por pantalla todos los datos 00:19:26
De un objeto 00:19:28
Lo que hago es imprimirlos en un fichero 00:19:30
Así que me los tenga allí 00:19:32
Cuando en un futuro me vaya a leer 00:19:34
Esos datos, con esos datos 00:19:36
Puedo volver a crear una nueva instancia 00:19:38
Que pero tiene 00:19:40
Todos los datos de la vieja instancia 00:19:42
Por lo tanto, como objeto 00:19:44
Es un objeto nuevo, pero que me vale como el viejo 00:19:46
¿Qué cambiaría? 00:19:50
¿Qué cambiaría? 00:19:52
La referencia en memoria 00:20:00
Lo que da el toString de object 00:20:02
¿Sí? 00:20:04
Cuando se hace el toString de object 00:20:06
Se da clase, arroba y un numerito 00:20:08
Pues ese numerito posiblemente cambiaría 00:20:10
Pero 00:20:12
En mi sistema ese numerito casi no lo uso 00:20:14
¿Vale? 00:20:16
Cuando yo gestiono un alumno ese numerito no me sirve 00:20:18
Es el alumno por si mismo 00:20:20
Con su nombre, apellido, etc. 00:20:22
¿Sí? 00:20:24
Es una forma de jugar con ello, lo haremos 00:20:26
Si yo mi objeto lo guardo allí 00:20:28
¿Dónde se complica esto? 00:20:30
En si uno de los atributos 00:20:32
De mi 00:20:34
De mi objeto que estoy guardando 00:20:38
No es un tipo primitivo 00:20:40
Si no es otro objeto 00:20:42
Entonces tengo que ver 00:20:44
Como lo hago 00:20:46
Podría a su vez 00:20:48
Guardar toda la información de esto 00:20:50
O guardar un numerito 00:20:52
Un identificador 00:20:54
Que luego me haga referencia a otro objeto 00:20:56
Que está más adelante en el 00:20:58
Fichero 00:21:00
Que yo tendré que crear 00:21:02
Antes este objeto de abajo 00:21:04
Y luego cuando voy a crear el objeto este de arriba 00:21:06
Poner que este link 00:21:08
Se complica la cosa 00:21:10
¿Dudas? 00:21:12
Sobre el primer método 00:21:14
Texto 00:21:16
Segundo método 00:21:18
Pidiéndole a la Java Virtual Machine 00:21:20
Que almacene todos los datos del objeto 00:21:22
En un archivo, pero dejando que gestione 00:21:24
La propia Java Virtual Machine 00:21:26
El formato 00:21:28
Es decir, oye Java Virtual Machine 00:21:30
Yo quiero guardar este objeto 00:21:32
Tú lo tienes almacenado de alguna forma 00:21:34
Pues almacénalo, hazme magia 00:21:36
¿Vale? 00:21:38
Esto tiene que ver con lo que se llama 00:21:40
La serialización 00:21:42
Y la interfaz 00:21:44
Serializable 00:21:46
Serializable 00:21:52
Si un objeto es serializable 00:21:54
Quiere decir que se puede transformar 00:21:56
En una secuencia de bytes 00:21:58
Y si yo consigo transformar un objeto 00:22:02
En una secuencia de bytes 00:22:04
Lo puedo disparar dentro de un flujo de información 00:22:06
Hacia un fichero por ejemplo 00:22:08
O leerlo 00:22:10
¿Vale? 00:22:12
Entonces la idea es, mira Java Virtual Machine 00:22:14
Tú tienes los datos almacenados de alguna forma 00:22:16
Léelos, y los mismos datos que estás leyendo 00:22:18
Los guardas en un fichero 00:22:20
En un futuro yo diría a la Java Virtual Machine 00:22:22
Mira 00:22:24
Una ejecución de la Java Virtual Machine 00:22:26
Anterior 00:22:28
Ha guardado los datos aquí 00:22:30
Vete a releerlos 00:22:32
Y como lo guardas con tu mismo formato 00:22:34
Porque ha sido tú que lo has guardado 00:22:36
O sea, tu hermana que se ha ejecutado antes 00:22:38
Pues ahora lo sabes entender 00:22:40
Este formato, y me construyes un objeto 00:22:42
Parecido a ese 00:22:44
¿Vale? 00:22:46
Esto también tiene sus limitaciones 00:22:48
Y luego se nos da 00:22:52
Sistema gestor de base de datos 00:22:54
Yo me creo una base de datos 00:22:56
Que tenga una tabla 00:22:58
Que más o menos refleje 00:23:00
La información que yo tengo 00:23:02
En mis objetos, por ejemplo 00:23:04
La tabla alumnos tendrá 00:23:06
Apellido, edad 00:23:08
Identificador, y que se yo 00:23:10
Y lo que hago es que cuando voy a guardar 00:23:12
Me conecto con esta base de datos 00:23:14
Hago una 00:23:16
Sentencia SQL de insert 00:23:18
Donde le doy los datos que tiene que hacer 00:23:20
Y me está guardando los datos relevantes 00:23:22
De este objeto en la base de datos 00:23:24
Cuando querré sacar 00:23:26
Esta información voy a hacer 00:23:28
Una SQL 00:23:30
A la base de datos 00:23:32
La base de datos me procesará esa SQL 00:23:34
Me dará un conjunto de records 00:23:36
Un conjunto de 00:23:38
Respuestas 00:23:40
¿No? 00:23:42
De registros 00:23:44
Que corresponden a mi query 00:23:46
Y me lo devolverá 00:23:48
En formato de una lista de objetos 00:23:50
De algún tipo 00:23:52
Y yo iré mirando allí dentro 00:23:54
Sacando los datos y si quiero 00:23:56
Creándome los objetos 00:23:58
Y procesándolos 00:24:00
¿Si? 00:24:02
En realidad 00:24:04
Hoy en día 00:24:06
No se usa ninguno 00:24:08
De los tres 00:24:10
Métodos concretamente 00:24:12
Para persistencia de objetos 00:24:14
¿Vale? 00:24:16
Se usan cosas más avanzadas 00:24:18
Que son framework 00:24:20
Son 00:24:22
Conjuntos de 00:24:24
Librerías 00:24:26
De métodos 00:24:28
Y de opciones 00:24:30
Que tengo por allí 00:24:32
Que me permiten guardar los objetos 00:24:34
De forma más eficaz 00:24:36
Y más interesante 00:24:38
Es un poco 00:24:40
Ocultar 00:24:42
La parte compleja de guardar los objetos 00:24:44
Y cosas por el estilo 00:24:46
Y si lo sé configurar y pierdo tiempo 00:24:48
En hacer las cosas 00:24:50
Bien hechas 00:24:52
Luego guardar y recuperar objetos 00:24:54
Va a ser más fácil 00:24:56
Yo configuro 00:24:58
Una herramienta avanzada 00:25:00
Hecha por otras personas 00:25:02
Y luego la uso 00:25:04
¿Vale? Y esto por ejemplo 00:25:06
No sé si os habéis oído alguna vez 00:25:08
El concepto de hibernate 00:25:10
¿Vale? Hibernate 00:25:12
¿Si? ¿Habéis visto? 00:25:14
El próximo año 00:25:18
Posiblemente 00:25:20
Seguramente 00:25:22
No lo sé 00:25:24
Pero es posible que se vea 00:25:26
También en 00:25:28
Un entorno servidor 00:25:30
No lo sé 00:25:32
Pero es posible que surja 00:25:34
Porque es una tecnología que se usa 00:25:36
No es la única 00:25:38
Pero es lo de siempre 00:25:40
A nosotros nos interesa 00:25:42
Empezar por lo fácil 00:25:44
Y lo bajo nivel 00:25:46
Entender que se está haciendo dentro 00:25:48
Cuáles son los problemas que pueden surgir 00:25:50
Y luego sobre esta base 00:25:52
Cuando ya tenemos la base para poder entender 00:25:54
Pues nos metemos a utilizar las cosas 00:25:56
Lo mismo que hemos hecho con la interfaz gráfica 00:25:58
¿Vale? 00:26:00
Con la interfaz gráfica 00:26:02
Cuando ya más o menos entiendo la filosofía 00:26:04
Pues entonces uso Windows 10 00:26:06
¿Si? 00:26:08
¿Dudas hasta aquí? 00:26:10
Java nos proporciona una clase 00:26:14
Que es la clase File ¿Vale? 00:26:16
La clase File es una abstracción de un fichero 00:26:18
¿Vale? 00:26:20
Normalmente cuando creo una clase File 00:26:22
Tengo una ruta 00:26:24
¿Vale? 00:26:26
La ruta donde debería estar este fichero 00:26:28
Si el fichero ya existe 00:26:30
Me hace como un manejador 00:26:32
Un handler, un objeto 00:26:34
Que se relaciona 00:26:36
Con el fichero real 00:26:38
¿Vale? 00:26:40
Y luego yo esto lo usaré para hacer lo que quiera hacer 00:26:42
¿Vale? 00:26:44
Si no existe 00:26:46
File me permite 00:26:48
No recuerdo el método 00:26:50
Pero me permite crear 00:26:53
¿Vale? 00:26:55
Yo puedo crear un fichero y decirle 00:26:57
Este fichero se debe llamar texto.txt 00:26:59
Y estar en esta dirección 00:27:01
¿Vale? 00:27:03
Y puedo preguntar ¿Existe? 00:27:05
Si existe, me da True 00:27:07
Y entonces ya existe, puedo acceder a él 00:27:09
Si no existe, le puedo decir tráemelo 00:27:11
¿Vale? 00:27:13
Puedo crear carpetas 00:27:15
File, si le doy los parámetros correctos 00:27:17
Mkdir 00:27:19
Pues lo que hace es 00:27:21
Me crea una directory 00:27:23
Y luego manejo este fichero 00:27:25
Como si fuera una directory 00:27:27
Le puedo pedir, por ejemplo, dame el listado de lo que tienes 00:27:29
Y cosas por eso 00:27:31
¿Vale? 00:27:33
En general, la clase File 00:27:35
Es una abstracción de un fichero 00:27:37
Que puedo tener en mi sistema 00:27:39
De almacenamiento 00:27:41
A largo plazo 00:27:43
En mi disco 2 00:27:45
En mi file system 00:27:47
Y me sirve para luego poder 00:27:49
Conectar a este fichero 00:27:51
Un flujo de lectura 00:27:53
O un flujo de escritura 00:27:55
De datos 00:27:57
En Java 00:27:59
Lo que creamos normalmente 00:28:01
Son flujos de informaciones 00:28:03
¿Vale? 00:28:05
Este flujo puede ser 00:28:07
Desde no se donde 00:28:09
Hacia el fichero 00:28:11
Entonces será en escritura 00:28:13
O desde el fichero 00:28:15
Hacia no se donde 00:28:17
Quien lo está pidiendo 00:28:19
Entonces sería en lectura 00:28:21
¿Vale? 00:28:23
La forma más baja 00:28:25
La forma más 00:28:27
Digamos 00:28:29
De bajo nivel 00:28:31
Más cercana 00:28:33
A lo que es el hardware 00:28:35
Que podemos encontrar 00:28:37
Es el input stream 00:28:39
El input stream 00:28:41
Es un stream 00:28:43
Un fuente 00:28:45
En input 00:28:47
Este de aquí cuando yo creo esto 00:28:49
Me estoy creando un tubo 00:28:51
Por el que vendrán bits 00:28:53
Desde el fichero 00:28:55
Por ejemplo si está conectado a un fichero 00:28:57
En realidad este es más amplio 00:28:59
No se habla solo de ficheros 00:29:01
Se puede hablar por ejemplo 00:29:03
De una conexión en red 00:29:05
Si yo creo lo que se llama un socket 00:29:07
De conexión entre dos dispositivos 00:29:09
Luego yo en el socket 00:29:11
Para leer lo que este ordenador 00:29:13
Me está mandando por internet 00:29:15
O podría ser 00:29:17
En vez de un fichero 00:29:19
Por ejemplo el teclado 00:29:21
¿Qué es System.in? 00:29:29
No os lo digo porque 00:29:35
Todos habéis ido a mirar 00:29:37
En la API 00:29:41
La clase System 00:29:43
Porque con la S mayúscula 00:29:45
Me suena a clase 00:29:47
Y habéis visto 00:29:49
El atributo in de System 00:29:51
Que es 00:29:53
¿Qué tipo tiene? 00:29:55
Por lo tanto ¿Por qué el ruedo? 00:29:57
¿Tipo input? 00:29:59
No lo sé 00:30:01
Entonces 00:30:03
El input stream es esto 00:30:05
Es un tubo por el que vienen bits 00:30:07
Lo que pasa es que yo puedo leer bits 00:30:09
¿Y qué hay al otro lado? 00:30:11
¿Hay un entero? 00:30:13
Pues no, yo leo bits 00:30:15
¿Hay un string? 00:30:17
Pues no, yo leo bits 00:30:19
Eso no me quita que 00:30:21
Puedo leer un montón de bits 00:30:23
Y luego decirle 00:30:25
Todos los bits que has leído 00:30:27
Interpretándolo como un entero 00:30:29
Yo sé que un entero 00:30:31
¿Cuántos bits son? 00:30:33
4 bytes 00:30:39
Entonces si yo quiero leer un entero 00:30:41
Leo 4 bytes 00:30:43
Y luego le digo todos los que has leído ahora 00:30:45
Estos 4 por 8 bits 00:30:47
Que tengo 00:30:49
Pues interpretándolo como un entero 00:30:51
Con un cast 00:30:53
Se puede hacer 00:30:55
Pero es un poco engordoso 00:30:57
¿Sí? 00:30:59
Ahora, si yo no tengo datos 00:31:01
Reales en el 00:31:03
¿Sabes? 00:31:05
No tengo datos que son 00:31:07
Tipos primitivos, objetos 00:31:09
O algo por el estilo 00:31:11
Dentro del fichero 00:31:13
Si no, por ejemplo, tengo un fichero ejecutable 00:31:15
Fichero ejecutable es un fichero 00:31:17
Que se ha ejecutado 00:31:19
Y dentro hay unos y ceros 00:31:21
Que los interpreta el procesador 00:31:23
El procesador es capaz de interpretar esos unos y ceros 00:31:25
Pero yo no, yo como ser humano 00:31:27
No sé qué son 00:31:29
Y tengo que copiar ese fichero, por ejemplo 00:31:31
Al leerlo 00:31:33
No lo puedo leer como enteros 00:31:35
Lo puedo leer como objetos 00:31:37
Lo tengo que leer 00:31:39
Como bytes 00:31:41
Entonces, por ejemplo, si yo quiero 00:31:43
Copiar un fichero 00:31:45
Y que sea cualquier fichero 00:31:47
Lo voy a leer así 00:31:49
Porque me da igual 00:31:51
Que sea un fichero de texto, que sea una imagen 00:31:53
Que sea un fichero exe 00:31:55
Que sea un fichero de audio 00:31:57
Voy a copiar los bytes que están escritos aquí 00:31:59
Y los copio en otro trozo de memoria 00:32:01
Ya está 00:32:03
Si yo empezara 00:32:05
Estos a interpretarlos como otra cosa 00:32:07
Pues entonces podría tener problemas 00:32:09
Porque si intento leer 00:32:11
Letras en un fichero audio 00:32:13
No funciona 00:32:17
¿Habéis abierto alguna vez 00:32:19
Un fichero doc 00:32:21
Con glocknotes? 00:32:23
Probadlo 00:32:29
Recibo 00:32:31
Los datos 00:32:33
Del fichero doc 00:32:35
No lo interpreto como 00:32:37
Lo interpretaría Word 00:32:39
Sino lo interpreto como carácter a carácter 00:32:41
Y me salen cosas raras 00:32:43
Esto es una forma 00:32:49
De leer un flujo 00:32:51
De información que son sólo bits 00:32:53
Voy leyendo bit a bit o byte a byte 00:32:55
¿Qué pasa? 00:32:57
¿Qué pasa si yo sé 00:33:01
Que me estoy conectando 00:33:03
Quiero tener un flujo de información 00:33:05
Pero con un fichero que es de texto 00:33:07
Sé que el fichero es de texto 00:33:09
Es un fichero lleno de carácter 00:33:11
¿Tengo de verdad 00:33:13
Que molestarme a leer 00:33:15
Bit por bit 00:33:17
Y una vez leído estos bits 00:33:19
Convertirlos a una letra 00:33:21
Leo 8 bits 00:33:23
¿Este qué es? 00:33:25
La F 00:33:27
África 00:33:29
Pues no 00:33:33
Hay una forma de decir 00:33:35
En vez de estar tan a bajo nivel 00:33:37
Subo un poquito de nivel 00:33:39
Y miro un input stream 00:33:41
Reader 00:33:43
Cuando tengo reader 00:33:45
Estoy trabajando con carácter 00:33:47
Este señor de aquí 00:33:51
Tiene métodos especiales 00:33:53
Para leer directamente carácteres 00:33:55
Entonces 00:34:01
En vez de decir 00:34:03
Lea algo y me llegará un array de bytes 00:34:05
Por ejemplo 00:34:07
Ahora puedo decirle 00:34:09
Lea algo y me llegue un array de carácteres 00:34:11
Stream 00:34:15
¿Sí? 00:34:17
Entonces 00:34:19
¿Tengo un fichero de texto? 00:34:21
¿Estoy trabajando con fichero de texto? 00:34:23
Reader 00:34:25
Me da algunos métodos que input stream 00:34:27
No tiene 00:34:29
Que me permiten trabajar directamente con carácter 00:34:31
Trabajar con strings 00:34:33
Mientras que input stream 00:34:35
No, input stream solo tiene los métodos 00:34:37
Relacionados con leer bytes 00:34:39
¿Entiende la diferencia? 00:34:41
Por debajo es lo mismo 00:34:43
Esto por debajo 00:34:45
Solo que hacen automático 00:34:47
La interpretación 00:34:49
Dentro de este mundo 00:34:53
De aquí 00:34:55
Existen los señores 00:34:57
File input stream y file reader 00:34:59
Que son los canales 00:35:01
Los flujos de información 00:35:03
Adaptados 00:35:05
A poder leer desde un fichero 00:35:07
¿Sí? 00:35:09
Hemos dicho que estos 00:35:11
Podría ser 00:35:13
Que es una comunicación en red 00:35:15
A través de un socket 00:35:17
O podría ser leer de teclado 00:35:19
O podría ser escribir en pantalla 00:35:21
Bueno, escribir no 00:35:23
Pero recibir datos 00:35:25
Desde cualquier tipo de cosa 00:35:27
¿Vale? 00:35:29
Este de aquí está especializado en 00:35:31
No, lo estás haciendo sobre un fichero 00:35:33
Nosotros cuando trabajaremos 00:35:35
Usaremos estos 00:35:37
Estos si estoy leyendo 00:35:39
Un fichero que es por ejemplo una imagen 00:35:41
Esto si estoy leyendo 00:35:43
Un fichero que es de texto 00:35:45
¿Dudas? 00:35:49
Si procedo en 00:35:55
La abstracción 00:35:57
Puedo llegar hasta mi amigo 00:35:59
El buffer reader 00:36:01
¿Vale? 00:36:03
Es como un reader 00:36:05
Que pero añade además 00:36:07
Un buffer 00:36:09
¿Qué es un buffer? 00:36:11
Buffer es como una memoria temporal 00:36:15
Que se va llenando 00:36:17
¿Sabéis cuando metéis Netflix 00:36:19
Le dais al play y veis un numerito 00:36:21
Que aumenta hasta el 99% 00:36:23
Y luego empieza la película? 00:36:25
Eso es un buffer 00:36:27
Me estoy guardando un trozo de película 00:36:29
Para que si luego hay un poquito de problemas 00:36:31
No se te bloque la película 00:36:33
Cada vez que hay un problema de conexión 00:36:35
Sino que tú tengas un margen 00:36:37
Para que siga la película 00:36:39
Y luego funcione otra vez internet 00:36:41
Y siempre tengo un trozo 00:36:43
De posibilidad de leer 00:36:45
¿Vale? 00:36:47
Eso es un buffer 00:36:49
Es una memoria temporal 00:36:51
Porque en cuanto se ha leído la puedo librar 00:36:53
Que puedo utilizar 00:36:55
Para que en vez de leer 00:36:57
Los datos directamente 00:36:59
Que llegan en los procesos 00:37:01
No, los datos llegan 00:37:03
Los guardo por algún lado 00:37:05
Y cuando ya tienen determinadas características 00:37:07
Pues los proceso 00:37:09
¿Para qué sirve? 00:37:13
Pues esto por ejemplo me permite leer 00:37:15
Una línea entera 00:37:17
Esto lee a bits 00:37:19
Bytes 00:37:21
Y luego los tengo interpretados 00:37:23
Esto lee caracteres 00:37:25
Es decir que puedo leer letra por letra 00:37:27
Ver donde acaba una frase aquí 00:37:29
Debería estar leyendo 00:37:31
Letra, letra, letra, letra 00:37:33
Hasta que encuentro un punto 00:37:35
Cuando encuentro un punto 00:37:37
Asumo A 00:37:39
En realidad cuando encuentro un retorno de carro 00:37:41
Un intro 00:37:43
Un enter 00:37:45
Entonces cuando encuentro ese carácter especial 00:37:47
Que es un enter 00:37:49
Diría aquí ha acabado una frase 00:37:51
Este señor de aquí lo que permite es 00:37:53
No leer solo un carácter 00:37:55
Empieza a leer carácter 00:37:57
Cuando llegas a un momento 00:37:59
Que has leído suficiente carácter 00:38:01
Y encuentras un retorno de carro 00:38:03
Pues esta es una línea y devuelve directamente 00:38:05
Un string que es toda la línea 00:38:07
¿Eh? 00:38:11
Y si quieres 00:38:13
O sea que 00:38:15
Sustancialmente todo esto son lo mismo 00:38:17
Leen desde una fuente 00:38:19
¿Vale? 00:38:21
Pero desde más cerca al binario 00:38:23
Hacia abstracciones más altas 00:38:25
¿Vale? 00:38:27
Este de aquí en particular 00:38:29
Si lo asociáis al método 1 00:38:31
Cuando vosotros guardáis 00:38:37
Los archivos 00:38:39
Los objetos 00:38:41
Guardáis cada objeto en una línea 00:38:43
Toda la información relacionada con el mismo objeto 00:38:45
En la misma línea 00:38:47
Y luego ponéis un buffered reader 00:38:49
Que lee línea por línea 00:38:51
Viendo objeto por objeto 00:38:53
Entonces me leo una línea 00:38:55
Que es un objeto y con esto hago el objeto 00:38:57
Me leo otra línea 00:38:59
Y con esto hago el segundo objeto 00:39:01
Leo otra línea 00:39:03
Por ejemplo 00:39:05
¿Dudas? 00:39:07
Si soy un programa de 00:39:09
Procesamiento de texto 00:39:11
Que tiene que buscar una palabra 00:39:13
Dentro de un texto muy largo 00:39:15
Pues lo que puedo hacer es 00:39:17
Leérmelo línea por línea 00:39:19
Una línea del texto 00:39:21
Y busca aquí la palabra 00:39:23
Otra línea del texto 00:39:25
Y además, cuando te tengo que decir 00:39:27
Si he encontrado la palabra 00:39:29
Te puedo decir, mira, la he encontrado 00:39:31
Y está en la línea 3 00:39:33
Cada vez que busco una línea 00:39:35
Sé en qué línea está 00:39:37
¿Dudas? 00:39:39
¿Si? 00:39:41
Esto es sólo presentación de la 00:39:43
De las clases 00:39:47
Después las usamos 00:39:49
Hacemos ejemplos 00:39:51
Aquí lo que hago es 00:39:57
Utilizar FileReader 00:39:59
Y BufferedReader 00:40:01
Para leer algo en un fichero 00:40:03
Entonces 00:40:05
Me creo un señor 00:40:07
FileReader a nul 00:40:09
Y un BufferedReader a nul 00:40:11
FR es mi FileReader 00:40:13
BR es mi BufferedReader 00:40:15
Tengo un nuevo FileReader 00:40:17
Con la ruta del archivo 00:40:19
Aquí debería poner 00:40:21
C dos puntos barra mi carpeta 00:40:23
Barra texto punto text 00:40:25
Por ejemplo 00:40:27
¿Si? 00:40:29
Mejor podría haber creado 00:40:31
Antes un File 00:40:33
Mi fichero es igual a 00:40:35
NewFile con la ruta 00:40:37
Y ahora aquí utilizar 00:40:39
Mi fichero 00:40:41
O podría utilizar 00:40:43
Uno de los 00:40:45
Componentes que seguramente 00:40:47
Habéis mirado en la 00:40:49
Parte gráfica que es el 00:40:51
FileChooser 00:40:53
Cuando lo pincháis se abre la clásica ventanita 00:40:55
Esa que te permite elegir un fichero 00:40:57
Con eso 00:40:59
Elegir el fichero y luego ponerlo 00:41:01
Aquí para ir a leer 00:41:03
Fijaos que creo un nuevo BufferedReader 00:41:09
Y le pongo dentro este 00:41:11
FileReader 00:41:13
Es el concepto que 00:41:15
Esto es como que se va 00:41:17
Encapsulando 00:41:19
En clases que hacen 00:41:21
Más cosas 00:41:23
Lo que ya tengo 00:41:25
He creado un FileReader 00:41:27
Este FR tendrá un conjunto de métodos 00:41:29
Como por ejemplo 00:41:31
Leerme un byte, leerme un carácter 00:41:33
O cosas por el estilo 00:41:35
Este 00:41:37
Stream 00:41:39
Esta información 00:41:41
Lo paso como parámetro a un BufferedReader 00:41:43
¿Qué me hará? 00:41:45
Me añadirá una memoria temporal 00:41:47
A la posibilidad de leer 00:41:49
Carácter por carácter 00:41:51
Y entonces ahora BR me ofrecerá 00:41:53
Más funcionalidades 00:41:55
Me ofrecerá 00:41:57
Lo mismo que hace un FR 00:41:59
Más algunos métodos que FR no tenía 00:42:01
Como por ejemplo leerte una línea entera de golpe 00:42:03
Cosa que 00:42:05
Esto no podría hacer 00:42:07
Por ejemplo 00:42:10
Me creo un StringLinea 00:42:12
Y digo que mientras 00:42:14
Linea es igual a 00:42:16
BR.readline 00:42:18
¿Qué hace BR.readline? 00:42:20
Lee una línea 00:42:24
Me la pasa 00:42:26
Dentro de linea 00:42:28
Y si esto ha pasado 00:42:30
Y ha funcionado 00:42:32
Pues entonces no se hará nada 00:42:34
¿Ok? 00:42:37
Si esta operación devuelve null 00:42:39
Quiere decir que ha acabado el fichero 00:42:41
Entonces si esta operación de aquí 00:42:47
Funciona 00:42:49
Y esto no es null lo que ha puesto aquí dentro 00:42:51
Pues entonces lo que hago es 00:42:53
Procesar la línea 00:42:55
Hacer lo que tenga que hacer con esta línea 00:42:57
Si la quiero imprimir por pantalla 00:42:59
Si quisiera crear un objeto a partir de aquí 00:43:01
Pues aquí crearía el objeto 00:43:03
Separaría todos los componentes 00:43:05
Que están en esta línea que he leído 00:43:07
De los objetos 00:43:09
Crearía el objeto y lo añadiría a una lista 00:43:11
O lo sé, hago lo que tengo que hacer 00:43:13
Con lo que he leído desde el fichero 00:43:15
En este caso lo escribe 00:43:17
Teniendo en cuenta que puede haber excepciones 00:43:19
Podéis ir a mirar 00:43:21
Que tipo de excepciones lanzan 00:43:23
Estas operaciones de aquí 00:43:25
Fijaos que el tráiler es aquí 00:43:27
Muchas de estas son 00:43:29
IOException 00:43:31
Pero puede ser 00:43:33
FileNotFoundException 00:43:35
Si yo intento acceder a un fichero que no existe 00:43:37
Os vais a mirar en el API 00:43:39
Y podéis ver todas las excepciones 00:43:41
Os recuerdo que las excepciones 00:43:43
Las hemos visto 00:43:45
Y este tipo de forma 00:43:47
De manejar las excepciones 00:43:49
Es pésimo 00:43:51
Porque no sé que ha pasado 00:43:53
Si pasa algo explota 00:43:55
Dime que ha pasado 00:43:57
Oye el fichero que has seleccionado no existe 00:43:59
Dime, oye mira, he intentado abrir 00:44:01
Pero no lo he conseguido 00:44:03
Dime algo, no me digas 00:44:05
Boom 00:44:07
Aquí hay una cosa 00:44:09
Finally 00:44:11
Cuando he utilizado todo esto 00:44:13
Porque fijaos que este es un while 00:44:15
Que mientras recibo cosas la escribo 00:44:17
Cuando esto me da null 00:44:19
Y entonces he acabado, salgo del while 00:44:21
Y al final 00:44:23
Tanto si ha explotado 00:44:25
Como si ha acabado el fichero 00:44:27
Lo que hago es 00:44:29
Si esto y esto 00:44:31
Si esto no es null 00:44:33
O sea si FR 00:44:35
Cuando lo he creado 00:44:37
Era algo y por lo tanto existe como objeto 00:44:39
Pues entonces cierralo 00:44:41
Si cuando he hecho esto 00:44:45
Ha explotado o no ha funcionado 00:44:47
Y por lo tanto FR se ha quedado null 00:44:49
Pues no lo hago, no he abierto el fichero 00:44:51
No lo cierro 00:44:53
¿Qué quiere decir cerrar el fichero? 00:44:55
Cuando yo creo un file reader 00:44:57
O un buffer reader 00:44:59
Lo que estoy haciendo es poner un tubo 00:45:01
Desde el fichero 00:45:03
Hasta mi programa 00:45:05
Y empiezo a pillar desde allí información 00:45:07
Cuando ya no lo quiero usar más 00:45:09
La cosa que debería hacer 00:45:11
Es quitar el tubo 00:45:13
Cerrar el fichero 00:45:15
Ya no lo estoy utilizando 00:45:17
Y entonces ya tengo esto 00:45:19
Sustancialmente quito todos los recursos 00:45:21
Que estos dos señores 00:45:23
Estos dos señores 00:45:25
Habían guardado por algún lado 00:45:27
Diciendo oye mira 00:45:29
Me han abierto un stream 00:45:31
Tengo que estar pendiente de recibir datos 00:45:33
Si me piden los datos 00:45:35
Lo tengo que pasar 00:45:37
Lo tengo que poner en una memoria 00:45:39
O hacer algo 00:45:41
Pues todos estos recursos que estaban a disposición de mi programa 00:45:43
Pues libéralos 00:45:45
Porque he acabado de mirar el fichero 00:45:47
Lo puedo cerrar 00:45:49
¿Qué hace este programa? 00:45:51
Escribir en pata y un fichero 00:45:55
Tengo un fichero de texto 00:45:57
Y esto lo escribo en pata 00:45:59
¿Sí? 00:46:01
¿Cómo se escribe? 00:46:03
Pues en vez de los readers 00:46:05
Hay los writers 00:46:07
¿Cómo se escribe? 00:46:09
Pues en vez de los readers 00:46:11
Hay los writers 00:46:13
¿Cómo se escribe? 00:46:15
Pues en vez de los readers 00:46:17
Hay los writers 00:46:19
¿Cómo se escribe? 00:46:21
Hay los writers 00:46:23
¿Vale? 00:46:25
Donde hay un input stream 00:46:27
Hay un output stream 00:46:29
Donde hay un input stream reader 00:46:31
Hay un output stream writer 00:46:33
Donde hay un file reader 00:46:37
Hay un file writer 00:46:39
¿Vale? 00:46:41
Todos los readers, input y cosas por el estilo 00:46:43
Me darán operaciones de leer 00:46:45
Todos los writers 00:46:47
Output y cosas por el estilo 00:46:49
Me darán operaciones para escribir 00:46:51
Para mandar datos 00:46:53
Desde mi programa hacia el fichero 00:46:55
¿Sí? 00:46:57
Por ejemplo aquí 00:46:59
Tengo este file writer 00:47:01
Este print writer 00:47:03
Alguno de vosotros os sonará 00:47:05
System.out 00:47:07
¿Vale? 00:47:11
Como vosotros 00:47:13
Sois buenos alumnos 00:47:15
Y sabéis que 00:47:17
System empieza por S 00:47:19
Y habéis ido a mirar en el 00:47:21
Apis que es 00:47:23
Y que tipo tiene 00:47:25
Este System.out 00:47:27
Ahora os sonará 00:47:29
Entonces 00:47:35
Creo un fichero file writer 00:47:37
Con la ruta del fichero 00:47:39
Repito que la foto la podía poner 00:47:41
Cuidado que aquí hay una cosa 00:47:43
Si pones la ruta 00:47:45
Y luego aquí coma true 00:47:47
Creo que esto no te 00:47:49
Sobrescribe el fichero 00:47:51
Sino te lo añade al final 00:47:53
Pero habría que ver nada 00:47:55
No me acuerdo bien 00:47:57
Y este file writer 00:47:59
Lo encrusto dentro 00:48:01
Lo paso como parámetro 00:48:03
Que es la versión del buffer 00:48:05
En un cierto sentido pero en escritura 00:48:07
Lo que me permite escribir 00:48:09
Una string de golpe 00:48:11
Entonces 00:48:13
For int y bla bla bla 00:48:15
10 veces 00:48:17
pv.println 00:48:19
¿Os suena de algo? 00:48:21
Linea mas i 00:48:23
¿Vale? 00:48:25
Si hay una excepción explota 00:48:27
Y al final cierrame el fichero 00:48:29
¿Qué hace este programa? 00:48:35
Escribe linea 1, 0 00:48:37
Linea 1, 0 00:48:39
Lo guardo en un fichero de texto 00:48:41
Dice esto guardado en un fichero de texto 00:48:43
¿Vale? 00:48:45
Fijaos que al usar el print writer 00:48:47
Puedo escribir una linea 00:48:49
println 00:48:51
Me permite escribir 00:48:53
Linea el numerito 00:48:55
Y dar un retorno de carro 00:48:57
Si pusiera solo print 00:48:59
Me lo escribiría todo en la misma linea 00:49:01
Parecido a 00:49:03
Ahora 00:49:05
Cuando vosotros usáis system.out 00:49:07
¿Está conectado a un fichero? 00:49:09
System.out.println 00:49:15
No, aquí está conectado 00:49:17
Al sistema 00:49:19
A la salida de mi sistema 00:49:21
Que normalmente es la consola 00:49:23
¿Vale? 00:49:25
Cuando yo escribo algo 00:49:27
Me lo escribe en esta parte de consola 00:49:29
Por defecto 00:49:31
Cuando yo arranco un programa 00:49:33
El systemin es el teclado 00:49:35
Systemout es la consola 00:49:37
Y ahora un tercero 00:49:39
Systemer 00:49:41
Que es la consola pero en rojo 00:49:43
Ahí es donde escribiría 00:49:45
Información sobre los errores 00:49:47
Si explota un error, en vez de hacer 00:49:49
System.out.println 00:49:51
Arroga a que ha pasado algo raro 00:49:53
Sería system.er 00:49:55
.println 00:49:57
Error, err 00:49:59
¿Vale? 00:50:01
Creo que viene ahora 00:50:03
Lectura y escritura de un archivo binario 00:50:07
¿Vale? 00:50:09
Voy a leer 00:50:11
Por ejemplo copiar un fichero 00:50:13
Voy a leer de un fichero 00:50:15
Es binario, esto no es de texto 00:50:17
Y lo que he leído 00:50:19
Lo escribo en otro fichero 00:50:21
Tengo un file input stream 00:50:25
Ahora no tengo reader y writer 00:50:27
Porque estoy leyendo 00:50:29
Quiero leer byte a byte 00:50:31
Es un fichero binario, no es un fichero de texto 00:50:33
Puede ser una imagen 00:50:35
Puede ser un ejecutable 00:50:37
Y creo 00:50:39
Un nuevo file input stream 00:50:41
Con la ruta del fichero original 00:50:43
Luego pillo un buffer 00:50:45
De input stream 00:50:47
No un buffer de reader 00:50:49
Le paso este de aquí 00:50:53
¿Qué es esto? Es un input stream con un buffer 00:50:55
Me permite leer en vez de byte a byte 00:50:57
Un trozo de byte 00:50:59
Me dará métodos que en vez de leer 00:51:01
Leer un byte me dirá leer mucho 00:51:03
¿Vale? 00:51:05
Luego tengo un file output stream 00:51:07
¿Vale? 00:51:09
Que le pongo el fichero copia 00:51:11
Entonces esto y esto 00:51:13
Son distintos 00:51:15
Esto será c2.micarpeta 00:51:17
Original.exe 00:51:19
Y este de aquí será 00:51:21
c2.micarpeta 00:51:23
Barra 00:51:25
Destino.exe 00:51:27
¿Vale? 00:51:29
Y un buffer de output stream 00:51:31
¿Sí? 00:51:33
Al que le paso este de aquí 00:51:35
Aquí estoy creando sustancialmente 00:51:37
Mis dos canales de entradas 00:51:39
De entrada y salida 00:51:41
Este que lee desde el fichero original 00:51:43
Y este que escribe en el fichero destino 00:51:45
¿Sí? 00:51:49
Vale 00:51:51
Pillo un array 00:51:53
De bytes 00:51:55
¿Vale? Con mil bytes dentro 00:51:57
Tendré una memoria, un bloque 00:51:59
De mil bytes 00:52:01
Lo rellenaré leyendo de aquí 00:52:03
De aquí 00:52:05
Y lo que he rellenado allí 00:52:07
Lo escribiré 00:52:09
Entonces vamos a ver como se hace 00:52:13
int leidos es igual a 00:52:15
bis.read 00:52:17
De array 00:52:19
La read, la operación read de leer 00:52:21
¿Vale? 00:52:23
Que hay varias read 00:52:25
Dependiendo de lo que pongo aquí 00:52:27
Hace una cosa u otra 00:52:29
Pero en general, si yo le pongo un array 00:52:31
Un cierto número de posiciones 00:52:33
Un array de bytes 00:52:35
Lo que hace el resultado de esta operación 00:52:37
Es que me pone dentro de este array 00:52:39
Lo que ha leído 00:52:41
Byte por byte 00:52:43
O sea que si hay mil bytes en el 00:52:45
En el fichero 00:52:47
Pues me leerá mil bytes 00:52:49
Hasta mil bytes 00:52:51
Si hay menos me leerá menos 00:52:53
Y aquí me dice cuantos has leído 00:52:55
Si el array tiene 00:52:59
1200 bytes, la primera vez que 00:53:01
Uso esto, aquí me verá mil 00:53:03
Porque ha leído mil bytes 00:53:05
Si el array 00:53:07
Si el fichero tiene 300 bytes 00:53:09
Solo, pues aquí me pondrá 300 00:53:11
Entonces si yo sé que de estos mil 00:53:13
Bytes, los primeros 300 00:53:15
Tienen sentido porque acabo de leerlos 00:53:17
Y son el fichero que he leído 00:53:19
Y los otros 700 no tienen sentido porque 00:53:21
A lo mejor son de una lectura anterior 00:53:23
Pero no es lo que he leído ahora 00:53:25
Ahora he leído solo 300 00:53:27
¿Si? 00:53:31
Y digo, mientras 00:53:33
Leídos es mayor que 0 00:53:35
¿Vale? O sea que 00:53:37
Mientras tengo cosas que he leído 00:53:39
Lo que voy a escribir es escribir 00:53:41
Lo que hay en el array 00:53:47
Leyendo desde 0 00:53:49
Desde el array 0 00:53:51
Hasta el número leídos 00:53:53
¿Vale? 00:53:55
Y leer otra vez el array 00:53:57
Substantialmente lo que hago es 00:54:01
Leo algo y lo escribo 00:54:03
Leo algo y lo escribo 00:54:05
Leo algo y lo escribo 00:54:07
Leo algo y lo escribo 00:54:09
Lo que he leído lo escribo 00:54:11
Ese último leído es igual a 00:54:13
BIS.READ 00:54:15
Si ya he leído un cacho pues seguiré leyendo el siguiente 00:54:17
¿Vale? 00:54:19
Como yo tengo este stream 00:54:21
El stream se acuerda 00:54:23
De donde ha llegado 00:54:25
Si yo leo la primera vez me lee esto 00:54:27
Si leo otra vez 00:54:29
Empieza desde aquí a leer 00:54:31
Ahora, si yo cerrara este BIS 00:54:33
Y lo vuelvo a abrir 00:54:35
Pues entonces es como si hubiese empezado 00:54:37
Desde el principio otra vez a leer el fichero 00:54:39
¿Vale? 00:54:43
Y entonces 00:54:45
¿Para qué sirve esto? 00:54:47
¿Qué me quiere decir esta cosa aquí? 00:54:49
Mientras haya leído algo 00:54:53
Si yo hago la read 00:54:55
Y me devuelve 0 00:54:57
Es que he acabado 00:54:59
O no hay bytes en el fichero 00:55:01
O que he acabado el fichero 00:55:03
He leído, he leído, he leído 00:55:05
Ahora no he leído nada 00:55:07
Pues quiere decir que no tienes nada que escribir 00:55:09
Pues sale 00:55:11
Cierro BIS 00:55:13
Cierro BOS 00:55:15
Y salgo 00:55:17
En mi experiencia 00:55:21
Pasaréis el resto de vuestra existencia 00:55:23
Llamando estas cosas 00:55:25
FIS, BIS, FOS y BOS 00:55:27
¿Vale? 00:55:29
Ahora, estaría bien que le hicierais 00:55:31
Algo de semántica 00:55:33
A estos nombres 00:55:35
Como estos son ejercicios sin semántica 00:55:37
Pues tampoco 00:55:39
Esto podría ser origen 00:55:41
De este destino 00:55:43
Para que luego entendáis mejor 00:55:45
La diferencia entre FIS, FOS, BOS y FIS 00:55:47
Si, porque si no es un poco malo 00:55:49
Una cosa 00:55:51
¿Por qué no funciona en el Default Package? 00:55:53
¿Por qué no funciona en él? 00:55:55
De hecho eso 00:55:57
Sale el de leer archivos en el Default Package 00:55:59
Y en uno con otro nombre 00:56:01
En el Default no funciona 00:56:03
En este fichero 00:56:05
No lo sé 00:56:07
Debería funcionar 00:56:09
¿Has importado? 00:56:11
No lo sé 00:56:19
No me resulta 00:56:21
Que no tenga que funcionar 00:56:23
Pues a lo mejor 00:56:25
No lo sé 00:56:27
¿Por qué lo has hecho mal? 00:56:29
¿Cómo guardar el atributo 00:56:31
De un objeto? 00:56:33
Hagamos una 00:56:35
Pausa 00:56:37
Autor/es:
Stefano Chiesa
Subido por:
Stefano C.
Licencia:
Reconocimiento - No comercial
Visualizaciones:
9
Fecha:
5 de mayo de 2023 - 13:52
Visibilidad:
Clave
Centro:
IES ROSA CHACEL
Duración:
56′ 39″
Relación de aspecto:
1.78:1
Resolución:
1280x720 píxeles
Tamaño:
473.85 MBytes

Del mismo autor…

Ver más del mismo autor

EducaMadrid, Plataforma Educativa de la Comunidad de Madrid

Plataforma Educativa EducaMadrid