Archivos Binarios

Introducción
 Si bien los archivos de texto en Java, facilitan la
labor en archivos de poco tamaño y que no
requieran seguridad, el empleo de un archivo
binario soluciona estos y otros inconvenientes, al
utilizar estos podemos guardar o leer cualquier
cosa: int, double, String, boolean, etc.

 Para poder utilizar archivos binarios, al igual que

cuando vamos a utilizar archivos, es necesario
importar la librería java.io.* para que podamos
utilizar todas las funciones de leer y escribir.
Archivos Binarios

 Los archivos binarios guardan una

representación de los datos en el archivo, es
decir, cuando guardamos texto no guardan el
texto en si, sino que guardan su representación
en un código llamado UTF-8.
 Archivos Binarios

 Los dos tipos de objetos que vamos a utilizar

para leer de archivos son el DataInputStream y
el DataOutputStream.
DataInputStream
El constructor a utilizar para iniciar el
DataInputStream es:

DataInputStream(new FileInputStream(fileName));

Donde fileName es un String con el nombre del

archivo que queremos abrir.
Este constructor crea un objeto tipo DataInputStream
que podemos utilizar para leer archivos binarios.
DataInputStream
Los métodos más útiles de DataInputStream son:
• String readUTF()
• byte readByte()
• int readInt()
• long readLong()
• double readDouble()
• short readShort()
• boolean readBoolean()

Estos métodos sirven para leer los diferentes tipos de

datos standar que soporta JAVA.
 Ejemplo de Lectura

String fileName = “C:\Archivo.dat”; Primero declaramos el objeto

DataInputStream fileIn = new De tipo DataInputStream
DataInputStream(new FileInputStream(fileName));
Iniciamos el DataInputStream con
try { un nuevo FileInputStream con el
nombre del archivo.
String unString = fileIn.readUTF();
int unInt = fileIn.readInt();
double unDouble = fileIn.readDouble()
} catch (IOException ioe) {
Estos métodos nos sirven para
} leer diferentes tipos de datos del
Archivo. Los datos permanecen
guardados en las variables y los
Siempre que leemos y
podemos utilizar después.
guardamos en archivos tenemos
que ponerlo en un try -> catch.
 DataOutputStream
El constructor que vamos a utilizar en esta clase para
iniciar el DataOutputStream es:

DataOutputStream(new FileOutputStream(fileName));

Como se observa el constructor es muy similar al

anterior ya que en esencia funciona de la misma
manera. Con este nuevo objeto DataOutputStream
vamos a poder escribir en archivos binarios.
DataOutputStream
Los métodos más útiles de DataOutputStream son:
• void writeUTF(String s)
• void writeByte(byte b)
• void writeInt(int i)
• void writeLong(long l)
• void writeDouble(double d)
• void writeShort(short s)
• void writeBoolean(boolean b)

Son muy similares a los de lectura, únicamente que en

lugar de devolver datos, los escriben.
 Ejemplo de Escritura

String fileName = “C:\Archivo.dat”;

