Si se quiere escribir o leer en un fichero o directorio, java tiene la posibilidad de diferenciar entre tratamiento de flujo de carácteres y flujo de binarios mediante las clases InputStream / OutputStrea y Reader /Writer respectivamente. Su uso es similar y se diferencua el la escritura o lectura del archivo correspondiente.

Lo primero que hya que tener claro es el uno de los objetos de tipo File, ya que es la base de toda entrada salida de datos. Esta clase File hace referencia a una dirección expresada en String donde se apunta al fichero – directorio con el que se quiere trabajar

File f = new File ("src/documentos/ejemplo.txt");

Este tipo de objetos permiten la ejecucion de diferentes métodos, como son:

// evalúa si es un directorio
f.isDirectory()
// evalúa si es n fichero
f.isFile();
// crea el directorio correspondiente
f.mkdir();
// crea todos los directorios si no están creados hasta llegar al indicado
f.mkdirs();
// comprueba si existe
f.exist();
// crea el fichero indicado
f.create();
// borra el fichero indicado
f.delete();
// lista los archivos del directorio indicado 
f.list();
// indica si se puede leer
f.canRead();
// indica si se puede escribir
f.canWrite();
// renombre el fichero indicado a un nombre dado
f.renameTo();

Flujo de carácteres

La primera posibilidad para trabajar con entradas y salidas en un fichero de tipo File son las clases FileReader y FileWriter. Dichas clases permiten el flujo de carácteres, leyendo y escribiendo en fichero indicado. Adicionalmente se utilizan las clases BufferedReader y BuffereWriter para crear un buffer de lectura / escritura para tratar la información de forma más segura. Para poder utilizar un objeto de este tipo se debe pasar como parámetro un objeto del tipo correspondiente

