Lectura / Escritura de datos de tipos primitivos en Java

Se utilizan las clases DataInputStream y DataOutputStream. Estas clases, además de los métodos read() y write(), proporcionan métodos específicos para cada tipo de dato primitivo.

Ejemplos:

File fich= new File(ruta);

FileInputStream fis= new FileInputStream(fich);

DataInputStream dis= new DataInputStream(fis);

File fich= new File(ruta);

FileOutputStream fos= new FileOutputStream(fich);

DataOutputStream dos= new DataOutputStream(fos);

Lectura/Escritura de datos de tipos primitivos (buffered)

Se pueden utilizar con memoria intermedia. Por ejemplo:

archivo_salida = new DataOutputStream(

new BufferedOutputStream(

new FileOutputStream(ruta)));

archivo_entrada = new DataInputStream(

new BufferedInputStream(

new FileInputStream(ruta)));

donde ruta denota un ejemplar de File o un ejemplar de String.

Ejemplo de uso:

package flujosdedatos;

import java.io.BufferedInputStream;

import java.io.BufferedOutputStream;

import java.io.DataInputStream;

import java.io.DataOutputStream;

import java.io.EOFException;

import java.io.FileInputStream;

import java.io.FileOutputStream;

import java.io.IOException;

public class FlujosDeDatos {

    static final double[] precios = {19.99, 9.99, 15.99, 3.99, 4.99};

    static final int[] numerosDeUnidades = {12, 8, 13, 29, 50};

    static final String[] descripciones = {"memoria usb", "tarjeta sd",         "teclado", "disco usb", "disco duro"};

    public static void main(String[] args) throws IOException {

        DataOutputStream f_sal = null;

        try {

            f_sal = new DataOutputStream(new BufferedOutputStream(new FileOutputStream("facturacion.bin")));

            for (int i = 0; i < precios.length; i++) {

                f_sal.writeDouble(precios[i]);

                f_sal.writeInt(numerosDeUnidades[i]);

                f_sal.writeUTF(descripciones[i]);

            }

        } finally {

            f_sal.close();

        }

       

        DataInputStream f_ent = null;

        double total = 0.0;

        try {

            f_ent = new DataInputStream(new BufferedInputStream(new FileInputStream("facturacion.bin")));

            double precio;

            int numero_de_unidades;

            String descripcion;

            try {

                while (true) {

                    precio = f_ent.readDouble();

                    numero_de_unidades = f_ent.readInt();

                    descripcion = f_ent.readUTF();

                    total += numero_de_unidades * precio;

                }

            } catch (EOFException e) {

            }

            System.out.format("Importe total: %.2f€%n", total);

        } finally {

            f_ent.close();

        }

    }

}

Flujos de datos – DataOutputStream

void flush()	Vuelca en disco la memoria intermedia
int size()	Proporciona el número de bytes escritos hasta el momento.
void write(byte[] b, int ppio, int num)	Escribe num elementos de byte, empezando en ppio.
void write(int b)	Escribe el byte menos significativo del int que se le proporciona como argumento.
void writeBoolean(boolean v)	Escribe un valor boolean en forma de byte
void writeByte(int v)	Escribe el byte menos significativo del int que se le proporciona como argumento.
void writeBytes(String s)	Escribe la cadena en forma de bytes, descartando el byte superior de cada char
void writeChar(int v)	Escribe un char en forma de 2 bytes, con el MSB en primer lugar.
void writeChars(String s)	Escribe la cadena como una sucesión de caracteres (con 2 bytes cada uno).
void writeDouble(double v)	Traduce v a long empleando el método de Double doubleToLongBits, y escribe ese long en forma de 8 bytes con el MSB en primer lugar.
void writeFloat(float v)	Traduce v a int empleando el método de FloatfloatToIntBits y escribe ese int en forma de 4 bytes con el MSB en primer lugar.
void writeInt(int v)	Escribe el int v en forma de 4 bytes, con el MSB en primer lugar.
void writeLong(long v)	Escribe el long v en forma de 8 bytes, con el MSB en primer lugar.
void writeShort(int v)	Escribe el short v en forma de 2 bytes, con el MSB en primer lugar.
void writeUTF(String str)	Escribe los caracteres de la cadena en formato UTF-8 modificado

Flujos de datos – DataInputStream

