Procesamiento

De
Archivos
En Java

V4.0
Julio 2014
Ferreiras

Ferreiras Procesamiento de Archivos Con 1

JAVA
 Conceptos Básicos
Introducción a los flujos o streams
Los flujos surgen por la necesidad de las aplicaciones Java de interaccionar
con el exterior de dos posibles formas:
• Generando salida a la consola del DOS, a un fichero, etc.
• Capturando datos procedentes del teclado, de ficheros, de páginas web, etc.
Concepto de flujo: es como un río. El agua en movimiento es el flujo, su
contenido son los datos. Lo que permite que esos datos viajen de un origen a
un destino es el agua en movimiento, es decir, el flujo. En el caso de la
captura, desde un programa Java, de datos introducidos por un usuario
mediante teclado, el origen es el teclado, el destino, el programa Java y los
datos, lo tecleado por el usuario.
Java modela flujos mediante clases del paquete java.io. Este paquete se
estudiará más adelante, por el momento se va a explicar cómo una aplicación
Java captura datos introducidos por el usuario a través del teclado y cómo
realiza todo tipo de operaciones sobre los mismos.
 Conceptos Básicos
• El procesamiento de archivos en Java es basado
en flujos de datos que pueden ser cualquiera de
los dos, leídos o escritos.
• Es el modelo “Java stream-based IO model”,
basado byte.
• Basado en byte significa cualquiera de las dos,
leer bytes desde el flujo o escribir bytes en el flujo.
 Conceptos Básicos
• Los paquete IO de java ( java.io y java.nio, a tratar más
adelante ) tienen que ver, principalmente, con todo lo que
se refiere a la lectura de datos desde una fuente y la
escritura de datos a un destino.
• En Java, las fuentes de datos y los destinos de datos
más típicos son:
• Los archivos ( más común en una aplicación Java )
• Los buffers de memoria
• System.in, System.out, System.error
• Una conexión de red
 Conceptos Básicos
• El siguiente diagrama ilustra el principio de un programa
leyendo datos desde una fuente y escribiendo datos a un
destino:

Fuente Programa Destino

Toda la operación es al través de un buffer de

memoria, que no esta indicado aquí. Esto es, de la
fuente al buffer y del buffer al programa; O, del
programa al buffer y del buffer al destino
 Conceptos Básicos
• Un programa que necesita leer datos desde una fuente
requiere de un “input stream” o un Reader ( a ver más
adelante ):

InputStream
ó Reader
Fuente Programa
Conceptos Básicos
 Conceptos Básicos
• Un programa que necesita escribir datos hacia un destino
requiere un output stream o Writer ( a ver más adelante ):

OutputStream
ó Writer
Programa Destino
Conceptos Básicos
Conceptos Básicos
 Conceptos Básicos
• El procesamiento de archivos, vía la java.io, puede ser realizado de
diferentes maneras:
• Escritura/Lectura secuencial
• Escritura/Lectura aleatoria
• Acceder a la información de un archivo o directorio
• Una vez que se establece una conexión de red entre dos procesos,
estos se comunican entre sí a través de dicha conexión al igual que lo
harían con un archivo: El uso de un InputStream para leer los datos, y un
OutputStream para escribir datos. En otras palabras, Java IO se utiliza
para pasar los datos a enviar a la API de red de Java. Ese tema esta fuera
del alcance de este curso.
 Conceptos Básicos
• Las clases IO de Java consisten principalmente de streams y de
readers/witers.
• Los propósitos de las clases IO de Java son:
• File Access
• Network Access
• Internal Memory Buffer Access
• Inter-Thread Communication (Pipes)
• Buffering
• Filtering
• Parsing
• Reading and Writing Text (Readers / Writers)
• Reading and Writing Primitive Data (long, int etc.)
• Reading and Writing Objects
 Conceptos Básicos
• El procesamiento de archivos ocurre dentro del contexto
de un sistema de archivos.
• Un sistema de archivos es una cosa muy diferente a un
dispositivo de almacenamiento masivo y permanente,
DAMyP.
• Los DAMyP son dispositivos del hardware que no saben
nada acerca de la semántica de los archivos.
• Los DAMyP simplemente proporcionan un medio donde los
datos pueden ser almacenados.
 Conceptos Básicos
• Un sistema de archivos es una abstracción de alto nivel.
Es un método particular de organización e interpretación de
los datos almacenados en un DAMyP. .

• Las aplicaciones Java interactúan con un sistema de

archivos, no con los DAMyP directamente.

• Es el sistema de archivos define las abstracciones de

nombres de archivos, rutas, archivos, atributos de archivo,
etc.
 Un archivo Es una colección de registros
relacionados los cuales podemos procesar al
colocarlos en RAM leyéndolos desde una memoria
secundaria o DAMyP.

 Un registro Está compuesto de

varios campos.

 Un campo Es un grupo de
caracteres.

 Los caracteres En Java son caracteres UNICODE

compuestos de dos bytes, cada byte contiene ocho
dígitos binarios, 1 o 0; Los primeros 127 son los que están
en el ASCII-STD.
Ferreiras Procesamiento de Archivos Con 15
JAVA
 Gráficamente 
byte byte
Carácter UNICODE

F o f i Campo ( 4 caracteres)

Fofi 25 0 4.55 Registro ( 4 campos)

