Lectura y Escritura de ficheros en Java, con ejemplos
El proyecto de este post lo puedes descargar pulsando AQUI.
En este tutorial vamos a ver como leer y escribir fichero en Java, dado que es una de las cosas que suele ser muy util y utilizada a la hora de programar. Bien es cierto que es bastante tedioso y largo el código que hay que escribir para hacer la lectura y escritura de fichero debido a que hay que utilizar objectos de clases que no se usan frecuentemente y hay que definir varias excepciones (ver tutorial "Excepciones (Exception) en Java, con ejemplos") en función de como se haga la lectura y escritura de los ficheros.
Aunque la lectura y escritura de ficheros se puede hacer de varias formas, en este tutorial os vamos a dar el código necesario para realizar estas acciones, aunque se puede hacer también de otras formas:
Lectura de Ficheros:
Vamos en primer lugar a leer el contenido del siguiente fichero (llamado 'fichero_leer.txt') e imprimir por pantalla lo que leemos:
Linea 1 Linea 2 Linea 3 Linea 4 Linea 5 Linea 6 Linea 7 Linea 8 Linea 9 Linea 10
En primer lugar tenemos que decir la ruta o directorio donde se encuentra el fichero que queremos leer. Si el fichero lo tenemos en la carpeta de nuestro proyecto (como es el caso del proyecto que estamos realizando) solo debemos de poner el nombre del fichero, sino hay que especificar la ruta donde se encuentra el fichero (ejem -> Windows: c:\\carpeta\……\fichero.txt, Linux o Unix: \var\www\……\fichero.txt). Esto lo hacemos de la siguiente manera:
File fichero = new File("fichero_leer.txt");
Una vez que tenemos el fichero que queremos leer, nos creamos un objeto de la clase "Scanner" e iremos leyendo linea a linea el fichero. A continuación vemos el programa que nos leera linea a linea el fichero e imprimirá por pantalla linea a linea el contenido del fichero:
import java.io.File;
import java.util.Scanner;
public class LecturaFicheros {
public static void main(String[] args) {
// Fichero del que queremos leer
File fichero = new File("fichero_leer.txt");
Scanner s = null;
try {
// Leemos el contenido del fichero
System.out.println("... Leemos el contenido del fichero ...");
s = new Scanner(fichero);
// Leemos linea a linea el fichero
while (s.hasNextLine()) {
String linea = s.nextLine(); // Guardamos la linea en un String
System.out.println(linea); // Imprimimos la linea
}
} catch (Exception ex) {
System.out.println("Mensaje: " + ex.getMessage());
} finally {
// Cerramos el fichero tanto si la lectura ha sido correcta o no
try {
if (s != null)
s.close();
} catch (Exception ex2) {
System.out.println("Mensaje 2: " + ex2.getMessage());
}
}
}
}
En el código vemos que nuestro objeto 's' de la clase "Scanner" va posicionandose linea a linea en el fichero y en el bucle "while" le vamos pidiendo la siguiente linea si es que existe.
Vemos también en el código como tenemos que definir varias excepciones, por si ocurre alguna de ellas, el programa no pare la ejecución. Por ejemplo vemos al final del código (en el "finally") como independientemente de si ha habido o no error en la lectura del fichero, nos lo cierre.
En definitiva aquí os hemos presentado el código para que podáis leer un fichero de texto (en este caso un 'txt') linea a linea.
Escritura de Ficheros:
Para la escritura de ficheros, vamos a presentar dos formas de hacerlo, una para escribir un fichero sin una codificación determinada y otra para escribirlo con una determinada codificación (en este caso en UTF-8).
En estos ejemplos vamos a escribir en el fichero (linea a linea) cada uno de los elementos del siguiente array:
String[] lineas = { "Uno", "Dos", "Tres", "Cuatro", "Cinco", "Seis", "Siete", "..." };
La forma más sencilla de hacer esta escritura (haciendo un foreach del array) es la que presentamos a continuación:
import java.io.FileWriter;
public class EscrituraFicheros {
public static void main(String[] args) {
String[] lineas = { "Uno", "Dos", "Tres", "Cuatro", "Cinco", "Seis", "Siete", "..." };
/** FORMA 1 DE ESCRITURA **/
FileWriter fichero = null;
try {
fichero = new FileWriter("fichero_escritura.txt");
// Escribimos linea a linea en el fichero
for (String linea : lineas) {
fichero.write(linea + "\n");
}
fichero.close();
} catch (Exception ex) {
System.out.println("Mensaje de la excepción: " + ex.getMessage());
}
}
}
Como vemos en este programa, solo utilizamos un objeto de la clase "FileWriter" en el que le pasamos el nombre del fichero. Si el fichero no existe nos lo crea. En realidad no solo hay que pasarle el nombre del fichero, sino que hay que pasarle la ruta donde queremos guardar el fichero más el nombre del fichero, aunque si lo hacemos como en el programa, nos guardará el fichero en la carpeta del proyecto.
Otra cosa muy importante es que abrimos el fichero y vamos escribiendo en el poco a poco (o elemento a elemento del array) y al final cuando ya hemos escrito todo cerramos el fichero (método "close()"). En realidad a la hora de escribir en un fichero, lo que hacemos es pasarle un determinado contenido (en este caso un String) y este lo escribe en el fichero. Se recomienda que la escritura la hagáis poco a poco ya que si almacenais en una variable de tipo String el contenido a escribir y luego lo escribís de golpe, os puede dar una excepción de exceso de memoria si lo que tenéis que escribir en el fichero es muy grande; por tanto hacerlo como se os indica aquí y no tendreis ese problema.
Como resultado de la ejecución de este programa, tendréis un nuevo fichero llamado "fichero_escritura.txt" con el siguiente contenido:
Uno Dos Tres Cuatro Cinco Seis Siete ...
La segunda forma de escribir es un fichero con una codificación determinada es la que presentamos a continuación:
import java.io.BufferedWriter;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.OutputStreamWriter;
import java.io.UnsupportedEncodingException;
import java.io.Writer;
public class EscrituraFicheros {
public static void main(String[] args) {
String[] lineas = { "Uno", "Dos", "Tres", "Cuatro", "Cinco", "Seis", "Siete", "..." };
/** FORMA 2 DE ESCRITURA. Con el fichero codificado en UTF-8 **/
Writer out = null;
try {
out = new BufferedWriter(new OutputStreamWriter(new FileOutputStream("fichero_escritura2.txt"), "UTF-8"));
// Escribimos linea a linea en el fichero
for (String linea : lineas) {
try {
out.write(linea+"\n");
} catch (IOException ex) {
System.out.println("Mensaje excepcion escritura: " + ex.getMessage());
}
}
} catch (UnsupportedEncodingException | FileNotFoundException ex2) {
System.out.println("Mensaje error 2: " + ex2.getMessage());
} finally {
try {
out.close();
} catch (IOException ex3) {
System.out.println("Mensaje error cierre fichero: " + ex3.getMessage());
}
}
}
}
Esta forma es un poco más compleja y hay que tratar diferentes excepciones pero nos permite escribir en el fichero con el formato que le especificamos.
Como resultado tenemos el mismo contenido que en el fichero anterior pero en este caso con el nombre "fichero_escritura2.txt".
Este ejemplo es poder transformar mi archivo XML, que esta en formato ANSI a FORMATO UTF-8, por medio de esta proceso.
Files.write(Paths.get(«7816.xml»), Charset.forName(«UTF-8»).encode(Charset.forName(«windows-1252»).decode(ByteBuffer.wrap(Files.readAllBytes(Paths.get(«7816.xml»))))).array());
El error es que tiene en la línea final del achivo, secuencias de NULLNULLNULLNULLNULLNULLNULL, casi ocupa una línea.
Hola Carlos.
Si tienes ficheros con errores lo primero que habría que hacer es corregirlos (ETL), bien leyendo línea a línea y descartando errores (o realizando el tratamiento adecuado) o si sabes que es al final siempre quizás puedas optimizar por posicionamiento en el fichero para descartar esa parte.
pero pasaría si se intenta abrir un archivo para escritura, pero el archivo está protegido contra escritura…y seria de que forma
Si el archivo está protegido por permisos del sistema operativo, le tendrás que dar permisos antes de utilizarlo. Puedes cambiar los permisos de un fichero con Java con:
* setExecutble(): Otorga permisos de ejecución.
* setWritable(): Otorga permisos de escritura.
* setReadable(): Otorga permisos de lectura.
Para tu caso podría valerte:
File fichero = new File("/ruta/hast/el/fichero"); fichero.setReadOnly();Si está protegido porque otro programa lo tiene abierto, tendrás que esperar a que lo cierre (principalmente por no tener problemas de sincronismo).
Desarrollar el siguiente taller sobre manejo de excepciones y colecciones.
¿Qué pasaría si se intenta abrir un archivo para escritura, pero el archivo (o dispositivo) está protegido contra escritura? Desarrolle un programa en java para realizar esta prueba.
Me podrías ayudar con este ejemplo? de antemano saludos y éxitos!!!
Por lo que te piden podrías tratar a forzar la excepción quitando permisos a un archivo de lectura (en linux con chmod 000 podría valer para probar).
Lo más probable es que te de una excepción java.io.IOException, con lo que deberás protegerla adecuadamente con un try y un catch
Realizar una clase de prueba que lea líneas de dos ficheros y las imprima en orden en
pantalla. Ejemplo, si el primer fichero tiene dos líneas «A» y «B» y el segundo fichero
contiene dos líneas «C» y «D», debe imprimir «A», «B», «C» y «D». La solución debe utilizar
internamente una cola.
no la entiendo ayuda
Buenas Juan Carlos.
Si sabes el orden de los dos ficheros bastaría con abrir el primero leerlo y luego el segundo.
Si no se asegura el orden, tendrás que ordenar. Tienes ejemplos de ordenación con Java en: https://jarroba.com/ordenar-un-arraylist-en-java/
Diseñar un Programa java que lee carácter a carácter el contenido de un fichero de texto datos.txt creado anteriormente. Y devuelve la cantidad de letras no vocales ingresadas en el archivo.
Podrías hacer algo como:
Reader miReader = new InputStreamReader(new FileInputStream(«ruta/mifichero.txt»), «US-ASCII»);
int codigoAsciiDelCaracter;
while ((codigoAsciiDelCaracter= miReader .read()) != -1) {
char miCaracter = (char) codigoAsciiDelCaracter;
}
Ya solo te queda contar las letras que necesites.
Hola quisiera saber como hacer para leer un archivo con datos String e Integer y ponerlo en una arraylist y de esa manera por ejemplo tomar los datos Integer para una posterior ecuación. Los datos son cargados previamente con getters y setters desde una superclass.
Muchas Gracias
Al leer los ficheros puedes leer línea a línea con un for: stream = Files.lines(Paths.get(«ruta/mi_fichero.txt»))) {
try (Stream
stream.forEach(System.out::println);
}
Podrías leer los datos y con el método split() separar los números de las de los strings siempre que se separen por un delimitador, así poder separarlos.
String miString = linea.split(«separador»)[0];
int miEntero = Integer.parseInt(linea.split(«separador»)[1]);
Una duda, y si quieres que se aumente al final de un fichero ya escrito y vayamos numerándolo?
Me refiero añado una linea y sea 1 : linea1.
Paso un segunda línea en otro momento y el archivo contenga:
1: linea1
2: linea2
El modo añadir (append mode) al final de un fichero es pasándole un true en el segundo parámetro, por ejemplo:
fichero = new FileWriter("fichero_escritura.txt", true);
como se haria para almacenar un un dato ymas un numero y almacenarlos y a la hora de leerlo como se haria para saber cual es el dato y cual es el numero gracias
Buenas tardes estimados. Les comento que hice un programa en java para comparar archivos txt y mostrar sus diferencias.. El problema que tengo es que cuando ejecuto el programa mas menos 3 veces dependiendo de la cantidad de archvios que este comparando el servidor linux me arroja el siguiente error. TOO MANY OPEN FILE. He revisado el codigo y cada archivo que se esta leyendo se esta cerrando. Tienen alguna idea a que se puede deber. Gracias
Buenas Felipe.
Linux tiene un máximo de descriptores de archivo que se pueden abrir a la vez. Siempre que abras un archivo (sea con el lenguaje que sea), hay que asegurar que se cierre independientemente del caso, es decir, jugando con los try y catch, como por ejemplo:
Writer miFichero = new FileWriter(…);
try {
// Intentar escribir en el fichero
} finally {
// Pase lo que pase va a intentar cerrar el fichero (tanto si ha ido bien como si ha dado error)
try {
// Intentar cerrar el fichero
miFichero.close();
} catch (IOException ex) {
// Sino consigue cerrar el fichero entrará aquí y lo tendrás que analizar.
}
}
Muchas gracias Ramòn por tu explicaciòn.
TAMBIEN SE PUEDE HACER CON ARCHIVOS DE TEXTO Y CON HASHSET, OTRO EJEMPLO:
package ejercicioconhashsetficheros;
import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.File;
import java.io.FileNotFoundException;
import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;
import java.text.Format;
import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.Date;
import java.util.HashSet;
import java.util.Iterator;
import java.util.StringTokenizer;
import java.util.logging.Level;
import java.util.logging.Logger;
public class GestionFichero {
public void EscribirEnElFichero(String nombreFichero, boolean anyadir, Persona p){
File f = new File(nombreFichero);
if(f.exists() && !anyadir) {
f.delete();
}
FileWriter flujoSalida = null;
BufferedWriter salida = null;
try{
flujoSalida = new FileWriter(f, anyadir);
salida = new BufferedWriter(flujoSalida);
String nom = p.getNom();
salida.write(nom);
salida.write(" ");
String cognom1 = p.getCognom1();
salida.write(cognom1);
salida.write(" ");
String cognom2 = p.getCognom2();
salida.write(cognom2);
salida.write(" ");
String dni = p.getDni();
salida.write(dni);
salida.write(" ");
Format formatter = new SimpleDateFormat("yyyy-MM-dd");
String formattedDate = formatter.format(p.getDataNaixement());
salida.write(formattedDate);
salida.newLine();
}catch (IOException ex) {
System.err.println("Error de escritura");
}finally {
try {
salida.close();
flujoSalida.close();
} catch (IOException ex) {
System.out.println("Problemas cerrando el fichero en la escritura");
}
}
}
public static void LeerArchivo(String nombreFichero){
Persona p;
String nom, cognom1, cognom2, dni, data, hayLinias;
Date dataNaixement = null;
HashSet personas= new HashSet();
BufferedReader entrada = null;
try {
entrada = new BufferedReader(new FileReader(nombreFichero));
while((hayLinias = entrada.readLine()) != null){
StringTokenizer st = new StringTokenizer(hayLinias);
nom = st.nextToken();
cognom1 = st.nextToken();
cognom2 = st.nextToken();
dni = st.nextToken();
data = st.nextToken();
SimpleDateFormat formato = new SimpleDateFormat("yyyy-MM-dd");
try {
dataNaixement = formato.parse(data);
} catch (ParseException ex) {
System.out.println("ERROR");
}
p = new Persona(nom, cognom1, cognom2, dni, dataNaixement);
personas.add(p);
}
Iterator i = personas.iterator();
while(i.hasNext()) {
System.out.println(i.next());
}
} catch (FileNotFoundException ex) {
System.err.println("No existe el fichero");
} catch (IOException ex) {
System.err.println("Error de Lectura");
} finally {
try {
if (entrada != null) {
entrada.close();
}
} catch (IOException ex) {
System.out.println("Problemas cerrando el fichero");
}
}
}
}
package ficherosenlazadosequipo;
import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.File;
import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;
import java.util.ArrayList;
import java.util.Iterator;
import java.util.StringTokenizer;
public class GestionArchivos2 {
public static String NOMBRE_ARCHIVO = "equipos.csv";
public static ArrayList<Equipo> leer(){
ArrayList<Equipo> equipos = new ArrayList();
try{
FileReader f = new FileReader(NOMBRE_ARCHIVO);
BufferedReader entrada = new BufferedReader(f);
String Linea;
while((Linea = entrada.readLine()) != null){
Equipo e = new Equipo();
StringTokenizer st = new StringTokenizer(Linea, ";");
e.setNombre(st.nextToken());
equipos.add(e);
}
entrada.close();
f.close();
}
catch(Exception e){
System.out.println("No se ha podido leer el archivo " + NOMBRE_ARCHIVO);
e.printStackTrace();
}
return equipos;
}
public static void leerEquipos(ArrayList<Equipo> equipos){
try{
for(Equipo equipoActual : equipos){
GestionArchivos2.leerJugadores(equipoActual);
}
}
catch(Exception e){
System.out.println("No se ha podido leer el archivo " + NOMBRE_ARCHIVO);
e.printStackTrace();
}
}
public static void leerJugadores(Equipo equipo){
ArrayList<Jugador> jugadores = new ArrayList();
String Filename = equipo.getNombre().replace(" ", "_").concat(".csv");
try{
FileReader f = new FileReader(Filename);
BufferedReader entrada = new BufferedReader(f);
String Linea;
while((Linea = entrada.readLine()) != null){
Jugador j = new Jugador();
StringTokenizer st = new StringTokenizer(Linea, ";");
j.setNombre(st.nextToken());
jugadores.add(j);
entrada.close();
f.close();
equipo.setJugadores(jugadores);
}
}
catch(Exception e){
System.out.println("No se ha podido leer el archivo " + Filename);
e.printStackTrace();
}
}
public static void guardarEquipos(ArrayList<Equipo> equipos){
File f = new File(NOMBRE_ARCHIVO);
if(f.exists()){
f.delete();
}
FileWriter flujoSalida = null;
BufferedWriter Salida = null;
try{
flujoSalida = new FileWriter(f);
Salida = new BufferedWriter(flujoSalida);
Iterator<Equipo> i = equipos.iterator();
Equipo e;
while(i.hasNext()){
e = i.next();
String nombre = e.getNombre();
Salida.write(nombre);
Salida.write(";");
Salida.newLine();
GestionArchivos2.guardarJugadores(e);
}
}
catch(IOException e){
System.err.println("Error de escritura");
}
finally{
try{
Salida.close();
flujoSalida.close();
}
catch(IOException e){
System.out.println("Problemas cerrando el fichero en la escritura");
}
}
}
public static void guardarJugadores(Equipo e){
ArrayList<Jugador> jugadores = e.getJugadores();
String filename = e.getNombre().replace(" ", "_").concat(".csv");
File f = new File(filename);
if(f.exists()){
f.delete();
}
FileWriter flujoSalida = null;
BufferedWriter Salida = null;
try{
flujoSalida = new FileWriter(f);
Salida = new BufferedWriter(flujoSalida);
Iterator<Jugador> i = jugadores.iterator();
Jugador j;
while(i.hasNext()){
j = i.next();
String nombre = j.getNombre();
Salida.write(nombre);
Salida.write(";");
Salida.newLine();
}
}
catch(IOException ex){
System.err.println("Error de escritura");
}
finally{
try{
Salida.close();
flujoSalida.close();
}
catch(IOException ex){
System.out.println("Problemas cerrando el fichero en la escritura");
}
}
}
}
HOLA, ME LLAMO ARTURO Y ME GUSTARIA QUE ME RESOLVIERAS UNA DUDA, ESTOY TRABAJANDO CON ARCHIVOS DBF, PERO NO ME SALE LA ESCRITURA, DEBIDO AQUE NECESITO REGISTRAR ALGUNOS CAMPOS, SOBRE UN ARCHIVO QUE YA TTIENE CAMPOS DEFINIDOS, ME PODRIAS AYUDAR???
gracias, me has ayudado demasiado todo esta muy bien explicado, eres grande, buen código
Una duda, y si quieres que se aumente al final de un fichero ya escrito?
FileWriter fw = new FileWriter("ArchivoQueContieneDatos", true);
fw.write("Esta cadena es agregada al final del fichero\n");
fw.close();
Saludos.