int read(byte[] b)	Lee bytes hasta llenar b o acabar el fichero. Devuelve el número de bytes leídos, o -1 si el archivo está vacío.
int read(byte[] b, int off, int ppio)	Lee hasta len bytes, almacenándolos a partir de ppio.
boolean readBoolean()	Lee un byte y proporciona false si es 0 o true si no.
byte readByte()	Lee un byte.
char readChar()	Lee 2 bytes y los devuelve en forma de carácter.
double readDouble()	Lee 8 bytes y los devuelve en forma de double.
float readFloat()	Lee 4 bytes y los devuelve en forma de float.
void readFully(byte[] b)	Intenta llenar b de bytes. Si acaba el archivo o hay un error de E/S lanza una EOFException o IOException.
void readFully(byte[] b, int ppio, int num)	Intenta leer num bytes, almacenándolos a partir de ppio.
int readInt()	Inverso de writeInt(), lee 4 bytes y devuelve un int. Supone que el MSB está a la izquierda.
long readLong()	Inverso de writeLong(), lee 8 bytes y devuelve un long. Supone que el MSB está a la izquierda.
short readShort()	Inverso de writeShort(), lee 2 bytes y devuelve un short. Supone que el MSB está a la izquierda.
int readUnsignedByte()	Lee un byte y lo extiende por ceros para dar un int, entre 0 y 255. Inverso de writeByte hasta 255.
int readUnsignedShort()	Lee dos bytes para dar un int, entre 0 y 65535. Inverso de writeShort hasta 65535.
String readUTF()	Lee cadenas escritas con writeUTF.
static String readUTF(DataInput in)	Lee cadenas escritas con writeUTF en el ejemplar de DataInput aportado
int skipBytes(int n)	Intenta saltar n bytes, proporciona el número de bytes que ha saltado. No lanza excepciones.

Lectura/Escritura de ficheros de caracteres en Java

Se utilizan las clases FileReader y FileWriter

Lo primero es crear un ejemplar de la clase pasando al constructor una cadena con el nombre del fichero o un File.

Para la lectura y la escritura se utilizan los métodos read o write, que se encargan de leer o escribir un carácter.

Los caracteres alfanuméricos se pueden tratar en muchos esquemas de codificación, por defecto utilizan UTF-8, pero se puede pasar como argumento a FileReader y FileWriter una Charset determinado (ASCII, UNICODE, ISO-8859-1, etc)

Cuando se terminan las operaciones sobre los datos se cierra el fichero con el método close.

FileReader además proporciona los siguientes métodos, que devuelven el número de caracteres leídos, o -1, si se ha llegado al final del fichero:

int read (),  lee un carácter.

int read (char[] buf), lee caracteres en un array buf.

int read(char[] buf, int despl, int n), lee como máximo n caracteres en el array buf y empezando en buf[despl].

FileWriter además proporciona los siguientes métodos:

void write (int car), escribe un carácter.

void write (char[] buf), escribe un array de caracteres.

void write (char[] buf, int despl, int n), escribe n caracteres en el array buf y empezando en buf[despl].

void write (String st), escribe una cadena de caracteres.

append (char car), añade un carácter al fichero.

Lectura/Escritura en ficheros de caracteres utilizando memoria intermedia (buffered)

Las clases anteriores traducen directamente cada operación de E/S a una llamada al sistema operativo subyacente. Esto puede ser muy ineficiente cuando se procesan grandes volúmenes de información; resulta mucho más rápido leer y escribir siempre en una zona de memoria intermedia, que solo se llena o vacía (mediante llamadas al sistema operativo) cuando es necesario.

Las clases con memoria intermedia para el tratamiento de caracteres son: BufferedReader y BufferedWriter.

El constructor de la clase con memoria intermedia recibe un ejemplar de la clase sin memoria intermedia.

Además nos permiten procesar líneas de texto completas, mediante los métodos readLine().

Ejemplos:

FileReader fr = new FileReader(fichent)

BufferedReader br = new BufferedReader(fr);

FileWriter fw = new FileWriter(fichsal);

BufferedWriter bw = new BufferedWriter(fw);

Lectura/Escritura en ficheros de caracteres haciendo lectura por líneas

Para leer textos por líneas se emplean las clases BufferedReader y PrintWriter. El método de funcionamiento puede ser leer una línea completa, procesarla y escribirla en el archivo de destino.