DataOutputStream fileOut = new Primero declaramos el objeto
De tipo DataOutputStream
DataOutputStream(new
FileOutputStream(fileName));
try {
String unString = “Hola mundo!” Iniciamos el DataOutputStream con
un nuevo FileOutputStream con el
fileOut.writeUTF(unString); nombre del archivo.
// Es lo mismo que fileOut.writeUTF(“Hola mundo!”)
int i = 5;
fileOut.writeInt(i);
Estos métodos nos sirven
// Es lo mismo que para escribir diferentes tipos
// fileOut.writeInt(5) de datos al archivo, una vez
que estén guardados
catch (IOException ioe) { podemos abrir el archivo
} binario y leerlo con el
DataInputStream como ya
vimos anteriormente.
 Clases de Streams
(Streams orientados a byte)
• Los módulos sombreados representan
fuentes de datos.
• Los módulos sin sombrear
representan procesadores.
• Los procesadores se pueden aplicar a
otro procesador o a una fuente.

11
 Subclases de InputStream
• FileInputStream: lectura de files byte a byte
• ObjectInputStream: lectura de files con
objetos.
• FilterInputStream:
– BufferedInputStream: lectura con buffer, más
eficiente.
– DataInputStream: lectura de tipos de datos
primitivos (int, double, etc.).

12
 Subclases de OutputStream
• FileOutputStream: escritura de files byte a byte
• ObjectOutputStream: escritura de files con
objetos.
• FilterOutputStream:
– BufferedOutputStream: escritura con buffer, más
eficiente.
– DataOutputStream: escritura de tipos de datos
primitivos (int, double, etc.).

13
 Clases de Streams
(Streams orientados a caracter)
• Soportan UNICODE (16 bits para un char).
• Módulos sombreados son fuentes, y sin sombrear son
procesadores.

14
 Subclases de Reader
• InputStreamReader: convierte un stream de
bytes en un stream de chars.
– FileReader: se asocia a files de chars para leerlos.
• BufferedReader: proporciona entrada de
caracteres a través de un buffer (más
eficiencia).

15
 Subclases de Writer
• OutputStreamWriter: convierte un stream de
bytes en un stream de chars.
– FileWriter: se asocia a files de chars para
modificarlos.
• BufferedWriter: proporciona salida de
caracteres a través de un buffer (más
eficiencia).
• PrintWriter: métodos print() y println() para
distintos tipos de datos.
16
 Otras Clases de java.io
• File: permite realizar operaciones habituales
con files y directorios.
• RandomAccessFile: permite acceder al n-
ésimo registro de un file sin pasar por los
anteriores.
• StreamTokenizer: permite “trocear” un stream
en tokens.

17
 Típicos Usos de los Streams
(lectura por líneas)
public static void main(String[] args) throws IOException {
// 1a. Se lee un file línea a línea
BufferedReader in = new BufferedReader( new
FileReader("IOStreamDemo.java"));
String s, s2 = new String();
while((s = in.readLine())!= null)
s2 += s + "\n";
in.close();
// 1b. Se lee una línea por teclado
BufferedReader stdin = new BufferedReader( new
InputStreamReader(System.in));
System.out.print("Enter a line:");
System.out.println(stdin.readLine());
} 18
 Parsing de tipos básicos
String linea;
int a;
BufferedReader stdin = new BufferedReader( new
InputStreamReader(System.in));
System.out.print("Enter a line:");
linea = stdin.readLine();
a = Integer.parseInt(linea);
System.out.println(a);

• También están disponibles: parseDouble(), parseLong()

19
 Típicos Usos de los Streams
(escritura por líneas)
// throws IOException
String []s = {“hola“, “que”, “tal”};
// Se inicializa s
PrintWriter out1 = new PrintWriter( new
BufferedWriter( new FileWriter("IODemo.out")));
int lineCount = 1;
for (int i=0; i<s.length(); i++)
out1.println(lineCount++ + ": " + s[i]);
out1.close();

20
 Típicos Usos de los Streams
(escritura de tipos básicos)
// throws IOException
DataOutputStream out2 = new
DataOutputStream(new
BufferedOutputStream(new
FileOutputStream("Data.txt")));

out2.writeDouble(3.14159);
out2.writeBytes("That was pi\n“);
out2.writeChars( "That was pi\n“);
out2.writeDouble(1.41413);
out2.writeUTF("Square root of 2");
out2.close();

21
 Típicos Usos de los Streams
(lectura de tipos básicos)
// throws IOException
DataInputStream in5 = new DataInputStream( new
BufferedInputStream( new
FileInputStream("Data.txt")));

System.out.println(in5.readDouble());
System.out.println(in5.readLine()); // deprecated
System.out.println(in5.readDouble());
System.out.println(in5.readUTF());

22
 Típicos Usos de los Streams
(files de acceso aleatorio)
// throws IOException
// acceso de lectura/escritura
RandomAccessFile rf = new RandomAccessFile("rtest.dat", "rw");
for(int i = 0; i < 10; i++)
rf.writeDouble(i*1.00);
rf.close();
rf = new RandomAccessFile("rtest.dat", "rw");
rf.seek(5*8); // salta 5 doubles (8 bytes cada uno)
rf.writeDouble(47.00); // modifica el sexto double
rf.close();
// acceso de sólo lectura
rf = new RandomAccessFile("rtest.dat", "r");
for(int i = 0; i < 10; i++)
System.out.println( "Value " + i + ": " + rf.readDouble()); rf.close();

23
 Típicos Usos de los Streams
(Object Stream)
• Java permite guardar objetos en ficheros, pero esos objetos
deben implementar la interfaz Serializable:
public class MySerializableClass implements Serializable { ... }
• Ejemplo:
// throws IOException
FileOutputStream out = new FileOutputStream("theTime.dat");
ObjectOutputStream s = new ObjectOutputStream(out);
s.writeObject("Today");
s.writeObject(new Date(1,1,2006));
s.close();
// throws IOException y ClassNotFoundException
FileInputStream in = new FileInputStream("theTime.dat");
ObjectInputStream s = new ObjectInputStream(in);
String today = (String)s.readObject();
Date date = (Date)s.readObject();
s.close();
24
Ventajas de Archivos Binarios

 Las ventajas son multiples, particularmente

en el caso de volumenes mayores de datos,
el elemento seguridad que se ve
incrementado y el tamaño del archivo, que
permite una mayor tasa de transferencias de
datos en el tiempo. Ademas para poder leer
diferentes tipos de dato de un archivo de
texto hay que hacer casting, y además es
muy difícil saber donde empieza y donde
termina cada dato.