// Lectura
File f = new File ("src/documentos/ejemplo.txt);
FileReader fr = new FileReader(f);
BufferedReader br = new BufferedReader(fr);
// Escritura
File f = new File ("src/documentos/ejemplo.txt);
FileWriter fr = new FileWriter(f);
BufferedWriter br = new BufferedWriter (fr);

Dentro de los métodos más utilizados para las clases de lectura y escritura encontramos los siguientes:

// Lectura
File f = new File ("src/documentos/ejemplo.txt);
FileReader fr = new FileReader(f);
BufferedReader br = new BufferedReader(fr);
// lectura de un solo caracter en código ASCII
br.read();
// lectura de la linea completa
br.readLine();
// indica si el flujo de datos tiene elementos pendientes
br.ready();	
// cierra el flujo de los datos
br.close();
// Escritura
File f = new File ("src/documentos/ejemplo.txt);
FileWriter fw = new FileWriter(f);
BufferedWriter bw = new BufferedWriter (fw);
// escribe los datos en el fichero
bw.write();
// escribe un salto de linea en el fichero
bw.newLine();
// cierra el fichero
bw.close():

Flujos de datos binarios

En el caso de querer escribir un archivo con algo más de complejidad que simples datos primitivos, se necesitan utilizar las clases derivadas de InputStream / OutputStream. Las principales son: FileInputStream (in/out), DataInputStream (in/out) y ObjectInputStream (in/out)

FileStream

Utilizados para escribir y/o leer ficheros con códigos binarios. En realidad este tipo de ficheros es la base de muchos de los flujos de datos.

Para la lectura se utiliza el objeto de tipo FileInputStream y el método read

    public static void lecturaFicheroFInput(File f) {

        try {
            FileInputStream fis = new FileInputStream(f);
            int caracteres;
            byte[] caracterByte = new byte[1];
            while ((caracteres = fis.read(caracterByte)) != -1) {
                //devolución byte combertido a coódigo ASCII
                System.out.println((char) caracteres);
                System.out.println(new String(caracterByte));
            }
            fis.close();
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        }

    }

Hay que tener en cuenta que este método me devuelve el valor numérico correspondiente, el cual hay que pasar a byte y a String consecutivamente para poder leer el contenido de forma comprensible

Para la escritura se utiliza el objeto de tipo FileOutputStream y el método write. Para poder utilizar este método hay que pasarle una cadena de bytes, por lo que habrá que convertir el objeto a guardar en bytes

    public static void escrituraFicheroFInput(File f) {

        try {
            FileOutputStream fos = new FileOutputStream(f);
            String texto = "ejemplo de texto a guardar codificado en bytes";
            byte[] caracterByte = texto.getBytes();
            System.out.println(caracterByte);
            fos.write(caracterByte);
            fos.close();


        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }

DataStream

Utilizados para escribir y/o leer ficheros donde cada lectura se asocia a un tipo concreto. La traducción se realiza de bytes al tipo indicado

Para la lectura se utiliza DataInputStream junto con el metro readXXX() indicando el tipo concreto

    public static void lecturaFicheroDInput(File f) {
        try {
            DataInputStream dis = new DataInputStream(new FileInputStream(f));
            int edad = dis.readInt();
            char separador = dis.readChar();
            dis.close();
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }

Para la escritura se utiliza DataOutputStream junto con el metro writeXXX() indicando el tipo concreto

    public static void escrituraFicheroDOutput(File f) {
        try {
            DataOutputStream dos = new DataOutputStream(new FileOutputStream(f));
            dos.writeChars("Ejemplo de escritura");
            dos.writeChar('\n');
            dos.writeInt(100);
            dos.close();
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }

ObjectStream

Utilizados para escribir y/o leer ficheros donde se guardan objectos complejos. Hay que tener en cuenta que para poder guardar / leer un objeto este debe ser serializado (implementar la interfaz serializable) de forma que sea procesado por partes.

Para la lectura se utiliza un objeto de tipo ObjectInputStream con el método readXXX y el tipo concreto. En este caso existe la posibilidad de ejecutar el método readObject()

    public static void lecturaFicheroOOutput(File f) {
        try {
            ObjectInputStream ois = new ObjectInputStream(new FileInputStream(f));
            Object o = ois.readObject();
            for (Producto p: (ArrayList<Producto>)o
                 ) {
                System.out.println(p.getNombre());
            }
            ois.close();
        } catch (IOException e) {
            e.printStackTrace();
        } catch (ClassNotFoundException e) {
            e.printStackTrace();
        }
    }

Para la escritura se utiliza un objeto de tipo ObjectOutStream con el método writeXXX y el tipo concreto. En este caso existe la posibilidad de ejecutar el método writeObject(), teniendo en cuenta que el objeto que se quiera escribir haya implementado la interfaz serializable

    public static void escrituraFicheroOOutput(File f) {

        ArrayList<Producto> listaProductos = new ArrayList<Producto>();
        listaProductos.add(new Producto("Nombre1", "Descripcion1", 12));
        listaProductos.add(new Producto("Nombre2", "Descripcion2", 23));
        listaProductos.add(new Producto("Nombre3", "Descripcion3", 43));
        listaProductos.add(new Producto("Nombre4", "Descripcion4", 62));
        listaProductos.add(new Producto("Nombre5", "Descripcion5", 145));
        try {
            ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream(f));
            oos.writeObject(listaProductos);
            oos.close();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }

El código completo del ejemplo es:

package Ficheros;

import java.io.*;
import java.util.ArrayList;

public class Entrada {

    public static void main(String[] args) {
        File f = new File("src/Ficheros/documentos/ejemplo.txt");
        File f2 = new File("src/Ficheros/documentos/ejemplo1.docx");
        File f3= new File("src/Ficheros/documentos/ejemplo1.obj");
        if (!f.exists()) {
            try {
                f.createNewFile();
            } catch (IOException e) {
                e.printStackTrace();
            }
        } else {
            //lecturaFichero(f);
            //lecturaFicheroFiltro(f);
            //escrituraFichero(f);
            //lecturaFicheroFInput(f);
            //escrituraFicheroFInput(f);
            //lecturaFicheroDInput(f);
            //escrituraFicheroDOutput(f2);
            //escrituraFicheroOOutput(f3);
            lecturaFicheroOOutput(f3);
        }
    }

    public static void lecturaFichero(File f) {
        try {
            FileReader fr = new FileReader(f);
            BufferedReader br = new BufferedReader(fr);

            String linea = br.readLine();

            while (linea != null) {
                System.out.println(linea);
                linea = br.readLine();
            }
            br.close();
            fr.close();

        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }

    public static void lecturaFicheroFiltro(File f) {
        FileReader fr = null;
        try {
            fr = new FileReader(f);
            BufferedReader br = new BufferedReader(fr);
            String linea = br.readLine();
            int posicion = linea.indexOf(',');

            while (linea != null) {
                String parteUno = linea.substring(0, posicion);
                String parteDos = linea.substring(posicion + 1);
                linea = br.readLine();
            }

            fr.close();

        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        }

    }

    public static void escrituraFichero(File f) {
        try {
            FileWriter fw = new FileWriter(f);
            BufferedWriter bw = new BufferedWriter(fw);
            bw.append("Ejemplo de escritura en fichero");
            bw.newLine();
            bw.append("mediante flujo de control java");
            bw.close();
            fw.close();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }

    public static void lecturaFicheroFInput(File f) {

        try {
            FileInputStream fis = new FileInputStream(f);
            int caracteres;
            byte[] caracterByte = new byte[1];
            while ((caracteres = fis.read(caracterByte)) != -1) {
                //debolución byte combertido a coódigo ASCII
                System.out.println((char) caracteres);
                System.out.println(new String(caracterByte));

            }

            fis.close();
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        }

    }

    public static void escrituraFicheroFInput(File f) {

        try {
            FileOutputStream fos = new FileOutputStream(f);
            String texto = "ejemplo de texto a guardar codificado en bytes";
            byte[] caracterByte = texto.getBytes();
            System.out.println(caracterByte);
            fos.write(caracterByte);
            fos.close();


        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }

    public static void lecturaFicheroDInput(File f) {
        try {
            DataInputStream dis = new DataInputStream(new FileInputStream(f));
            int edad = dis.readInt();
            char separador = dis.readChar();
            dis.close();
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }

    public static void escrituraFicheroDOutput(File f) {
        try {
            DataOutputStream dos = new DataOutputStream(new FileOutputStream(f));
            dos.writeChars("Ejemplo de escritura");
            dos.writeChar('\n');
            dos.writeInt(100);
            dos.close();
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }

    public static void escrituraFicheroOOutput(File f) {

        ArrayList<Producto> listaProductos = new ArrayList<Producto>();
        listaProductos.add(new Producto("Nombre1", "Descripcion1", 12));
        listaProductos.add(new Producto("Nombre2", "Descripcion2", 23));
        listaProductos.add(new Producto("Nombre3", "Descripcion3", 43));
        listaProductos.add(new Producto("Nombre4", "Descripcion4", 62));
        listaProductos.add(new Producto("Nombre5", "Descripcion5", 145));
        try {
            ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream(f));
            oos.writeObject(listaProductos);
            oos.close();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
    public static void lecturaFicheroOOutput(File f) {

        try {
            ObjectInputStream ois = new ObjectInputStream(new FileInputStream(f));
            Object o = ois.readObject();
            for (Producto p: (ArrayList<Producto>)o
                 ) {
                System.out.println(p.getNombre());
            }
            ois.close();
        } catch (IOException e) {
            e.printStackTrace();
        } catch (ClassNotFoundException e) {
            e.printStackTrace();
        }
    }
}