Saltar navegación

20250327 Ficheros_1 - Contenido educativo

Ajuste de pantalla

El ajuste de pantalla se aprecia al ver el vídeo en pantalla completa. Elige la presentación que más te guste:

Subido el 2 de abril de 2025 por Raquel G.

34 visualizaciones

Más información Transcripción

Descargar la transcripción

Venga, vamos allá. 00:00:00
Vale, vamos a hacer una pequeña introducción al acceso a ficheros. 00:00:03
Sí, bueno, entrar dentro de nuestros contenidos, pero vamos a hacerlo a modo de pequeña introducción. 00:00:14
yo estoy 00:00:19
contenta 00:00:30
en general estoy contenta 00:00:32
sí, estoy contenta en general 00:00:34
y todavía queda un mes y pico de curso 00:00:38
para llevarse más alegrías 00:00:42
entonces bueno 00:00:46
¿Estás feliz con este curso? 00:00:48
Yo sí 00:00:50
¿Y tú? ¿Tú cómo estás? 00:00:51
¿Y tú cómo estás? 00:00:54
Vale, pues entonces 00:00:58
como ahora ya que hemos confirmado que estamos 00:00:59
todos contentos, vamos con 00:01:01
la introducción, una pequeña introducción 00:01:03
a César Ficheros, ¿vale? 00:01:05
Sí, eso no demuestra 00:01:07
nada, que yo esté contenta 00:01:09
no significa estar contentísima con todo su peso 00:01:11
Bueno 00:01:13
Bueno, nuestra aplicación de Java 00:01:16
Estábamos en Java, ¿verdad? 00:01:27
Sí, pues en realidad 00:01:30
Da un poco igual en lo que estemos 00:01:32
Pero Java es más completo 00:01:33
Lo tiene todo 00:01:36
Entonces si uno programa en Java 00:01:36
Programa en casi cualquier otra cosa 00:01:38
Bueno, pues nuestra aplicación 00:01:39
Eso 00:01:41
Pues nuestra aplicación Java, ya sabéis que como cualquier aplicación en cualquier otro programa, solamente puede trabajar silencio con datos que estén en su memoria RAM, ¿vale? 00:01:44
Las variables que tenemos aquí, ya sabemos que estas variables están alojadas en la memoria RAM y ahí están los datos. 00:01:58
Nosotros las declaramos, les damos un nombre y operamos con ellas, las mostramos por consola y poco más, ¿vale? 00:02:05
Entonces, ¿de dónde proceden los datos de esas variables? Pues de donde los requisitos de la aplicación te digan. Hasta ahora para nosotros los datos de la aplicación siempre procedían de aplicación que solicita por consola bla bla bla y con esos datos hace bla bla bla. 00:02:14
entonces nuestras aplicaciones hasta ahora 00:02:34
tenían una limitación 00:02:37
lógicamente enorme 00:02:38
de que en tiempo real cuando la aplicación había arrancado 00:02:40
tenía que estar alguien 00:02:43
ahí enfrente sentado 00:02:45
pidiendo los datos que se iban solicitando 00:02:46
bien por consola 00:02:49
si la aplicación era por consola 00:02:50
o bien colocándolo en las áreas de texto 00:02:52
o si era por interfaz gráfica 00:02:55
entonces esa es una 00:02:57
la limitación que hemos tenido hasta ahora con nuestras aplicaciones 00:02:58
que en el tiempo real, en tiempo de ejecución 00:03:01
alguien tiene que estar ahí 00:03:03
dando respuesta a las peticiones 00:03:04
de los datos 00:03:06
primera pega 00:03:07
segunda pega 00:03:10
que ya como ya sabéis cuando el programa 00:03:12
termina toda la memoria 00:03:14
RAM se libera 00:03:16
entonces todos los datos con los que la aplicación 00:03:18
ha trabajado pues se han liberado 00:03:20
y se han ido a la basura 00:03:22
si alguien ha estado delante 00:03:23
mirándolos en consola 00:03:26
y le ha dado tiempo a tomar nota 00:03:28
pues estupendo, pero si no ha habido nadie 00:03:30
delante para mirarlos y tomar nota 00:03:32
pues esos datos se han perdido 00:03:34
¿vale? bueno 00:03:35
obviamente en una aplicación real este no es 00:03:38
el proceder, está claro, en una aplicación 00:03:40
real ya sabemos 00:03:42
que los datos 00:03:44
estarán en una base de datos y así 00:03:46
no se van a perder y aparte 00:03:48
podrá haber muchísimos 00:03:50
porque una base de datos permite un 00:03:51
volumen de datos enorme, podrá haber muchísimos 00:03:54
y además podrán estar estructurados 00:03:56
porque los datos no son una caja 00:03:58
con todo así a mogollón, los datos 00:04:00
si no tienen una estructura 00:04:02
es muy complicado de manejar 00:04:03
entonces como 00:04:06
esto es nuestro 00:04:07
uy Cristian, fuera de ahí 00:04:08
ay Cristian 00:04:12
bienvenido a tu compañero 00:04:13
bienvenido 00:04:16
bueno 00:04:17
entonces los datos no son 00:04:21
solo, ala, una cosa ahí a mogollón 00:04:24
que la aplicación 00:04:26
haga con ellos lo que buenamente 00:04:28
pueda. Si fuera así, las aplicaciones 00:04:30
se complicarían muchísimo. Los datos 00:04:32
están en una base de datos 00:04:34
que además, como habéis estudiado 00:04:36
a lo largo de todo el curso en bases de datos, 00:04:38
tenemos la suerte de que 00:04:41
están estructurados. 00:04:42
Entonces, unos datos 00:04:45
que no están estructurados son inmanejables. 00:04:46
Luego, la base de datos siempre es la mejor opción. 00:04:48
Bases de datos, 00:04:51
pues tenemos las bases 00:04:52
de datos SQL, 00:04:54
las que llamamos relacionales, 00:04:56
que se organizan en tablas, que son 00:04:58
las únicas que habéis estudiado 00:05:00
y que además de 00:05:02
organizarse en tablas 00:05:04
nos ofrecen un lenguaje 00:05:05
de consulta y de 00:05:08
modificación de los datos, el SQL. 00:05:10
Y luego están 00:05:12
las bases de datos 00:05:13
no SQL. 00:05:15
No SQL viene de 00:05:19
not only SQL. 00:05:21
Las bases de datos no SQL 00:05:25
no guardan los datos en tablas 00:05:27
sino que los guardan 00:05:29
en lo que se llama documentos 00:05:32
en general 00:05:34
el acrónimo no es not only 00:05:34
si es confuso verdad 00:05:37
es lo peor que he visto nunca 00:05:39
not only SQL 00:05:41
no SQL pero la vez de eficaz 00:05:42
no solo SQL 00:05:45
pues si o estoy mal informada 00:05:46
o recuerdo mal 00:05:49
o eso es de not only 00:05:50
me parece el peor acrónimo de mi vida 00:05:52
otra cosa es que 00:05:54
IFEMA es peor 00:05:55
y FEMA no, y FEMA está bien 00:05:57
pero los nombres que te van a poner en FEMA Feria de Madrid 00:05:58
al lado 00:06:01
y FEMA ya son por si las siglas 00:06:02
de Feria de Madrid 00:06:05
sí, pero y, la y de que viene 00:06:07
no me acuerdo, pero como era 00:06:09
era como súper redundante 00:06:10
sí, y FEMA 00:06:13
te aclaran, Feria de Madrid por si no te has enterado 00:06:15
doble vez de Feria de Madrid 00:06:17
bueno, pues estas son malas 00:06:18
no, hoy es el jueves 00:06:21
que guardan los datos en documentos 00:06:23
documentos que también tienen que tener 00:06:25
una estructura, los datos tienen que tener una estructura 00:06:28
es que no nos vale... Ana 00:06:30
entonces los documentos 00:06:31
también tienen que tener una estructura, no nos vale 00:06:36
ala, todos hay documentos 00:06:38
de cualquier manera, entonces como 00:06:40
los documentos tienen que tener una estructura 00:06:42
también 00:06:44
pues esos documentos 00:06:44
o tienen la estructura de XML 00:06:47
que también conocéis 00:06:50
bueno, pues los ficheros XML 00:06:51
aparte de la información en sí 00:06:55
que está en los nodos 00:06:57
tiene la jerarquía que te permite 00:06:58
entender de qué va eso 00:07:01
el hecho de que un nodo cuelgue de otro 00:07:03
ya te da información 00:07:05
bueno, pues el fichero XML 00:07:06
te da algo de estructura 00:07:08
que son horribles 00:07:11
los XML 00:07:13
pero a ti te parecen horribles muchas cosas 00:07:14
la interfaz gráfica 00:07:17
todo te parece horrible 00:07:19
eres muy negativa 00:07:20
Bueno, pues XML y otra forma de estructurar un documento es esta. 00:07:22
Bueno, esto es lo que a bases de datos se refiere. 00:07:39
Esta es la foto o el panorama de las bases de datos con las que nosotros trabajaremos el año que viene para acceder a nuestros datos, etc. 00:07:43
esta de aquí 00:07:52
esta de aquí 00:07:55
es la opción de Google 00:07:59
por ejemplo, ¿vale? 00:08:01
la opción de Google es esta de aquí 00:08:02
entonces algo cómodo y algo bueno tendrá 00:08:04
ya veremos 00:08:07
bueno, pues a veces 00:08:08
no es necesario fletar toda una base 00:08:11
de datos gigante con toda 00:08:13
la complicación que 00:08:15
implica el hacer el diseño de las 00:08:17
tablas de las relaciones, a veces no hace falta 00:08:19
fletar una base de datos entera 00:08:21
no nos gusta fletar bases de datos 00:08:22
¿qué es fletar? 00:08:25
perdón 00:08:28
bueno, a ver, fletar de toda la vida 00:08:29
es poner a disposición 00:08:32
una cantidad de recursos 00:08:33
cuando tú fletas una flota 00:08:34
¿no puedes fletar una flota? 00:08:36
suena raro, pero sí 00:08:38
bueno, da igual 00:08:39
a veces no hace falta poner en marcha 00:08:41
toda una base de datos con todo lo que implica 00:08:44
que eso sí que lo habéis vivido 00:08:46
de hacer un diseño entidad-relación 00:08:47
Pasarlo al modelo relacional, normalizarlo, etc 00:08:50
A veces no merece la pena 00:08:52
Sino que tenemos 00:08:54
Una opción B 00:08:56
Para guardar nuestros datos 00:08:57
De forma permanente 00:09:00
De tal manera que 00:09:01
Cuando la aplicación se cierra 00:09:03
No se pierda sin más 00:09:06
Que son los ficheros 00:09:07
Bueno, pues los ficheros 00:09:09
Es que los tenemos ahí 00:09:13
En cualquier sistema operativo tenemos los ficheros 00:09:15
Pues ya está, entonces en una aplicación más 00:09:17
a lo mejor de un ámbito más reducido 00:09:20
o privada nuestra 00:09:22
pues para qué montar este rollo 00:09:24
podemos organizar la información 00:09:25
en ficheros y ya está 00:09:28
y aquí pues entonces 00:09:29
ya Java nos ofrece 00:09:32
Java nos ofrece 00:09:33
unas herramientas para acceder 00:09:36
de forma sencilla a ficheros 00:09:38
calla 00:09:40
pero aquí es donde, calla el que sea 00:09:41
calla en general 00:09:43
aquí es donde 00:09:45
vosotros haríais la pregunta 00:09:47
o más que la pregunta, el comentario 00:09:50
pero ficheros, hay un montón 00:09:52
de tipos de ficheros distintos 00:09:54
entonces, no es lo mismo 00:09:56
acceder a un fichero de texto 00:09:58
que como bien sabéis, es una secuencia de bits 00:10:00
donde cada pack de 8 00:10:02
se interpreta como una 00:10:04
correspondencia en la tabla ASCII con un carácter 00:10:06
correspondiente, como un fichero 00:10:08
binario de 00:10:10
Word, que lo que tiene ahí no tiene que ver 00:10:12
con la tabla ASCII, o como un fichero 00:10:14
o de un ejecutable. 00:10:16
Hay de muchos tipos. 00:10:18
Si es cierto, hay de muchos tipos. 00:10:20
Pero esencialmente, Java 00:10:22
los distingue en dos 00:10:24
clases grandotas. 00:10:26
Los ficheros 00:10:28
que se asume que tienen 00:10:29
texto 00:10:32
y los ficheros 00:10:32
mal llamados 00:10:35
binarios. Digo mal llamados 00:10:37
porque es que todos son binarios. 00:10:40
A día de hoy, todos los ficheros 00:10:42
de nuestras maquinitas 00:10:44
Pues están compuestos por ceros y unos 00:10:45
Ya está 00:10:48
De hecho, me cabe la duda de si ahora mismo 00:10:49
Ahí existieran 00:10:51
Existen sistemas de almacenamiento 00:10:54
Donde puedes 00:10:56
En más de dos bits 00:10:56
Cero, uno y cero, cincuenta 00:10:59
La computación cuántica que está en cero, uno y todos los estados intermedios 00:11:00
Esa era mi duda, ahora mismo 00:11:03
Entonces ahí tienes muchísima más capacidad 00:11:05
De almacenamiento 00:11:08
Porque en cada biestable o cada condensador 00:11:08
O cada cosa 00:11:11
Que en ese caso no serán condensados, ya lo que sea 00:11:12
claro, no 00:11:15
tiene solamente la posibilidad de guardar dos datos 00:11:16
0, 1, sino una cantidad de datos 00:11:19
pero bueno, no estamos con ordenadores de computación 00:11:21
cuántica y nada de eso 00:11:23
con lo cual hasta donde nosotros sabemos ya está 00:11:24
donde vais a llegar a trabajar seguramente 00:11:27
muchísimo tiempo más 00:11:29
No, no me refiero porque 00:11:30
esa tecnología no creo que llegue 00:11:35
a las máquinas de uso 00:11:36
generalizado en mucho tiempo 00:11:41
Y ya Google permite acceder a sus ordenadores cuánticos antes de que hagan pruebas y todo. 00:11:43
¿Y es por qué se ha colado en las encuestas cuánticas? 00:11:48
Pues bueno, no corren. 00:11:51
Hay que pedir plaza, hay que pedir que no se cuelguen. 00:11:53
Un chip. 00:11:56
¿Cuánto corren? 00:11:57
No corren un chip. 00:11:58
Bueno, pero ¿qué hacemos? ¿Ignoramos los ficheros cuánticos? 00:12:00
Sí, más que nada, porque no sé si Java te deja acceder a ficheros cuánticos. 00:12:04
No creo. 00:12:09
Pero a ver, si Google tiene una API 00:12:09
Pues desde Java 00:12:12
Lo que se puede hacer es consumir cualquier API 00:12:13
Javi la 00:12:16
Javi no, Java 00:12:17
Consumiría ese API y ya está 00:12:18
¿Vale? 00:12:21
Entonces, Google como cualquier otra 00:12:23
Plataforma que ofrece herramientas para 00:12:26
Desarrolladores 00:12:27
Que Google es una de ellas, pues Microsoft es otra 00:12:28
Todas las plataformas que ofrecen herramientas 00:12:31
Para desarrolladores 00:12:33
Las ofrecen articuladas en torno 00:12:34
A APIs 00:12:37
y APIs son métodos 00:12:38
que te dan y te dicen 00:12:41
tú desde tu aplicación, me da igual que sea Java 00:12:42
que sea Python, desde tu aplicación 00:12:44
llama a esta función 00:12:46
y yo ya me encargo en mis ordenadores cuánticos 00:12:47
donde sea, hacer lo que sea y te devuelvo el resultado 00:12:50
¿vale? 00:12:52
entonces muchas veces efectivamente 00:12:54
tiramos de servicios que ya tienen 00:12:56
hecho esas plataformas, pues el de autenticación 00:12:58
que lo tiene Google, todos esos, tiramos 00:13:00
desde nuestros propios códigos 00:13:02
llamamos a esos métodos 00:13:04
que son lo que ellos llaman 00:13:07
APES, ellos y nosotros 00:13:08
esto todo venía a cuento de que 00:13:09
si ellos nos permiten usar 00:13:12
almacenamiento cuántico 00:13:13
en sus ordenadores, pues desde nuestra aplicación 00:13:15
Java podríamos llamarlo de esa función 00:13:18
vale, pero esa es una situación 00:13:20
muy concreta en la que no estamos 00:13:21
veníamos a cuento de que 00:13:23
Java distingue 00:13:26
de texto y binarios 00:13:28
entre comillas, aunque esta es una traducción 00:13:30
repito, poco afortunada porque todos 00:13:32
son binarios 00:13:34
¿Y por qué hace esta división tan grosera? 00:13:35
Porque es que es imposible hacer una división más afinada 00:13:40
Porque es que ficheros hay de muchísimos tipos 00:13:42
Tantos como aplicaciones distintas tengamos 00:13:44
Entonces Java te puede ofrecer métodos para algunos de los más conocidos 00:13:46
Te puede ofrecer métodos para acceder de forma fácil a XML 00:13:53
Por ejemplo, o para acceder de forma fácil a JSON 00:13:57
pero no te puede ofrecer métodos para acceder 00:14:00
de forma fácil a todas las 00:14:02
extensiones y formatos 00:14:05
de archivo que hay, entonces los mete todos 00:14:07
en el pack de binarios 00:14:09
que son, yo te ofrezco leer 00:14:10
la secuencia de bits y luego tú haces la interpretación 00:14:12
que sea, bueno 00:14:14
y luego tenemos 00:14:16
este otro grupo 00:14:18
que este es el que, para el que realmente 00:14:19
es interesante los métodos 00:14:22
que te ofrece Java, porque cuando 00:14:25
uno tiene que leer archivos 00:14:26
Word, archivo, lo que sea, pues no lo va a hacer 00:14:28
Desde Java, obviamente 00:14:30
Archivos XML y JSON sí 00:14:31
Pero cuando uno va 00:14:34
A trabajar con archivos 00:14:36
De tipos tan genéricos, es que no lo va a hacer desde Java 00:14:38
Entonces lo que realmente 00:14:40
Nos interesa 00:14:42
Porque sí, que puede tener cierto uso 00:14:44
Aprender a hacer desde Java 00:14:46
Es acceso a ficheros de texto 00:14:48
Porque en un fichero de texto es facilísimo 00:14:50
Guardar la información 00:14:52
Acceso a ficheros de texto 00:14:53
Y luego ver en general como movilizar 00:14:55
de un lado a otro para copiar 00:14:58
para hacer cosas, ficheros 00:15:00
ya genéricos, binarios 00:15:02
entonces vamos a empezar con 00:15:03
qué posibilidades nos ofrece Java 00:15:06
para trabajar con un fichero de todos 00:15:08
bueno pues 00:15:09
las clases que vamos a mencionar 00:15:25
las poquitas clases que vamos a mencionar 00:15:27
para hacer esta introducción 00:15:29
que no vamos a hacer hoy toda 00:15:31
para hacer esta introducción 00:15:32
están en 00:15:34
este paquete 00:15:36
java.io 00:15:38
¿Vale? 00:15:40
Menudo 00:15:44
Vale, pues este tiene prácticamente 00:15:44
Todas las clases que se usan cuando uno tiene que hacer 00:15:47
Un acceso a ficheros 00:15:49
Normalucho y corrientucho 00:15:50
Luego cuando hay, cuando tenemos que hacer 00:15:53
Acceso a ficheros específicos 00:15:55
Como xml, json 00:15:57
Archivos de propiedades, de properties 00:15:58
Archivos de logs, que son archivos específicos 00:16:01
Para esas librerías específicas 00:16:03
Y todo eso pues ya lo veremos 00:16:05
El año que viene 00:16:07
acceso a archivos específicos 00:16:07
de logs, de propiedades, de no sé qué 00:16:10
¿vale? eso tiene sus paquetes específicos 00:16:11
pero los genéricos para acceso 00:16:14
a ficheros 00:16:16
de forma genérica en este paquete 00:16:17
tenemos 00:16:20
también, por si estudiáis 00:16:23
por ahí, lo veis, este de aquí 00:16:25
que se incorporó un poquito 00:16:27
más tarde, que incorpora algunas cositas 00:16:29
útiles a este 00:16:31
¿vale? 00:16:32
bueno, pues entonces 00:16:35
Y vamos a ver un poquito acceso a ficheros de texto 00:16:36
Para poder hacer ya alguna otra aplicación 00:16:40
Con interfaz gráfica 00:16:43
Que haga cosas un poquito más interesantes 00:16:44
Vale 00:16:47
Clases involucradas 00:16:48
Para hacer un archivo a ficheros de texto 00:16:53
Bueno, pues hay dos cosas que se puede hacer con un fichero de texto 00:16:55
Leer de él 00:17:00
Y claro, efectivamente 00:17:02
Y escribir en él 00:17:06
leer del fichero implica 00:17:08
mover 00:17:13
del fichero 00:17:14
el contenido que tiene 00:17:17
moverlo a variables 00:17:18
eso es leer 00:17:20
la información 00:17:23
que tiene el fichero, moverlo a variables 00:17:26
de la aplicación 00:17:28
y luego ya la aplicación con las variables hace lo que quiera 00:17:29
y escribir ¿qué es? 00:17:32
pues escribir es 00:17:35
de variables 00:17:36
que tienen los datos de la aplicación, 00:17:38
de variables que tienen los datos, 00:17:42
moverlo al fichero. 00:17:45
Entonces, estamos hablando ahora mismo solo de texto. 00:17:48
Entonces, 00:17:53
o el fichero se abre para leer 00:17:54
o se abre para escribir, 00:17:57
o una cosa o la otra. 00:17:58
No se puede simultáneamente leer y escribir. 00:18:00
No se puede. 00:18:03
Entonces, si quisiéramos, 00:18:05
Por ejemplo, si tenemos un fichero y quisiéramos modificar algo de lo que tiene, es decir, que implica leer, cuando he llegado a lo que quiero modificar, modificarlo, pues no podemos abrirlo para leer y escribir a la vez, no podemos. 00:18:06
Tendríamos que hacerlo siempre a través de un fichero intermedio. 00:18:22
Luego en el cambio, a ver si me da el otro roto. 00:18:26
Tendríamos que hacerlo a través de un fichero intermedio. 00:18:29
y entonces a través del fichero intermedio 00:18:32
iríamos 00:18:34
leyendo y copiando 00:18:36
lo que yo quiero mantener 00:18:38
cuando leo lo que quiero sobrescribir 00:18:39
lo sobrescribo 00:18:42
y en lugar de copiar lo que he leído 00:18:44
copio la otra cosa 00:18:46
y sigo leyendo 00:18:48
y copiando tal cual 00:18:50
¿vale? entonces si queremos un fichero 00:18:51
que ya tiene algo, modificarlo 00:18:54
y sobrescribir algo sobre él 00:18:56
pues tenemos que hacerlo a través de uno intermedio 00:18:57
¿vale? 00:19:00
Este se abriría para leer y este para escribir. 00:19:02
Iríamos leyendo y copiando, leyendo y copiando. 00:19:06
Cuando encontramos eso que queríamos sobreescribir, 00:19:09
pues en lugar de copiarlo tal cual, escribimos lo nuevo. 00:19:13
Y luego seguiríamos leyendo y copiando. 00:19:17
Como cuando trabajábamos con un array que queríamos modificar una posición, 00:19:19
pues hacíamos a veces lo mismo. 00:19:23
Hacíamos un array auxiliar. 00:19:25
Leíamos y copiábamos lo que no queríamos tocar. 00:19:27
cuando llegábamos a la posición que queríamos 00:19:30
sobreescribir, la escribíamos 00:19:32
modificada en el otro 00:19:35
y luego ya queda lo que hacíamos por último 00:19:36
sustituir uno por otro 00:19:38
pues aquí sustituir implicaría 00:19:40
cambiar el nombre, o sea eliminar 00:19:42
este, este a la basura 00:19:44
y a este darle el nombre 00:19:46
que tenía este 00:19:48
el objeto referencia en la variable 00:19:49
si el fichero 00:19:56
no será el mismo en el disco duro 00:19:58
O sea, este lo has eliminado y tienes otro distinto 00:20:00
Otro fichero 00:20:02
Con el contenido que tú quieres 00:20:04
Y con el mismo nombre que tenía 00:20:06
Pero vamos, que eso nos da igual 00:20:07
En el disco duro, el apaño que haya hecho él 00:20:09
Pero realmente el fichero físicamente es otro 00:20:12
Como tiene el mismo nombre 00:20:14
Y este se ha eliminado, efectos prácticos es lo mismo 00:20:16
¿Vale? 00:20:18
Pues entonces esa es la primera cosa que tiene que quedar clara 00:20:19
Que de un fichero 00:20:22
O bien lo abrimos solamente 00:20:24
Para leer de él 00:20:25
Y coger sus datos e irlos llevando a variables 00:20:27
o bien lo abrimos 00:20:30
para escribir en él 00:20:32
e irle mandando la información que hay en variables 00:20:33
o una cosa o la otra 00:20:36
simultáneamente las dos no 00:20:37
luego 00:20:39
como consecuencia 00:20:41
si quisiéramos hacer algo tipo esto 00:20:43
un archivo, irlo leyendo 00:20:45
para ver la información que tiene 00:20:47
pero en algún momento escribir además 00:20:49
a través de uno intermedio 00:20:50
el que se ha llamado de toda la vida 00:20:52
en la teoría antigua de la informática 00:20:54
el fichero de maniobra 00:20:57
Pero ahora ya como no se estudian ficheros en informática, bueno, igual sí que se estudian, pues ya ese término se queda muy antiguo, el fichero de maniobras, ¿vale? 00:20:58
Bueno, pues entonces nos ofrece leer o escribir, ¿vale? 00:21:07
Para leer nos ofrece esta clase, FileReader, y para escribir nos ofrece esta otra, FileWriter. 00:21:11
Estas clases tienen métodos que son los que nos permiten hacer esta operación. 00:21:27
Entonces, clase que necesitamos instanciar cuando queremos leer de un archivo para pasarla a variables 00:21:36
y clase que necesitamos instanciar cuando queremos escribir en un archivo la información que esté en las variables. 00:21:43
ahora ya lo haremos en un ejemplo 00:21:51
pero para que nos vaya sonando 00:21:57
bueno pues que métodos son los que nos ofrece 00:21:59
el objeto que instanciemos 00:22:01
bueno pues 00:22:03
como no podía ser 00:22:05
de otra manera 00:22:07
el método que nos permite leer 00:22:08
se llama 00:22:11
así 00:22:13
no esa es la clase 00:22:14
la clase te ofrece métodos 00:22:17
Pues este método 00:22:19
Este método 00:22:22
Que ahora lo usaremos 00:22:26
¿Qué es lo que hace? 00:22:27
Pues este método 00:22:29
Te coge un carácter 00:22:30
Un carácter del archivo 00:22:34
Y te lo lleva la variable 00:22:36
Que tú le digas 00:22:38
Son clases 00:22:39
Son clases que tú 00:22:44
Las clases no son estáticas 00:22:46
A ver, son clases que tú tienes que asociar 00:22:47
al archivo en particular 00:22:51
con lo cual no son 00:22:53
objetos estáticos 00:22:56
tu pregunta era 00:22:57
si estos métodos se usan de forma 00:22:59
estática en estas clases 00:23:01
en realidad no, porque 00:23:03
cuando tú instancies un file reader 00:23:05
lo tendrás que instanciar asociado 00:23:07
a un archivo en concreto 00:23:09
con lo cual no puede ser estático 00:23:10
porque depende del archivo en concreto al que esté asociado 00:23:13
si tú quieres leer de tres archivos 00:23:16
cada file reader 00:23:17
estará asociado a un archivo distinto 00:23:19
luego los métodos no son estáticos 00:23:21
los métodos se asocian 00:23:23
a un objeto file reader que a su vez 00:23:26
está asociado a un archivo 00:23:27
con lo cual cuando se llame a read 00:23:29
se hará la lectura del archivo 00:23:31
al que está asociado el file reader 00:23:34
esto es un poquito para ver por encima 00:23:35
la filosofía de funcionamiento 00:23:37
pero en un ejemplo pues se ve mejor 00:23:39
uy que ruto 00:23:41
vale 00:23:44
el método mueve 00:23:45
un carácter a una variable y de nuevo me diréis cuál es el carácter porque el fichero tendrá 00:23:47
muchos bueno pues cuando el fichero está recién abierto es decir cuando este objeto está recién 00:23:55
instanciado asociado este archivo hay una especie de puntero interno al que no podemos acceder 00:24:00
que inicialmente está apuntando al primer carácter entonces cada real tele un único carácter 00:24:08
que queda apuntado 00:24:15
bajo ese posicionador, ese puntero 00:24:17
entonces el primer read que hagamos 00:24:20
el primero de todos 00:24:22
nos lee el primer carácter 00:24:23
que luego hacemos otro read después 00:24:25
pues ese otro read nos leerá el segundo 00:24:27
que luego hacemos otro read 00:24:29
pues ese otro read nos leerá el tercero 00:24:31
que queremos 00:24:33
leer todo el contenido del archivo 00:24:35
pues tendremos que hacer un bucle 00:24:37
de muchos read e ir concatenando 00:24:39
todos esos caracteres 00:24:42
que nos va dando 00:24:44
vale, entonces diréis 00:24:46
ya y como sé yo que he terminado 00:24:48
porque cuando yo abro un archivo 00:24:50
instancio un archivo, no tengo por qué saber ese archivo 00:24:52
cuántos bytes tiene 00:24:54
como sé yo cuántos read tengo que hacer 00:24:56
si es que quiero leerlos todos 00:24:58
bueno, pues afortunadamente 00:25:00
read tiene 00:25:01
una forma de avisarte 00:25:04
de que ha terminado el archivo 00:25:05
una forma sencilla que es 00:25:08
devolviéndote 00:25:10
el numerito menos uno 00:25:11
es decir, read 00:25:14
está pensado en realidad 00:25:16
aunque te lee un único carácter 00:25:18
lo que te devuelve no es una variable char 00:25:20
read lo que te devuelve 00:25:23
es una variable entera 00:25:25
una variable entera 00:25:27
esto ya no vale para nada 00:25:30
y te guarda el char que ha leído 00:25:33
el char que ha leído te lo guarda 00:25:35
en el byte 00:25:38
menos significativo del entero 00:25:39
es lo que hace read 00:25:42
te coge un carácter, el que toque en ese momento 00:25:43
recordad que van en secuencia 00:25:46
te lee un carácter 00:25:49
el que toque en ese momento 00:25:50
y te lo guarda en el byte menos significativo 00:25:51
de una variable entera 00:25:54
que es la que te devuelve como valor de retorno 00:25:56
y con el resto que hace 00:25:58
con el resto te lo devuelve 00:26:00
todo así con un montón de ceros 00:26:01
con 24 ceros 00:26:03
y diríais 00:26:06
¿qué necesidad tiene 00:26:09
de ese carácter que ha leído 00:26:11
devolvértelo guardado en una variable entera 00:26:13
n que le sobra espacio 00:26:16
que te lo devuelva en una variable char 00:26:17
o en una variable char cabe 00:26:20
bueno pues precisamente el sentido que tiene esto 00:26:21
es habilitarse 00:26:24
la opción de avisarte 00:26:26
de que ha llegado al final 00:26:27
porque 00:26:29
sea cual sea el char que lea 00:26:30
sea cual sea 00:26:34
si esto lo interpretáramos 00:26:35
como número entero 00:26:37
siempre sería positivo 00:26:38
porque el bit de signo es positivo 00:26:40
luego si hiciéramos 00:26:42
si no hiciéramos el casting a char de esto 00:26:45
porque al hacer el casting a char de esto 00:26:47
cuando uno hace el casting a char 00:26:49
ya se queda con esta parte 00:26:51
que es la que queremos 00:26:53
pues si no hiciéramos el casting a char 00:26:53
e interpretáramos directamente el número como entero 00:26:56
siempre sería positivo 00:26:59
sería el que fuera pero sería positivo 00:27:00
porque el bit de signo es cero 00:27:03
bueno pues si cuando read 00:27:04
te devuelve algo 00:27:07
que he interpretado como un numerito 00:27:08
entero n sin hacer el char 00:27:10
es menos 1 00:27:12
entonces es la forma de avisarte de que 00:27:13
no, perdona, es que estás intentando ya leer 00:27:16
en el final 00:27:18
después de haberte pasado el último 00:27:20
es su forma de avisarte, es que ya no hay más que leer 00:27:22
es que ya se ha acabado, ya no hay más 00:27:24
y no hay ninguna confusión posible 00:27:26
porque si te devuelve menos 1 00:27:29
es porque aquí el bit de signo es 1 00:27:30
con lo cual no ha hecho la lectura 00:27:33
correctamente 00:27:37
a ver si tú lo casteas a chat 00:27:37
te saldrá lo que sea 00:27:41
pero que necesidad tienes de castearlo 00:27:42
porque ya sabes que eso no 00:27:43
si hubiera leído algún carácter 00:27:45
Pablo, si hubiera leído algún carácter 00:27:48
que no fuera el fin de archivo 00:27:51
te lo habría rellenado todo a ceros 00:27:52
entonces no habría sido menos uno 00:27:54
pero si has leído el carácter del fin de archivo 00:27:56
te devuelve el menos uno 00:27:59
que es esto a uno 00:28:00
y lo demás pues no sé si te da uno 00:28:01
o como sea da igual 00:28:03
entonces pues 00:28:04
pues por ejemplo 00:28:06
vamos a leer un archivo cualquiera de texto 00:28:08
con esto 00:28:10
para que veáis 00:28:11
que fácil es 00:28:17
y en realidad 00:28:18
bastante útil porque hay muchos archivos 00:28:21
de texto a veces que necesitamos 00:28:23
dígame 00:28:24
uff 00:28:26
hay 00:28:28
como a ver 00:28:29
hay acceso a bases de datos 00:28:32
pero no nos va a dar tiempo a dar 00:28:33
os recuerdo 00:28:35
que 00:28:36
esta semana o la siguiente 00:28:39
teníamos el examen. 00:28:42
Y bueno, y tenemos. 00:28:45
Tenemos. 00:28:47
A ver, 00:28:50
era... 00:28:51
¿Qué día lo habíamos puesto? Que me acuerde yo. 00:28:52
El 7. 00:28:58
Seguro, pero... 00:29:00
¿Al final habíamos decidido que dejábamos a Rosa? 00:29:02
Tranquila. 00:29:05
el 7 de abril, lo habíamos puesto el 7 de abril seguro 00:29:06
el lunes 7 de abril 00:29:09
después de todas las idas y venidas 00:29:11
con Estefano 00:29:12
vale, bueno 00:29:14
pues os recuerdo eso 00:29:25
que en nada tenemos un examen 00:29:26
vacaciones 00:29:29
no, es que tenía yo 00:29:30
la cabeza me puse fatal, tenía yo el recuerdo 00:29:33
de que íbamos a hacer 00:29:35
un change con Rosa 00:29:37
bueno 00:29:39
nada, olvidadlo 00:29:40
lo último que os dije 00:29:44
a vosotros es el 7 00:29:47
pues sería que yo me he quedado 00:29:48
en una fase anterior, mi cerebro 00:29:51
desconectó a partir de ahí 00:29:53
pues 00:29:54
claro, no, porque 00:30:00
un jueves para dejarle a 00:30:02
el jueves 27 lo descartamos 00:30:05
era una propuesta que habíamos hecho 00:30:08
y lo descartamos 00:30:10
perdón, el 3 00:30:11
el 3 hicimos esa propuesta 00:30:14
y luego la descartamos 00:30:16
y después de esa 00:30:17
que es en la que yo me quedé 00:30:20
lo habíamos quedado en el 7 00:30:21
y luego 00:30:23
os recuerdo que 00:30:27
a la vuelta de Semana Santa 00:30:29
venimos, nos vamos de Puente de Mayo 00:30:32
y venimos a examinarnos. 00:30:34
No, yo no. 00:30:38
El calendario escolar. 00:30:40
A ver. 00:30:43
Silencio. 00:30:45
Uy, eso es una buena... 00:30:48
Vale, pues venga. 00:30:51
Lo primero vamos a hacernos el fichero 00:30:54
que queremos leer. 00:30:55
Vale, por ahora para no complicarnos la vida 00:30:57
porque recordad que un fichero 00:31:00
está ubicado dentro del sistema de ficheros 00:31:03
del sistema operativo 00:31:06
y el sistema de ficheros del sistema operativo no es plano 00:31:07
no están todos los ficheros puestos ahí a mogollón 00:31:11
el sistema de ficheros de cualquier sistema operativo 00:31:13
al menos hasta donde yo creo 00:31:19
suele estar organizado de forma jerárquica 00:31:21
para facilitarnos la búsqueda de los archivos 00:31:24
entonces cuidado porque un archivo 00:31:26
se caracteriza no solo por su nombre 00:31:29
sino también por la ubicación 00:31:32
donde está dentro del sistema de archivos 00:31:36
entonces cuando nosotros le indiquemos un archivo a Java 00:31:38
aparte del nombre tendremos que indicarle la ubicación 00:31:41
donde está, efectivamente la ruta absoluta 00:31:44
o relativa respecto a algún punto 00:31:48
bueno, pues ahora mismo en este primer ejemplo 00:31:50
para no complicarnos la vida con la información 00:31:54
de la ruta, vamos a colocar 00:31:57
el fichero 00:31:59
donde para Java 00:32:00
es la ruta por defecto 00:32:02
que es la raíz del proyecto 00:32:05
entonces 00:32:07
la raíz del proyecto es su ruta por defecto 00:32:09
si nosotros le damos una ruta 00:32:11
relativa, él va a entender 00:32:13
que es a partir de la raíz 00:32:16
del proyecto y si le damos una absoluta 00:32:18
pues es la absoluta y ya está 00:32:20
bueno, pues entonces vamos a crearnos un fichero 00:32:21
de texto 00:32:23
a Ana 00:32:24
en la propia raíz del proyecto 00:32:27
pues pincháis 00:32:29
y os creáis un nuevo 00:32:31
file, venga 00:32:35
en el propio raíz un nuevo 00:32:36
file y así no nos complicamos la vida 00:32:39
como queráis 00:32:41
por ejemplo 00:32:43
un archivo de nombres 00:32:45
venga 00:32:47
nombres.txt 00:32:48
a ver, la extensión en realidad me da igual 00:32:50
ya sabéis que lo de las extensiones es informativo 00:32:53
para el que lo está mirando 00:32:55
Y algunas aplicaciones 00:32:57
Pues a lo mejor usan la extensión para hacer cosas 00:32:59
Pero no hay ninguna obligación 00:33:01
El fichero puede ser de texto aunque no tenga 00:33:03
Extensión .txt, lógicamente 00:33:05
Bueno, vamos a poner nombres 00:33:06
Siempre 00:33:09
En Venezuela 00:33:14
Tenéis que poner fulanito, menganito 00:33:16
¿Qué elegís? 00:33:19
O sea, Pepito, Juanito, ¿qué elegís? 00:33:20
Porque yo los pongo 00:33:23
Pero es que aquí es Pepito, Juanito, siempre 00:33:24
Bueno 00:33:26
No, porque me gusta a mí 00:33:33
Vale, entonces lo pongo así 00:33:37
Venga, Pepito, Juanito y Luis 00:33:40
¿John no ha venido? 00:33:44
Vale, este es nuestro archivo 00:33:48
Que está en la ruta por defecto 00:33:50
Del sistema de la máquina virtual 00:33:52
Con lo cual nos ahorra la vida 00:33:54
Ahora vamos a hacer nuestra aplicación 00:33:55
Hacemos un paquete 00:33:58
Pues para 00:34:02
Claro, lo he hecho 00:34:02
New file y luego ya lo he abierto 00:34:05
Y cuando yo lo abro 00:34:07
Él me lo abre en un editor 00:34:08
De texto 00:34:11
¿Vale? Entonces, esto de aquí es un editor 00:34:12
De texto 00:34:15
Entonces, si yo abriera 00:34:16
Aquí un archivo cualquiera 00:34:19
El sistema operativo que no fuera texto 00:34:21
Él al abrírmelo con un editor de texto 00:34:23
me mostraría ahí fantasmitas 00:34:25
claro, me mostraría 00:34:27
los fantasmas que ha sacado 00:34:30
de interpretar cada pack de 8 00:34:34
con el código ASCII 00:34:35
vale, es decir 00:34:36
Ana y demás, tallaos 00:34:38
sí, hombre Ana, estabas hablando 00:34:40
o no 00:34:43
sí, eso decía Hitler 00:34:46
es que le estaba 00:34:49
explicando que no podía hacer eso y de repente 00:34:51
mira, lo pasé, pues esto es lo mismo 00:34:53
Venga 00:34:55
¿Habéis hecho el paquete main? 00:34:59
Vale 00:35:05
Hacemos nuestra clase 00:35:06
Vale 00:35:15
Vale 00:35:17
¿Qué Mayan? 00:35:20
Bueno, si me gusta a mí Mayan 00:35:25
Bueno, la mía se llama Mayan 00:35:30
A vosotros como queráis 00:35:34
Silencio, vale, pues ahora 00:35:35
Vamos a hacer un método 00:35:38
De verdad, os estáis riendo 00:35:40
Tanto como voy a reír yo corrigiendo vuestros exámenes 00:35:42
Vamos 00:35:44
Lo que me voy a reír 00:35:45
Es que estáis arriesgando mucho 00:35:48
vuestras vidas, la verdad, no haciéndome 00:35:54
ni caso, pero allá vosotros. ¿Es lo único que me escucha, 00:35:56
Juan? 00:35:58
Bueno. 00:35:59
Leer fichero. 00:36:03
Vale. 00:36:05
Vamos a hacer un método. 00:36:06
Sí. 00:36:07
Sí, Josi, el que faltaba. 00:36:10
Venga, anda, pasa. 00:36:12
Venga. 00:36:18
Nombre 00:36:22
fichero 00:36:23
vamos a hacer un método 00:36:24
al que le pasamos el nombre de un fichero 00:36:27
y nos va a devolver 00:36:29
una cadena con su contenido 00:36:31
si fuera muy largo pues una cadena muy larga 00:36:33
vale 00:36:38
entonces cuando tengamos este método 00:36:38
pues ahora ya 00:36:41
vamos a suponer que este es el resultado 00:36:43
este va a ser nuestro método 00:36:54
que tengamos que hacer 00:36:56
Y cuando lo tengamos hecho, pues simplemente podremos hacer esto, leer fichero y le pasaremos el nombre del fichero que nos dé la gana, ¿vale? Pues, por ejemplo, nombre de XT en nuestro caso, ¿vale? Este será el uso que hagamos de ese método. 00:36:57
Le pasaremos el nombre de un fichero 00:37:21
Y este método lo construiremos 00:37:23
Para que nos devuelva su contenido 00:37:25
Vale 00:37:27
Como está estratégicamente colocado 00:37:28
En la raíz del proyecto 00:37:31
Que es la ruta por defecto 00:37:33
Aquí no he tenido yo que acompañarlo 00:37:35
De ninguna ruta 00:37:37
Bueno, pues venga 00:37:38
¿Qué tenemos que hacer con ese fichero? 00:37:41
Leer 00:37:46
Es decir, coger lo que tiene dentro 00:37:46
Y pasarlo a variables de alguna manera 00:37:48
Pues File Reader 00:37:50
Muy bien, vale, pues este objeto tendremos que instanciarlo, este objeto lo tendremos que instanciar, efectivamente no lo reconoce si no lo importamos de la librería o si no le ponemos su nombre completito, vale, no se os olvidan estas cosas, verdad, que me da igual hacer el import que poner el nombre completo. 00:37:52
Vale, pues 00:38:22
No lo olvidéis porque hay veces 00:38:27
Que es recomendable 00:38:29
No hacer el import porque puede crear confusiones 00:38:32
Y muchas veces los plugins que te generan 00:38:34
Código automático 00:38:36
No te hacen los import 00:38:37
Te ponen directamente, de hecho el builder 00:38:39
No sé si, bueno 00:38:41
Si que te lo hace como importación 00:38:42
Vale 00:38:45
A ver, hay muchas clases 00:38:47
es que se llaman igual en diferentes librerías 00:38:52
entonces tú 00:38:54
has hecho el import y el import está 00:38:55
200 millas más arriba y te crees que 00:38:57
estás usando la de un paquete y estás usando 00:38:59
la de otro, sin embargo si lo hubieras puesto 00:39:01
con su nombrecito no habría ninguna confusión 00:39:04
entonces se pasa, se pierden 00:39:06
muchas horas 00:39:08
porque algo no te está funcionando 00:39:08
no porque no compile, porque si no compila 00:39:12
es fácil llegar al problema 00:39:13
sino porque algo 00:39:15
no te está funcionando, te está haciendo algo que no es 00:39:17
y no entiendes por qué 00:39:20
no entiendes por qué. Y el error no está ahí. 00:39:21
El error está 200 millas más arriba en el 00:39:23
import. Y entonces, tú solo 00:39:25
preguntas a HGPT por todos lados. 00:39:27
Prueba esto, prueba lo otro. 00:39:29
Ay, pues sí, ay, pues no. Ay, pues no sé cuántos. 00:39:31
Ay, pues no sé qué. A él no se 00:39:33
le ocurre decirte, ¿tú estás seguro de que esta 00:39:35
clase es la que quieres usar? 00:39:37
Bueno, 00:39:40
pues dicho este inciso, a Rodrigo 00:39:41
le ha pasado eso. ¿Ves? 00:39:43
Esto es como las canciones de los hombres 00:39:45
que todo te ha pasado a ti. Pues igual. 00:39:47
Entonces, para no arrastrarnos otros 00:39:49
con eso vamos a hacer el import 00:39:51
ahí 00:39:52
vale, pues el file reader 00:39:54
hay que instanciarlo 00:39:56
y tendrá, seguramente 00:39:57
tenga constructores sobrecargados 00:40:01
el constructor sin parámetros 00:40:03
pues no le gusta, al menos 00:40:04
habrá que darle el fichero 00:40:07
al que asociarlo, el file reader 00:40:09
se asocia a un fichero 00:40:10
hay varias formas de asociar un objeto 00:40:11
claro, al instanciarlo 00:40:15
lo tienes que asociar a un fichero 00:40:17
vale, bueno 00:40:18
Tanto como guay 00:40:20
Entonces hay muchas 00:40:21
Variantes del constructor 00:40:23
Una de ellas, la más sencilla 00:40:25
Es que tú le pases directamente 00:40:27
El string 00:40:29
¿Vale? 00:40:32
Con el nombre del fichero 00:40:33
Esta es la más sencilla 00:40:34
Se le puede pasar el fichero de otra manera 00:40:38
Sí, no le gusta 00:40:41
Ya, pero no pasa nada 00:40:44
Ahora le satisfacemos al completo 00:40:45
No pasa nada 00:40:47
Entonces, ¿por qué no le gusta? 00:40:48
Eso 00:40:51
Primero, porque automáticamente esto que hemos creado es una cosa que se llama flujo, que es un objeto que está asociado a un recurso ajeno al, bueno, no ajeno, un objeto que es una puerta a un recurso, ¿vale? 00:40:52
Es decir, esto es un ejemplo de algo que en Java y en programación en general se llama flujo, que es un objeto de mi programa que es una puerta a un recurso, es una puertita a un recurso. 00:41:14
un flujo es en general 00:41:30
una puertecita 00:41:32
a un recurso 00:41:33
entonces, esto es un flujo 00:41:35
porque es una puerta de entrada a un fichero 00:41:37
el escáner 00:41:40
famoso, el objeto que 00:41:42
es un flujo, porque es la puerta 00:41:44
de acceso a la consola 00:41:46
también podemos crear 00:41:48
flujos asociados 00:41:50
a colecciones de datos, a Arrays 00:41:52
porque sería una puerta de entrada 00:41:54
a esa colección de datos 00:41:56
no estamos usando porque nosotros ya podemos 00:41:57
entrar directamente en la colección para iterar en ella 00:41:59
pero hay flujos que se pueden asociar 00:42:02
a colecciones o a stream o a lo que sea 00:42:03
hay flujos que se pueden 00:42:05
asociar a una 00:42:08
conexión de red 00:42:10
que son los sockets 00:42:11
etcétera, bueno pues es un ejemplo de flujo 00:42:13
vale, pues el primer aviso que te 00:42:16
dice es, que peligro abrir 00:42:17
una puerta que no cierras 00:42:19
es lo primero que te dice, porque cuando tú abres 00:42:21
una puerta, a ese recurso 00:42:23
al que lo has asociado lo dejas bloqueado. 00:42:26
Entonces, si no la cierras 00:42:29
todo el tiempo que estés sin cerrar, 00:42:30
ese recurso no está disponible para otros. 00:42:33
Entonces, cuando se abre un flujo por sistema, 00:42:36
cuando has terminado de usarlo, hay que cerrarlo. 00:42:38
Claro, entonces, es el primer aviso que te dice. 00:42:41
Cuidado que el flujo está sin cerrar. 00:42:43
Hombre, claro, es que si lo cierro, 00:42:45
espérate que opere y trabaje y ya lo cerraré después. 00:42:47
También te avisa. 00:42:54
Bueno, y aquí también te ha quedado 00:42:56
Ah, bueno, es que aquí te quedarían 00:42:58
Aquí te quedarían amarillo también 00:43:00
El rojo viene por la de la excepción 00:43:02
Ahora cuando pongamos la excepción se quedarán amarillo 00:43:03
Vale, entonces lo primero de lo que te avisa 00:43:06
Es de que cuidado que el flujo no está cerrado 00:43:08
Sí, vale, ya está, ya lo cerraré 00:43:10
Ahora mismo no puedo porque entonces me quedo sin 00:43:12
Opciones de atacar 00:43:14
Y lo siguiente que te avisa, ya lo sabemos de memoria 00:43:16
Cuidado que esto 00:43:18
Te puede sacar una excepción 00:43:20
De tipo no encuentro ese fichero 00:43:22
y esa excepción no es de tipo 00:43:24
runtime exception 00:43:27
es de tipo exception 00:43:28
te obliga a que tú digas 00:43:30
¿qué hago? 00:43:33
si no existe el archivo, ¿qué hago? 00:43:34
o somos vagos 00:43:37
horriblemente vagos 00:43:39
y hacemos esto 00:43:40
o hacemos el try catch 00:43:41
pero aquí 00:43:46
hacer el throw no es tan mala opción 00:43:48
claro, justo 00:43:50
el throw cuando es 00:43:53
una opción terrible 00:43:55
es en el main, porque 00:43:55
cuando al main le llega una excepción 00:43:58
él, que ya es el último 00:44:00
en la pila 00:44:02
es el que te para la aplicación 00:44:04
entonces yo aquí hacer el throw no es tan 00:44:06
grave, porque aquí estoy avisando al que 00:44:08
me llama, cuidado que puedo fallar 00:44:10
por esto, entonces ni siquiera es mala opción 00:44:12
porque si yo me hago aquí 00:44:14
un try catch, me lo guiso y me lo como 00:44:16
y el main, a menos que 00:44:18
yo le avise con el valor de retorno 00:44:20
con algo, no se entera 00:44:22
de lo que ha pasado. Entonces, aquí 00:44:24
en este método, tampoco es mala opción hacer un 00:44:26
throws, porque yo estoy avisando 00:44:28
al de arriba que esto 00:44:30
no me ha funcionado porque es que me has pasado 00:44:32
un fichero que no existe. 00:44:34
Me has pasado un fichero que no existe. 00:44:36
Entonces, yo te aviso. Entonces, al avisar 00:44:38
con el throws, ahora 00:44:40
el problema le ha llegado al main, que es el que nos está 00:44:42
llamando. Y al 00:44:44
haberle propagado el problema 00:44:46
al main, aquí de nuevo tenemos 00:44:48
que decir, oye, ¿qué 00:44:50
pasa si leer fichero me saca la excepción 00:44:52
y aquí sí que hacer el 00:44:54
vago y hacer el throws 00:44:56
aquí sí que sería 00:44:58
muy cómodo a la hora de escribir el código 00:45:00
porque es comodísimo 00:45:02
pero muy feo en tiempo de ejecución 00:45:03
porque si yo he metido aquí un 00:45:06
fichero que no existe, aquí es que 00:45:08
lo he metido a capón, pero podría haberlo cogido de una 00:45:10
interfaz gráfica, de lo que fuera 00:45:12
si el usuario me ha metido uno que no existe 00:45:13
en lugar de decirme el fichero no 00:45:15
existe, mete otro 00:45:18
pues la aplicación se para radical 00:45:19
entonces esas no son maneras de proceder 00:45:21
con la gente 00:45:24
entonces 00:45:25
aquí no le vamos a poner throws 00:45:27
eso es un poco feo 00:45:30
aquí le 00:45:31
vamos a 00:45:32
gracias chicos 00:45:34
vale 00:45:39
aquí vamos a ponerle el try catch 00:45:39
vale y en el try catch 00:45:43
como estamos en tiempo de desarrollo 00:45:47
nos viene estupendo dejarlo el print extract 00:45:48
trace que nos avisa de todo lo que ha ocurrido 00:45:51
pero si estuviéramos 00:45:53
ya en tiempo de entregar la aplicación 00:45:55
pues aquí en lugar de eso le avisaríamos 00:45:57
con un system out o lo que fuera 00:45:59
que quisiéramos que el tío viera 00:46:01
¿vale? 00:46:03
¿ves? ahora ya se ha quedado amarillo 00:46:05
porque eso es un aviso 00:46:07
lo del flujo 00:46:09
lo mismo que el escáner, vale, pues ahora 00:46:10
¿qué queremos hacer? 00:46:13
tenemos que ir leyendo los caracteres 00:46:15
es decir 00:46:18
queremos hacer esto 00:46:19
fr.read 00:46:20
el int que me devuelve 00:46:22
hacerle el casting a char 00:46:24
y concatenarlo 00:46:27
sobre result 00:46:29
claro, el asunto es 00:46:29
yo quiero hacer esto 00:46:34
quiero hacer esto 00:46:35
cada fr.read me va a dar un char 00:46:37
le haré el casting a char 00:46:40
porque él me lo devuelve en int 00:46:42
y lo concatenaré a result 00:46:43
pero claro, quiero hacer esto un montón de veces 00:46:45
es decir 00:46:48
esto lo voy a necesitar meter en un while 00:46:50
claro, para que se haga 00:46:52
un montón de veces 00:46:54
y ahora 00:46:55
¿cuándo acaba el while? 00:47:02
cuando esto que yo he leído 00:47:05
sea menos 1 00:47:07
entonces, como vamos a poner aquí la sentencia 00:47:08
de evaluación y tengo que haber leído 00:47:11
ya el carácter, o bien leemos 00:47:13
el primero fuera 00:47:15
que queda un poco raro 00:47:16
sí, o más sencillo 00:47:18
nosotros sabemos que una condición 00:47:21
a la vez que evalúa puede ejecutar cosas 00:47:22
entonces 00:47:25
en esa condición vamos a aprovechar 00:47:27
leemos el carácter y lo comparamos 00:47:29
directamente con el menos 1 00:47:32
es decir 00:47:34
esta va a ser la variable en la que vamos 00:47:35
a guardar 00:47:37
cada carácter leído 00:47:39
int 00:47:42
porque lo guarda en variable entera en realidad 00:47:43
pues entonces ahora hacemos 00:47:45
para cada c 00:47:47
siendo c el resultado 00:47:49
de hacer esta lectura 00:47:52
mientras sea 00:47:53
distinto de menos 1 00:48:00
¿vale? 00:48:03
entonces esta es una condición 00:48:05
porque es comparar si esto es 00:48:07
diferente de menos 1 00:48:09
pero aprovechamos porque en una condición 00:48:11
ya sabemos que podemos a la vez ejecutar 00:48:13
código ¿vale? pues aprovechamos 00:48:15
y ya de paso 00:48:18
que usamos C para compararla con menos 1 00:48:19
le hacemos una asignación 00:48:21
¿qué asignación le hacemos? 00:48:23
la que hemos leído 00:48:26
vale, pues para cada c 00:48:26
siendo c el resultado de leer un carácter 00:48:28
en ese momento 00:48:31
no, bueno 00:48:32
lo que no hago dentro de es la 00:48:34
la lectura, pero lo tengo que 00:48:37
concatenar result, claro 00:48:39
pues que hacemos 00:48:40
result más igual 00:48:42
esto 00:48:45
vale 00:48:47
entonces leemos el carácter 00:48:50
mientras no sea menos uno, hago con el carácter lo que sea 00:48:52
sí, de hecho no tendría ni que hacer el casting 00:48:55
porque la operación de concatenación 00:49:00
si se encuentra algo que no es un string 00:49:01
lo pasa a string 00:49:03
de hecho es que aunque no hiciera el casting 00:49:04
el paso, como él tiene que forzar 00:49:06
la conversión para la operación de concatenación 00:49:09
ya la forzaría correctamente 00:49:11
es decir, este forzar a char 00:49:13
vamos a comprobarlo 00:49:15
porque si nosotros lo eliminamos 00:49:19
¿qué es lo que va a hacer? 00:49:21
tiene una operación de concatenación 00:49:23
que es cadena, que es result 00:49:25
con un número entero 00:49:27
entonces fuerza su concatenación a string 00:49:28
pero fuerza la concatenación a string 00:49:31
del número entero 00:49:33
entonces nosotros queremos la conversión 00:49:35
a char 00:49:37
¿vale? entonces 00:49:38
por eso ahí seguramente 00:49:40
vamos a dejarlo de hecho 00:49:43
para ver ese 00:49:44
numerito entero que él ha leído 00:49:47
que sabemos que en el byte menos significativo 00:49:49
está el char, eso lo sabemos 00:49:51
y que en el resto hay todo cero 00:49:52
vamos a ver cómo fuerza la conversión a string 00:49:53
para concatenar 00:49:56
seguramente lo convierta al entero que representa 00:49:57
no, aunque eso lo haría 00:50:00
integer parseín, eso lo hacemos con 00:50:02
integer parseín normalmente, entonces si lo hacemos 00:50:04
con integer parseín 00:50:06
ah no, perdón, sí, sí, sí, olvidadlo 00:50:07
vale, entonces 00:50:10
él forzará la conversión a string 00:50:11
porque la necesita de ese numerito 00:50:14
y la concatenará 00:50:15
result 00:50:18
esa conversión, casi seguro que no 00:50:19
estará bien, con lo cual tendremos que arreglarlo 00:50:22
haciendo el casting a char 00:50:24
porque el casting a char ya sí que es 00:50:26
me quedo con el menos significativo 00:50:27
el casting a char ya sí que es corto y me quedo 00:50:29
con el menos significativo 00:50:32
vale 00:50:33
me avisa lo de que cuidado 00:50:34
que esto me puede sacar una excepción y trae salida 00:50:37
pero a mí no me ha dejado un casting a char 00:50:39
o un string, lo he tenido que hacer sumarle 00:50:42
una cadena vacía 00:50:43
pero no sirve para nada 00:50:44
para que no dé error 00:50:50
no sé 00:50:52
No sé 00:50:54
Bueno, ahora estamos concatenando un int 00:50:56
Pero en cualquier caso, un char a un string 00:51:01
Debería 00:51:03
Bueno, lo probamos 00:51:04
Pero debería concatenar 00:51:09
Pero vamos, debería 00:51:11
Poder hacer un string más un char 00:51:13
Debería hacer la conversión 00:51:16
Y que el resultado fuera un string 00:51:17
Bueno, habría que ver en qué situaciones 00:51:18
Vale, entonces, lógicamente nos vuelve a decir 00:51:22
oye que puede salir una excepción 00:51:23
no de tipo runtime 00:51:25
y pues bueno vamos a propagarla 00:51:26
y que el de arriba decida 00:51:30
otro throws 00:51:31
porque ahora hay dos posibles causas de error 00:51:33
que el fichero no exista 00:51:35
y que la operación de lectura no haya sido exitosa 00:51:37
porque el fichero justo se ha roto 00:51:40
en ese momento el disco duro 00:51:41
pues si justo en ese momento se ha roto el disco duro 00:51:43
pues habrá habido un problema 00:51:45
entonces como ahora este tiene 00:51:47
dos throws 00:51:49
no, a ver 00:51:50
no tiene dos throws, lo ha metido en uno 00:51:53
porque el file not found exception 00:51:55
hereda de io exception 00:51:57
hereda 00:52:00
entonces gracias a que todas las 00:52:01
claro, gracias a que todas las 00:52:03
clases en general de los paquetes que usamos 00:52:05
están estructuradas 00:52:08
en una jerarquía de clases con herencia 00:52:09
eso tiene su lado malo, no puedes decirle 00:52:11
por qué acepta 00:52:13
bueno, tú puedes hacerla 00:52:14
sí, tú hará 00:52:17
a ver, yo podría hacer esto, lo que pasa es que tengo que 00:52:20
ya, pero yo puedo hacer un multicatch 00:52:23
a ver, el multicatch yo lo puedo hacer 00:52:27
perfectamente 00:52:34
que es file not found exception, hace esto 00:52:35
que no es file not found exception 00:52:38
y es io exception 00:52:40
pues hace esto otro 00:52:41
¿vale? lo que no puedo hacer en el multicatch 00:52:44
es ponerlo al revés 00:52:46
porque como file not found exception hereda 00:52:47
de esta, me diría, oye que ya 00:52:50
me has capturado en la anterior 00:52:52
vale, pero yo puedo hacer un multicatch así 00:52:53
y distinguir 00:52:56
no se encontró el archivo 00:52:57
A ver, tira 00:53:22
No, esto está en tiempo de ejecución 00:53:31
No tira la padre 00:53:33
Tira la que es 00:53:35
Tira la que es porque es un objeto 00:53:36
Lo que pasa es que el compilador 00:53:38
Te permite poner esta 00:53:43
Porque en tiempo de compilación 00:53:45
Casan las dos 00:53:46
Claro, claro 00:53:47
pero con un error específico 00:53:50
¿a qué te refieres? 00:53:56
un objeto específico 00:53:57
claro, claro, claro 00:53:58
file not found exception es una clase 00:53:59
io exception es otra 00:54:01
file not found exception hereda de io exception 00:54:02
claro, entonces si tú aquí 00:54:05
el error ha venido por aquí 00:54:07
el throw que se lanza es 00:54:10
file not found exception 00:54:12
se lanza esa 00:54:13
lo que pasa es que el compilador te dice 00:54:14
aunque sea esa la que lances 00:54:16
como cae aquí yo te dejo que en tiempo de compilación 00:54:17
me pongas eso, pero en tiempo de ejecución 00:54:20
la que se lanza es esa, con lo cual cuando llegue 00:54:23
aquí arriba, entrará en esta parte 00:54:24
del catch, entrará en esa de arriba 00:54:26
¿vale? 00:54:28
vale 00:54:30
bueno, pues ahora 00:54:31
ya está 00:54:34
ya podemos probar esto 00:54:36
si le hacemos caso 00:54:38
como mi aplicación termina, en realidad 00:54:40
no me haría falta cerrar el flujo porque 00:54:42
cuando una aplicación termina, cierra todos los 00:54:44
flujos que lo acompañan, pero 00:54:46
siempre es muy buena idea 00:54:48
no olvidarse de cerrar 00:54:50
vamos a ver 00:54:53
como nos lee los nombres 00:54:55
que me ha faltado aquí 00:54:56
ah, que esta la he llamado ex 00:54:58
pues ex, vale 00:55:00
que me ha faltado aquí, por ejemplo 00:55:02
vamos a ponerle un nombre que no exista 00:55:05
vale 00:55:07
entonces aquí 00:55:09
vale 00:55:10
no estoy ejecutando 00:55:25
Vale, estaba ejecutando otra aplicación 00:55:28
Vale, pues efectivamente 00:55:33
No se encontró el archivo y la que lanza es esta 00:55:35
Porque no se encontró 00:55:38
Forzar la otra no podemos forzarla 00:55:39
Porque hombre, romper el disco duro en el momento 00:55:41
En el que está leyendo no lo podemos hacer 00:55:43
Pero esta la podemos forzar 00:55:45
Efectivamente 00:55:47
Bueno, tu poder podrías 00:55:48
Ya está claro 00:55:52
Ya, pero bueno, no hay necesidad 00:55:53
vale, vamos a probar ahora 00:55:57
pues efectivamente 00:55:59
fijaos el archivo 00:56:01
que me ha leído, estos son 00:56:04
la sucesión de los números enteros 00:56:06
que son 00:56:08
los int 00:56:10
que me ha leído con ese char 00:56:12
etcétera, vale 00:56:13
entonces esto no tiene sentido 00:56:16
claro, porque que nos ha faltado 00:56:17
esta con este casting 00:56:20
de aquí 00:56:22
vale, claro 00:56:22
ahora ya, C, se queda 00:56:25
con el byte menos significativo 00:56:27
y ahora ves, Juanjo 00:56:29
te deja concatenar 00:56:32
un string a un char sin problemas 00:56:34
¿vale? estamos haciendo el casting 00:56:35
ahora ya sí, está leyendo los 00:56:37
char y concatenándolos, no convirtiendo 00:56:39
en el int, ahora ya 00:56:42
pues sí, ¿vale? nos lee 00:56:44
el archivo y todo eso 00:56:45
vale 00:56:47
entonces, este es el bucle de lectura 00:56:49
clásico para leer del archivo de texto 00:56:54
el bucle de lectura 00:56:56
y dentro del bucle 00:56:59
de lectura uno hace lo que quiere 00:57:02
¿vale? 00:57:04
por ejemplo, si ahora hacemos otro 00:57:06
método, que sea 00:57:09
vale, pues ahora vamos a cambiarlo 00:57:11
a este método 00:57:39
que sea, ahora en lugar de mostrar 00:57:40
el fichero tal cual 00:57:45
el fichero tal cual 00:57:47
vamos a mostrarlo sin los saltos de línea 00:57:48
todo seguido, vamos a mostrarlo todo seguido 00:57:51
sin los saltos de línea 00:57:53
pues de nuevo será el bucle de lectura 00:57:54
y habrá que ver que hacemos 00:57:57
para mostrarlo sin los saltos de línea 00:57:59
todo seguido, pues venga 00:58:01
hacer este método 00:58:03
basado sobre el anterior pero habrá que 00:58:04
modificar un poquito lo que se hace dentro del bucle 00:58:07
pues venga 00:58:09
Materias:
Programación
Niveles educativos:
▼ Mostrar / ocultar niveles
  • Formación Profesional
    • Ciclo formativo de grado superior
      • Primer Curso
Subido por:
Raquel G.
Licencia:
Todos los derechos reservados
Visualizaciones:
34
Fecha:
2 de abril de 2025 - 12:23
Visibilidad:
Clave
Centro:
IES ROSA CHACEL
Duración:
58′ 12″
Relación de aspecto:
1.78:1
Resolución:
1920x1080 píxeles
Tamaño:
787.45 MBytes

Del mismo autor…

Ver más del mismo autor

EducaMadrid, Plataforma Educativa de la Comunidad de Madrid

Plataforma Educativa EducaMadrid