2º DAM - Desarrollo de Aplicaciones Multiplataforma

ACCESO A DATOS - RESUMEN MANEJO DE FICHEROS JAVA

ENTRADA/SALIDA ESTÁNDAR

Para la entrada y salida estándar tenemos varias clases que podemos emplear.

* Clase java.lang.System
· System.in implementa la entrada estándar
· System.out implementa la salida estándar
· System.err implementa la salida de error

Éstas clases se implementan con el paquete java.io.

* System.out
· Instancia de la clase PrintStream – flujo de bytes de salida
· Métodos de utilidad – impresión de datos
+ print(), println()
+ flush() vacía el buffer de salida escribiendo su contenido
* System.in
· Instancia de la clase InputStream – flujo de bytes de entrada
· Métodos
+ read() permite leer un caracter
+ skip(n) ignora n caracteres siguientes de la entrada
+ available() número de caracteres disponibles para leer en la trada
* System.err
· Funcionamiento similar a System.out

STREAMS

Un stream representa un flujo de información, una secuencia ordenada de datos procedente

de una fuente (teclado, file, memoria, red, etc.) o dirigida a un destino (pantalla, file, etc).

Los streams comparten una misma interfaz que hace abstracción de los detalles específicos
de cada dispositivo de E/S.

Todas las clases de streams están en el paquete java.io.

Hay varios tipos de Streams que se pueden clasificar según:

Representación de la información
+ Flujos de bytes
+ Flujos de caracteres

Propósito
+ Entrada – (InputStream, Reader)
+ Salida – (OutputStream, Writer)
+ Entrada / Salida – (RandomAccessFile)

Acceso
+ Secuencial
+ Directo o aleatorio – (RandomAccessFile)

Por operación
+ Transferencia de datos
+ Transformación de los datos (Realizan algún tipo de procesamiento sobre los
datos, por ejemplo buffering, conversiones, filtrados…)

Un stream es una secuencia ordenada de datos.

Tienen:
+ Una fuente = streams de entrada
+ Un destino = streams de salida
PAQUETE JAVA.IO

E/S puede estar basada en:

+ Texto. Streams de caracteres legibles. Por ejemplo el código fuente de un
programa
+ Datos. Streams de datos binarios. Por ejemplo el patrón de bits de una imagen.

Los streams de caracteres se utilizan en la E/S basada en texto. Se denominan lectores

(reader) y escritores (writer).

Los streams de bytes se utilizan en la E/S basada en datos. Se denominan streams de

entrada y streams de salida.

Clases principales java.io

Clases de flujo de entrada.

Se utilizan para leer datos de una fuente de entrada (archivo, cadena o memoria).
+ Flujo de bytes: InputStream, BufferedInputStream, DataInputStream,
FileInputStream.
+ Flujo de caracteres: Reader, BufferReader, FileReader.

Clases de flujo de salida.

Son las homogéneas a las clases de flujo de entrada y se utilizan para enviar flujos de datos
a dispositivos de salida.
+ Flujo de bytes: OutputStream, PrintStream, BufferedOutputStream,
DataOutputStream y FileOutputStream.
+ Flujo de caracteres: Writer, PrintWriter, FileWriter

Clases de archivo:
File y RandomAccessFile que permiten mayor control sobre los archivos.
InputStream

OutputStream

STREAMS SOBRE FICHEROS

FileInputStream​. Muy similar a la clase InputStream, sólo que está diseñada para leer
archivos.
FileInputStream(String name)
FileInputStream(File name)

FileOutputStream​. Muy similar a la clase OutputStream, sólo que está diseñada para escribir
en archivos.
FileOutputStream(String name)
FileOutputStream(String name, boolean append)
· Si append = true queremos añadir al final del fichero
FileOutputStream(File name)

FileReader

FileWriter
LECTURA DE UN FICHERO DE TEXTO EN JAVA

Podemos abrir un fichero de texto para leer usando la clase FileReader. Esta clase tiene
métodos que nos permiten leer caracteres. Sin embargo, suele ser habitual querer las líneas
completas, bien porque nos interesa la línea completa, bien para poder analizarla luego y
extraer campos de ella. FileReader no contiene métodos que nos permitan leer líneas
completas, pero sí BufferedReader. Afortunadamente, podemos construir un
BufferedReader a partir del FileReader de la siguiente forma:

File archivo = new File ("C:\\archivo.txt");

FileReader fr = new FileReader (archivo);
BufferedReader br = new BufferedReader(fr);
...
String linea = br.readLine();

La apertura del fichero y su posterior lectura pueden lanzar excepciones que debemos
capturar. Por ello, la apertura del fichero y la lectura debe meterse en un bloque try-catch.
Además, el fichero hay que cerrarlo cuando terminemos con él, tanto si todo ha ido bien
como si ha habido algún error en la lectura después de haberlo abierto. Por ello, se suele
poner al try-catch un bloque finally y dentro de él, el close() del fichero.
El siguiente es un código completo con todo lo mencionado.

import java.io.*;

class LeeFichero {
public static void main(String [] arg) {
File archivo = null;
FileReader fr = null;
BufferedReader br = null;

try {
// Apertura del fichero y creacion de BufferedReader para poder
// hacer una lectura comoda (disponer del metodo readLine()).
archivo = new File ("C:\\archivo.txt");
fr = new FileReader (archivo);
br = new BufferedReader(fr);

// Lectura del fichero

String linea;
while((linea=br.readLine())!=null)
System.out.println(linea);
}
catch(Exception e){
e.printStackTrace();
}finally{
// En el finally cerramos el fichero, para asegurarnos
 // que se cierra tanto si todo va bien como si salta
// una excepcion.
try{
if( null != fr ){
fr.close();
}
}catch (Exception e2){
e2.printStackTrace();
}
}
}
}

Como opción para leer un fichero de texto línea por línea, podría usarse la clase Scanner en
vez de el FileReader y el BufferedReader.

ESCRITURA DE UN FICHERO DE TEXTO EN JAVA

El siguiente código escribe un fichero de texto desde cero. Pone en él 10 líneas.

import java.io.*;

public class EscribeFichero

{
public static void main(String[] args)
{
FileWriter fichero = null;
PrintWriter pw = null;
try
{
fichero = new FileWriter("c:/prueba.txt");
pw = new PrintWriter(fichero);

for (int i = 0; i < 10; i++)

pw.println("Linea " + i);

} catch (Exception e) {
e.printStackTrace();
} finally {
try {
// Nuevamente aprovechamos el finally para
// asegurarnos que se cierra el fichero.
if (null != fichero)
fichero.close();
} catch (Exception e2) {
e2.printStackTrace();
}
 }
}
}

Si queremos añadir al final de un fichero ya existente, simplemente debemos poner un flag

a true como segundo parámetro del constructor de FileWriter.

FileWriter fichero = new FileWriter("c:/prueba.txt",true);