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".

Comparte esta entrada en:
Safe Creative #1401310112503
Lectura y Escritura de ficheros en Java, con ejemplos por "www.jarroba.com" esta bajo una licencia Creative Commons
Reconocimiento-NoComercial-CompartirIgual 3.0 Unported License.
Creado a partir de la obra en www.jarroba.com

9 comentarios en “Lectura y Escritura de ficheros en Java, con ejemplos”

  1. 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

  2. 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

    1. 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.
      }
      }

  3. 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");
                }
            }
        }
    }
     

  4. 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");
                    }
                }
        }
        
    }
     

  5. 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???

    1. FileWriter fw = new FileWriter("ArchivoQueContieneDatos", true);

      fw.write("Esta cadena es agregada al final del fichero\n");

      fw.close();

      Saludos.

Deja un comentario

Tu dirección de correo electrónico no será publicada. Los campos obligatorios están marcados con *

Uso de cookies

Este sitio web utiliza cookies para que usted tenga la mejor experiencia de usuario. Si continúa navegando está dando su consentimiento para la aceptación de las mencionadas cookies y la aceptación de nuestra política de cookies

ACEPTAR
Aviso de cookies