Archivos de Texto

Introducción
 Los archivos son una secuencia de bits que se
guarda en el disco duro. La ventaja de utilizar
archivos es que los datos que guardemos no son
volátiles (a diferencia de la memoria) y por lo tanto
podemos verlos después de reiniciar la
computadora o en otra computadora.
 Los archivos de computadora, por convención
cuentan con diferentes extensiones. Por lo regular
las extensiones son de tres letras y nos permiten
saber el tipo de archivo. Es importante cuando
utilizamos archivos pensar en que el tipo de
extensión sea congruente con el archivo.
Archivos de Texto
 Para poder leer archivos de texto en Java
debemos crear un objeto de tipo BufferedReader.
BufferedReader es una clase que contiene
métodos predefinidos para poder leer de una
secuencia de bits.
 Para poder guardar archivos de texto en Java
debemos crear un objeto de tipo PrintWriter.
PrintWriter es una clase que contiene métodos
predefinidos para meter datos a una secuencia de
bits.
 Puedes hacer click en los nombres para ver el
API que contiene muchos métodos útiles.
BufferedReader

 El constructor que vamos a utilizar para crear un

BufferedReader es:
BufferedReader fileIn = new BufferedReader(new
FileReader(fileName);
 Ya que tenemos el objeto tipo BufferedReader
podemos utilizar varios métodos para leer, él más
común es:
fileIn.readLine();
 Este método lee una línea y la devuelve o
devuelve null si llegamos al final del archivo y no
hay nada que leer.
BufferedReader

 Es importante recordar cuando trabajamos

con archivos que cada que leemos o
escribimos a un archivo debemos hacerlo
dentro de un try.
 Un try es un manejador de excepciones,
cuando sucede un error en la ejecución de
nuestro programa ejecuta ciertas
instrucciones dependiendo del tipo de error
que sucedió.
 Primero ponemos try
Uso de try
try { y abrimos una llave
int n1 = 1;
int n2 = 0;

double r = n1 / n2; //Aqui hay un error porque

//no podemos dividir entre 0!!!
} catch (ArithmeticException ae) {
//Manejar la excepcion;
} finally { n1 / n2 podría ser una división entre
System.out("Ya termine!"); cero, por lo tanto es una buena
} práctica de programación utilizar un
try para que si fue una división entre
0 el programa maneje el error
(regularmente imprimiendo un mensaje
Lo que se encuentra en un finally se de error).
ejecuta hasta el final, sin importar si el
código se ejecutó sin errores.
 BufferedReader

 Los dos tipos de excepciones que debemos

atrapar al leer archivos son IOException (se
genera normalmente porque el disco está
lleno o protegido contra escritura/lectura) y
FileNotFoundException (se genera porque
el nombre de archivo no es válido)
try {
BufferedReader fileIn = new BufferedReader(
new FileReader(fileName));
String s = fileIn.readLine();
} catch (IOException ioe) {
} catch (FileNotFoundException fnfe) {
}
 BufferedReader
 Otro método muy importante es el método
fileIn.read();

 Este método nos permite leer un solo

carácter del flujo de datos. El método
regresa un número (int) del 1 al 65535 si
puede leer del archivo o regresa -1 si no.
try {
BufferedReader fileIn = new BufferedReader(
new FileReader(fileName));
int i = fileIn.read(); //Iniciamos una variable a la que
//vamos a leer
char c = (char) i; //Como lo que leimos es un int debemos
// hacer un cast a char
} catch (IOException ioe) {
} catch (FileNotFoundException fnfe) {
}
 BufferedReader

 Ya que el método read nos devuelve -1

cuando se termina el archivo podemos
utilizar un while que siga leyendo caracteres
hasta encontrar el final de archivo.
try {
BufferedReader fileIn = new BufferedReader(
new FileReader(fileName));
int i = 0;
while (i != -1) {
i = fileIn.read();
char c = (char) i;
}
} catch (IOException ioe) {
} catch (FileNotFoundException fnfe) {
}
Ejercicios

 Vamos a hacer un ejercicio para entender

mejor como funcionan los archivos de texto. El
ejercicio consiste en leer cuantas veces
aparece una letra en un archivo. Con los
métodos que hemos visto hay dos maneras
de resolver este problema: la primera es leer
todo el archivo de texto con el método
readLine() y después buscar ahí todas las
letras. El otro método sería leer letra por letra
y comparar en cada lectura.
 Ejercicios
 Ninguna de las dos maneras es “peor” que
la otra sino que depende de lo que haga el
programa y las limitaciones que nos
pongan. En este caso sería prudente utilizar
la segunda porque es más sencilla.
try {
int suma = 0; //Ponemos una variable donde llevemos la suma
BufferedReader fileIn = new BufferedReader(
new FileReader(fileName)); //Creamos el BufferedReader
int i = 0;
while (i != -1) {
i = fileIn.read();
char c = (char) i;
if (c == letra) suma++;
}
} catch (IOException ioe) {
} catch (FileNotFoundException fnfe) {
}
BufferedReader
 Si te fijas el ejercicio se parece mucho a los
ejemplos anteriores, esa es una de las
ventajas de los archivos de texto: la sintaxis
es muy parecida siempre.
 Por último es importante que una vez que
terminamos de utilizar el archivo lo cerremos
utilizando el método close() del objeto
BufferedReader que creamos.
String fileName = "Texto.txt";
//Se declara desde aqui para que no haya error en el finally
BufferedReader fileIn = null;
try {
fileIn = new BufferedReader(new FileReader(fileName));

String s = fileIn.readLine();
System.out("La primera linea es: " + s);
} catch (IOException ioe) {
System.out("Error, disco protegido contra lectura");
} catch (FileNotFoundException fnfe) {
System.out("Error, no se encuentra el archivo");
} finally {
if (fileIn != null) {
try {
/**
* Una vez que termine de leer el archivo es
* importante cerrarlo para que otros programas lo
* puedan abrir y para que los cambios se guarden.
*/
fileIn.close(); //Es importante cerrar el archivo
} catch(IOException ioe) {
}
}
}
Ejercicio de Tarea
 Un hospital necesita saber la temperatura más
alta y más baja de sus paciente que están
conectados a una máquina que realiza
reportes cada hora en el siguiente formato:
 Debido a que los
doctores no tienen
tiempo para analizar los
resultados de cada
paciente nos han pedido
desarrollar un programa
que les diga el máximo y
mínimo de la lista.
Ejercicio de Tarea
 Primero tienes que decidir que método de
lectura es más conveniente para resolver este
ejercicio. Fíjate que los números están
separados por líneas.
 Otra nota importante es que cuando leemos
de un archivo utilizando el método readLine()
nos regresa un String y no números. Cuando
leemos con el método read() nos devuelve un
número que representa el carácter que leyó,
NO el número. Por ejemplo, si el archivo tiene
un 9 el método read() nos devuelve 57 (el
código ASCII del carácter '9') y NO 9 como
podríamos esperar.
PrintWriter

 El constructor que vamos a utilizar para

crear un PrintWriter es:
PrintWriter fileOut = new PrintWriter(new
FileWriter(fileName);

 Ya que tenemos el objeto PrintWriter

podemos utilizar varios métodos para
escribir, los más comunes son:
fileOut.print(String);
fileOut.println(String);

 Estos dos métodos reciben un String y lo

imprimen en el archivo, el segundo método
le pone un carácter de fin de línea al final.
PrintWriter

 Al igual que al leer debemos recordar

utilizar un try. Cuando utilizamos el
PrintWriter todo entra a un buffer y una vez
que terminemos de escribir los datos
debemos recordar utilizar el método flush()
del PrintWriter para escribir todo al archivo.
 Al terminar de usar el archivo también
debemos recordar que debemos cerrarlo
mediante el método close() del PrintWriter.
String fileName = "Texto.txt";
PrintWriter fileOut = null;
try {
fileOut = new PrintWriter(new FileWriter(fileName));

String s = "Una linea de texto";

fileOut.println(s);
fileOut.flush();

} catch (IOException ioe) {

System.out("Error, disco protegido contra lectura");
} catch (FileNotFoundException fnfe) {
System.out("Error, no se encuentra el archivo");
} finally {
if (fileIn != null) {
try {
fileIn.close();
} catch (IOException ioe) {
}
}
}