Hay que tener en cuenta que cada sistema operativo hace uso de marcadores de fin de línea diferentes.

BufferedReader flujoDeEntrada = null;       

PrintWriter flujoDeSalida = null;       

try {           

flujoDeEntrada =  new BufferedReader(new FileReader(“libro.txt"));           

flujoDeSalida =  new PrintWriter(new FileWriter("copia_libro.txt"));

String linea;

while ((linea = flujoDeEntrada.readLine()) != null) {

flujoDeSalida.print(linea);

}

}  finally {

if (flujoDeEntrada != null) {

flujoDeEntrada.close();

}

if (flujoDeSalida != null) {

flujoDeSalida.close();

}

Lectura/Escritura de ficheros binarios en Java

Se utilizan las clases FileInputStream y FileOutputStream

Lo primero es crear un ejemplar de la clase pasando al constructor una cadena, con el nombre del fichero, o un File.

Para la lectura y la escritura se utilizan los métodos read o write, que se encargan de leer o escribir un byte.

Cuando se terminan las operaciones sobre los datos se cierra el fichero con el método close.

Ejemplo:

FileInputStream in =  new FileInputStream(fichero);

FileOutputStream out = new FileOutputStream("copia_"+fichero);           

int c;           

while ((c = in.read()) != -1) {

out.write(c);

int.close();

out.close();

Lectura/Escritura en ficheros binarios utilizando memoria intermedia (buffered)

Para leer y escribir bytes con memoria intermedia:

FileInputStream fis;

fis = new FileInputStream(“imagen.jpg”)

BufferedInputStream bis= new BufferedInputStream(fis);

FileOutputStream fos;

fos = new FileOutputStream(“copia_imagen.jpg”);

BufferedOutputStream bos = new BufferedOutputStream(fos);

Los Streams, tipos y jerarquías en Java

Definición

Los flujos de datos o Streams, son abstracciones que permiten tratar la comunicación de información entre una fuente y un destino. Los flujos actúan como interfaz con el dispositivo o clase asociada:

·         Operación independiente del tipo de datos y del dispositivo, por lo que aporta mayor flexibilidad

·         Diversidad de dispositivos (fichero, pantalla, teclado, red, …)

·         Diversidad de formas de comunicación

Modo de acceso: secuencial, aleatorio

Información intercambiada: binaria, caracteres, líneas

Están definidos en el paquete java.io

En Java se accede a la E/S estándar mediante los siguientes atributos estáticos de la clase java.lang.System:

System.in                    implementa la entrada estándar

System.out                  implementa la salida estándar

System.err                  implementa la salida de errores

Tipos de flujos

 Flujos de bytes (8 bits)

Realizan operaciones de entrada y salida de bytes.

Están orientados al tratamiento de datos binarios.

Utilizan las clases abstractas InputStream y OutputStream y sus descendientes.

Flujos de caracteres (16 bits)

Realizan operaciones de entrada y salida de caracteres.

Utilizan las clases abstractas Reader y Writer.

Se utilizan sobre todo para la internacionalización ya que permite manejar caracteres Unicode de 16 bits.

Jerarquía de flujos de bytes

Subclases de InputStream

Clase	Función
ByteArrayInputStream	Utiliza un buffer interno para los bytes leídos del stream
StringBufferInputStream	Obsoleta, se recomienda StringReader. Los bytes leídos al stream son proporcionados desde una cadena.
FileInput Stream	Obtiene los bytes de entrada desde un fichero del sistema
PipedInputStream	Permite implementar mecanismos de tubería,  para por ejemplo desacoplar la entrada de la salida
FilterInputStream	Toma datos de otro stream transformándolos o añadiéndoles funcionalidad
SequenceInputStream	Permite realizar una concatenación lógica de flujos de entrada

Subclases de OutputStream

Clase	Función
ByteArrayOutputStream	Implementa un flujo de salida en el que los datos se van escribiendo en una matriz de bytes que va creciendo
FileOutputStream	Es un flujo de salida para escribir datos en un fichero o en un descriptor de fichero
PipedOutpudStream	Permite implementar mecanismos de tubería,  junto con PipedInputStream
FilterOutputStream	Permite hacer transformaciones en los datos de salida

Jerarquía de flujo de caracteres