Saltar navegación

Persistencia datos 1: I/O texto - 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 10 de marzo de 2026 por Stefano C.

1 visualizaciones

Más información Transcripción

Descargar la transcripción

Voy a grabar esta clase, por lo tanto, si habláis, me dais vuestro consentimiento de grabar vuestro. 00:00:00
Entonces, hoy vamos a empezar a ver lo que es la persistencia de datos. 00:00:07
¿Qué es la persistencia de datos? 00:00:11
Nosotros hemos tenido un problema desde el principio de este curso, 00:00:13
que es que nuestros programas funcionan sólo al darle el play 00:00:16
y que se acuerdan de todo mientras que el programa funcione, 00:00:22
pero en cuanto el programa se acaba, todo lo que he hecho se destruye. 00:00:25
Ahora, si mi programa es, te doy un número y me dices si es par o impar, ¿qué más me da? ¿Vale? Se apaga, lo lanzo otra vez y le digo otro número para saber si es par o impar. Interesantísimo. 00:00:30
Si mi sistema es una escuela donde tiene tu menú que dice, ¿qué quieres hacer? ¿Quieres añadir un alumno? ¿Quieres asignar una materia a un alumno? ¿Quieres asignar una nota a una materia de un alumno? Y cosas por el estilo. 00:00:40
Tú cuando lo has creado y empiezas a poner alumnos, cada vez que apagas y reenciendes, tu sistema es sin alumnos. Es a cero. Y eso es feo. Entonces, nosotros necesitamos un modo para, sustancialmente, hacer persistir los datos entre ejecuciones. 00:00:55
ahora nosotros sabemos que dentro del mundo de la informática hay una cosa que se llama jerarquía de 00:01:13
memoria donde empezamos desde la memoria más pequeña pequeña pequeña pequeña y más rápida 00:01:19
rápida rápida vida que son los registros gracias no sé quién ha dicho luego vamos un poquito más 00:01:28
grande llegamos a un pollo más grande un poquito más lento llegamos a saltar un par más caché 00:01:45
la que pone cuando te compras un procesador y te pone memoria de caché de nivel 2 de 64 mega 00:01:56
y luego hay nivel 3 pues esas son todas siempre memorias más grandes pero más lentas que se alejan 00:02:08
del procesador vale los registros son los más cercanos luego están los que están en el chip 00:02:20
del procesador que son estas memorias caché vale de dos o tres niveles y luego se llega 00:02:24
a la ram y hasta aquí todas estas son exactos volátiles qué quiere decir que cada vez que 00:02:30
apago el ordenador todo el contenido de estas memorias desaparece la ram en particular que es 00:02:44
mi memoria de trabajo es donde he trabajado hasta ahora vale todos mis programas han utilizado la 00:02:51
y cuando yo apago el ordenador y lo enciendo, no hay nada. Virtualmente hablando, cuando yo cierro 00:02:57
la java virtual machine, o sea, cuando vosotros le dais al botón verde y se enciende la java virtual machine 00:03:04
e interpreta vuestro programa y hay el botón rojo abajo, que a veces cuando hacéis un while eterno 00:03:09
se queda ahí rojo y le tenéis que pinchar para pararlo. A ver, que vos lo paráis, borráis el proceso y el 00:03:15
proceso es? Es un proceso. Esta pregunta te la he hecho ya hace un momento, efectivamente. O sea, cuando he ejecutado el 00:03:22
programa, entonces se ha creado el proceso con todos los recursos. Cuando el proceso se quita, se le 00:03:35
desasigna también el trozo de RAM que se le había dado al proceso y por lo tanto toda 00:03:40
mi memoria se ha borrado. Si sigo con la jerarquía de memoria, la siguiente memoria sería el escuduro. 00:03:45
la memoria secundaria. Disco duro sea como sea, de qué tipo sea, pero eso sí que es la primera memoria 00:03:56
no volátil. La memoria que cuando apago e enciendo mi ordenador pues sigue allí. De lo que hemos 00:04:03
hecho nosotros, ¿qué está en la memoria no volátil? El programa como tal, el código fuente. El código se 00:04:11
se escribe en disco duro. Cuando yo arranco el programa, en realidad lo que escribimos 00:04:28
nosotros está en el punto java, pero lo que se utiliza para arrancar no es el punto java, 00:04:36
es el punto class, se hace la compilación, se escribe el punto class por algún lado, 00:04:40
cuando arranco la java de esta máquina, arranco mi programa, el programa va a pillar este 00:04:45
punto clas lo carga en memoria ram y empieza a trabajar con todos los datos 00:04:49
que yo creo las variables la cosa así que creo dentro de mi programa se crean 00:04:59
donde 00:05:05
en la memoria ram en un espacio dedicado porque al ejecutar el programa y 00:05:11
transformándose en un proceso se hace una llamada de sistema al sistema 00:05:18
operativo que le dice oye mira de toda la RAM que tienes reserva un poquito de RAM para mí por favor 00:05:22
y él dice toma esta es tu RAM entonces yo trabajo allí dentro vale ese es mi trozo de memoria si 00:05:28
necesito más tendré posibilidad de pedir más al sistema operativo si necesito sólo esa me quedo 00:05:34
con esa allí pero tengo mi RAM dedicada otros procesos no pueden acceder a mi RAM si no es un 00:05:42
problema. Es un problema que en C se puede lograr a veces con una segmentation fault, 00:05:49
cosa por el estilo, que es un enemigo malvado de C, porque aparece siempre que os equivocáis con 00:05:54
algo de malloc o de gestión de memoria mal hecha. Dicho todo esto, dentro del espacio de RAM que yo 00:05:59
tengo, por un lado cargaré los trozos de código o el código de mi programa y lo tendré allí, 00:06:11
Ahí trabajo dónde están las instrucciones que tengo que ejecutar. 00:06:17
Fenomenal. 00:06:21
Que copiaré, si este es todo mi programa, 00:06:22
un trocito lo copiaré en nivel 3, 00:06:25
un trocito de este nivel 3 en nivel 2, 00:06:27
un trocito de este nivel 2 me lo cargo en los registros 00:06:29
y desde los registros lo ejecuto en el procesador. 00:06:33
¿Vale? 00:06:37
Siempre tengo como trocitos siempre más grandes 00:06:37
cerca del procesador para que sea mucho más rápido 00:06:41
cambiar de ejecución y cosas por el estilo. 00:06:43
Ahí. 00:06:45
funcionalidad. Esto lo habéis estudiado, ¿no? 00:06:45
¿No? 00:06:49
Sistema informático, ¿no? 00:06:50
Hay todo un mecanismo en el 00:06:52
ordenador para que prevea 00:06:54
lo que tú vas a utilizar y lo 00:06:55
cargue en las zonas 00:06:58
de memoria más cercana 00:07:00
al procesador. Si lo hace bien 00:07:02
tu programa va bien, si lo hace mal 00:07:04
llega un momento en que tiene que 00:07:06
pararse a buscar esta información 00:07:08
en un lado o en el otro, en el caso peor 00:07:10
desde el disco duro y por lo tanto 00:07:11
ralentiza todo el proceso. 00:07:13
Mi ram, parte, está allí con el código del OJD, y lo de otra parte de la ram, donde 00:07:15
yo creo las variables que yo creo. 00:07:23
Y aquí hay dos cosas, hay el heap, que es donde se crean los objetos, no todas las variables, 00:07:26
Y el stack, la pila. 00:07:45
¿Sabéis cuando se decía llamada de métodos? 00:07:56
Era la pila de la llamada de métodos. 00:07:59
Pues a esta está asociada una pila en la memoria 00:08:01
donde en cada bloque que yo apilo en esta pila 00:08:03
creo las variables locales de ese método. 00:08:07
Las llamadas de métodos corresponden a 00:08:10
construcción de variables locales a ese método. 00:08:13
Cuando yo quito ese método, pues toda la variable local 00:08:16
de ese método se pierde. 00:08:19
Esto lo vimos con los scope 00:08:21
de las variables en 00:08:22
octubre. 00:08:25
Entonces, todo esto 00:08:30
memoria volátil. 00:08:31
Ahora lo que queremos hacer nosotros 00:08:33
es hacer que persistan estos datos. Quiere decir 00:08:35
que cuando llegue un momento 00:08:37
determinado, yo puedo decirle 00:08:39
a mi programa, vale, muy bien, lo que tú 00:08:40
tengas ahora en memoria RAM, 00:08:43
guárdalo, cópialo, escríbelo 00:08:45
de alguna forma en la memoria 00:08:46
secundaria para que cuando yo 00:08:49
apague este programa 00:08:51
los datos se queden allí 00:08:52
y cuando yo vuelva a encender 00:08:54
este programa, el programa mismo 00:08:57
puede preguntarse, oye mira, ¿has guardado 00:08:59
algo anteriormente? 00:09:01
o podría decirme, oye mira 00:09:04
¿quieres cargar algún fichero? 00:09:05
y yo le puedo decir, mira, vete 00:09:08
a este fichero de aquí, allí dentro 00:09:09
encontrarás algo y con 00:09:11
ese algo, sácame los datos 00:09:13
para volver al mismo estado 00:09:15
o un estado lo más parecido posible de cuando apague la última vez. 00:09:17
Eso puede ser que lo haga de forma automática, en el sentido de que yo arranco 00:09:22
y él, sin preguntarme nada, vaya a buscar un particular fichero 00:09:25
y si ese fichero está, lo cargue en memoria, 00:09:29
o puede ser que simplemente arranque siempre en vacío 00:09:32
y que tú digas, oye, mira, lo ad este de aquí, ¿vale? 00:09:35
Nosotros empezaremos ahora, porque este año lo hacemos al revés, 00:09:39
con forma 00:09:42
de forma, digamos, textual 00:09:44
le pediremos que hagan las cosas 00:09:46
mandándole comandos que creamos 00:09:48
nosotros o dándole a uno para 00:09:49
cargar o lo que sea, ¿vale? Como hemos hecho 00:09:51
los menús. La cosa interesante 00:09:53
será después, pues, todas 00:09:55
estas opciones hacerlas a través de una 00:09:57
interfacturación, ¿vale? El año pasado 00:09:59
para quien estaba el año pasado o quien 00:10:01
había visto vídeos del año pasado 00:10:03
empezamos con la 00:10:05
parte, digamos, antes gráfica 00:10:07
y luego hicimos esta de aquí 00:10:09
pues este año intentamos al revés 00:10:11
porque 00:10:14
no está claro si es mejor 00:10:15
hacer una cosa o la otra 00:10:18
¿Conceptos? 00:10:19
El código en la 00:10:23
programación orientada a objetos, los objetos 00:10:24
sobre que se funda 00:10:26
¿Vale? 00:10:27
Datos y código ejecutable 00:10:29
¿Vale? Esto de aquí son 00:10:32
el repaso de lo que acabamos de decir toda hora 00:10:33
¿Vale? Nosotros cuando 00:10:36
cuando trabajamos con programación 00:10:38
orientada a objetos, por un lado tenemos 00:10:40
los atributos que son los datos del objeto 00:10:42
por otro lado tenemos los métodos que es código 00:10:44
¿vale? esto se guardará por algún lado 00:10:46
el código almacenado 00:10:48
en el dispositivo de almacenamiento con un disco duro 00:10:50
¿vale? es el código compilado 00:10:52
que se guarda allí, o sea los métodos 00:10:54
no se guardan en el heap 00:10:56
los métodos están guardados por otro lado 00:10:58
y siguen allí, son el código que yo he 00:11:00
escrito, sin embargo los atributos 00:11:02
dependen de la ejecución ¿vale? 00:11:04
de lo que estoy haciendo con el objeto 00:11:06
O sea, que el comportamiento en un cierto sentido, una vez escrito, se compila y se queda allí, los datos sobre los que se trabaja pueden mudar durante la ejecución. 00:11:08
Yo lo que no puedo modificar es cómo funciona un método mientras lo estoy ejecutando y mientras lo estoy utilizando. 00:11:18
Para eso debería parar el sistema, crear un nuevo método, compilarlo y en ese punto utilizaría el nuevo método. 00:11:26
Cuando ejecutamos un programa sobre una Javita Machine, el código compilado se carga en memoria RAM y se ejecuta, lo hemos dicho. 00:11:32
Cuando la electricidad se apaga, el programa desaparece de la memoria, pero persiste en el disco, el programa, el código, sigue ahí. 00:11:39
Los atributos. Los valores de atributos de los objetos no existen previamente en el disco, ¿vale? 00:11:49
Todo lo que yo defino en el código está en el código, pero no existe una zona de memoria con la que yo pueda trabajar tanto con objetos como con variables de tipo primitivo y cosas por el estilo. 00:11:56
Se van creando a la hora de ejecutar el objeto, hay algunas instrucciones como la declaración de variables o la asignación de valores a variables creadas que me permiten sostantivamente crear lo que necesito en RAM. 00:12:08
Una vez en la introducción del programa, cuando se ejecuta una new, se crea en un espacio de memoria RAM, que es el int, 00:12:20
toda la estructura necesaria para que este objeto exista y que pueda trabajar con él. 00:12:29
El resto de datos, como variables locales, parámetros de entradas, los parámetros de los métodos que se asigna desde formal a actual, etc. 00:12:35
Se guardan en una zona de memoria llamada stack, una pila, stack en inglés. 00:12:45
porque efectivamente se va creando 00:12:50
cuando yo llamo un método, creo todas las cosas de este método 00:12:53
en un bloque que voy apilando, cada llamada 00:12:56
yo siempre ejecuto la última llamada del método 00:12:59
lo vimos cuando vimos la stack de llamadas a método 00:13:02
yo llamo el método main, pues estoy ejecutando el main 00:13:05
si desde el main se llama el método calcularArea 00:13:07
dejo colgado el main 00:13:10
me voy a calcular, creo un nuevo bloque 00:13:15
donde aquí puede haber nuevas variables y uso estas 00:13:17
que son visibles desde este método, son locales a este método. Cuando acaba este método, este nuevo 00:13:20
bloque se destruye y vuelvo a donde estaba antes, que era la llamada del main, y por lo tanto, 00:13:26
a la línea siguiente de la llamada al método calcular era del main. ¿Entiendes? Este contenido 00:13:31
es volátil en el sentido que se libera cada vez que se acaba la ejecución y todo esto es RAM, 00:13:42
vale, entonces cuando acaba 00:13:48
vale 00:13:50
cuando finaliza el programa los datos de los atributos 00:13:51
del IP no persisten, aunque 00:13:54
en muchos casos sería deseable, vale 00:13:56
este es el concepto de, tengo mi escuela 00:13:58
he hecho mis alumnos y ahora 00:14:00
no puedo 00:14:02
cruzar los dedos diciendo, mientras que 00:14:03
este ordenador no se apague, tengo aquí 00:14:06
los alumnos y si 00:14:08
mañana se va la luz, pues tengo 00:14:10
que volver a poner los 1200 alumnos de este año 00:14:12
vale 00:14:14
los lenguajes orientados a objetos 00:14:15
no prevén de ningún mecanismo automático 00:14:18
de persistencia 00:14:21
por tanto debemos programar 00:14:22
¿qué datos queremos que sean persistentes? 00:14:23
no existe normalmente 00:14:27
a nivel de programación de orientados a objetos 00:14:28
un método mágico que dice 00:14:30
esto cuárdame todo por ahí 00:14:32
se puede lograr hasta un cierto nivel 00:14:34
con estas cosas de Evernet 00:14:36
facilitan 00:14:38
el hacerlo 00:14:39
a precio 00:14:42
de tener que configurarlo y tener que saber 00:14:44
lo que estoy haciendo. O sea, a cambio de una formación previa que me permite 00:14:48
utilizarlo, luego me facilita el último. Nosotros 00:14:51
no estamos a ese nivel, estaremos a un nivel mucho más bajo. 00:14:55
Como muchas cosas que hemos hecho, tendemos a empezar desde niveles 00:15:00
más bajos de abstracción, más cercanos a 00:15:04
lo que podría ser el lenguaje máquina, aun si estamos en un lenguaje de alto 00:15:08
nivel y por lo tanto muchas cosas reales se esconden y luego a partir de allí construimos 00:15:12
encima clases o métodos o abstracciones que nos permiten sustancialmente hacer lo que a 00:15:18
bajo nivel son muchas instrucciones con una instrucción sola que digamos esconde lo que 00:15:25
hay por debajo un poco si queremos verlo con lo que hemos hecho con ArrayList nosotros antes 00:15:31
hemos aprendido como funciona un array 00:15:35
como se añade un elemento a un array 00:15:38
y cosas por el estilo, luego hicimos un paso 00:15:40
intermedio que era crear nuestra 00:15:42
clase gestión 00:15:44
array que me permitía hacer cosas 00:15:46
mágicas sobre los arrays sin toquetear 00:15:48
los arrays directamente porque lo he tocado una vez 00:15:50
y a partir de ahora uso un método 00:15:52
que me añade el elemento sin 00:15:54
tocar el array y luego ver 00:15:56
que esta cosa efectivamente es tan lista 00:15:58
que alguien lo ha hecho y ha creado una clase 00:15:59
arrayist que sustancialmente 00:16:02
me permite añadir cosas 00:16:04
sin tener que estar pendiente de lo mismo. 00:16:06
¿Sí? 00:16:08
Un viaje desde muy bajo nivel 00:16:09
a niveles más altos de astral. 00:16:11
¿Vale? 00:16:15
Para conservar el valor 00:16:17
un dato en un dispositivo 00:16:18
de almacenamiento. 00:16:21
Se puede hacer de varias maneras. 00:16:23
¿Vale? 00:16:25
Entonces, nosotros 00:16:25
cuando tenemos un dato 00:16:26
y lo queremos guardar 00:16:29
en el sentido de no en RAM 00:16:32
a nivel de persistencia, podemos tener varias formas de arte. Nosotros nos centraremos y tendremos en cuenta tres, 00:16:34
en esta parte dos de ellas, pero para que tengáis una idea. Primero es crear un archivo. ¿Qué es un archivo? 00:16:45
Es un trozo de memoria dentro de un disco duro, ¿vale? 00:16:55
Habéis visto un archivo o cosa por el estilo. 00:17:03
Hay dos tipos de archivos, grosso modo. 00:17:05
Uno son los archivos normales con extensión que conocéis, 00:17:08
y el otro son las carpetas. 00:17:11
Las carpetas son archivos especiales que tienen dentro, 00:17:13
sustancialmente, punteros a otros archivos. 00:17:15
Pero al fin y al cabo son archivos ellos también. 00:17:18
¿Vale? Entonces, yo tengo este archivo, 00:17:20
tengo este espacio de memoria, quiero guardar mis datos, los guardo 00:17:23
en modo row, ¿vale? crudo en inglés, es decir 00:17:27
me invento un formato en el que yo pillo 00:17:31
los valores que normalmente conforman mi objeto y 00:17:34
escribo estos valores con un determinado formato inventado por mí 00:17:38
separado por coma, entre paréntesis, lo que me dé la gana 00:17:42
en un fichero, ¿vale? sea como en tipo 00:17:46
texto sea en hexadecimal sea en lo que yo necesite en un formato que yo decido y cuando tengo este 00:17:50
alumno que se llama stefano y que tiene todos 10 es en sus asignaturas claramente toda media 00:17:57
10 pues lo que hacemos es guardar en un fichero stefano dos puntos 10 vale para mí esto punto y 00:18:03
coma esto es un alumno vale y si hay otro alumno que se llama no lo sé y que tiene cinco de media 00:18:10
pues después del punto y coma pondré 00:18:17
no lo sé, dos puntos, cinco 00:18:19
punto y coma. Y así, me invento 00:18:21
un método mío. Podría no ser 00:18:23
texto. 00:18:25
Podría ser binario 00:18:27
si hace falta. 00:18:29
Pero tengo una forma para 00:18:31
tengo un objeto, lo escribo así 00:18:33
en un fichero. 00:18:35
Cuando tenga este fichero con esta cosa escrita 00:18:37
con un determinado formato, puedo leer este 00:18:39
formato para reconstruir 00:18:41
el objeto. 00:18:43
Tenemos que controlar nosotros el formato de dicho archivo. El formato es mío, el propietario, me invento yo como sea. 00:18:44
Segunda opción, pidiendo a la Llamator Machine que almacene todos los datos del objeto en un archivo, pero dejando la gestión del formato a ella. 00:18:55
Esto lo hacemos serializando el objeto, lo que implementa la interfaz Serializable. 00:19:08
Esto es sustancialmente, hago una extracción, esto lo estoy haciendo yo. 00:19:21
Aquí voy a perder el control sobre el formato y a cambio le digo a la Javeton Machine, 00:19:26
usa tus métodos para guardar estos objetos. 00:19:33
¿Cómo se guardan? No lo sé, no lo quiero saber. 00:19:37
Pero si te digo, guárdame este objeto, tú lo guardarás con el mecanismo que te parezca a ti, 00:19:40
que alguien más habrá implementado de un formato que yo a lo mejor no sé, no quiero saber, 00:19:46
porque yo no voy luego a hurgar en ese formato, 00:19:51
sino que voy simplemente a trabajar con ese fichero diciendo, guárdame el objeto, recupérame el objeto. 00:19:54
Finalmente, pidiéndole a un sistema gestor de bases de datos que almacene los datos en 00:19:58
algunas estructuras, tablas y cosas por el estilo. 00:20:06
Entonces, para que esto funcione necesitaría tener una base de datos activa, una posibilidad 00:20:10
de conectarme a esta base de datos y, sustancialmente, lo que se llama un ORM, un Object Relational 00:20:15
que sería sustancialmente un mecanismo entre medias 00:20:22
en el que yo hablo con él diciendo 00:20:28
oye mira, yo necesito guardar este objeto 00:20:30
él mapea los datos de este objeto con tablas 00:20:33
y con la estructura de una base de datos que guarda este objeto 00:20:38
y a ese punto él en automático guarda en la base de datos 00:20:42
a la que tiene que conectarse, por lo tanto la base de datos tiene que estar encendida 00:20:45
guarda todos los datos de ese objeto 00:20:48
En los tres casos, la parte compleja no es guardar el objeto. 00:20:50
La parte compleja es el persistir de las referencias entre objetos. 00:21:01
Porque mientras que yo guardo alumno con nombre Estefano y nota media 10, es muy fácil. 00:21:10
pero cuando guardo profesor 00:21:17
que dentro tiene una lista de alumnos 00:21:20
y una lista de materias 00:21:22
y estos alumnos se refieren a estas materias 00:21:24
y las materias a notas 00:21:27
y cosas por el estilo 00:21:28
cuando guardo estas cosas 00:21:29
no tengo que guardar solo los valores 00:21:31
tengo que también guardar las relaciones 00:21:33
que tienen estos valores 00:21:35
porque cuando luego recargo esa información 00:21:37
no solo quiero saber los valores 00:21:40
sino que tengo también 00:21:42
que las relaciones 00:21:44
los punteros que trabajaban antes 00:21:46
mantengan los punteros 00:21:48
a las mismas cosas, y que si 00:21:50
había dos punteros que apuntaban al mismo objeto 00:21:52
no quiero ahora crear dos copias 00:21:54
del mismo objeto con punteros separados 00:21:56
quiero crear una vez el objeto 00:21:58
y luego punteros que tengan 00:21:59
el mismo objeto, ¿vale? 00:22:02
y esa es la parte compleja, sobre todo aquí 00:22:03
¿vale? 00:22:06
porque como aquí hago todo yo 00:22:08
nadie me da una mano 00:22:10
en preservar estas 00:22:12
conexiones 00:22:14
esto te estoy diciendo, no, no, el formato es mío 00:22:15
lo hago yo, pues entonces tú tendrás que escribir 00:22:19
cuando guardas alumno, también las referencias 00:22:21
a otros objetos posibles que 00:22:24
están dentro del propio alumno 00:22:26
aquí a mitad 00:22:30
en el sentido que le estoy dando a la Jabberton Machine 00:22:32
o ya hace esto, entonces si lo hago de golpe 00:22:36
o si no le pido cosas extremadamente 00:22:39
complejas, más o menos lo entiende y me 00:22:42
preserva él, porque como lo está haciendo 00:22:45
él, pues, lo hará bien 00:22:47
él, ¿vale? Entonces, más 00:22:49
o menos puede funcionar. Lo mejor 00:22:51
sería aquí, porque estas son cosas mucho 00:22:53
más avanzadas, y cuando hace el 00:22:55
ORM, el Object Relational Mapping, 00:22:57
pues, debería, si está bien 00:22:59
hecho, y si lo ha configurado bien, 00:23:01
pues, preservar también 00:23:03
las varias referencias a objetos, 00:23:04
a otros objetos, ¿vale? 00:23:07
También pensarlo a nivel de base de datos, 00:23:09
si yo puedo crear que cada objeto, puedo 00:23:11
asignarle una 00:23:13
una clave primaria 00:23:14
entonces cuando luego tengo desde otros 00:23:16
objetos, referirme a un 00:23:19
objeto de estos, puedo usar esta clave primaria 00:23:21
para decir exactamente este objeto de aquí 00:23:23
entonces se mantendría 00:23:25
la posibilidad de 00:23:27
gestionar referencias al mismo 00:23:29
objeto en base a esta clave primaria 00:23:31
que yo tengo, ¿vale? aún así 00:23:33
no es trivial, no es trivial 00:23:35
implementarlo en un sistema como este 00:23:37
no lo implementamos nosotros, sería 00:23:38
una buena práctica de unos 00:23:41
también el hacer que arranque que funcione es lo de siempre si lo sabes hacer no es una cosa 00:23:42
tremendamente difícil a lo mejor se acomoda pero llegar al nivel de saber que estoy toqueteando 00:23:52
y que todo funcione bien pues requiere de su formación dudas hay una clase de java y que 00:23:58
representa un muy bien, un fichero o un file. Representa el nombre de un archivo concreto o 00:24:12
los nombres de archivos de un directorio. Vale, file me vale tanto por directorio como por fichero 00:24:24
porque el directorio es un fichero al fin y al cabo. Dependiendo de cuando la creo le puedo 00:24:29
decir si es un directorio o no y le puedo preguntar oye fichero eres un directorio o no. 00:24:34
Hay una función, si no me equivoco, que es isdir, o algo por el estilo, que devuelve true si es una directory, 00:24:42
y falsa si es un archivo normal y correcto. 00:24:47
Cuando yo creo un objeto de tipo file, yo tengo una representación a nivel de Java de un fichero que está en el disco duro. 00:24:55
Pero son dos cosas distintas. 00:25:09
yo puedo tener una representación de un objeto sin tener el fichero en el disco duro. 00:25:12
Está claro que si yo lo estoy leyendo, entonces voy allí y digo, este file es este fichero. 00:25:20
Vale, si no está, explota. Si está, pues lo tengo. 00:25:25
Pero si yo voy a crear un fichero nuevo y digo, mira, en este fichero voy a poner este texto, 00:25:28
hasta que no lo haya creado el fichero, pues no está. 00:25:34
Es una referencia a un objeto en Java. Es una... ¿Cómo decir? Es una abstracción, es un manejador, es la idea de un fichero. 00:25:39
Pero luego hay comandos para decir, ok, yo tengo esta representación de fichero, ahora créamelo de verdad. 00:25:57
y entonces hablará la Java Virtual Machine con el sistema operativo y dirá a mí en el sistema operativo 00:26:02
me están solicitando de crear un fichero. Por lo tanto, pilla un trozo de memoria, 00:26:08
márcalo como fichero y guárdalo para mí. Vale, entonces a ese punto sí que aparecerá el sistema. 00:26:13
¿Vale? Me está claro que en el momento en que yo le digo file, vuestra mente ha pensado, 00:26:19
exacto ha pensado que gana tengo de irme al api y leer todos los métodos de file para ver qué 00:26:28
puede hacer qué puedo hacer con un file muy bien así piensa un programador además del file que es 00:26:40
la base digamos para decir vale con esto manipuló manejo los ficheros tengo una serie de señores que 00:26:49
me permiten crear stream, crear flujos de información que van desde mi programa al 00:26:59
fichero o desde el fichero a mi programa dependiendo de si son input o output. Aquí 00:27:09
tenéis varios ejemplos que van desde más bajo nivel a más alto nivel. 00:27:18
siempre la misma idea. Hay metoditos, 00:27:27
hay funciones, hay clases que me permiten hacer 00:27:31
las cosas a muy bajo nivel, más cerca posible 00:27:35
a los bits, a los unos y los ceros. Y una vez que yo tengo 00:27:39
algo que puede hacer algo así a bajo nivel, pues le construyo encima 00:27:43
métodos para que sea más sencillo manejar esa cosa. 00:27:46
Porque si yo tengo que escribir un texto, hola, ¿qué tal? 00:27:50
y para escribirlo tengo que ponerlo en binario, 00:27:54
a mí, ser humano, me molesta. 00:27:57
No me gusta para decir, hola, ¿qué tal poner 1, 0, 0, 1, 1, 0, 1, 0, 1, 1, 0, 1, 0, 1, 0? 00:28:00
Feo, porque no me acuerdo la H en binario. 00:28:06
Sin embargo, a la máquina le flipa el binario. 00:28:09
Él quiere todo en binario. 00:28:12
Entonces, tengo que crear algo en el medio, ¿vale? 00:28:14
Que puede ser más hacia la máquina o más hacia mí, ¿vale? 00:28:18
Y es un poco esto. 00:28:22
El input stream es un poco más cerca de la máquina, muy lejos de la máquina, porque 00:28:24
la máquina está en binario, encima del binario está el asemblador, por encima del asemblador 00:28:31
está no sé qué, por encima del no sé qué estará esto, y luego llega un momento en 00:28:35
que tengo el Java y por encima del Java tengo el input stream. 00:28:40
Hay niveles, pero dentro de estos tres métodos es el más cerca a la cosa. 00:28:45
¿Qué quiere decir? Que sustancialmente me permite, estos son input, ¿vale? 00:28:51
Pero input es recibir datos, leer datos, ¿vale? 00:28:56
Pero si yo uso un input stream, leeré, tengo un flujo de información en input, 00:29:00
siempre el concepto de input-output se considera desde la óptica del programa. 00:29:07
Yo soy un programa, input es lo que desde fuera llega dentro del programa, 00:29:13
Output es el que genera el programa y suelta afuera. 00:29:17
Por eso System.out es un output a la pantalla, por ejemplo. 00:29:21
Cuando nosotros teníamos el escáner, el parámetro que poníamos era System.in, 00:29:28
porque es un input desde el teclado a mi programa. 00:29:35
Entonces, este de aquí es un input stream, es un flujo stream de información 00:29:40
que va desde fuera, desde no sé qué, hacia mi programa. 00:29:44
Si yo este de aquí lo asocio con un fichero, tendré un fichero en el disco duro 00:29:50
y cuando aquí le digo lee, pues estará leyendo datos desde el fichero. 00:29:54
Si yo en vez de un fichero aquí conecto otro proceso de mi programa, 00:29:59
cuando le diré lee, pues recibiré datos desde este otro proceso. 00:30:03
Si yo aquí en vez de ponerle un proceso de otro programa le pongo un socket, 00:30:08
Pues tendré una lectura desde Internet. 00:30:12
Y cuando otro ordenador se conecte a ese socket y me mande datos, 00:30:16
yo leeré desde este socket con InputStream. 00:30:20
Cuando vosotros otra vez estaréis en segundo de DAM, 00:30:24
en programación de procesos y servicios, 00:30:30
veréis, reutilizaréis estas cosas de aquí, 00:30:33
diciendo, es que en primero no lo hemos dado, ¿vale? 00:30:36
Pero sí, lo habéis dado ahora. 00:30:40
grabado. Y usaréis los mismos métodos, pero en vez de conectarnos a ficheros os 00:30:42
conectaréis a otros procesos o a software, a otros, digamos, programas en red. 00:30:48
Encapsula un flujo de bits para leer que pueden provenir del teclado de un 00:30:59
fichero de una conexión de red. Proporciona métodos para leerlos byte a byte. Es muy 00:31:04
bajo nivel. Aquí estamos trabajando con bytes. Tú puedes decir, léeme un byte. ¿Y qué es este byte? 00:31:10
No tengo ni idea. Podría ser un carácter, entonces luego lo puedo leer como una letra, 00:31:15
puede ser un trocito de un fichero de audio, podría ser un trocito de un objeto que luego 00:31:20
tendré que reconstruir, no lo sé. Pero voy leyendo byte a byte. Estamos muy a bajo nivel porque lo 00:31:29
que voy a hacer es trabajar con binario. Voy leyendo los bytes, cuando tengo cuatro bytes 00:31:34
los puedo juntar y hacer un entero, por ejemplo. ¿Os acordáis que un entero ocupa cuatro bytes? 00:31:40
Si hubiese leído cuatro bytes, podría hacer un entero. O leo ocho bytes y con estos ocho bytes puedo sacar un... 00:31:52
por ejemplo no lo sé pero aquí yo estoy trabajando le puedo decir oye leme un string 00:31:59
y esperar o saber cuántos bytes tengo que leer para leer el string entero cuando lo 00:32:11
he leído decir y este es un string y porque en mi formato por ejemplo he almacenado string de 00:32:23
10 bytes siempre. Si tengo un texto más largo, lo debo a 10 bytes, 10 bytes, 10 bytes. Entonces luego leo de 10 bytes en 10 bytes, por ejemplo. 00:32:30
Depende de mi formulario. Sí, ahora yo sé, pero, que voy a trabajar con letras, con carácteres, porque he almacenado ficheros de texto, 00:32:38
ficheros binarios, ahora pasamos a ficheros de texto. En vez de utilizar un input stream más secas, puedo usar un input stream reader. 00:32:51
esta parte de Reader 00:33:00
me está diciendo, oye mira 00:33:02
no eres un input stream de más bajo 00:33:04
nivel posible, eres un poquito 00:33:06
más abstracto, asumes 00:33:08
que aquí dentro tú no has puesto 00:33:10
byte por byte, mas has puesto 00:33:12
caracteres, que serán siempre byte 00:33:14
por byte, por debajo este va 00:33:16
a leer byte por byte, pero 00:33:18
tendrá algunos métodos 00:33:20
más que un input stream básico 00:33:22
que me permitan, en vez de 00:33:25
decir lee y me da un byte 00:33:26
decir lee y me da un char 00:33:28
directamente 00:33:31
yo interpretaré 00:33:34
leeré cuantos bytes tengo que leer 00:33:35
para que sea un char 00:33:38
y te devuelvo el char directamente 00:33:39
¿se entiende? 00:33:41
vale 00:33:45
si yo trabajo 00:33:46
con file 00:33:49
en vez de utilizar input stream 00:33:50
o input stream reader 00:33:54
tengo file input stream 00:33:55
y FileReader, que son mecanismos de lectura más específicos 00:33:58
para trabajar no con cualquier posible input, 00:34:04
sino en particular con ficheros. 00:34:08
Son los que usaremos nosotros principalmente junto al último. 00:34:10
Entonces, cuando el flujo de caracteres proviene de un fichero, 00:34:16
podemos utilizar estas clases especializadas en ficheros 00:34:19
en lugar de InputStream y InputStreamReader. 00:34:22
normalmente, pero estos dentro tienen 00:34:25
un input stream o un input stream reader. 00:34:27
Lo veremos. 00:34:29
Finalmente, 00:34:32
está el buffer reader. ¿Qué es un buffer? 00:34:33
No es caso. 00:34:39
Es un buffer. Personaje 00:34:43
que lanza hechizos 00:34:48
que potencian... 00:34:50
Sí, eso también es un buffer, pero 00:34:52
no este buffer de aquí. 00:34:53
Es el numerito que aparece 00:35:02
cuando vosotros le dais al Netflix. 00:35:03
Miráis vuestra serie 00:35:06
y aparece un numerito que hace 0, 00:35:07
un 99%? Pues ese es el 00:35:09
base. ¿Qué es? Es una 00:35:12
memoria temporal que se va 00:35:14
llenando, ¿vale? 00:35:16
Para que tú, cuando vas a procesar 00:35:17
las cosas, en vez de procesar 00:35:20
directamente la fuente, 00:35:21
vas haciendo como 00:35:24
un cojín entre 00:35:26
la lectura desde la fuente y 00:35:27
lo que se está reproduciendo de verdad. ¿Por qué? 00:35:29
Porque si tu 00:35:32
velocidad de red tiene algunas 00:35:33
fluctuaciones, a veces va un poquito más rápida, 00:35:35
a veces un poquito más lenta, no tienes 00:35:38
un parón en tu vídeo 00:35:40
o en tu audio, en tú lo que 00:35:42
estás haciendo, cada vez que tu red va 00:35:44
un poquito más lenta, mantiene un margen 00:35:46
de unos megas 00:35:48
de información, que si la 00:35:50
red, por ejemplo, se bloquea un segundo 00:35:52
pues tú vas tirando de este 00:35:54
buffer y cuando vuelve la red 00:35:56
pues lo rellena otra vez 00:35:57
¿sí? 00:35:59
pues 00:36:03
misma cosa 00:36:03
solo que aquí ahora nuestra fuente de información es el fichero o es internet o es lo que sea 00:36:04
y yo cuando leo del fichero, si todo está bien, lo leo tranquilamente 00:36:14
si hay muchos programas que están pidiendo de fichero, si el disco duro tiene que leer un poco de esto, un poco de esto, un poco de esto 00:36:19
y cosas por el estilo, mientras que el procesador está haciendo otra cosa 00:36:24
entonces un poco me puede hacer caso, pero a veces no me puede hacer caso, está haciendo otros procesos 00:36:28
pues yo tenga 00:36:33
la posibilidad de leer 00:36:35
un trozo y sacar 00:36:37
el trozo de golpe 00:36:40
¿vale? 00:36:41
sustancialmente es 00:36:44
una abstracción más 00:36:45
con respecto al reader 00:36:48
que me permite en vez de leer 00:36:49
carácter por carácter 00:36:52
si el input stream lee byte por byte 00:36:53
el reader permite leer 00:36:56
carácter por carácter 00:36:58
esto permite leer líneas enteras por ejemplo 00:36:59
O sea, una línea entera. 00:37:02
¿Sí? 00:37:04
Este aquí añade uno de los métodos más cómodos para nosotros, que es el Readline. 00:37:06
O sea, lee una línea entera de un fichero. 00:37:10
¿Sí? 00:37:14
Entonces lee todas las líneas hasta llegar a un retorno de tarra, un intro. 00:37:16
¿Vale? Y todo esto me lo devuelve de golpe. 00:37:20
¿Sí? 00:37:23
Irá baserizando todos los caracteres. 00:37:24
¿Qué lee? ¿Leo un carácter? 00:37:28
Es un intro, no. Entonces leer otro. Vale. Es un intro, no. Es otro, es otro. 00:37:30
Cuando encuentras un intro, dice todo lo que has leído aquí en un bonito string 00:37:34
te lo das. 00:37:38
Este de aquí lee bytes, este de aquí lee char, este de aquí 00:37:41
lee string. 00:37:46
¿Todas esas clases serán de file o de cada una de las dos? 00:37:53
No, no. Ninguna es file. 00:37:56
File será el parámetro 00:37:58
que tú pones por algún lado aquí 00:38:01
para decir, oye mira, tú eres un input stream 00:38:03
sí, de qué fichero, de este file 00:38:05
un puntito de la mano 00:38:07
pero el file representa un fichero 00:38:12
esto representa una información 00:38:15
que viene de un fichero, para decirle 00:38:17
para decirle 00:38:19
qué fichero, tú te crearás un file 00:38:21
este es el file, vale 00:38:23
lo pasas como parámetro a este file reader 00:38:25
y ahora tienes algo que lee de ese fichero 00:38:27
estas son 00:38:29
crean tubos de conexión 00:38:34
entre el fichero y tu programa 00:38:37
y cada vez que tu programa 00:38:39
dirá, pilla algo de este tubo 00:38:40
le llegará información desde el fichero 00:38:43
hacia adentro 00:38:45
lo que nosotros 00:38:47
hacíamos con el teclado 00:38:49
solo que en vez del teclado la información viene de un fichero 00:38:50
pues 00:38:54
preguntas 00:38:57
igual que los dos anteriores, pero está mejorado 00:38:59
el funcionamiento es para poder 00:39:06
leer líneas enteras 00:39:07
de caracteres como por ejemplo strings 00:39:10
¿si? 00:39:12
entonces, más o menos 00:39:14
la idea es esta, yo tengo por un lado 00:39:15
posibilidad de manejar 00:39:18
los ficheros, por otro lado posibilidad 00:39:20
de manejar canales de comunicaciones 00:39:21
con este fichero, esto es input 00:39:24
habrá también 00:39:25
output, si input 00:39:27
me permite leer desde 00:39:29
teclado desde el fichero de cosas e incluirla en mi programa en mi programa lo puedo modificar y 00:39:31
hacer lo que me haga cuando los quiero guardar pues lo que hago es escribirlas en un fichero 00:39:39
normalmente el formato de escritura y de lectura tiene que ser el mismo si yo decido guardar mis 00:39:48
mis objetos como cadenas de texto, pues tendré que escribir cadenas de textos y leer cadenas 00:39:54
de textos. No puedo, o es desaconsejado, escribir una cosa y leer otra. Se puede hacer en determinados 00:40:01
Por ejemplo, quiero leer un fichero .txt de la lista de la compra. ¿Qué uso? 00:40:09
De los en negrita. ¿Qué uso? 00:40:23
No, uso password reader. ¿Por qué? Porque en la lista, cada línea será una cosa que quiero comprar, 00:40:44
y le digo, dime la primera, dime la segunda, dime la tercera. ¿Por qué uso reader? 00:40:53
¿Por qué de todas estas uso un blablabla reader? No, no te oí. 00:41:03
¿Y por qué uso un reader? ¿Por qué puedo usar un reader? Claro, porque hemos dicho que yo estoy 00:41:12
leyendo un fichero .txt. Estoy leyendo un fichero de texto. ¿Sí? ¿Lo habéis notado? 00:41:35
Está en un fichero de texto. 00:41:44
Lo ha dicho el profe, pero ¿para qué? 00:41:46
Las limitas soy también. 00:41:51
Vale, entonces uso un líder porque como es un fichero de texto, 00:41:53
voy a utilizar algo que me permite leer carácteres. 00:41:57
Y como es una lista de la compra, 00:42:00
¿y alguna vez en mi vida he hecho la compra? 00:42:03
¿Y me he escrito una lista? 00:42:07
¿Y escribo cada cosa en una línea? 00:42:10
Pues qué buen binario. 00:42:12
Entonces, me puedo imaginar que una lista al ordenador esté hecha de cada producto 00:42:19
en una línea. 00:42:28
Si no, tenéis un problema, ahí lo habláis con vuestro psicólogo. 00:42:30
Por esto, el bachelor en 3D podría ser útil para decir, leo una ley hasta si la escrita 00:42:35
todas separadas por coma, ¿vale? 00:42:40
Que soy raro, pero no tanto. 00:42:42
Pues me leo toda una línea 00:42:43
y luego lo pasa a un split con 00:42:45
regex coma y me la 00:42:48
divide. ¿Sí? ¿Están de acuerdo? 00:42:50
Pero me puede valer, 00:42:52
en un fichero de este tipo, me puede valer 00:42:53
poder leer una string. 00:42:55
¿Vale? Lo leeré varias veces 00:42:58
hasta que haya líneas y cada 00:42:59
línea diré, oh, compra esto también, compra esto 00:43:02
también. ¿Sí? Ahora, 00:43:04
quiero leer 00:43:06
un fichero 00:43:08
audio. ¿Qué uso? Input string. ¿Vale? No puedo leer un reader. ¿Sí? Porque en un fichero de audio 00:43:09
habrá datos, habrá bits, pero estos bits no son caracteres. ¿Vale? Representarán un formato que 00:43:33
sello de la frecuencia que tiene que hacer el no sé qué para poder codificar para decodificar y 00:43:41
modular un determinado sonido vale por lo tanto eso no lo puedo representar como una letra vale 00:43:48
entonces una de estas dos y como es un fichero pues posiblemente optaré por file in bootstream 00:43:53
Que dentro probablemente tenga un inputStream. 00:44:01
¿Sí? ¿Entienden? 00:44:03
Entonces, ¿cuál se usa? 00:44:05
Pues depende de lo que quiero usar. 00:44:07
¿Sí? Dependiendo de lo que quiero 00:44:09
hacer, pues puedo utilizarlo. 00:44:11
Ahora, ¿puedo yo, si tengo 00:44:13
mi fichero de lista de la compra 00:44:15
.txt, utilizar un inputStream? 00:44:17
Sí, ¿por qué no? 00:44:19
¿Vale? 00:44:21
Es decir, lo leeré byte por 00:44:23
byte, será un infierno 00:44:25
porque luego tengo que pillar estos bytes y 00:44:27
yo en mi programa castigarlos a algo que sea leíble como un char y identificar qué char era. 00:44:29
¿Puedo, si yo tengo el fichero de audio, leerlo línea por línea con un buffer reader? Claro, 00:44:37
pero es todavía más infernal porque lo que leeré es una string que no tiene ningún sentido y luego 00:44:48
tendré que pillar char por char, transformarlo a binario y ese binario 00:44:57
interpretarlo como un sonido. La transformación está ahí. Es como cuando abrís en 00:45:01
formato de texto un powerpoint y salen caracteres infernales. ¿Por qué? Porque no 00:45:06
es código de texto, no es texto plano y entonces el bloque de notas intenta 00:45:12
interpretar cada ocho bits como una letra y salen carácteres que 00:45:19
depende de las preguntas muy bien le damos un archivo de texto vale se 00:45:28
utiliza la clave la clase es file reader o va a ser el reader 00:45:39
entonces me creo un file reader no es necesaria aquí lo que voy a crear 00:45:43
directamente aquí, pero bueno, fileReader es igual a null, va a ser el reader es igual a null, ¿vale? 00:45:48
Primero hago un new fileReader con una ruta de archivo, ¿vale? Esta de aquí será el fichero. 00:45:54
Si yo le pongo directamente lista.txt, asumo que el fichero esté en la carpeta principal de mi 00:46:02
proyecto si en vez le pongo una ruta distinta pues 00:46:10
estará donde está la ruta aquí no necesariamente le pongo lista compra 00:46:18
punto txt puedo ponerse dos puntos barra no sé cuánto barra no sé cuánta ancora 00:46:23
barra si para navegar cuidado con poner rutas absolutas porque es la clave para 00:46:28
nos funciona y nosotros ponéis un fichero en el escritorio hacéis vuestro programa en casa luego 00:46:36
lo lleváis aquí diciendo profe mira que funciona y como en el escritorio en parte de la ruta está 00:46:44
vuestro usuario que aquí no tenéis nuestro programa que no funciona pero esto lo sabéis de sobra de 00:46:50
lenguaje marca cuántas veces el lenguaje marca nos ha funcionado el css porque habéis puesto una 00:46:56
ruta absoluta en vez de una ruta relativa 00:47:02
por lo tanto aquí no lo vais a ver este de aquí me crea un file reader una 00:47:08
conexión que puede leer caracteres desde un fichero y este es el fichero 00:47:15
creo que aquí le puedes poner un file en vez de ponerle un string de la ruta le 00:47:21
pones un objeto file. Y luego, por encima de esto, como wrapper a esto, tú dices, me 00:47:28
crea un buffer reader, que es un buffer reader, es un lector que puede hacer strings, ¿vale? 00:47:35
Al que le pasas este de aquí. Sostantivamente está diciendo, yo tengo algo que puede leer 00:47:40
carácter por carácter, ¿vale? Ahora creo algo que usa este leer carácter por carácter, 00:47:44
pero en vez de darme carácter por carácter, me da el string entero. ¿Entiendes? Entonces, 00:47:49
a partir de aquí 00:47:56
br es lo que va a utilizar 00:47:57
es un objeto 00:48:00
mágico, que si yo le digo 00:48:02
léeme una línea, me lee una línea del fichero 00:48:04
sean cuantas sean las líneas del fichero 00:48:06
me creo string línea 00:48:08
y digo, mientras 00:48:10
línea es igual a br.redline 00:48:11
not null 00:48:15
¿qué quiere decir esto? 00:48:16
si, dice, ve a este br 00:48:26
lee una línea 00:48:28
hay dos opciones 00:48:29
o hay una línea para leer 00:48:31
y me la has leído 00:48:33
o no has podido leer nada 00:48:34
bien porque en el fichero no estaba 00:48:37
bien porque has llegado al final del fichero 00:48:39
y entonces me devolverá null 00:48:41
si no es null 00:48:43
mientras que no sea null 00:48:45
quieres decir que algo lo has leído 00:48:47
y te lo has guardado en línea 00:48:49
entonces ahora 00:48:51
lo imprime en pantalla 00:48:52
o lo parcheo 00:48:54
o lo transformo en un objeto 00:48:56
O le cambio la letra B por la letra S. 00:48:58
Lo que tengas dentro de tu programa, ¿vale? 00:49:03
Va a procesar esta línea, ¿sí? 00:49:06
Touch exception, por si cuando hago algo de esto explota, 00:49:10
veréis que ahora os lo pide, os aportáis que las excepciones 00:49:15
había dos tipos, algunas que podías no controlar 00:49:17
y algunas que sí tenías que controlar como las... 00:49:20
Exacto, muy bien, hoy estáis así, ¿eh? 00:49:28
la IO exception, ¿vale? 00:49:31
La excepción es de input-output. 00:49:33
Input-output, pues, eran de las que tenías que controlar, ¿vale? 00:49:35
Entonces, si tú intentas hacer uno de estos de aquí, 00:49:39
Fire Reader o Buzzer Reader, sin poner un try-catch, 00:49:42
te va a decir no. 00:49:46
Tienes dos posibilidades. 00:49:48
O try-catch o throws. 00:49:50
Para poner aquí ese throw, perdón. 00:49:57
Pones que aquí, aquí no está, pero en la declaración del método, 00:49:59
pones que throw esta cosa, entonces 00:50:03
estás diciendo, no, la voy a gestionar yo 00:50:05
esta sección, la va a gestionar quien me 00:50:07
llama. 00:50:09
Muy bien. 00:50:12
Y aquí, finally, 00:50:13
try if the error is not null 00:50:15
a error.cruise. 00:50:17
Esto de aquí, cada vez que abrís un 00:50:19
file reader o cosa por el estilo, 00:50:22
en algún momento de vuestra vida, deberías 00:50:23
cerrarlo. ¿Vale? Todos estos 00:50:25
recursos, lo vimos en el 00:50:27
scanner. 00:50:29
Nosotros hemos creado scanners en nuestra vida 00:50:31
y nunca los hemos cerrado 00:50:33
y hemos ignorado un warning que decía 00:50:34
deberías cerrarlo. Y nosotros, ¿qué más 00:50:36
debemos dar? ¿Vale? Porque nuestros 00:50:38
programas duran 20 segundos, luego 00:50:40
se quitan y entonces 00:50:42
tampoco es un problema. ¿Vale? 00:50:44
Pero si tú te metes a abrir C-Share 00:50:46
o si nunca lo cierras, si nunca lo cierras, 00:50:48
si nunca lo cierras, tienes lo que se llama un 00:50:50
memory leak. O sea que 00:50:52
tu programa 00:50:54
crea recursos y no los cierra. 00:50:56
Crea recursos y no los cierra. Crea recursos 00:50:58
y no los cierra. Y esto, 00:51:00
estos recursos van creciendo 00:51:01
y creciendo y creciendo 00:51:03
y en un mes nada, en tres meses nada 00:51:05
en seis años tienes un programa 00:51:07
que raramente 00:51:09
ocupa el triplo de lo que debería ocupar 00:51:10
dices, ¿por qué será? 00:51:13
o un programa que cada seis meses colapsa 00:51:15
porque le acaba la memoria, lo reinicias 00:51:17
y va todo bien por los dos años 00:51:19
¿eh? por eso 00:51:20
un 95% de los 00:51:24
problemas de informática se solucionan 00:51:26
¡muy bien! 00:51:29
¿Dudas? 00:51:33
¿Se entiende esto? 00:51:35
¿Mecanismo? 00:51:37
¿Sí? 00:51:39
Escritura de un archivo de texto. 00:51:46
¿Vale? Vamos a escribir. 00:51:48
Para escribir, claramente, 00:51:50
no puedo usar ni el Reader, 00:51:52
ni el Input, 00:51:54
ni el Buffer Reader. 00:51:56
Voy a utilizar, en vez de Reader, 00:51:58
Writer. 00:52:00
En vez de Input, 00:52:02
Aquí, por ejemplo, tenemos un FileWriter y un PrintWriter, ¿vale? 00:52:04
Entonces, parecido a antes, me creo un FileWriter, 00:52:12
que sustancialmente es un punto de acceso en salida a un fichero de mi sistema operativo, 00:52:17
y lo involucro en un PrintWriter. 00:52:22
¿Habéis visto alguna vez un PrintWriter en vuestra vida? 00:52:24
Sí, desde el primer día de este curso. 00:52:29
desde que pusiste System.out 00:52:33
System.out 00:52:36
es un objeto de clase 00:52:38
PrintWrite 00:52:40
y que tiene dentro el objeto 00:52:41
el método 00:52:44
Println 00:52:45
que normalmente 00:52:47
en el System.out está conectado 00:52:49
con 00:52:52
la consola 00:52:52
y por lo tanto cuando vosotros hacéis un System.out 00:52:57
Println lo veis en consola 00:52:59
lo que habéis escrito, sin embargo 00:53:01
Pero aquí este printwriter estará conectado con este fichero, entonces que cuando yo escribo 00:53:04
println, ¿dónde escribirá? 00:53:13
Muy bien. 00:53:19
Entonces, por int igual a cero diez veces, tv, que es printwriter, es este objeto de 00:53:20
aquí, está por un lado, este, punto println, ¿vale?, línea, más i, entonces ¿qué hará 00:53:27
este señor? 00:53:34
¿Escriben un fichero o qué? 00:53:35
¿En qué sentido? 00:53:44
No escriben nueve líneas. 00:53:45
¿Qué escriben? 00:53:50
Literalmente esto escribe línea 1, línea 2, línea 3, línea 4, línea 5... 00:53:53
Bueno, concretamente, línea 0, línea 1, línea 2, línea 3, hasta línea 9. 00:53:57
10 líneas 00:54:02
y por cada línea 00:54:04
escribe línea más i 00:54:06
que va de 0 a 9 00:54:07
¿sí? ¿lo veis? 00:54:09
esto crea un fichero 00:54:13
que si yo abro con el 00:54:14
no hace par más más, me encuentro dentro literalmente 00:54:15
línea 0 y debajo línea 1 00:54:18
línea 2 hasta línea 9 00:54:20
¿sí? 00:54:22
bla bla bla se explota 00:54:25
bla bla bla 00:54:26
¿sí? 00:54:27
una pregunta, va a mostrar 10 líneas 00:54:29
¿Puedo mostrar siempre la misma o mostrar una y luego hacer un salto de líneas a la siguiente? 00:54:32
Contéstate. 00:54:40
Lm, next line, ok. 00:54:41
Exactamente como si tú, piensa esto, si en vez de fuera de la prueba fuera de la system.out, 00:54:45
¿qué te daría? 00:54:51
Pues eso, en vez que en consola, es escrito en un fichero, ¿sí? 00:54:52
Falso, esto no va a funcionar en la vida, ¿vale? 00:54:57
Esta es la idea de las cosillas porque Java intenta optimizar las cosas y si vosotros tenéis una empresa de camión y de transporte y una persona, tipo Amazon, imaginaos, y una persona ordena un cepillo de dientes, 00:55:02
¿Vosotros qué hacéis? ¿Lo metéis en el camión y decís, sal, llévalo esto? ¿O esperáis que se llene el camión y cuando está lleno mandáis todo? 00:55:28
Misma cosa, ¿vale? Cuando tú le dices, escribe, escribe, escribe, escribe, él ni te mira, ¿vale? Lo haré, ¿vale? 00:55:39
Es la diferencia entre, por un lado está el mundo de Java y la RAM, y por otro lado está el disco duro. 00:55:47
Disco duro es lento. No quiero trabajar con disco duro. Quiero trabajar con disco duro lo menos 00:55:54
posible. Si me pongo por cada cosa a hacerlo, mi programa va muy lento. Mucho más lento, porque con 00:56:00
respecto a la RAM es horriblemente más lento el disco duro. Vosotros que sois jóvenes, ¿habéis arrancado 00:56:08
alguna vez un ordenador que no tiene ssd ssd si habéis notado diferencia 00:56:17
y hoy en día parece que está roto y ahora lo que hacemos nosotros por esos 00:56:29
viejos toda la vida el ssd mucho más lento de la rama 00:56:35
todos imaginamos todas estas cosas la rama dice ok el programa dice ok lo voy 00:56:40
a hacer me lo guardo aquí y ya cuando tengo suficientes datos para hacerlo de golpe lo voy 00:56:46
a hacer más de aquí por el problema es que en la vista real tú metes muchos datos llegará un 00:56:53
momento que tiene todo suficiente lo guardo lo que sea nosotros no no haremos nunca datos 00:57:01
suficientes entonces por aquí en algún lado habrá un momento en que tú tendrás que decirle vale lo 00:57:05
que tienes guardado ejecútate esfuerzo a ejecutar lo que tú tenías pendiente que tenía marcado en 00:57:11
la dama esto lo voy a escribir vale pues escríbelo de verdad porque yo tendré por un lado el fichero 00:57:18
real y por otro lado una copia de este fichero en la ram y mi programa usa esta copia aquí trabaja 00:57:26
sobre esto lee está inscribe está pero tengo que tener un determinado momento en que digo no 00:57:33
asegúrate que esta copia aquí, ahora la copias aquí. ¿Es lento? Sí, lo sé, pero hazlo, porque si no, lo pierdo. 00:57:38
Nuevamente se hace con un tv.flush, que es como decir, manda. En teoría también cuando hace una close, 00:57:46
como última operación, debería hacer una flash. Pero esto es un territorio raro de Java, en el que 00:57:58
a veces lo hace, a veces no, y a veces 00:58:07
vosotros lo hacéis todo bien y no escribe 00:58:09
nada, y luego le ponéis un flash 00:58:11
por algún lado y de repente escribe. 00:58:13
Vamos a probarlo, ¿vale? 00:58:23
Antes de seguir. En los próximos días 00:58:25
lo que vamos a hacer es 00:58:27
ver otras cosas. Esto, por ejemplo, es un programa 00:58:28
que copia un fichero. 00:58:31
¿Vale? Esta es la copia de un fichero. 00:58:34
Me das un fichero, me das 00:58:35
dónde lo quieres copiar, y yo te copio 00:58:37
esto en otro lado. Y para copiar 00:58:39
un fichero, se usa 00:58:41
input stream y output stream 00:58:43
o sea, se hace byte por byte 00:58:45
porque tú no sabes qué fichero 00:58:47
estás copiando, no copias un fichero de texto 00:58:49
puedes copiar un fichero ejecutable 00:58:51
puedes copiar un fichero de audio 00:58:53
entonces aquí se usa 00:58:54
input stream 00:58:56
luego entraceremos 00:58:58
a trabajar con objetos, ¿vale? 00:59:00
por ahora estamos solo en lectura y escritura de datos 00:59:02
luego decimos, sí, va a ver, pero si 00:59:05
lo que quiero escribir en vez de un texto es un 00:59:07
objeto, ¿qué hago? 00:59:09
lo veremos aquí 00:59:11
Materias:
Programación
Niveles educativos:
▼ Mostrar / ocultar niveles
  • Formación Profesional
    • Ciclo formativo de grado superior
      • Primer Curso
Autor/es:
Stefano Chiesa
Subido por:
Stefano C.
Licencia:
Reconocimiento - No comercial
Visualizaciones:
1
Fecha:
10 de marzo de 2026 - 14:05
Visibilidad:
Clave
Centro:
IES ROSA CHACEL
Duración:
59′ 17″
Relación de aspecto:
1.78:1
Resolución:
1920x1080 píxeles
Tamaño:
497.42 MBytes

Del mismo autor…

Ver más del mismo autor

EducaMadrid, Plataforma Educativa de la Comunidad de Madrid

Plataforma Educativa EducaMadrid