Luisa 35 3 5.45
Archivo ( 3 registros)
Tania` 25 1 6.33

Maria 55 12 6.77

nombre
identificadores de
edad
hijos
los campos.
altura

Ferreiras Procesamiento de Archivos Con 16

JAVA
 Procesamiento de archivos Es el
almacenamiento y gestión de datos usando
archivos. Esto incluye tareas como:
 Creación de campos;

 Creación de registros

 Actualización de los archivos;

 Manipulación de los datos

 ...

Ferreiras Procesamiento de Archivos Con 17

JAVA
 La escritura y lectura De datos en un
archivo se puede hacer:
 A nivel de caracteres;

 A nivel de bytes ;

 A nivel de campos.

 Lectura y escritura directa de objetos de una clase. Este

proceso se llama serialización de objetos;
 Téngase en cuenta que un registro puede ser representado
como un objeto de una clase

Ferreiras Procesamiento de Archivos Con 18

JAVA
 Para la creación de un archivo debemos
decidir:
 Un nombre de archivo apropiado ( La longitud y tipos de
caracteres permitidos dependerá del SO en el que se
ejecutará la JVM );

 Tipo de datos a ser almacenados ( caracteres, bytes,

primitivos );

 Propósito de uso, esto es, si es para escritura, lectura o

ambos;

 Método de creación

Ferreiras Procesamiento de Archivos Con 19

JAVA
 Para almacenar datos Hay dos
maneras, fundamentalmente distintas:

 En formato de texto
‘1’ ‘2’ ‘3’ ‘4’ ‘5’ ‘@’ ‘f’ ‘o’ ‘F’ ‘i’

 En formato binario
01010110110011101110101010111...

Ferreiras Procesamiento de Archivos Con 20

JAVA
  En formato de texto
Los elementos de datos se
representan en forma legible para
humanos, como una secuencia de
caracteres. Por ejemplo, en formato
de texto, el entero 12345 es
almacenado con una secuencia de
cinco caracteres:
‘1’ ‘2’ ‘3’ ‘4’ ‘5’

Ferreiras Procesamiento de Archivos Con 21

JAVA
  Para el manejo de entradas y salidas de
datos en formato de texto, como una
secuencia de caracteres, Java provee las
clases abstractas Reader y Writer:

Reader

InputStreamReader

FileReader

Ferreiras Procesamiento de Archivos Con 22

JAVA
  Para el manejo de entradas y salidas de
datos en formato de texto, como una
secuencia de caracteres, Java provee las
clases abstractas Reader y Writer:

Writer

OutputStreamWriter PrintWriter

FileWriter

Ferreiras Procesamiento de Archivos Con 23

JAVA
• Algunos métodos de la clase Writer:

void write(int c)
Writes a single character. Ver ejemplo
FileTextWrite0.java
void write(String str)
Writes a string.

void write(String str, int off, int len)

Writes a portion of a string.

Ferreiras Procesamiento de Archivos Con 24

JAVA
• Algunos métodos de la clase PrintWriter:
void println()
Terminates the current line by writing the line separator string.

void println(boolean x)
Prints a boolean value and then terminates the line.
Ver ejemplo
void println(char x) FileTextWrite0d.java
Prints a character and then terminates the line.

void println(char[ ] x)
Prints an array of characters and then terminates the line.

void println(double x)
Prints a double-precision floating-point number and then terminates the line.

void println(float x)
Prints a floating-point number and then terminates the line.

void println(int x)
Prints an integer and then terminates the line.

void println(long x)
Prints a long integer and then terminates the line.

Ferreiras Procesamiento de Archivos Con 25

JAVA
  En formato binario
Lo elementos de dato son
representados en bytes. Por ejemplo,
en formato binario, el numero entero
12345 es almacenado como una
secuencia de cuatro bytes1:
byte1 byte2 byte3 byte4
00000000 00000000 00110000 00111001

1: Recuerde el tema de INF-206 “Representación de información para el

Computador”, específicamente, la representación de los E+ usando 4 bytes.

Ferreiras Procesamiento de Archivos Con 26

JAVA
 Para el manejo de entradas y salidas de
datos binarios, como una secuencia de
bytes, Java provee las clases abstractas
InputStream y OutputStream:
InputStream

FileInputStream ObjectInputStream

Ferreiras Procesamiento de Archivos Con 27

JAVA
 Para el manejo de entradas y salidas de
datos binarios, como una secuencia de
bytes, Java provee las clases abstractas
InputStream y OutputStream:

OutputStream

FileOutputStream ObjectOutputStream PrintStream

Ferreiras Procesamiento de Archivos Con 28

JAVA
  ObjectInputStream,
ObjectOutputStream Son usadas
en la entrada y salida de streams
(flujos) de objetos como un todo,
completos.

Ferreiras Procesamiento de Archivos Con 29

JAVA
  Para el manejo de entradas y salidas de
datos en archivos de acceso aleatorio
(Random Access Files), Java provee la
clase RandomAccessFile:
public class RandomAccessFile extends Object

La cual soporta ambas operaciones sobre

archivos de acceso aleatorio, esto es,
lectura y escritura.

Ferreiras Procesamiento de Archivos Con 30

JAVA
  Otras clases en java.io de interés en este curso son
File y Console; Del paquete java.util es de interés la
clase Scanner;

 Muchas otras clases en el paquete java.io Como, por

ejemplo, BufferedInputStream(),
BufferedOutputStream(), BufferedReader() and
BufferedWriter(), DataInputStream(),
DataOutputStream(), StreamTokenizer,
PipedInputStream, PipedOutputStream,
PipedReader, PipedWriter, estas ultimas utilizadas en
pares para mover los datos dentro de una aplicación, están
fuera del alcance de este curso, al igual que las que están
en el paquete java.nio

Ferreiras Procesamiento de Archivos Con 31

JAVA
 java.nio package
http://docs.oracle.com/javase/tutorial/essential/io/fileio.html

• Defines buffers, which are containers for data, and provides an

overview of the other NIO packages.

• A buffer is a container for a fixed amount of data of a specific

primitive type. Buffer classes. These classes are the foundation upon
which java.nio is built.

• Is the file I/O mechanism introduced in the JDK 7 release. This API
may be used to overcome many of the limitations of the java.io.File

• Since: 1.4

• See on http://docs.oracle.com/javase/7/docs/api/index.html

Ferreiras Procesamiento de Archivos Con 32

JAVA
 java.nio package
http://docs.oracle.com/javase/tutorial/essential/io/fileio.html

• The java.nio.file package and its related package,

java.nio.file.attribute, provide comprehensive support for file
I/O and for accessing the default file system.

• The Path class is the primary entry point for the package.

• java.nio packages introduces some new I/O concepts that

are outside the scope of the java.io package.

• See more in the above URL

Ferreiras Procesamiento de Archivos Con 33

JAVA
 java.nio package
http://docs.oracle.com/javase/tutorial/essential/io/fileio.html

• The central abstractions of the NIO APIs are:

• Buffers, which are containers for data;

• The Buffer classes are the linkage between regular Java classes
and channels.

• Buffers implement fixed-size arrays of primitive data elements,

wrapped inside an object with state information. They provide a
rendezvous point: a Channel consumes data you place in a Buffer
(write) or deposits data (read) you can then fetch from the buffer. There
is also a special type of buffer that provides for memory-mapping files.

Ferreiras Procesamiento de Archivos Con 34

JAVA
 java.nio package
http://docs.oracle.com/javase/tutorial/essential/io/fileio.html

• The central abstractions of the NIO APIs are: - cont -

• Charsets and their

associated decoders and encoders, which translate
between bytes and Unicode characters;

• Channels of various types, which represent

connections to entities capable of performing I/O
operations;

• Channels are the most important new abstraction

provided by NIO.
Ferreiras Procesamiento de Archivos Con 35
JAVA
 java.nio package
http://docs.oracle.com/javase/tutorial/essential/io/fileio.html

• The central abstractions of the NIO APIs are: - cont -

• A Channel object models a communication connection.

The pipe may be unidirectional (in or out) or
bidirectional (in and out).

• A channel can be thought of as the pathway between

a buffer and an I/O service.

Ferreiras Procesamiento de Archivos Con 36

JAVA
 java.nio package
http://docs.oracle.com/javase/tutorial/essential/io/fileio.html

• The central abstractions of the NIO APIs are: - cont -

• In some cases, the older classes of the java.io

package can make use of channels. Where appropriate,
new methods have been added to gain access to the
Channel associated with a file or socket object.

• Selectors and selection keys, which together

with selectable channels define a multiplexed, non-blocking
I/O facility.

Ferreiras Procesamiento de Archivos Con 37

JAVA
 El paquete java.io
• Package java.io
http://docs.oracle.com/javase/7/docs/api/index.html

• Provides for system input and output through data streams, serialization and the file system.

• Unless otherwise noted, passing a null argument to a constructor or method in any class or
interface in this package will cause a NullPointerException to be thrown.

Ferreiras Procesamiento de Archivos Con 38

JAVA
 EOF no existe en JAVA !!
EOFException es usado, entre otras varias
formas inventadas por los javologos
guruses, para detectar el dichoso eof. Por
ejemplo:
try {
// Poner aqui el codigo que lee el archivo, dentro de un bocle
} catch (EOFException eofe) {
// OK. El archivo ha sido leido completamente.
} catch (IOException fofi ) {
System.out.println(fofi);
}

Ferreiras Procesamiento de Archivos Con 39

JAVA
 La clase File
La clase File proporciona un constructor
para crear un manejador de archivo ( file
handler ), el cual es, entonces, utilizado
por:
 Los métodos de la clase para acceder a las
propiedades de un archivo en especifico; O,

 Por los constructores de flujo (stream ) para

construir un objeto archivo asociado con el
nombre el archivo usado en el objeto File.

Ferreiras Procesamiento de Archivos Con 40

JAVA
  La clase File Describe los archivos y
directorios en un disco. Los Objetos File
realmente no abren un archivo ni
proporciona ninguna capacidad de
procesamiento de archivos. La utilidad de
esta clase esta en los métodos que
proporciona: Ver File en
http://download.oracle.com/javase/7/docs/api/

Ferreiras Procesamiento de Archivos Con 41

JAVA
 La clase Console
jva.io.Console
public final class Console extends Object

Methods to access the character-based console device, if any, associated with the current Java
virtual machine.

Whether a virtual machine has a console is dependent upon the underlying platform and also upon
the manner in which the virtual machine is invoked. If the virtual machine is started from an
interactive command line without redirecting the standard input and output streams then its console
will exist and will typically be connected to the keyboard and display from which the virtual machine
was launched. If the virtual machine is started automatically, for example by a background job
scheduler, then it will typically not have a console.

If this virtual machine has a console then it is represented by a unique instance of this class which
can be obtained by invoking the System.console() method. If no console device is available then an
invocation of that method will return null.

Read and write operations are synchronized to guarantee the atomic completion of critical
operations; therefore invoking methods readLine(), readPassword(), format(), printf() as well as the
read, format and write operations on the objects returned by reader() and writer() may block in
multithreaded scenarios.: Ver Console en http://download.oracle.com/javase/7/docs/api/

Ferreiras Procesamiento de Archivos Con 42

JAVA
 Escritura y Lectura de datos
en forma de texto

Ejemplos

Ferreiras Procesamiento de Archivos Con 43

JAVA
/*
FileTextWrite0.java
jdk1.7.0

Ferreiras /JAVA / Procesamiento de archivos / Archivos de texto /

Uso de la clase Writer

*/

Ferreiras Procesamiento de Archivos Con 44

JAVA
import java.io.*;

public class FileTextWrite0 {

public static void main(String[ ] args) {

try {
/ / Indicar que se tiene la intención de trabajar con un archivo
File objetoFile = new File("archivoTexto0.txt");
// Crear el archivo si no existe
boolean exito = objetoFile.createNewFile(); // true si creado
if( exito ) {
// Crear el archivo y lo prepara para escribirle datos.
FileWriter objetoWriter = new FileWriter(objetoFile);
objetoWriter.write("\nEsto es un ejemplo de un archivo de texto ");
objetoWriter.write("\nEsta es otra linea a un ejemplo de un archivo de texto\n ");
objetoWriter.close();
System.out.println("\n\t=> Archivo de texto creado exitosamente\n");
}
else { // El archivo no es sobreescrito si ya existe.
System.out.println(" \n\t=> El archivo ya existe " );
}
}
catch (IOException e) {
e.printStackTrace(); flush() vacía el buffer asociado a un flujo. Es usado cuando se
} quiere enviar los datos a su destino sin cerrar el flujo. Con el método
close() , los recursos asignados al OutputStream son liberados y
}
} los datos enviados a su destino, liberando el flujo de su buffer
asociado.

Ferreiras Procesamiento de Archivos Con 45

JAVA
 /*

C:\Archivos de programa\Java\jdk1.7.0\bin>java FileTextWrite0

=> Archivo de texto creado exitosamente

C:\Archivos de programa\Java\jdk1.7.0\bin>java FileTextWrite0

=> El archivo ya existe

C:\Archivos de programa\Java\jdk1.7.0\bin>

C:\Archivos de programa\Java\jdk1.7.0\bin> type archivoTexto0.txt

Esto es un ejemplo de un archivo de texto

Esta es otra linea a un ejemplo de un archivo de texto

C:\Archivos de programa\Java\jdk1.7.0\bin>

*/

Ferreiras Procesamiento de Archivos Con 46

JAVA
 /*
FileTextWritingExistingFile0.java
jdk1.7.0

Ferreiras / JAVA / Procesamiento de Archivos / Archivos de Texto

Clases JAVA a usar:

java.util.Scanner
java.util.Console
java.io.File
java.io.FileWriter
java.io.PrintWriter
java.io.IOException

(-_-) : En el codigo fuente en el grupo hay mas detalles.

*/

Ferreiras Procesamiento de Archivos Con 47

JAVA
 import java.io.*;
import java.util.Scanner;

public class FileTextWritingExistingFile0 {

public static void main(String[ ] args) {
File objetoFile = new File("texto0.txt");
boolean seleccion = true; // false no lo sobreescribe
Scanner leerTeclado = new Scanner(System.in);
String opcionSeleccionada;

Ferreiras Procesamiento de Archivos Con 48

JAVA
 try {
if ( objetoFile.exists( ) ) {
System.out.print("\n\t=> El archivo " + objetoFile.getName() +
“ ya existe, Usted quiere:\n “ +
“ \n\t * Sobreescribirlo.... S “ +
“ \n\t * Agregar.... A\n\n\t=> Su seleccion ( S o A ) : “ );
opcionSeleccionada = leerTeclado.next();
if ( opcionSeleccionada.equals("S") || opcionSeleccionada.equals("s") )
seleccion = false;
}
else {
System.out.println( "\n\t=> El archivo " + objetoFile.getName() +
" NO EXISTE, se procede a su creacion\n“ );
}
FileWriter objetoFileWriter = new FileWriter( objetoFile, seleccion );
PrintWriter objetoPrintWriter = new PrintWriter( objetoFileWriter, true);

Console console = System.console(); El objetoPrintWriter

String linea = console.readLine("\n\t=> Entre el texto a escribir: \n\n "); se necesita para
poder usar println( )
objetoPrintWriter.println(linea);
// objetoPrintWriter.flush();
objetoPrintWriter.close();
} flush() vacía el buffer asociado a un flujo. Es usado cuando se
catch( IOException fofi ) { } quiere enviar los datos a su destino sin cerrar el flujo. Con el método
} close() , los recursos asignados al OutputStream son liberados y
} los datos enviados a su destino, liberando el flujo de su buffer
asociado.

Ferreiras Procesamiento de Archivos Con 49

JAVA
C:\Archivos de programa\Java\jdk1.7.0\bin>java FileTextWritingExistingFile0

=> El archivo texto0.txt ya existe, Usted quiere:

* Sobreescribirlo.... S
* Agregar.... A

=> Su seleccion ( S o A ) : S

=> Entre el texto a escribir:

Estamos en lucha por el 5 % !!

C:\Archivos de programa\Java\jdk1.7.0\bin> type texto0.txt

Estamos en lucha por el 5 % !!

Ferreiras Procesamiento de Archivos Con 50

JAVA
C:\Archivos de programa\Java\jdk1.7.0\bin>java FileTextWritingExistingFile0

=> El archivo texto0.txt ya existe, Usted quiere:

public FileWriter( File file,
* Sobreescribirlo.... S boolean append )
* Agregar.... A throws IOException

Constructs a FileWriter object

=> Su seleccion ( S o A ) : A given a File object. If the second
argument is true, then bytes will be
=> Entre el texto a escribir: written to the end of the file rather
than the beginning.

Victimas de los criminales delincuentes

C:\Archivos de programa\Java\jdk1.7.0\bin> type texto0.txt

Estamos en lucha por el 5 % !!

Victimas de los criminales delincuentes

C:\Archivos de programa\Java\jdk1.7.0\bin>

Ferreiras Procesamiento de Archivos Con 51

JAVA
 Lectura y Escritura de
secuencia de bytes
La clase FileInputStream sobrecarga
el método read() para leer un solo byte a
la vez, que es retornado como un entero
en el rango [ 0, 255 ], esto es, un carácter
de la tabla ASCII - Extended. Si el fin de la
entrada ha sido alcanzado, read() retorna
un -1.

Ferreiras Procesamiento de Archivos Con 52

JAVA
  El trabajo de un flujo de entrada es
Obtener bytes, no analizarlos. Si queremos
leer números, cadenas o otros objetos se
debe combinar la clase con otras clases
cuya responsabilidad es agrupar los bytes
individuales en números, cadenas u
objetos.

Ferreiras Procesamiento de Archivos Con 53

JAVA
 Escritura y Lectura de
Secuencia de bytes

Ejemplos

Ferreiras Procesamiento de Archivos Con 54

JAVA
 /*

FilebyteLectura0b.java
jdk1.7.0

Ferreiras / JAVA / Procesamiento de archivos / Bytes / Lectura,

Escritura

Uso de la clase FileInputStream para leer secuencias de bytes

desde un archivo.

El programa lee un archivo cuyo nombre es suplido en línea de

comando y muestras por stdout la información que contiene.

*/

Ferreiras Procesamiento de Archivos Con 55

JAVA
 import java.io.*;

public class FileByteLectura0b {

public static void main( String [ ] args ) {

int unByte;

try {
// Crear un objeto File con el archivo en args [ 0 ]
File objetoFile =new File( args [0] );
// Construir un objeto FileInputStream con el objeto File
FileInputStream flujoEntrada = new FileInputStream ( objetoFile ) ;
// Leer los bytes y mostrarlos
System.out.println( "\n\t=> La informacion en el archivo " +
objetoFile.getName() + " son como sigue:\n");
while ( ( unByte = flujoEntrada.read( ) ) != -1 ) {
System.out.print ( (char) unByte );
}
flujoEntrada.close( );
}
catch( IOException fofi ) {
System.out.println (fofi ) ; Obsérvese: Conversión explicita
}
} del byte leido a un carácter ASCII-
} extended.

Ferreiras Procesamiento de Archivos Con 56

JAVA
/*

Procesamos archivo encontrado en http://lib.stat.cmu.edu/datasets/detroit

C:\Program Files\Java\jdk1.7.0\bin>java FileByteLectura0b detroitCrime.data

*/

Obsérvese que el args[0] en

esta línea de comando es el
archivo a procesar.

Ferreiras Procesamiento de Archivos Con 57

JAVA
 /*
FileImage0c.java
jdk1.7.0

Ferreiras / JAVA / Procesamiento de Archivos /

Lectura de imagen como una secuencia de bytes desde un archivo.

Class ImageIO

java.lang.Object
javax.imageio.ImageIO

static BufferedImage read( InputStream input )

Returns a BufferedImage as the result of decoding a supplied

InputStream with an ImageReader chosen automatically from among
those currently registered.

*/

Ferreiras Procesamiento de Archivos Con 58

JAVA
import java.io.*;
import javax.imageio.ImageIO; // Para lectura de la imagen
import javax.swing.*;
import java.awt.Image;
import java.awt.BorderLayout;

public class FileImage0c {

public static void main( String[ ] fifa ) {

Image imagen = null;

try {

// lectura como secuencia de bytes desde un archivo

File objetoFile = new File( "Sunset.jpg" );

FileInputStream fofi = new FileInputStream( objetoFile );
imagen = ImageIO.read( fofi ); // fofi es el InputStream suplido

catch (IOException e) {
}

Ferreiras Procesamiento de Archivos Con 59

JAVA
// mostrar la imagen leida en un JLabel en un JFrame

JFrame unMarco = new JFrame();

JLabel unaEtiqueta = new JLabel(new ImageIcon( imagen ));
unMarco.getContentPane().add( unaEtiqueta, BorderLayout.CENTER);
unMarco.pack();
unMarco.setVisible(true);
unMarco.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
}
}

Ferreiras Procesamiento de Archivos Con 60

JAVA
 C:\Program Files\Java\jdk1.7.0\bin>java FileImage0c

C:\Program Files\Java\jdk1.7.0\bin>

Ferreiras Procesamiento de Archivos Con 61

JAVA
/*
FileImage0d.java
jdk1.7.0

Ferreiras / JAVA / Procesamiento de Archivos /

Lectura de imagenes desde un URL como secuencia de bytes.

static BufferedImage read(URL input)

Returns a BufferedImage as the result of decoding a supplied URL with an

ImageReader chosen automatically from among those currently registered.
An InputStream is obtained from the URL, which is wrapped in an
mageInputStream.

If no registered ImageReader claims to be able to read the resulting stream,

null is returned.

*/

Ferreiras Procesamiento de Archivos Con 62

JAVA
import java.io.*;
import javax.imageio.ImageIO;
import javax.swing.*;
import java.awt.Image;
import java.awt.BorderLayout;
import java.net.*;

public class FileImage0d {

public static void main( String[ ] fofi ) {

Image imagen = null;

URL url = null;

try {

// lectura de la imagen desde un URL

// String direccion = "http://pookey.co.uk/gallery2/v/home/Sunset.jpg";
String direccion = "http://spaghettioh.com/wp-content/review_mirrors_edge/mirrors_edge_rooftop.jpg";
url = new URL(direccion);
imagen = ImageIO.read(url);
}

catch (IOException e) {
}

Ferreiras Procesamiento de Archivos Con 63

JAVA
 // mostrar la imagen leida en un JLabel en un JFrame

JFrame unMarco = new JFrame();

JLabel unaEtiqueta = new JLabel(new ImageIcon( imagen ));
unMarco.getContentPane().add( unaEtiqueta, BorderLayout.CENTER);
unMarco.pack();
unMarco.setVisible(true);
unMarco.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
}
}

Ferreiras Procesamiento de Archivos Con 64

JAVA
C:\Program Files\Java\jdk1.7.0\bin>java FileImage0d

C:\Program Files\Java\jdk1.7.0\bin>

Ferreiras Procesamiento de Archivos Con 65

JAVA
 Lectura y Escritura Aleatoria
de archivos

Similar to array index, to access individual byte or group of bytes in

primitive types (such as int and double). The file pointer is located at 0
when the file is opened. It advances automatically for every read and write
operation by the number of bytes processed.

Ferreiras Procesamiento de Archivos Con 66

JAVA
 Lectura y Escritura Aleatoria
de archivos
La clase RandomAccessFile provee las
facilidades para la escritura y lectura
aleatoria de registros en un archivo, esto
es, usando dicha clase podemos leer y
escribir datos en una posición
especificada dentro de un archivo.

Ferreiras Procesamiento de Archivos Con 67

JAVA
 La clase RandomAccessFile permite
moverse alrededor de un archivo y leer o
escribir en este como se quiera. También
permite modificar el contenido de los
registros en el archivo. Esto no es posible
con FileInputStream o
FileOutputStream.

Ferreiras Procesamiento de Archivos Con 68

JAVA
  Usando la clase RandomAccessFile,
Un archivo puede ser abierto en modo de
escritura, en modo de lectura o en ambos
modos para ser actualizado. Los
constructores disponibles son:
RandomAccessFile( File fileObject, String accessMethod)

RandomAccessFile( String name, String accessMethod)

accessMehod  Especifica el modo de acceso en el cual el

archivo será abierto puede ser "r", "rw", "rws" ó "rwd"

Ferreiras Procesamiento de Archivos Con 69

JAVA
 De la documentación API disponible
en el portal de Oracle:

RandomAccessFile(File file, String mode)

Creates a random access file stream to read from, and
optionally to write to, the file specified by the File argument.

RandomAccessFile(String name, String mode)

Creates a random access file stream to read from, and
optionally to write to, a file with the specified name.

Ferreiras Procesamiento de Archivos Con 70

JAVA
The mode argument specifies the access mode in which
the file is to be opened. The permitted values and their
meanings are:

Value Meaning
"r" Open for reading only. Invoking any of the write methods of the
resulting object will cause an IOException to be thrown.
"rw" Open for reading and writing. If the file does not already exist
then an attempt will be made to create it.
"rws" Open for reading and writing, as with "rw", and also require that
every update to the file's content or metadata be written
synchronously to the underlying storage device.
"rwd" Open for reading and writing, as with "rw", and also require that
every update to the file's content be written synchronously to the
underlying storage device.

 Ver más en dicho portal ...

Ferreiras Procesamiento de Archivos Con 71

JAVA
long getFilePointer()
Returns the current offset in this file.
long length()
Returns the length of this file.
Parte de los métodos de
int read() la clase
Reads a byte of data from this file.
byte readByte() RandomAccessFile. Ver
Reads a signed eight-bit value from this file.
char readChar() completo en el portal de
Reads a character from this file.
double readDouble()
documentación de
Reads a double from this file. oracle.
float readFloat()
Reads a float from this file.
void seek(long pos)
Sets the file-pointer offset, measured from the beginning of this file,
at which the next read or write occurs.
void setLength(long newLength)
Sets the length of this file.
void write(int b)
Writes the specified byte to this file.
void writeByte(int v)
Writes a byte to the file as a one-byte value.
void writeBytes(String s)
Writes the string to the file as a sequence of bytes.

Ferreiras Procesamiento de Archivos Con 72

JAVA
 seek( long position ) Es el método que
mueve el puntero de posición de archivo. Es
incrementado automáticamente después de
una escritura o lectura. Cuando un archivo de
acceso aleatorio es abierto, el puntero de
posición de archivo es, automáticamente,
posicionado al principio del archivo.

 getFilePointer( ) Es el metodo que retorna la posición

actual del puntero del archivo;

 setLength() Es el metodo para ajustar el tamaño del

archivo.

Ferreiras Procesamiento de Archivos Con 73

JAVA
/*
RandomAccessFileRW0.java

Ferreiras / Java / Procesamiento de Archivos / RandomAccessFile / Lectura y Escritura

public final void writeByte(int v) throws IOException

Writes a byte to the file as a one-byte value. The write starts at the current position of the file
pointer.

public final void writeChar(int v) throws IOException

Writes a char to the file as a two-byte value, high byte first. The write starts at the current
position of the file pointer.

public final String readLine() throws IOException

Reads the next line of text from this file. This method successively reads bytes from the file,
starting at the current file pointer, until it reaches a line terminator or the end of the file. Each
byte is converted into a character by taking the byte's value for the lower eight bits of the
character and setting the high eight bits of the character to zero. This method does not,
therefore, support the full Unicode character set.

Ferreiras Procesamiento de Archivos Con 74

JAVA
/*
RandomAccessFileRW0.java

Ferreiras / Java / Procesamiento de Archivos / RandomAccessFile / Lectura y Escritura

...

A line of text is terminated by a carriage-return character ('\r'), a newline character ('\n'), a

carriage-return character immediately followed by a newline character, or the end of the file.
Line-terminating characters are discarded and are not included as part of the string
returned.

This method blocks until a newline character is read, a carriage return and the byte following
it are read (to see if it is a newline), the end of the file is reached, or an exception is thrown.

Specified by: readLine in interface DataInput

Returns: the next line of text from this file, or null if end of file is encountered before even
one byte is read.
Throws: IOException - if an I/O error occurs.

*/

Ferreiras Procesamiento de Archivos Con 75

JAVA
// RandomAccessFileRW0.java

import java.io.*;

public class RandomAccessFileRW0 {

public static void main(String[] fofi) {

try {

// Creacion del archivo aleatorio para lectura y escritura

RandomAccessFile raf = new RandomAccessFile("D:/Ferreiras2/Java, Mi Codigo/raf1.bin", "rw" );
// Escribimos algo en el archivo raf1.bin
raf.writeBytes("Hola mis ovejas, ahora es con RAF");
raf.writeBytes("La suma de 45 + 15 es : ");
raf.writeInt( (45 + 15) );
raf.writeChars("Israel-USA realizan masascre en Gaza"); // Pruebe y autoexpliquese
raf.writeChars("\nHoy 27 es dia del padre en D.R."); // Pruebe y autoexpliquese por que no se muestra
por stdout

Ferreiras Procesamiento de Archivos Con 76

JAVA
// RandomAccessFileRW0.java

// establecemos el puntero de archivo a la posicion 0

raf.seek(0);
//leemos y mostramos el contenido del archivo
System.out.println(" " + raf.readLine()); // Ver readLine(): Lee todo a un String
// Vemos donde quedo posicionado el puntero de archivo
System.out.println(" " + raf.getFilePointer());
// cambiamos la posicion del puntero de archivo
raf.seek(5);
// Vemos donde esta posicionado el puntero de archivo
System.out.println("" + raf.getFilePointer());

// cerramos el stream para liberar los recursos

raf.close();
} catch (IOException ex) {
ex.printStackTrace();
}
}
}

Ferreiras Procesamiento de Archivos Con 77

JAVA
// RandomAccessFileRW0.java

D:\Ferreiras2\Java, Mi Codigo>javac RandomAccessFileRW0.java

D:\Ferreiras2\Java, Mi Codigo>java RandomAccessFileRW0

Hola mis ovejas, ahora es con RAFLa suma de 45 + 15 es : <Israel-U
SA realizan masascre en Gaza
135
5

D:\Ferreiras2\Java, Mi Codigo>type raf1.bin

Hola mis ovejas, ahora es con RAFLa suma de 45 + 15 es : <Israel-US
A realizan masascre en Gaza
Hoy 27 es dia del padre en D.R.
D:\Ferreiras2\Java, Mi Codigo>

Ferreiras Procesamiento de Archivos Con 78

JAVA
 RandomAccessFileRW0.java

Por qué 33 ? Veamos:

Bayte 0 Byte 32

Hola mis ovejas, ahora es con RAF

Es el siguiente byte, esto es 33

Ferreiras Procesamiento de Archivos Con 79

JAVA
 Para implementar un sistema de
gestión de archivos de acceso aleatorio
debemos estructurar un formato de registro
y determinar su tamaño para usarlo en el
método seek(). También se debe proveer
un método de indexación basado en uno o
mas campos del registro. El paquete
java.io solo suple las funciones primitivas
necesarias.

Ferreiras Procesamiento de Archivos Con 80

JAVA
/*

FileRandomWriteRead0.java
jdk1.7.0

Ferreiras / JAVA / Procesamiento de archivos / Archivos de acceso aleatorio

Escritura y lectura de de un archivo de acceso aleatorio (RandomAccessFile )

*/

Ferreiras Procesamiento de Archivos Con 81

JAVA
import java.io.*;

public class FileRandomWriteRead0 {

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

RandomAccessFile raf = new RandomAccessFile("misNumeros.bin", "rw");

// Escribimos secuencialmente 10 numeros enteros ( 4 bytes por cada uno )
for(int i = 0; i < 10; i++) {
raf.writeInt(i*100);
}
// Vemos la posicion actual del puntero en el archivo
System.out.println("\n\t * La posicion actual del puntero en el archivo es " + raf.getFilePointer());
// Movemos en puntero de archivo al principio ( indice 0 ) del archivo
raf.seek(0);
System.out.println("\n\t * La posicion actual del puntero en el archivo es " + raf.getFilePointer());

Ferreiras Procesamiento de Archivos Con 82

JAVA
 // Leemos secuencialmente el archivo
System.out.println("\n\t * Lectura secuencial de los registros en el archivo:\n");
for(int i = 0; i < 10; i++) {
System.out.println(" indice " + i + " registro " + (i + 1) + "\t=> " + raf.readInt());
}
// Leemos aleatoriamente el 4to registro ( un entero ) en el archivo
raf.seek(3*4); // Recordar que cada registro es de 4 bytes porque son enteros
System.out.println("\n\t* El 4to registro almacena el entero: " + raf.readInt());
// Modificamos aleatoriamente el contenido de un registro, por ejemplo, el registro # 5 (indice 4)
raf.seek(4*4); // posiciona el puntero
raf.writeInt(3377); // escribimos el valor 3377
// Posicionamos de nuevo el puntero al principio y leemos secuencialmente
raf.seek(0);
System.out.println("\n\t* Valores despues de modificar el registro # 5\n");
for(int i = 0; i < 10; i++) {
System.out.println(" indice " + i + " registro " + (i + 1) + "\t=> " + raf.readInt());
}
raf.close();
}
}

r0 r1 r2 r3 r4 r5 r6 r7

Ferreiras Procesamiento de Archivos Con 83

JAVA
 /*
C:\Program Files\Java\jdk1.7.0\bin>javac FileRandomWriteRead0.java

C:\Program Files\Java\jdk1.7.0\bin>java FileRandomWriteRead0

* La posicion actual del puntero en el archivo es 40

* La posicion actual del puntero en el archivo es 0

* Lectura secuencial de los registros en el archivo:

indice 0 registro 1 => 0

indice 1 registro 2 => 100
indice 2 registro 3 => 200
indice 3 registro 4 => 300
indice 4 registro 5 => 400
indice 5 registro 6 => 500
indice 6 registro 7 => 600
indice 7 registro 8 => 700
indice 8 registro 9 => 800
indice 9 registro 10 => 900

Ferreiras Procesamiento de Archivos Con 84

JAVA
* El 4to registro almacena el entero: 300

* Valores despues de modificar el registro # 5

indice 0 registro 1 => 0 Observes que este registro

indice 1 registro 2 => 100 fue accedido directamente
indice 2 registro 3 => 200 y modificado su contenido.
indice 3 registro 4 => 300 Eso solo es posible en
indice 4 registro 5 => 3377 archivos de tipo
indice 5 registro 6 => 500 RandomAccessFile
indice 6 registro 7 => 600
indice 7 registro 8 => 700
indice 8 registro 9 => 800
indice 9 registro 10 => 900

C:\Program Files\Java\jdk1.7.0\bin>

*/

Ferreiras Procesamiento de Archivos Con 85

JAVA
 /*
FileRandomWriteRead0a.java
jdk1.7.0

Ferreiras / JAVA / Procesamiento de archivos /

Archivos de acceso aleatorio

Escritura y lectura en un archivo de acceso aleatorio

(RandomAccessFile ) de números de tipo int ( 4 bytes ) y de
números de tipo double (8 bytes) en la secuencia

intdoubleintdoubleintdoubleintdoubleintdoubleintdoubleintdouble

*/
Ver en el grupo.

Ferreiras Procesamiento de Archivos Con 86

JAVA
 /*
FileRandom1b.java
jdk1.7.0

Ferreiras / JAVA / Procesamiento de Arcivos en JAVA

/ Archivos de Acceso Aleatorio

*/

import java.io.IOException;
import java.io.RandomAccessFile;
import java.io.IOException;
import java.util.Scanner;

Ver completo en el
grupo.

Ferreiras Procesamiento de Archivos Con 87

JAVA
 /*
FileRandomWriteReadRegistros.java
jdk1.7.0

Ferreiras / JAVA / Procesamiento de archivos / Archivos de Acceso Aleatorio

Escritura y lectura de registros de tamano fijo en un archivo aleatorio.

*/

import java.io.IOException; Es muy importante que su

import java.io.RandomAccessFile; código garantice el
// Definicion del registro procesamiento de registros del
tamaño diseñado.
class RegistroEmpleado {

// campos del registro

private String primerNombre; // 2 X 15 bytes --> 30

private String primerApellido; // 2 X 15 bytes --> 30
private String direccion; // 2 X 30 bytes --> 60
private byte edad; // 1 byte --> 1
private double salario; // 8 ---> 8
// TOTAL = 129 bytes

Ferreiras Procesamiento de Archivos Con 88

JAVA
C:\Archivos de programa\Java\jdk1.7.0\bin>java FileRandomWriteReadRegistros

* Longitud actual del archivo: 645 bytes

* Size del registro: 129 bytes
* Cantidad actual de registros: 5 registros

* Archivo original

Leandra Acosta La Jaiba # 22 22 1235.4

Evangelina Perez Los Cocos # 7 15 4566.33
Acacia Guzman B. Aires # 456 32 33345.1
Kalika Aquino C R, # 56, Haine 13 5435.67
Luisa Lopez XXXX YY 16 1234.56

* Archivo modificado

Leandra Acosta La Jaiba # 22 22 0.0

Evangelina Perez Los Cocos # 7 15 4566.33
Acacia Guzman B. Aires # 456 32 0.0
Kalika Aquino C R, # 56, Haine 13 5435.67
Luisa Lopez XXXX YY 16 0.0

C:\Archivos de programa\Java\jdk1.7.0\bin>

Ver completo en el grupo.

Ferreiras Procesamiento de Archivos Con 89

JAVA
Lectura y Escritura de objetos
En Java podemos escribir objetos
completos y leerlos completos también:
 ObjectOuputStream
Es la clase para escribir un objeto completo a un archivo:

 ObjectInputStream
Es la clase para leer un objeto completo desde un archivo:

Los objetos deben pertenecer a clases que

implementan la interface Serializable. Esta
interface no contiene métodos.
Ferreiras Procesamiento de Archivos Con 90
JAVA
  ObjectOuputStream
Es la clase para escribir un objeto
completo a un archivo:

CuentaAhorro objetoCA = ... ;

FileOuputStream fos = new FileOutputStream( nombreArchivo.bin);
ObjectOutputStream oos = new ObjectOutputStream( fos );
oos.writeObject(ocjetoCA);

Ferreiras Procesamiento de Archivos Con 91

JAVA
  ObjectInputStream
Es la clase para leer un objeto completo
desde un archivo:

FileInputStream fis = new FileInputStream( nombreArchivo.bin);

ObjectInputStream ois = new ObjectInputStream( pos );
CuantaAhorro cah = ( CuentaAhorro ) ois.readObject();

readObject() Retorna una referencia a

Object por lo que hay que hacer el
casting hacia el tipo de objetos que hay
escritos en el archivo.

Ferreiras Procesamiento de Archivos Con 92

JAVA
 Escritura de objetos en un
contenedor
También podemos almacenar objetos en
un objeto contenedor que implemente la
interface Serializable y escribir este ultimo
al archivo. Todos los objetos en la
referencia al contenedor quedaran
escritos en dicho archivo:

Ferreiras Procesamiento de Archivos Con 93

JAVA
 Símbolo de un
Gráficamente: DAMyP

obj0
obj1 oos.writeObject( contenedor );
obj2


Escribe el objeto contenedor en el archivo

Ferreiras Procesamiento de Archivos Con 94

JAVA
 Por ejemplo, considerando usar un
contenedor tipo ArrayList:
ArrayList<CuentaAhorro> aca = new ArrayList<CuentaAhorro> ();
// Agregamos ( a.add( objetoCuentaAhorro ); )
FileOuputStream fos = new FileOutputStream( nombreArchivo.bin);
ObjectOutputStream oos = new ObjectOutputStream( fos );
oos.writeObject(aca);

Todos los objetoCuentaAhorro que estén

almacenados en el contenedor aca se escribirán
en el archivo nombreArchivo.bin

Ferreiras Procesamiento de Archivos Con 95

JAVA
 /*
FileObjectStream0a.java
jdk1.7.0

Ferreiras / JAVA / Procesamiento de archivos / Flujo de objetos

Escritura secuencial de archivo de objetos

*/

import java.io.Serializable;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
import java.util.ArrayList;

Ferreiras Procesamiento de Archivos Con 96

JAVA
 class Exportables implements Serializable {

private long cedula;

private String nombre;
private int edad;
private String sexo;

// Construye un objeto persona ( Un "registro" )

public Exportables( long cedula, String nombre, int edad, String sexo) {
this.cedula = cedula;
this.nombre = nombre;
this.edad = edad;
this.sexo = sexo;
}

Ferreiras Procesamiento de Archivos Con 97

JAVA
 public long getCedula() {
return cedula;
}

public void setCedula(long cedula) {

this.cedula = cedula;
}

public int getEdad() {

return edad;
}

public void setEdad(int edad) {

this.edad = edad;
}

Ferreiras Procesamiento de Archivos Con 98

JAVA
 public String getNombre() {
return nombre;
}

public void setNombre(String nombre) {

this.nombre = nombre;
}

public String getSexo() {

return sexo;
}

public void setSexo(String sexo) {

this.sexo = sexo;
}
}

Ferreiras Procesamiento de Archivos Con 99

JAVA
 public class FileObjectStream0a {

@SuppressWarnings("unchecked")

public static void main(String[ ] args) {

String filename = "dominicanos.bin";

Exportables p1 = new Exportables(12345, "Pedro Lopez", 35, "Masculino ");
Exportables p2 = new Exportables(56789, "Maria LaKieta", 23, "Femenino");
Exportables p3 = new Exportables(45633, "Ricarda LaLoka", 18, "Metro");
ArrayList<Exportables> listaExportables = new ArrayList();
try {
listaExportables.add(p1);
listaExportables.add(p2);
listaExportables.add(p3);
}
finally { }

Ferreiras Procesamiento de Archivos Con 100

JAVA
FileOutputStream fos = null;
ObjectOutputStream out = null;
try {
fos = new FileOutputStream(filename);
out = new ObjectOutputStream(fos);
out.writeObject(listaExportables); // Escribe el ArrayList en el archivo
out.close();
System.out.println("\n\t El archivo fue creado exitosamente\n");
} catch (IOException fofi ) {
fofi.printStackTrace();
}
}
}

Ferreiras Procesamiento de Archivos Con 101

JAVA
 /*

C:\Program Files\Java\jdk1.7.0\bin>java FileObjectStream0a

El archivo fue creado exitosamente

C:\Program Files\Java\jdk1.7.0\bin>

*/

Ferreiras Procesamiento de Archivos Con 102

JAVA
 Lectura de objetos hacia un
contenedor
Con una sola instrucción de lectura podemos
leer todos los objetos en el archivo:
FileInputStream fis = new FileInputStream( nombreArchivo.bin);
ObjectInputStream ois = new ObjectInputStream( pos );
ArrayList<CuentaAhorro> aca = (ArrayLis< CuentaAhorro> ) ois.readObject();

readObject() Retorna una referencia a Object por lo

que hay que hacer el casting hacia el tipo de
objetos que hay escritos en el archivo.

Ferreiras Procesamiento de Archivos Con 103

JAVA
 Siempre deberemos hacer las
Gráficamente: conversion explicita al tipo de los
objetos almacenados en el
contenedor escrito en el archivo

obj0
obj1 (contenedor) ois.readObject( );
obj2


Lee los objetos en el archivo hacia el contenedor

Ferreiras Procesamiento de Archivos Con 104

JAVA
 /*
FileObjectStream0b.java
jdk1.7.0

Ferreiras / JAVA / Procesamiento de Arcivos / Flujo de objetos

Lectura secuencial de archivo de objetos

*/

import java.io.Serializable;
import java.io.FileInputStream;
import java.io.IOException;
import java.io.ObjectInputStream;
import java.util.ArrayList;

Ferreiras Procesamiento de Archivos Con 105

JAVA
 class Exportables implements Serializable {

private long cedula;

private String nombre;
private int edad;
private String sexo;

// Construye un objeto persona ( Un "registro" )

public Exportables( long cedula, String nombre, int edad, String sexo) {
this.cedula = cedula;
this.nombre = nombre;
this.edad = edad;
this.sexo = sexo;
}

Ferreiras Procesamiento de Archivos Con 106

JAVA
 public long getCedula() {
return cedula;
}

public void setCedula(long cedula) {

this.cedula = cedula;
}

public int getEdad() {

return edad;
}

public void setEdad(int edad) {

this.edad = edad;
}

Ferreiras Procesamiento de Archivos Con 107

JAVA
 public String getNombre() {
return nombre;
}

public void setNombre(String nombre) {

this.nombre = nombre;
}

public String getSexo() {

return sexo;
}

public void setSexo(String sexo) {

this.sexo = sexo;
}
}

Ferreiras Procesamiento de Archivos Con 108

JAVA
 public class FileObjectStream0b {

@SuppressWarnings("unchecked")

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

String nombreArchivo = "dominicanos.bin";

ArrayList<Exportables> listaExportables= null;
FileInputStream fis = null;
ObjectInputStream in = null;
try {
fis = new FileInputStream(nombreArchivo);
in = new ObjectInputStream(fis);
listaExportables = (ArrayList<Exportables>) in.readObject();
in.close();
} catch (IOException fofi ) {
fofi.printStackTrace();
} catch (ClassNotFoundException fofi) {
fofi.printStackTrace();
}

Ferreiras Procesamiento de Archivos Con 109

JAVA
// Mostrarmos los registros
System.out.println("\nCantidad de registros en el archivo: " + listaExportables.size()+ "\n" );
for( int i = 0; i < listaExportables.size(); ++i ) {
System.out.println( "Registro : " + i + " " + listaExportables.get(i).getCedula() +
" " + listaExportables.get(i).getNombre() +
" " + listaExportables.get(i).getSexo() +
" " + listaExportables.get(i).getEdad() );
}

System.out.println();
}
}

Ferreiras Procesamiento de Archivos Con 110

JAVA
 /*

C:\Program Files\Java\jdk1.7.0\bin>java FileObjectStream0b

Cantidad de registros en el archivo: 3

Registro : 0 12345 Pedro Lopez Masculino 35

Registro : 1 56789 Maria LaKieta Femenino 23
Registro : 2 45633 Ricarda LaLoka Metro 18

C:\Program Files\Java\jdk1.7.0\bin>

*/

Ferreiras Procesamiento de Archivos Con 111

JAVA
 Serialización
El proceso de guardar objetos en un flujo es
llamado serialización. A cada objeto le es asignado
un numero de serie en el flujo. Si el mismo objeto
es guardado dos veces, únicamente el numero de
serie es escrito la segunda vez. Cuando el objeto
es leído los números de series duplicados son
restaurados como referencias al mismo objeto.

Ferreiras Procesamiento de Archivos Con 112

JAVA
  La serialización de objetos es un
mecanismo automático para guardar y
recuperar el estado de un objeto.
Básicamente, una instancia de cualquier
clase que implemente la interface
Serializable puede ser guardado y
recuperado de un flujo.

Ferreiras Procesamiento de Archivos Con 113

JAVA
  Las clases ObjectOutputStream y
ObjectInputStream son usadas para serializar
tipos primitivos y objetos. Toda derivada de
clases Serializables son también Serializable. El
mecanismo de serialización por defecto guarda
todos los campos de los objetos, a excepción de
aquellos que son static o que estén marcados
como transient. Cuando un objeto es
serializado, cualquier referencia que este
contenga también es serializada.

Profundizar este tema esta fuera del alcance de este curso. Sorry.

Ferreiras Procesamiento de Archivos Con 114

JAVA
 EJEMPLOS

INF512_JAVA_Archivos_Ejem.zip

FileTextWrite0.java
FileTextWritingExistingFile0.java
FilebyteLectura0b.java
FileImage0c.java
FileImage0d.java
FileRandomWriteRead0.java
FileRandomWriteRead0a.java
FileRandom1b.java
FileRandomWriteReadRegistros.java
FileObjectStream0a.java
FileObjectStream0b.java

Ferreiras Procesamiento de Archivos Con 115

JAVA
 EJERCICIOS

INF512_JAVA_Archivos_Ejerc.doc

Ferreiras Procesamiento de Archivos Con 116

JAVA
 Referencias
•
• Package java.io, Package java.nio
http://docs.oracle.com/javase/7/docs/api/index.html

• Java™ NIO; Ron Hitchens; O’Reilly, First Edition August, 2002

• Streams-Readers-Writers Classes for Input and Output, Summary of
java.io; See in the Ferreiras´s group “Streams-Readers-Writers
Classes for IO.doc”

Ferreiras Procesamiento de Archivos Con 117

JAVA
 GRACIAS

Ferreiras Procesamiento de Archivos Con 118

JAVA