Descargar para leer sin conexión
![Archivos
Métodos constructores
File f=new File(“nombre_archivo”);
File f=new File(“ruta”);
File f=new File(“ruta”, “nombre_archivo”);
File f=new File (objeto_File, “nombre_archivo”);
boolean x=obj_File.canRead(); true si es de lectura
boolean x=obj_File.canWriter(); true si es de escritura
boolean x=obj_File.exists(); true si el archivo existe
boolean x=obj_File.isHidden(); true si el archivo está oculto
boolean x=obj_File.isDirectory(); true si es un directorio (caso Windows una carpeta)
boolean x=obj_File.delete(); true si se pudo borrar el archivo
boolean x=obj_File.mkdir(); true si se pudo crear el directorio
boolean x=obj_File.renameTo(archivo_nuevoNombre); renombrar un archivo, regresa true si se pudo cambiar el nombre
String [] obj_File.list(); Regresa un arreglo con los nombres de los archivos y directorios que contiene un directorio
String n=obj_File.getName(); Regresa el nombre del archivo o directorio
String n=obj_File.getParent(); Regresa el nombre del directorio al que pertenece el archivo
String n=obj_File.getPath(); Regresa la ruta donde se localiza el archivo
String n=obj_File.getAbsolutePath(); Regresa la ruta absoluta (desde la raíz) donde se localiza el archivo
String cad=obj_File.toString(); regresa el objeto File en cadena
long tam=obj_File.length() Regresa el tamaño del archivo, en bytes.
long fecha=obj_File.lastModified(); Regresa la fecha de la última modificación del archivo, desde -------
obj_File.createTemFile(); Permite crear un archivo temporal
obj_File.setReadOnly(); Cambia el estado del archivo a solo lectura
obj_File.deleteOnExit(); Solicita al sistema que elimine el archivo cuando finalice la máquina virtual. Esta solicitud sólo
se aplica en una finalización normal de la máquina virtual, y no se puede revocar una vez
emitida.
Clase Reader
Algunos de sus métodos
int y=obj.read() regresa un valor entre 0 y 65535, un –1 para indicar final del flujo
int y=obj.read(char [] x, int posicionInicioArreglo, int cantidadCaracteres) regresa el número de caracteres almacenados en el
arreglo x
int y= obj.read(char [] x); regresa el número de caracteres almacenados en el arreglo, inicia desde la posición 0, es
equivalente a: obj.read(char [] x, 0, x.length);
long z=obj.skip(long cantidadBytes); ignora bytes en el buffer, regresa la cantidad de bytes brincados
boolean c=obj.ready(); regresa true si el stream (flujo) está listo para ser leído
obj.close(); cierra el flujo de entrada de datos
Clase InputStream
Algunos de sus métodos
int y=obj.read() regresa un valor entre 0 y 255, un –1 para indicar final del flujo
int y=obj.read(byte [] x, int posicionInicioArreglo, int cantidadDatos) regresa el número de datos almacenados en el arreglo x
int y= obj.read(byte [] x); regresa el número de datos almacenados en el arreglo, inicia desde la posición 0, es equivalente
a: obj.read(byte [] x, 0, x.length);
long z=obj.skip(long cantidadBytes); ignora bytes en el buffer, regresa la cantidad de bytes brincados, pero puede invocarse sin
la asignación, es decir: obj.skip(cantidad); u obj.skip(obj.available());
boolean c=obj.ready(); regresa true si el stream (flujo) está listo para ser leído
obj.close(); cierra el flujo de entrada de datos
int y=obj.available(); regresa la cantidad de bytes que se pueden leer (o saltar) sin bloquearse
Clase Writer
Algunos de sus métodos
obj.write(int x);
Maria Eugenia Puga Nathal Página 6 17/09/2015](https://image.slidesharecdn.com/archivos15-150917140852-lva1-app6891/85/Archivos-15-6-320.jpg)
![Archivos
obj.write(char [] x, int posicionInicioArreglo, int cantidadCaracteres); escribe una cantidad x de caracteres a partir de una posición
dada en el arreglo
obj.write(char [] x); escribe (almacena) caracteres en un arreglo a partir de la posición 0, es equivalente a: obj.write(char [] x, 0,
x.length);
obj.write(String cad);
obj.write(String cad, int posicionIncialCadena, int cantidadCaracteres); escribe una cantidad x de caracteres a partir de una
posición dada en la cadena
obj.flush(); obliga a vaciar el buffer enviando a los datos a su destino
obj.close(); cierra el flujo de salida de datos
Clase OutputStream
Algunos de sus métodos
obj.write(byte x);
obj.write(byte [] x, int posicionInicioArreglo, int cantidadElementos); escribe una cantidad x de datos de tipo byte a partir de una
posición dada en el arreglo
obj.write(byte [] x); escribe (almacena) datos tipo byte en un arreglo a partir de la posición 0, es equivalente a: obj.write(byte [] x,
0, x.length);
obj.flush(); obliga a vaciar el buffer enviando a los datos a su destino
obj.close(); cierra el flujo de salida de datos
Todos los métodos presentados en las cuatro clases anteriores, son heredados a las clases que se derivan de estas y que fueron
presentadas en la última tabla, algunas de ellas vamos a estar utilizando para el manejo de archivos.
Es aconsejable que cuando se de la creación de un objeto que se asociara con un archivo, primero se verifique la existencia de éste
a través del método exists() de la clase File, por ejemplo:
Clase FileReader
Clase que permite leer archivos de texto (secuenciales), si se quiere leer línea por línea, se auxilia de la clase BufferedReader.
Algunos de sus métodos
Método constructor
FileReader(String nombArchivo);
FileReader(File objFile);
Clase FileWriter
Clase que permite crear archivos de texto (secuenciales), en caso de que se quiera grabar línea por línea se auxilia de la clase
PrintWriter.
Algunos de sus métodos
Método constructor
FileWriter(String nombArchivo);
FileWriter(File objFile);
FileWriter(String nombArchivo, true); el valor true permite que se respeten los caracteres existente, y que los nuevos se agreguen
al final de la archivo.
FileWriter(File objFile, true);
Clase PrintWriter
Permite producir salida formateada, es decir se preocupa por la visualización. Si se utiliza en combinación con la clase
FileOutputStream o FileWriter para escribir una cadena, le añade al final un salto de línea si se utiliza el método println.
Algunos de sus métodos
Métodos constructores
PrintWriter(destino)
PrintWriter(destino,true) el valor booleano indica que se vacía el espacio de almacenamiento intermedio con cada nueva línea.
Maria Eugenia Puga Nathal Página 7 17/09/2015](https://image.slidesharecdn.com/archivos15-150917140852-lva1-app6891/85/Archivos-15-7-320.jpg)
![Archivos
Algunos de sus métodos
Método constructor
DataOutputStream sal=new DataOutputStream(fuente);
La fuente para el caso que nos interesa será la clase FileOutputStream, por lo que el objeto sal lo podemos crear de dos maneras:
Primera
FileOutputStream archivo=new FileOutputStream(”archivo.dat”);
DataOutputStream sal=new DataOutputStream(archivo);
Segunda
DataOutputStream sal=new DataOutputStream(new FileOutputStream(”archivo.dat”));
sal.write(byte n); // escribe un valor de tipo byte
sal.write(byte [] n); // escribe un arreglo de datos de tipo byte
sal.writeByte(byte b); // escribe un valor de tipo byte
sal.writeShort(short s); // escribe un valor de tipo short
sal.writeInt(int i);// escribe un valor de tipo int
sal.writeLong(long l);// escribe un valor de tipo long
sal.writeFloat(float f);// escribe un valor de tipo float
sal.writeDouble(double d);// escribe un valor de tipo double
sal.writeChar(char car);// escribe un valor de tipo char
sal.writeChars(String cad);// escribe un valor de tipo String como un arreglo de caracteres
sal.writeUTF(String cad);// escribe un valor de tipo String en formato UTF
sal.writeBoolean(boolean bol);// escribe un valor de tipo boolean
Para el caso del formato UTF, cuando se tenga que contabilizar la cantidad de bytes necesario para el almacenamiento de la cadena
en el archivo (caso archivos aleatorios) agregar dos bytes mas, que utiliza la clase para guardar el tamaño de la cadena.
Serialización
La serialización de objetos en Java permite tomar cualquier objeto que implemente la interfaz Serializable y convertirlo en una
secuencia (flujo) de bits que puede ser posteriormente restaurada para regenerar el objeto original. La serialización de un objeto
permite darle mas persistencia al objeto (la vida del objeto se alargara), ya que éste seguirá existiendo aun cuando termine la
ejecución del programa, solo que ahora lo hará en memoria secundaria y no en la memoria principal y cuando sea nuevamente
leído cobrará ese efecto de persistencia.
Cabe mencionar que la interfaz Serializable es una simple bandera, y no contiene métodos, es un indicador de que un objeto puede
o no serializarse, es decir, convertirse o no a un flujo de bits.
Para serializar objetos es necesario hacer uso de la clase ObjetcOutputStream a través del método writeObject(objetoSerializable),
y para invertir este proceso, es decir obtener el objeto nuevamente en su forma original (deserializar) es necesario utilizar la clase
ObjectInputStream a través del método readObject(), pero en este caso se regresa una referencia a un objeto Object por lo que es
necesario hacer una conversión explícita al momento de la lectura al tipo de objeto en particular. Por ejemplo:
Obj.writeObject(”objeto cadena”); // serializa
String cad=(String) obj.readObject(); // deserializa
Cuando se está controlando la serialización, puede ocurrir que haya un subobjeto (o atributo) en particular para el que no se desee
que se produzca un salvado y recuperación automáticos por parte del mecanismo de serialización de Java. Como por ejemplo una
contraseña. Una forma de cómo evitar que partes sensibles de un objeto sean serializables es anteponer el modificador de tipo
transient. Cabe mencionar que cuando se tienen datos u objetos con el modificador de tipo static, tampoco serán serializados.
Clase ObjectInputStream
Permite obtener una secuencia de bytes (o de bits) y convertirla a un objeto en particular. Lee un objeto (convertido en una
secuencia de bytes (o de bits)) de alguna fuente de entrada en particular (red, archivo).
Algunos de sus métodos
Método constructor
Maria Eugenia Puga Nathal Página 10 17/09/2015](https://image.slidesharecdn.com/archivos15-150917140852-lva1-app6891/85/Archivos-15-10-320.jpg)
![Archivos
class EjemFile2
{public static void main (String arg[])
{String directorio;
if (arg.length>0)
{directorio=arg[0];} // el nombre del directorio se introduce al momento de ejecutar el programa
else {directorio=".";} // directorio actual
File actual=new File(directorio);// creo objeto que se enlaza con el directorio
if (actual.exists()) // se verifica la existencia del archivo o del directorio
{if (actual.isFile()) // se verifica si es archivo, si se regresa true si lo es, en caso contrario se trata de un directorio
{System.out.println("Es un archivo");}
else
{ System.out.println("El directorio es:");
try {System.out.println(actual.getCanonicalPath());}
catch(IOException e){}
System.out.println("Su contenido es:");
File archivos[]=actual.listFiles(); // obtienen el contenido del directorio
for (int i=0;i<archivos.length && archivos!=null;i++) // presenta el contenido del directorio
{System.out.print(archivos[i].getName());
if (archivos[i].isFile())
{System.out.print("t"+archivos[i].length());
System.out.print("t"+(new Date(archivos[i].lastModified())));
}
System.out.println();
}
}
}
else {System.out.println("no existe el directorio o el archivo");}
}
}
Archivos secuenciales
Archivos de texto
LECTURA
Clase FileReader
Ejemplo de la lectura de un archivo de texto, caracter por caracter:
import java.io.*;
class lectura_archivo_car
{public static void main(String arg[]) throws IOException
{ // introduzco el nombre del archivo desde el teclado al momento de ejecutar
// el programa, es capturado por el parámetro arg del método main
String archivo=arg[0];
String cad="";
int car=0;
// se crea un objeto de la clase FileReader, lo que significa que el archivo
//esta abierto en modo lectura
FileReader ent=new FileReader(archivo);
try { car=ent.read(); // se lee el primer caracter del archivo
while(car!=-1) // se verifica que no sea fin de archivo
{cad=cad+(char)car; //opcional, formo una cadena con los caracteres leídos del archivo
System.out.print((char)car); // se imprime el caracter leído
car=ent.read(); // se lee el siguiente caracter del archivo, se almacena -1 cuando se haya llegado al final de éste
}
System.out.println("nnnSe imprime la cadena formada por los caracteres leídos del");
System.out.println("archivo lo anterior se imprimió caracter por caracter.");
System.out.println(cad); //opcional, imprimo la cadena formada con los caracteres leidos del archivo
ent.close(); // Se cierra el archivo
Maria Eugenia Puga Nathal Página 12 17/09/2015](https://image.slidesharecdn.com/archivos15-150917140852-lva1-app6891/85/Archivos-15-12-320.jpg)
![Archivos
}
catch (IOException e)
{// por si se genera algún problema en la lectura del archivo
// por el momento la dejo en blanco
}
}
}
Ejemplo de la lectura de un archivo de texto donde lectura de éste es cadena (línea) por cadena(línea):
import java.io.*;
class lectura_archivo
{public static void main(String arg[]) throws IOException
{ // introduzco el nombre del archivo desde el teclado al momento de ejecutar
// el programa, es capturado por el parámetro arg del método main
String archivo=arg[0];
String cad=null;
// creo un objeto de la clase BufferedReader para obtener la cadena
// completa del archivo, línea por línea, es decir al momento de encontrar
// los carcateres rn (enter+salto de línea) se forma una primera cadena
// (línea de texto), se envía como parámetro un objeto anónimo de la clase
// FileReader, la cual es utilizada como fuente de donde se obtendrán las
// cadenas, al momento de crear este objeto anónimo, se está dando la
// apertura al archivo en modo de lectura
BufferedReader ent=new BufferedReader(new FileReader(archivo));
try { cad=ent.readLine(); // se lee la primera cadena (o línea de texto) del archivo
while(cad!=null) // se verifica que no sea fin de archivo
{System.out.println(cad); // se imprime la cadena leída desde del archivo
cad=ent.readLine(); // se lee la siguiente línea del archivo
}
ent.close(); // se cierra el flujo del objeto que contiene el control del flujo del archivo
}
catch (EOFException e)
{// por si se genera algún problema en la lectura del archivo
// por el momento la dejo en blanco
}
}
}
Si la aplicación que se está desarrollando requiere la lectura de un archivo de texto, pero que a su vez vaya listando el número de
línea, se puede utilizar la clase LineNumberReader, la cual es una extensión de la clase BufferedReader, es decir hereda los
métodos y atributos de la clase, agregando otros como getLineNumber(), el cual permite obtener el número de una línea,
setLineNumber(int NumeroLinea).
Ejemplo de la lectura de un archivo de texto línea por línea, además de enumerar cada línea leída:
import java.io.*;
class lectura_archivo_linea
{public static void main(String arg[]) throws IOException
{ // introduzco el nombre del archivo desde el teclado al momento de ejecutar
// el programa, es capturado por el parámetro arg del método main
String archivo=arg[0];
String cad=null;
int nl=0;
// creo un objeto de la clase LineNumberReader para obtener la cadena (línea) y número de línea
// completa del archivo, línea por línea, se envía como parámetro un objeto
// anónimo de la clase FileReader, la cual es utilizada como fuente de donde
// se obtendrán las cadenas, al momento de crear este objeto anónimo, se está dando la
// apertura al archivo en modo de lectura
LineNumberReader ent=new LineNumberReader(new FileReader(archivo));
Maria Eugenia Puga Nathal Página 13 17/09/2015](https://image.slidesharecdn.com/archivos15-150917140852-lva1-app6891/85/Archivos-15-13-320.jpg)
![Archivos
try { cad=ent.readLine(); // se lee el primera línea de texto del archivo
while(cad!=null) // se verifica fin de archivo
{nl=ent.getLineNumber(); // se obtiene el numero de línea
System.out.println(nl+" "+cad); //se imprime numero de línea y contenido de la línea
cad=ent.readLine(); // se lee la siguiente línea de texto
}
ent.close();// se cierra el flujo del objeto que contiene el control del flujo del archivo
}
catch (IOException e)
{// por si se genera algún problema en la lectura del archivo
// por el momento la dejo en blanco
}
}
}
Clase FileInputStream
Ejemplo de la lectura de un archivo de texto, caracter por caracter:
import java.io.*;
class lectura_archivo_car_2
{public static void main(String arg[]) throws IOException
{ // introduzco el nombre del archivo desde el teclado al momento de ejecutar
// el programa, es capturado por el parámetro arg del método main
String archivo=arg[0];
String cad="";
int car=0;
// se crea un objeto de la clase FileReader, lo que significa que el archivo
//esta abierto en modo lectura
FileInputStream ent=new FileInputStream(archivo);
try { car=ent.read(); // se lee el primer caracter del archivo
while(car!=-1) // se verifica que no sea fin de archivo
{cad=cad+(char)car; //opcional, formo una cadena con los caracteres leídos del archivo
System.out.print((char)car); // se imprime el caracter leído
car=ent.read(); // se lee el siguiente caracter del archivo, se almacena -1 cuando se haya llegado al final de éste
}
System.out.println("nnnSe imprime la cadena formada por los caracteres leídos del");
System.out.println("archivo lo anterior se imprimió caracter por caracter.");
System.out.println(cad); //opcional, imprimo la cadena formada con los caracteres leídos del archivo
ent.close(); // Se cierra el archivo
}
catch (IOException e)
{// por si se genera algún problema en la lectura del archivo
// por el momento la dejo en blanco
}
}
}
Ejemplo de la lectura de un archivo de texto línea por línea:
import java.io.*;
class lectura_archivo_2
{public static void main(String arg[]) throws IOException
{ // introduzco el nombre del archivo desde el teclado al momento de ejecutar
// el programa, es capturado por el parámetro arg del método main
String archivo=arg[0];
String cad=null;
// creo un objeto de la clase BufferedReader para obtener la cadena
// completa del archivo, línea por línea, es decir al momento de encontrar
// los carcateres rn (enter+salto de línea) se forma una primera cadena
Maria Eugenia Puga Nathal Página 14 17/09/2015](https://image.slidesharecdn.com/archivos15-150917140852-lva1-app6891/85/Archivos-15-14-320.jpg)
![Archivos
// (línea de texto), se envía como parámetro un objeto anónimo de la clase
// FileInputStream para convertir el flujo de bytes a caracteres, a su vez,
// éste tendrá como parámetro un objeto anónimo de la clase FileInputStream,
// la cual es utilizada como fuente de donde se obtendrán las cadenas, al
// momento de crear este objeto anónimo, se está dando la apertura al archivo en modo de lectura
BufferedReader ent=new BufferedReader(new InputStreamReader(new FileInputStream(archivo)));
try { cad=ent.readLine(); // se lee la primera cadena (o línea de texto) del archivo
while(cad!=null) // se verifica que no sea fin de archivo
{System.out.println(cad); // se imprime la cadena leída desde del archivo
cad=ent.readLine(); // se lee la siguiente línea del archivo
}
ent.close(); // se cierra el flujo del objeto que contiene el control del flujo del archivo
}
catch (EOFException e)
{// por si se genera algún problema en la lectura del archivo
// por el momento la dejo en blanco
}
}
}
Clase RandomAccessFile
Ejemplo de la lectura de un archivo de texto cadena por cadena (para que funcione de manera correcta, el archivo se debió de
haber creado con la clase RandomAccessFile):
import java.io.*;
class aleatorio_texto_lect
{public static void main(String arg[]) throws IOException
{ // introduzco el nombre del archivo desde el teclado al momento de ejecutar
// el programa, es capturado por el parámetro arg del método main
String archivo=arg[0];
String cad="";
// se crea un objeto de la clase RandomAccessFile, en modo lectura (r)
RandomAccessFile arch=new RandomAccessFile(archivo,"r");
try {// se genera un ciclo infinito donde se estarán leyendo los datos del
// archivo, el ciclo se rompe al momento en que no hay elementos en el
// archivo, y se lanza la excepción EOFException
while(true)
{cad=arch.readUTF(); // se lee la cadena en formato UTF
System.out.println(cad); // se imprime la cadena leída
}
}
catch(EOFException fin)
{System.out.println("fin de archivo "+ fin.getMessage());
arch.close();
}
}
}
ESCRITURA
Clase FileWriter
Ejemplo de la generación de un archivo de texto, caracter por caracter
import java.io.*;
class escritura_archivo_car
{public static void main(String arg[]) throws IOException
{// introduzco el nombre del archivo desde el teclado al momento de ejecutar
// el programa, es capturado por el parámetro arg del método main
String arch=arg[0];
Maria Eugenia Puga Nathal Página 15 17/09/2015](https://image.slidesharecdn.com/archivos15-150917140852-lva1-app6891/85/Archivos-15-15-320.jpg)
![Archivos
// se crea un objeto de la clase FileWriter, lo que significa que el archivo
// está abierto en modo escritura, el valor de true indica, que tantas veces ejecute
// el programa podré agregar datos al mismo archivo, si en un momento dado, quiero
// que cada vez que ejecute el programa y sea el mismo archivo, tenga nuevos datos éste,
// se elimina el valor booleano y la coma, dejando solo el nombre (o variable) del archivo
FileWriter escribe=new FileWriter(arch,true);
char car=' ';
try {System.out.println("dar * para terminar");
while(car!='*')
{ car=(char)System.in.read();
if (car!='*')
{escribe.write(car);} // se escribe o graba el caracter en el archivo
System.in.skip(System.in.available());
}
escribe.close(); // se cierra el archivo
}
catch(IOException e)
{}
finally {escribe.close();} // es otra parte del try, esta se realiza se produzca o no una excepción
}
}
Ejemplo de la generación de un archivo de texto, cadena por cadena
import java.io.*;
class escritura_archivo_cad
{public static void main(String arg[]) throws IOException
{// introduzco el nombre del archivo desde el teclado al momento de ejecutar
// el programa, es capturado por el parámetro arg del método main
String arch=arg[0];
BufferedReader ent=new BufferedReader(new InputStreamReader(System.in));
// se crea un objeto de la clase FileWriter, lo que significa que el archivo
// está abierto en modo escritura, el valor de true indica, que tantas veces ejecute
// el programa podré agregar datos al mismo archivo, si en un momento dado, quiero
// que cada vez que ejecute el programa y sea el mismo archivo, tenga nuevos datos éste,
// se elimina el valor booleano y la coma, dejando solo el nombre (o variable) del archivo
FileWriter escribe=new FileWriter(arch,true);
String cad="";
try {System.out.println("dar fin para terminar");
while(cad.equalsIgnoreCase("fin")!=true)
{ cad=ent.readLine();
if (cad.equalsIgnoreCase("fin")!=true)
{escribe.write(cad);} // se escribe o graba la cadena en el archivo
}
escribe.close(); // se cierra el archivo
}
catch(IOException e)
{}
finally {escribe.close();} // es otra parte del try, esta se realiza se produzca o no una excepción
}
}
Ejemplo de la generación de un archivo de texto, línea por línea
import java.io.*;
class escritura_archivo
{public static void main(String arg[]) throws IOException
{// introduzco el nombre del archivo desde el teclado al momento de ejecutar
// el programa, es capturado por el parámetro arg del método main
String arch=arg[0];
Maria Eugenia Puga Nathal Página 16 17/09/2015](https://image.slidesharecdn.com/archivos15-150917140852-lva1-app6891/85/Archivos-15-16-320.jpg)
![Archivos
BufferedReader ent=new BufferedReader(new InputStreamReader(System.in));
// se crea un objeto de la clase PrintWriter para que me permita grabar
// una cadena e incorpore el salto de línea, esto a través del método println,
// cuando se crea el objeto se manda como parámetro el objeto anónimo de la clase
// FileWriter, el cual se tomará como destino, además con la creación de este objeto
// anónimo se da la apertura al archivo, el valor de true indica, que tantas veces ejecute
// el programa podré agregar datos al mismo archivo, si en un momento dado, quiero
// que cada vez que ejecute el programa y sea el mismo archivo, tenga nuevos datos éste,
// se elimina el valor booleano y la coma, dejando solo el nombre (o variable) del archivo
PrintWriter escribe=new PrintWriter(new FileWriter(arch,true));
String cad="";
try {System.out.println("dar fin para terminar");
while(cad.equalsIgnoreCase("fin")!=true)
{ cad=ent.readLine();
if (cad.equalsIgnoreCase("fin")!=true)
{escribe.println(cad);} // se escribe o graba la línea de texto (cadena) en el archivo
}
escribe.close(); // se cierra el flujo del objeto que contiene el flujo del archivo
}
catch(IOException e)
{}
finally {escribe.close();} // es otra parte del try, ésta se realiza se produzca o no una excepción
}
}
Clase FileOutputStream
Ejemplo de la generación de un archivo de texto, caracter por caracter
import java.io.*;
class escritura_archivo_car_2
{public static void main(String arg[]) throws IOException
{// introduzco el nombre del archivo desde el teclado al momento de ejecutar
// el programa, es capturado por el parametro arg del metodo main
String arch=arg[0];
// se crea un objeto de la clase FileOutputStream, lo que significa que el archivo
// está abierto en modo escritura, el valor de true indica, que tantas veces ejecute
// el programa podré agregar datos al mismo archivo, si en un momento dado, quiero
// que cada vez que ejecute el programa y sea el mismo archivo, tenga nuevos datos éste,
// se elimina el valor booleano y la coma, dejando solo el nombre (o variable) del archivo
FileOutputStream escribe=new FileOutputStream(arch,true);
char car=' ';
try {System.out.println("dar * para terminar");
while(car!='*')
{ car=(char)System.in.read();
if (car!='*')
{escribe.write((byte)car);} // se escribe o graba el caracter en el archivo, con un valor explixito de tipo byte
System.in.skip(System.in.available());
}
escribe.close(); // se cierra el archivo
}
catch(IOException e)
{}
finally {escribe.close();} // es otra parte del try, esta se realiza se produzca o no una excepción
}
}
Ejemplo de la generación de un archivo de texto, línea por línea
import java.io.*;
Maria Eugenia Puga Nathal Página 17 17/09/2015](https://image.slidesharecdn.com/archivos15-150917140852-lva1-app6891/85/Archivos-15-17-320.jpg)
![Archivos
class escritura_archivo_2
{public static void main(String arg[]) throws IOException
{// introduzco el nombre del archivo desde el teclado al momento de ejecutar
// el programa, es capturado por el parámetro arg del método main
String arch=arg[0];
BufferedReader ent=new BufferedReader(new InputStreamReader(System.in));
// se crea un objeto de la clase PrintStream para que me permita grabar
// una cadena e incorpore el salto de línea, esto a través del método println,
// cuando se crea el objeto se manda como parámetro el objeto anónimo de la clase
// FileOutputStream, el cual se tomará como destino, además con la creación de este objeto
// anónimo se da la apertura al archivo, el valor de true indica, que tantas veces ejecute
// el programa podré agregar datos al mismo archivo, si en un momento dado, quiero
// que cada vez que ejecute el programa y sea el mismo archivo, tenga nuevos datos éste,
// se elimina el valor booleano y la coma, dejando solo el nombre (o variable) del archivo
PrintStream escribe=new PrintStream(new FileOutputStream(arch,true));
String cad="";
try {System.out.println("dar fin para terminar");
while(cad.equalsIgnoreCase("fin")!=true)
{ cad=ent.readLine();
if (cad.equalsIgnoreCase("fin")!=true)
{escribe.println(cad);} // se escribe o graba la línea de texto (cadena) en el archivo
}
escribe.close(); // se cierra el flujo del objeto que contiene el flujo del archivo
}
catch(IOException e)
{}
finally {escribe.close();} // es otra parte del try, esta se realiza se produzca o no una excepción
}
}
Clase RandomAccessFile
Ejemplo de la generación de una archivo de texto, cadena por cadena:
import java.io.*;
class aleatorio_texto_escr
{public static void main(String arg[]) throws IOException
{ // introduzco el nombre del archivo desde el teclado al momento de ejecutar
// el programa, es capturado por el parametro arg del metodo main
String archivo=arg[0];
long tam;
String cad;
// se crea un objeto de la clase RandomAccessFile, lo que significa que el archivo
// está abierto en modo lectura/escritura (rw), esto permite tanto escribir datos en
// el archivo como leerlo, para este caso solo lo voy a utilizar para la escritura,
// si en un momento dado se necesitará modificar algún dato del archivo, bajo este
// modo se puede hacer, sin necesidad de primer abrir el archivo en modo de lectura
// y después en modo escritura para hacer éste cambio.
RandomAccessFile arch=new RandomAccessFile(archivo,"rw");
tam=arch.length(); // obtiene el tamaño del archivo, en bytes
arch.seek(tam); // coloca el puntero del archivo en la última posición, esto es por
// si ya existen datos en el archivo no se pierdan, y que los nuevos
// datos queden hasta el final de éste, en caso contrario los encimaría
for (int i=1;i<arg.length;i++)
{// introduzco las cadenas desde el teclado al momento de ejecutar
// el programa, son capturadas por el parámetro arg del método main
cad=arg[i];
// se graban los datos en el archivo
arch.writeUTF(cad); // una cadena, en formato UTF
Maria Eugenia Puga Nathal Página 18 17/09/2015](https://image.slidesharecdn.com/archivos15-150917140852-lva1-app6891/85/Archivos-15-18-320.jpg)
![Archivos
}
arch.close();
}
}
Archivo de datos
LECTURA
Clase FileInputStream
Ejemplo de un archivo de lectura de datos:
import java.io.*;
class lectura_datos_1
{public static void main(String arg[]) throws IOException
{ String cad="";
int len=0;
double oper=0;
char car=' ';
// se crea un objeto de la clase DataInputStream con la finalidad de que me
// permita leer del archivo datos de diferentes tipos, toma como parámetro
// el objeto anónimo de la clase FileInputStream, que es la fuente de donde
// se tomarán los datos, este objeto indica la apertura del archivo en modo lectura.
DataInputStream arch=new DataInputStream(new FileInputStream("datos1.dat"));
try {// se genera un ciclo infinito donde se estarán leyendo los datos del
// archivo, el ciclo se rompe al momento en que no hay elementos en el
// archivo, y se lanza la excepción EOFException
while(true)
{// se leen los datos del archivo
cad=arch.readUTF(); // se lee una cadena en formato UTF
len=arch.readInt(); // se lee un valor tipo int
oper=arch.readDouble(); // se lee un valor tipo double
car=arch.readChar(); // se lee un caracter
// se imprimen los datos que se leyeron del archivo
System.out.println(cad+" "+len+" "+oper+" "+car);
}
}
catch(EOFException fin) // capta excepción fin de archivo
{System.out.println("fin de archivo "+ fin.getMessage());
arch.close(); // cierra el flujo que está relacionado con el archivo
}
}
}
Clase RandomAccessFile
Ejemplo de un archivo de lectura de datos:
import java.io.*;
class lectura_datos_2
{public static void main(String arg[]) throws IOException
{ String cad="";
int len=0;
double oper=0;
char car=' ';
// se crea un objeto de la clase RandomAccessFile, en modo lectura (r)
RandomAccessFile arch=new RandomAccessFile("datos2.dat","r");
try {// se genera un ciclo infinito donde se estarán leyendo los datos del
// archivo, el ciclo se rompe al momento en que no hay elementos en el
// archivo, y se lanza la excepción EOFException
while(true)
Maria Eugenia Puga Nathal Página 19 17/09/2015](https://image.slidesharecdn.com/archivos15-150917140852-lva1-app6891/85/Archivos-15-19-320.jpg)
![Archivos
{ // se leen los datos del archivo
cad=arch.readUTF(); // se lee una cadena en formato UTF
len=arch.readInt(); // se lee un valor de tipo int
oper=arch.readDouble(); // se lee un valor de tipo double
car=arch.readChar(); // se lee un caracter
// se imprimen los datos leídos del archivo
System.out.println(cad+" "+len+" "+oper+" "+car);
}
}
catch(EOFException fin)
{System.out.println("fin de archivo "+ fin.getMessage());
arch.close(); // se cierra el flujo de entrada del archivo
}
}
}
ESCRITURA
Clase FileOutputStream
Ejemplo de un archivo de escritura de datos:
import java.io.*;
class escritura_datos_1
{public static void main(String arg[]) throws IOException
{ String archivo="datos1.dat";
long tam;
String cad;
int len;
double oper;
char car;
// se crea un objeto de la clase DataOutputStream con la finalidad de que me
// permita escribir en el archivo datos de diferentes tipos, toma como parámetro
// el objeto anónimo de la clase FileOutputStream, que es la destino en donde
// se escribirán los datos, este objeto indica la apertura del archivo en modo
//escritura, el valor booleano indica que cada vez que se ejecute el programa,
// los nuevos datos se agregaran al final del archivo, si se quita este valor,
// indica que cada vez que se ejecute el programa se borraran los datos y se
// escribirá de nueva cuenta en el archivo.
DataOutputStream arch=new DataOutputStream(new FileOutputStream(archivo,true));
for (int i=0;i<arg.length;i++)
{// introduzco las cadenas desde el teclado al momento de ejecutar
// el programa, son capturadas por el parámetro arg del método main
cad=arg[i];
len=cad.length();
oper=Math.random()*len;
car=cad.charAt(0);
// se graban los datos en el archivo
arch.writeUTF(cad); // una cadena, en formato UTF
arch.writeInt(len); // un valor de tipo int
arch.writeDouble(oper); // un valor de tipo double
arch.writeChar(car); // un caracter
}
arch.close(); // se cierra el flujo que depende del archivo
}
}
Clase RandomAccessFile
Ejemplo de un archivo de escritura de datos:
Maria Eugenia Puga Nathal Página 20 17/09/2015](https://image.slidesharecdn.com/archivos15-150917140852-lva1-app6891/85/Archivos-15-20-320.jpg)
![Archivos
import java.io.*;
class escritura_datos_2
{public static void main(String arg[]) throws IOException
{ String archivo="datos2.dat";
long tam;
String cad;
int len;
double oper;
char car;
// se crea un objeto de la clase RandomAccessFile, lo que significa que el archivo
// está abierto en modo lectura/escritura (rw), esto permite tanto escribir datos en
// el archivo como leerlo, para este caso solo lo voy a utilizar para la escritura,
// si en un momento dado se necesitará modificar algún dato del archivo, bajo este
// modo se puede hacer, sin necesidad de primer abrir el archivo en modo de lectura
// y despues en modo escritura para hacer éste cambio.
RandomAccessFile arch=new RandomAccessFile(archivo,"rw");
tam=arch.length(); // obtiene el tamaño del archivo, en bytes
arch.seek(tam); // coloca el puntero del archivo en la última posición, esto es por
// si ya existen datos en el archivo no se pierdan, y que los nuevos
// datos queden hasta el final de éste, en caso contrario los encimaría
for (int i=0;i<arg.length;i++)
{// introduzco las cadenas desde el teclado al momento de ejecutar
// el programa, son capturadas por el parámetro arg del método main
cad=arg[i];
len=cad.length();
oper=Math.random()*len;
car=cad.charAt(0);
// se graban los datos en el archivo
arch.writeUTF(cad); // una cadena, en formato UTF
arch.writeInt(len); // un valor de tipo int
arch.writeDouble(oper); // un valor de tipo double
arch.writeChar(car); // un caracter
}
arch.close(); // se cierra el flujo de salida del archivo
}
}
Almacenar Objetos en un archivo
Clase del objeto que implementa la interface Serializable
// datos que conformaran el objeto, debe de implementar la interface Serializable
// la cual es una interface vacia, es decir no contiene métodos, pero es un requisito
// para que un objeto se pueda serializar (convertir a un flujo de bytes (o bits) o deserializar
// (convertir un flujo de bytes (o bits) a un objeto en particular), los atributos y métodos que
// tengan los modificadores de tipo static o transient no serán serializados, el resto
// del objeto si
import java.io.*;
public class Datos implements Serializable
{String cad;
int len;
double oper;
char car;
}
Clase ObjectInputStream (entrada(lectura)
import java.io.*;
Maria Eugenia Puga Nathal Página 21 17/09/2015](https://image.slidesharecdn.com/archivos15-150917140852-lva1-app6891/85/Archivos-15-21-320.jpg)
![Archivos
class fileobjetos1_1
{public static void main(String arg[]) throws IOException
{// se crea un objeto de la clase ObjectInputStream con la finalidad de que me
// permita leer del archivo datos un objeto completo en lugar de cada uno de sus atributos,
// además de permitir leer tipos de datos primitivos (los mismos que DataInputStream), toma
// como parámetro para este caso, el objeto anónimo de la clase FileInputStream, que es la
// fuente de donde se tomarán los datos, este objeto indica la apertura del archivo en modo lectura.
ObjectInputStream objeto=new ObjectInputStream(new FileInputStream("objetos.dat"));
Datos datos=new Datos(); // se crea un objeto de la clase datos
try
{while(true) // ciclo para la lectura de los datos del archivo
{ // se lee el objeto del archivo, y el flujo obtenido se convierte a través de
// un cast (conversión explícita) al tipo de objeto en particular a obtener, es decir se
// deserializa (conversión de un flujo de bytes (o bits) a un objeto en particular)
datos=(Datos) objeto.readObject();
// se imprimien los datos del objeto
System.out.println(datos.cad+" "+datos.len+" "+datos.oper+" "+datos.car);
}
}
catch(EOFException fin) // se captura la excepción de fin de archivo
{System.out.println(fin.getMessage()+" fin de archivo");
objeto.close(); // se cierra flujo de entrada del archivo
}
catch(Exception e) // captura algún problema (excepción) con el objeto
{System.out.println("error al leer el objeto");}
}
}
Clase ObjectOutputStream (salida/escritura)
import java.io.*;
class fileobjetos1
{public static void main(String arg[]) throws IOException
{ // se crea un objeto de la clase ObjectOutputStream con la finalidad de que me
// permita escribir en el archivo un objeto completo en lugar de ir grabando
// atributo por atributo, también me permite escribir (grabar) datos de diferentes
// tipos como lo hace la clase DataOutputStream, toma como par metro el objeto
// anónimo de la clase FileOutputStream, que es la destino en donde se escribir n
// los datos, este objeto indica la apertura del archivo en modo escritura, el valor
// booleano indica que cada vez que se ejecute el programa, los nuevos datos se agregaran
// al final del archivo, si se quita este valor, indica que cada vez que se ejecute el
// programa se borraran los datos y se escribir de nueva cuenta en el archivo.
ObjectOutputStream objeto=new ObjectOutputStream(new FileOutputStream("objetos.dat",true));
Datos datos=new Datos(); // se crea un objeto de la clase Datos
for (int i=0;i<arg.length;i++) // de acuerdo a las cadenas que se proporcionaron al ejecutar
// el programa, serán los objetos a almacenar en el archivo
{datos=new Datos();
datos.cad=arg[i];
datos.len=datos.cad.length();
datos.oper=Math.random()*datos.len;
datos.car=datos.cad.charAt(0);
// se graba (escribe) el objeto en el archivo, pero para esto lo serializar, es decir lo
// convierte en un flujo de bytes (o bits)
objeto.writeObject(datos);
}
objeto.close(); // se cierra el flujo de salida del archivo
}
}
Maria Eugenia Puga Nathal Página 22 17/09/2015](https://image.slidesharecdn.com/archivos15-150917140852-lva1-app6891/85/Archivos-15-22-320.jpg)
![Archivos
Archivos aleatorios
Clase RandomAccessFile
ESCRITURA
import java.io.*;
class escritura_aleatorio
{public static void main(String arg[]) throws IOException
{ String cad;
int len;
double oper;
char car;
StringBuffer cadmod;
int tam=22+4+8+2; // se calcula el tamaño del registro de datos
// se crea un objeto de la clase RandomAccessFile, lo que significa que el archivo
// está abierto en modo lectura/escritura (rw), esto permite tanto escribir datos en
// el archivo como leerlo, para este caso solo lo voy a utilizar para la escritura,
// si en un momento dado se necesitará modificar algún dato del archivo, bajo este
// modo se puede hacer, sin necesidad de primer abrir el archivo en modo de lectura
// y despues en modo escritura para hacer éste cambio.
RandomAccessFile arch=new RandomAccessFile("datos3.dat","rw");
// se calcula el total de los elementos almacenados en el archivo con la finalidad de
// colocarnos en la siguiente posición válida para almacenar el nuevo elemento del archivo,
// una posición mas adelante de la última
long total=arch.length()/tam;
if (total!=0)
{total+=1;}
System.out.println("tamaño "+tam+" total "+total);
for (int i=0;i<arg.length;i++)
{// introduzco las cadenas desde el teclado al momento de ejecutar
// el programa, son capturadas por el parámetro arg del método main
cad=arg[i];
// debido a que un archivo de acceso aleatorio requiere de registros de tamaño uniforme,
// obligo a que la cadena tenga una longitud fija, en este caso de 10 caracteres, para esto
// me auxilio de la clase StringBuffer y su método setLength() que permite fijar una
// longitud a la cadena, para esto creo un objeto de la clase StringBuffer pasando como
// parámetro la cadena a modificar, se establece el nuevo tamaño, una vez que se tiene esto,
// se hace una conversión a través del método toString() de un objeto StringBuffer a un objeto String
cadmod=new StringBuffer(cad); // se crea el objeto
cadmod.setLength(10); // se establece la longitud
cad=cadmod.toString(); // se convierte a objeto String
len=cad.length();
oper=Math.random()*len;
car=cad.charAt(0);
arch.seek(tam*(i+total)); // posición donde se grabara el nuevo registro de datos
// se graban los datos
arch.writeUTF(cad); // una cadena en formato UTF
arch.writeInt(len); // un valor de tipo int
arch.writeDouble(oper); // un valor de tipo double
arch.writeChar(car); // un caracter
}
arch.close(); // se cierra el flujo de salida del archivo
}
}
LECTURA
Maria Eugenia Puga Nathal Página 23 17/09/2015](https://image.slidesharecdn.com/archivos15-150917140852-lva1-app6891/85/Archivos-15-23-320.jpg)
![Archivos
Ejemplo 1
import java.io.*;
class lectura_aleatorio_1
{public static void main(String arg[]) throws IOException
{ String cad="";
int len=0;
double oper=0;
char car=' ';
int tam=22+4+8+2;// se calcula el tamaño del registro de datos
int cont=0;
// se crea un objeto de la clase RandomAccessFile, en modo lectura (r)
RandomAccessFile arch=new RandomAccessFile("datos3.dat","r");
try {// se genera un ciclo infinito donde se estarán leyendo los datos del
// archivo, el ciclo se rompe al momento en que no hay elementos en el
// archivo, y se lanza la excepción EOFException
while(true)
{arch.seek(tam*cont); // se posiciona el puntero en el byte donde se
// localiza el registro de los datos que se comenzarán a leer
// se leen los datos del archivo, en este ejemplo los leo e imprimo directamente,
// pero pueden primero asignarse los valores a las varianles que están declaradas
// al inicio del método y después imprimirlas
System.out.println(arch.readUTF()); // una cadena en formato UTF
System.out.println(arch.readInt()); // un valor int
System.out.println(arch.readDouble()); // un valor double
System.out.println(arch.readChar()); // un caracter
cont++;
// esto lo puse con la finalidad de poder visualizar los datos leidos
System.in.read();
System.in.skip(System.in.available());
}
}
catch(EOFException fin) // se capura la excepción de fin de archivo (EOFException)
{System.out.println("fin de archivo "+ fin.getMessage());
arch.close(); // se cierra el flujo de entrada del archivo
}
catch(IOException e)
{System.out.println("fin de archivo "+ e.getMessage());
}
}
}
Ejemplo 2
import java.io.*;
class lectura_aleatorio_2
{public static void main(String arg[]) throws IOException
{ String cad="";
int len=0;
double oper=0;
char car=' ';
int tam=22+4+8+2; // se calcula el tamaño del registro de datos
long cont=0;
// se crea un objeto de la clase RandomAccessFile, en modo lectura (r)
RandomAccessFile arch=new RandomAccessFile("datos3.dat","r");
// se calcula el total de los elementos almacenados en el archivo
long total=arch.length()/tam;
if (total!=0)
{total+=1;}
Maria Eugenia Puga Nathal Página 24 17/09/2015](https://image.slidesharecdn.com/archivos15-150917140852-lva1-app6891/85/Archivos-15-24-320.jpg)
Archivos 15
- 1. Archivos Archivos en Java Conceptosbásicos Estructura jerárquica de datos: Conceptos lógicos que se refieren al medio en que el usuario ve los datos y se organizan. nombre telefono direccion nombre telefono direccion nombre telefono direccion ....... Campo Registro Registro Archivo Otra forma de ver una estructura jerárquica de datos Archivo: Colección de información que almacenamos en un soporte magnético para poderla manipular en cualquier momento. Esta información se almacena como un conjunto de registros, conteniendo todos ellos, generalmente, los mismos campos. Cada campo almacena un dato de un tipo predefinido o de un tipo definido por el usuario. El registro mas simple estaría formado por un carácter. Archivo: Colección de información (datos relacionados entre sí) localizada o almacenada como una unidad en alguna parte de la memoria de la computadora, por lo general en una memoria secundaria. Esta colección de datos sirve para entrada y salida de datos de datos a la computadora, y se manejan con un programa. En contraste con los arreglos y registros, el tamaño de esta colección no es fijo, está limitado solo por la cantidad de memoria secundaria disponible. Un archivo es dinámico y un arreglo es estático al igual que un registro o una cadena. Ya que hay que indicar a estos últimos el número de elementos que contendrá, y en ocasiones una vez creados, ya no pueden cambiar de tamaño. Un archivo es una estructura de datos externa, a diferencia de los arreglos, cadenas, objetos, interfaces, que son internas. Ya que su almacenamiento siempre es en una unidad de memoria secundaria (disco flexible, disco duro, memoria flash, memory stick, cinta magnética, entre otros). Cada archivo es referenciado por un identificador (su nombre). Archivo de datos: colección de registros relacionados entre sí con aspectos en común y organizados para un propósito especifico. Archivo de texto: Archivo con organización secuencial. Es una serie continua de caracteres que se pueden leer uno tras otros. Es un archivo en que cada registro es del tipo cadena de caracteres. Maria Eugenia Puga Nathal Página 1 17/09/2015
- 2. Archivos Base de datos:Colección de archivos a los que se puede acceder por un conjunto de programas y que contienen todos ellos datos relacionados. Tipos de archivos Existen varias clasificaciones de los archivos, por su extensión, por su organización, por el tipo de acceso, por la estructura interna de los datos, por mencionar algunas, por ejemplo: Por la estructura de los datos - archivos de texto = con formato (contiene etiquetas especiales que indican algún formato del texto: tamaño, fuente, estilo, color, salto de línea. Para su visualización correcta requieren de algún procesador de textos o interprete especial, por ejemplo: word, pdf, navegador (html), works) = sin formato (texto plano, no se agregan etiquetas de formato de datos, por lo general son caracteres del código ascii, no requieren de algún procesador de texto especializado) - archivos de datos o binarios (requieren de un programa especial para poder visualizar su contenido) Por su extensión - de aplicación: .exe - datos: .dat - de texto: .txt, .pdf, .doc, .rtf, .ps - de imágenes: .jpg, .gif - de video: .mpg, .avi - de programas: .c, .java, .pas - de audio: .wav, .mid, .mp3 Por su tipo de acceso - secuencial - aleatorio o directo Por su tipo de organización - secuencial - aleatoria o directa - indexada Por su orientación - secuenciales (estándar) - orientados al sistema (bajo nivel Por su modo de apertura - solo escritura - solo lectura - lectura/escritura Acceso secuencial: exploración de los elementos comenzando por el primero, y pasando elemento por elemento hasta llegar al último. Acceso aleatorio o directo: permite procesar o acceder a un elemento determinado a través de su posición. Organización secuencial: los elementos se almacenan uno tras otro, un nuevo elemento siempre se almacena hasta el final del archivo. Organización aleatoria o directa: permite seleccionar la posición (dirección de memoria válida) para almacenar el elemento, por lo general se requiere de espacio de memoria homogéneos para almacenar cada conjunto de datos (registro). Maria Eugenia Puga Nathal Página 2 17/09/2015
- 3. Archivos Organización indexada: permiteordenar contenidos poniendo índices. La acción de ordenar registros mediante la utilización de índices. Las bases de datos, por ejemplo, suelen almacenar índices de su contenido en función de unos parámetros previamente definidos. La indexación proporciona agilidad en las búsquedas, lo que se traduce en mayor rapidez a la hora de mostrar resultados. Operaciones básicas - crear archivo - abrir archivo - escribir datos en el archivo (guardar, grabar, salida de datos) - lectura datos del archivo (leer, entrada de datos) - cerrar archivo Un archivo debe crearse antes de ser procesado. Un archivo secuencial puede crearse de dos maneras: 1. Crearlo directamente utilizando un procesador de texto o un editor 2. Escribir un programa que permita introducir la información a través de la entrada estándar de la computadora (teclado) y la escriba (grabe) en un archivo Los archivos sin formato o de datos, solo pueden crearse con programas especializados (manejadores de bases de datos) o con programas hechos por nosotros en algún lenguaje de programación especifico que soporte el manejo de archivos de datos. Otras operaciones - consultar: individual (un elemento), grupo (varios elementos), general (todos los elementos) - actualizar (altas (agregar elemento), bajas (eliminar elemento), modificar (datos de un elemento)) - clasificar (ordenar) - reorganizar (optimizar) - destruir (todo el archivo) - fusionar (juntar, unir archivos) - particionar (dividir archivos) Datos de un archivo - nombre - extensión - tipo de archivo - fecha de creación - fecha de la última modificación - autor - tamaño - estado del archivo (solo lectura, solo escritura, oculto) (o propiedades del archivo) Para crear un archivo se requiere de la información siguiente - nombre del dispositivo (lugar donde se va a crear) - nombre del archivo - organización del archivo - tamaño del bloque o registro físico Flujos Un flujo en Java representa un objeto que se puede utilizar para realizar una entrada o salida de datos. Un flujo representa un canal de información de donde se puede leer información o donde se puede escribir información. La lectura y salida se hace en forma secuencial, dato por dato, uno tras otro. Java y c# realizan operaciones en archivos a través de flujos (secuencia de bytes o caracteres), manipulados por clases, que conectan con el medio de almacenamiento. Para crear y abrir un archivo, se requiere utilizar una clase que defina la funcionalidad del flujo. Los flujos determinan el sentido de la comunicación (lectura, escritura, lectura/escritura), la posibilidad de Maria Eugenia Puga Nathal Página 3 17/09/2015
- 4. Archivos posicionamiento directo ono en un determinado registro y la forma de leer y/o escribir en el archivo. Cerrar el archivo implica cerrar el flujo, ejemplo: RandomAccessFile f=new RandomAccessFile (”archivo.dat”,”rw”); crea un archivo de acceso aleatorio de lectura/escritura. Pueden utilizarse flujos de bytes, caracteres, cadenas o de tipos primitivos (numéricos). La clase FileInputStream permite crear un flujo para lectura secuencial de bytes desde un archivo. La clase FileReader permite crear un flujo para la lectura secuencial de caracteres. Todas las entradas y salidas de datos están dirigidas a través de flujos, por lo que hay flujos de entrada (lectura) y flujos de salida (escritura), a su vez solo son dos tipos de datos los que viajan; bytes (tipo base) y caracteres, por lo que tenemos nuevamente dos tipos de flujos de acuerdo al tipo de datos que viajan: flujos de bytes y flujos de caracteres. Existen clases que permiten de modo algún dar la entrada a diferentes tipos de datos primitivos e inclusive objetos, al igual que la salida, el medio de donde se obtienen los flujos (fuente, origen) es indistinto ya que al ser transmitidos a la memoria principal son convertidos en flujos, al igual que el medio que se tendrá como destino (salida). Lo que hacen las clases es una transformación bien sea de flujo de bytes a datos u objetos (flujo de entrada), o de datos u objetos a un flujo de bytes (flujo de salida). Resumen de tipos de Flujos (Stream) - de entrada (secuencia de datos de un archivo o de algún otro dispositivo que son enviados al programa para que sean procesados) - de salida (secuencia de datos obtenidos como resultado de un programa y que son enviados para que se almacenen en un archivo o enviado los datos a algún otro dispositivo) - de bytes (unidad básica, es una secuencia de bytes) - de caracteres (secuencia de caracteres) Las clases principales para el manejo de flujos tanto de entrada como de salida son: Entrada Salida bytes InputStream OutputStream caracteres Reader Writer Estas clases heredan sus métodos y atributos a otras clases que permitirán el manejo de los diferentes flujos tanto de datos como de entrada/salida Clases para el manejo de flujos de datos bytes caracteres Memoria ByteArrayInputStream ByteArrayOutputStream StringBufferedInputStream CharArrayReader CharArrayWriter StringReader StringWriter Archivo FileInputStream FileOutputStream FileReader FileWriter Tuberia PipedInputStream PipedOutputStream PipedReader PipedWriter Clases para el manejo de flujos de datos de entrada/salida bytes caracteres Establecer buffer BufferedInputStream BufferedOutputStream BufferedReader BufferedWriter Establecer filtro FilterInputStream FilterOutputStream FilterReader FilterWriter Convertir bytes a caracteres InputStreamReader OutputStreamReader Concatenar SequenceInputStream Serializar ObjectInputStream Maria Eugenia Puga Nathal Página 4 17/09/2015
- 5. Archivos ObjectOutputStream Convertir a datosprimitivos DataInputStream DataOutputStream Contar números de líneas LineNumberInputStream LineNumberReader Mirar anticipadamente PushbackInputStream PushbackReader Escribir PrintStream PrintWriter Tipos de flujos en general Flujos con bytes Flujos con caracteres Flujos de entrada de datos InputStream ByteArrayInputStream FileInputStream FilterInputStream BufferedInputStream DataInputStream LineNumberInputStream PushbackInputStream ObjectInputStream PipedInputStream SequenceInputStream StringBufferdInputStream Reader BufferedReader LineNumberReader CharArrayReader FilterReader PushbackReader InputStreamReader FileReader PipedReader StringReader Flujos de salida de datos OutputStream ByteArrayOutputStream FileOutputStream FilterOutputStream BufferedOutputStream DataOutputStream PrintStream ObjectOutputStream PipedOutputStream Writer BufferedWriter CharArrayWriter FilterWriter OutputStreamReader FileWriter PipedWriter PrintWriter StringWriter Para el manejo de archivos existen diferentes clases, derivadas de las clases InputStream y OutputStream: FileIntputStream Archivo secuencial para la entrada tanto de texto como de datos (modo de apertura, solo lectura) FileOutputStream Archivo secuencial para la salida tanto de texto como de datos (modo de apertura, solo escritura) Derivadas de las clases Reader y Writer: FileReader Archivo secuencial para la entrada de texto (modo de apertura, solo lectura) FileWriter Archivo secuencial para la salida de texto (modo de apertura, solo escritura) Existen otras dos clases que permiten también hacer la manipulación de los archivos: La clase File que representa un archivo y las operaciones que se pueden hacer con el. No incluye operaciones de lectura o escritura en archivo, solo permite hacer operaciones de manera externa con el archivo como por ejemplo: cambiarle el nombre, cambiarlo a un estado de solo lectura, eliminarlo físicamente, saber la ruta en la que se encuentra, saber a que directorio pertenece, saber si se trata de un archivo o de un directorio, saber su tamaño, la fecha de su última modificación, entre otras operaciones. La clase RandomAccessFile, que permite crear archivos de acceso aleatorio (o directo). Permite utilizar los archivos tanto en modo de lectura como en modo lectura y escritura simultáneamente, acceder a los elementos (registros) de forma aleatoria (o directa) indicando la posición en la que se quiere operar. Se usa el termino de cursor, indicador o puntero para hacer referencia a la posición en la que estemos ubicados dentro del archivo. La clase StreamTokeneizer, permite leer un flujo en trozos seleccionados por marcas. Clase File Algunos de sus métodos Maria Eugenia Puga Nathal Página 5 17/09/2015
- 6. Archivos Métodos constructores File f=newFile(“nombre_archivo”); File f=new File(“ruta”); File f=new File(“ruta”, “nombre_archivo”); File f=new File (objeto_File, “nombre_archivo”); boolean x=obj_File.canRead(); true si es de lectura boolean x=obj_File.canWriter(); true si es de escritura boolean x=obj_File.exists(); true si el archivo existe boolean x=obj_File.isHidden(); true si el archivo está oculto boolean x=obj_File.isDirectory(); true si es un directorio (caso Windows una carpeta) boolean x=obj_File.delete(); true si se pudo borrar el archivo boolean x=obj_File.mkdir(); true si se pudo crear el directorio boolean x=obj_File.renameTo(archivo_nuevoNombre); renombrar un archivo, regresa true si se pudo cambiar el nombre String [] obj_File.list(); Regresa un arreglo con los nombres de los archivos y directorios que contiene un directorio String n=obj_File.getName(); Regresa el nombre del archivo o directorio String n=obj_File.getParent(); Regresa el nombre del directorio al que pertenece el archivo String n=obj_File.getPath(); Regresa la ruta donde se localiza el archivo String n=obj_File.getAbsolutePath(); Regresa la ruta absoluta (desde la raíz) donde se localiza el archivo String cad=obj_File.toString(); regresa el objeto File en cadena long tam=obj_File.length() Regresa el tamaño del archivo, en bytes. long fecha=obj_File.lastModified(); Regresa la fecha de la última modificación del archivo, desde ------- obj_File.createTemFile(); Permite crear un archivo temporal obj_File.setReadOnly(); Cambia el estado del archivo a solo lectura obj_File.deleteOnExit(); Solicita al sistema que elimine el archivo cuando finalice la máquina virtual. Esta solicitud sólo se aplica en una finalización normal de la máquina virtual, y no se puede revocar una vez emitida. Clase Reader Algunos de sus métodos int y=obj.read() regresa un valor entre 0 y 65535, un –1 para indicar final del flujo int y=obj.read(char [] x, int posicionInicioArreglo, int cantidadCaracteres) regresa el número de caracteres almacenados en el arreglo x int y= obj.read(char [] x); regresa el número de caracteres almacenados en el arreglo, inicia desde la posición 0, es equivalente a: obj.read(char [] x, 0, x.length); long z=obj.skip(long cantidadBytes); ignora bytes en el buffer, regresa la cantidad de bytes brincados boolean c=obj.ready(); regresa true si el stream (flujo) está listo para ser leído obj.close(); cierra el flujo de entrada de datos Clase InputStream Algunos de sus métodos int y=obj.read() regresa un valor entre 0 y 255, un –1 para indicar final del flujo int y=obj.read(byte [] x, int posicionInicioArreglo, int cantidadDatos) regresa el número de datos almacenados en el arreglo x int y= obj.read(byte [] x); regresa el número de datos almacenados en el arreglo, inicia desde la posición 0, es equivalente a: obj.read(byte [] x, 0, x.length); long z=obj.skip(long cantidadBytes); ignora bytes en el buffer, regresa la cantidad de bytes brincados, pero puede invocarse sin la asignación, es decir: obj.skip(cantidad); u obj.skip(obj.available()); boolean c=obj.ready(); regresa true si el stream (flujo) está listo para ser leído obj.close(); cierra el flujo de entrada de datos int y=obj.available(); regresa la cantidad de bytes que se pueden leer (o saltar) sin bloquearse Clase Writer Algunos de sus métodos obj.write(int x); Maria Eugenia Puga Nathal Página 6 17/09/2015
- 7. Archivos obj.write(char [] x,int posicionInicioArreglo, int cantidadCaracteres); escribe una cantidad x de caracteres a partir de una posición dada en el arreglo obj.write(char [] x); escribe (almacena) caracteres en un arreglo a partir de la posición 0, es equivalente a: obj.write(char [] x, 0, x.length); obj.write(String cad); obj.write(String cad, int posicionIncialCadena, int cantidadCaracteres); escribe una cantidad x de caracteres a partir de una posición dada en la cadena obj.flush(); obliga a vaciar el buffer enviando a los datos a su destino obj.close(); cierra el flujo de salida de datos Clase OutputStream Algunos de sus métodos obj.write(byte x); obj.write(byte [] x, int posicionInicioArreglo, int cantidadElementos); escribe una cantidad x de datos de tipo byte a partir de una posición dada en el arreglo obj.write(byte [] x); escribe (almacena) datos tipo byte en un arreglo a partir de la posición 0, es equivalente a: obj.write(byte [] x, 0, x.length); obj.flush(); obliga a vaciar el buffer enviando a los datos a su destino obj.close(); cierra el flujo de salida de datos Todos los métodos presentados en las cuatro clases anteriores, son heredados a las clases que se derivan de estas y que fueron presentadas en la última tabla, algunas de ellas vamos a estar utilizando para el manejo de archivos. Es aconsejable que cuando se de la creación de un objeto que se asociara con un archivo, primero se verifique la existencia de éste a través del método exists() de la clase File, por ejemplo: Clase FileReader Clase que permite leer archivos de texto (secuenciales), si se quiere leer línea por línea, se auxilia de la clase BufferedReader. Algunos de sus métodos Método constructor FileReader(String nombArchivo); FileReader(File objFile); Clase FileWriter Clase que permite crear archivos de texto (secuenciales), en caso de que se quiera grabar línea por línea se auxilia de la clase PrintWriter. Algunos de sus métodos Método constructor FileWriter(String nombArchivo); FileWriter(File objFile); FileWriter(String nombArchivo, true); el valor true permite que se respeten los caracteres existente, y que los nuevos se agreguen al final de la archivo. FileWriter(File objFile, true); Clase PrintWriter Permite producir salida formateada, es decir se preocupa por la visualización. Si se utiliza en combinación con la clase FileOutputStream o FileWriter para escribir una cadena, le añade al final un salto de línea si se utiliza el método println. Algunos de sus métodos Métodos constructores PrintWriter(destino) PrintWriter(destino,true) el valor booleano indica que se vacía el espacio de almacenamiento intermedio con cada nueva línea. Maria Eugenia Puga Nathal Página 7 17/09/2015
- 8. Archivos obj.println(cadena); visualiza unacadena y salta línea, si el destino es un archivo, se agrega a la cadena un salto de línea. obj.print(); visualiza una cadena y el cursor se coloca enseguida de ésta. Si por ejemplo se declara el siguiente objeto, PrintWriter sal=new PrintWriter(System.out,true); se puede substituir la instrucción siguiente para imprimir un dato System.out.println(”cualquier cosa”); por sal.println(”cualquier cosa”); Clase InputStreamReader Convierte un InputStream (flujo de bytes de entrada) en un Reader (flujo de caracteres de entrada). Clase OutputStreamReader Convierte un OutputStream (flujo de bytes de salida) en un Writer (flujo de caracteres de salida). Clase BufferedReader Devuelve una línea de texto en forma de cadena. Permite obtener (leer) una secuencia de caracteres como entrada de datos, en lugar de caracter por carácter. Algunos de sus métodos obj.readLine(); obtiene o lee una cadena de caracteres hasta encontrar un separador de línea que puede ser un salto de línea (n), un retorno de carro (r (enter o return), o ambos ( r n en esta combinación), no los incluye como parte de ésta. Si se encuentra el final del flujo (stream) antes del final de una línea, regresa un valor null. Clase LineNumberReader Lleva la cuenta de los números de línea al leer el texto. Añade números de línea en la lectura de cadenas. Si se utiliza en combinación con la clase FileReader, permite obtener el número de línea que se va leyendo en un archivo de texto. Hereda todos los métodos y atributos de la clase BufferedReader. Algunos de sus métodos Utiliza los mismos métodos que la clase BufferedReader obj.setLineNumber (int n); // añade un número de línea int n=obj.getLineNumber (); // regresa el número de línea leído Clase FileInputStream Clase que permite abrir archivos secuenciales en modo lectura tanto de texto como de datos, para estos últimos se auxilia de la clase DataInputStream. Para el caso de los primeros, si se quiere leer línea por línea, se auxilia de la clase BufferedReader. Algunos de sus métodos Métodos constructores FileInputStream f=new FileInputStream(“archivo.extension”); FileInputStream f=new FileInputStream(objeto_File); Hereda los métodos de la clase InputStream Clase FileOutputStream Clase que permite crear archivos secuenciales tanto de texto como de datos, para estos últimos se auxilia de la clase DataOutputStream, para los primeros se puede auxiliar en un momento dado de la clase PrintStream, en caso de que se quiera grabar línea por línea. Algunos de sus métodos Métodos constructores FileOutputStream f=new FileOutputStream(“archivo.extension”); FileOutputStream f=new FileOutputStream(objeto_File); FileOutputStream f=new FileOutputStream(“archivo.extension”, true); FileOutputStream f=new FileOutputStream(objeto_File, true); Maria Eugenia Puga Nathal Página 8 17/09/2015
- 9. Archivos El valor truesignifica que cuando se vuelva a ejecutar el programa que contiene esta clase, los datos del archivo permanecerán en éste, y que los nuevos se anexarán al final. Es decir los datos se conservarán, a diferencia de cuando no se pode este valor booleano, cada vez que se ejecute el programa, los datos del archivo se borraran, y los nuevos se grabaran desde la primera posición. Hereda los métodos de la clase OutputStream Clase PrintStream Permite producir salida formateada, es decir se preocupa por la visualización. Si se utiliza en combinación con la clase FileOutputStream para escribir una cadena, le añade al final un salto de línea si se utiliza el método println. Algunos de sus métodos Métodos constructores PrintStream(destino); PrintStream(destino, true); el valor booleano indica que se vacía el espacio de almacenamiento intermedio con cada nueva línea. obj.println(cadena); visualiza una cadena y salta línea, si el destino es un archivo, se agrega a la cadena un salto de línea. obj.print(); visualiza una cadena y el cursor se coloca enseguida de ésta. Si por ejemplo se declara el siguiente objeto, PrintStream sal=System.out; se puede substituir la instrucción siguiente para imprimir un dato System.out.println(”cualquier cosa”); por sal.println(”cualquier cosa”); Clase DataInputStream Esta clase permite transformar un flujo de bytes a un tipo de dato primitivo. Es muy utilizada en combinación con la clase FileInputStream para la creación de un archivo de lectura de datos. Algunos de sus métodos Método constructor DataInputStream ent=new DataInputStream(fuente); La fuente para el caso que nos interesa será la clase FileInputStream, por lo que el objeto ent lo podemos crear de dos maneras: Primera FileInputStream archivo=new FileInputStream(”archivo.dat”); DataInputStream ent=new DataInputStream(archivo); Segunda DataInputStream ent=new DataInputStream(new FileInputStream(”archivo.dat”)); byte b=ent.readByte(); // lee un valor de tipo byte byte b=ent.readUnsignedByte(); // lee un valor de tipo byte sin signo short s=ent.readShort(); // lee un valor de tipo short short s=ent.readUnsignedShort(); // lee un valor de tipo short sin signo int i=ent.readInt();// lee un valor de tipo int long l=ent.readLong();// lee un valor de tipo long float f=ent.readFloat();// lee un valor de tipo float double d=ent.readDouble();// lee un valor de tipo double char car=ent.readChar();// lee un valor de tipo char String cad=ent.readUTF();// lee un valor de tipo String en formato UTF String cad=ent.readLine();// lee un valor de tipo String, obtiene toda la línea de texto incluyendo el enter y salto de línea boolean bol=ent.readBoolean();// lee un valor de tipo boolean ent.readFully(); ent.skipBytes(numeroBytes); //brinca un numero x de bytes Clase DataOutputStream Esta clase permite transformar un tipo de dato primitivo a un flujo de bytes. Es muy utilizada en combinación con la clase FileOutputStream para la creación de un archivo de escritura de datos. Maria Eugenia Puga Nathal Página 9 17/09/2015
- 10. Archivos Algunos de susmétodos Método constructor DataOutputStream sal=new DataOutputStream(fuente); La fuente para el caso que nos interesa será la clase FileOutputStream, por lo que el objeto sal lo podemos crear de dos maneras: Primera FileOutputStream archivo=new FileOutputStream(”archivo.dat”); DataOutputStream sal=new DataOutputStream(archivo); Segunda DataOutputStream sal=new DataOutputStream(new FileOutputStream(”archivo.dat”)); sal.write(byte n); // escribe un valor de tipo byte sal.write(byte [] n); // escribe un arreglo de datos de tipo byte sal.writeByte(byte b); // escribe un valor de tipo byte sal.writeShort(short s); // escribe un valor de tipo short sal.writeInt(int i);// escribe un valor de tipo int sal.writeLong(long l);// escribe un valor de tipo long sal.writeFloat(float f);// escribe un valor de tipo float sal.writeDouble(double d);// escribe un valor de tipo double sal.writeChar(char car);// escribe un valor de tipo char sal.writeChars(String cad);// escribe un valor de tipo String como un arreglo de caracteres sal.writeUTF(String cad);// escribe un valor de tipo String en formato UTF sal.writeBoolean(boolean bol);// escribe un valor de tipo boolean Para el caso del formato UTF, cuando se tenga que contabilizar la cantidad de bytes necesario para el almacenamiento de la cadena en el archivo (caso archivos aleatorios) agregar dos bytes mas, que utiliza la clase para guardar el tamaño de la cadena. Serialización La serialización de objetos en Java permite tomar cualquier objeto que implemente la interfaz Serializable y convertirlo en una secuencia (flujo) de bits que puede ser posteriormente restaurada para regenerar el objeto original. La serialización de un objeto permite darle mas persistencia al objeto (la vida del objeto se alargara), ya que éste seguirá existiendo aun cuando termine la ejecución del programa, solo que ahora lo hará en memoria secundaria y no en la memoria principal y cuando sea nuevamente leído cobrará ese efecto de persistencia. Cabe mencionar que la interfaz Serializable es una simple bandera, y no contiene métodos, es un indicador de que un objeto puede o no serializarse, es decir, convertirse o no a un flujo de bits. Para serializar objetos es necesario hacer uso de la clase ObjetcOutputStream a través del método writeObject(objetoSerializable), y para invertir este proceso, es decir obtener el objeto nuevamente en su forma original (deserializar) es necesario utilizar la clase ObjectInputStream a través del método readObject(), pero en este caso se regresa una referencia a un objeto Object por lo que es necesario hacer una conversión explícita al momento de la lectura al tipo de objeto en particular. Por ejemplo: Obj.writeObject(”objeto cadena”); // serializa String cad=(String) obj.readObject(); // deserializa Cuando se está controlando la serialización, puede ocurrir que haya un subobjeto (o atributo) en particular para el que no se desee que se produzca un salvado y recuperación automáticos por parte del mecanismo de serialización de Java. Como por ejemplo una contraseña. Una forma de cómo evitar que partes sensibles de un objeto sean serializables es anteponer el modificador de tipo transient. Cabe mencionar que cuando se tienen datos u objetos con el modificador de tipo static, tampoco serán serializados. Clase ObjectInputStream Permite obtener una secuencia de bytes (o de bits) y convertirla a un objeto en particular. Lee un objeto (convertido en una secuencia de bytes (o de bits)) de alguna fuente de entrada en particular (red, archivo). Algunos de sus métodos Método constructor Maria Eugenia Puga Nathal Página 10 17/09/2015
- 11. Archivos ObjectInputStream objeto=new ObjectInputStream(fuentede entrada); ClaseObjetoSerializable obj=( ClaseObjetoSerializable) objeto.readObject(); // transforma el objeto en una secuencia de bits y los // envía a su destino Para poder hacer la lectura de cualquier tipo de dato primitivo, hace uso de los mismos métodos que la clase DataInputStream. Clase ObjectOutputStream Permite convertir un objeto en particular (serializable) a una secuencia de bytes (o de bits) y enviarla a un destino específico (red, archivo). Algunos de sus métodos Método constructor ObjectOutputStream objeto=new ObjectOutputStream(fuente de salida); objeto.writeObject(objetoSerializable); // transforma el objeto en una secuencia de bits y los envía a su destino Para poder hacer la escritura de cualquier tipo de dato primitivo, hace uso de los mismos métodos que la clase DataOutputStream. Clase RandomAccessFile Permite crear archivos con una organización aleatorio o directa y su acceso puede ser de manera secuencial o directa. Ofrece dos modos de apertura: solo lectura, o lectura/escritura. Si se requiere, en un momento dado pueden crearse también archivos de una organización secuencial. Por lo general va orientado al manejo de archivos de datos. Algunos de sus métodos Métodos constructores RandomAccessFile f=new RandomAccessFile(”nombreArchivo.ext”, ”modoApertura”); RandomAccessFile f=new RandomAccessFile(objetoFile, ”modoApertura”); Modo apertura: r solo lectura rw lectura/escritura long x=f.getFilePointer(); regresa la posición actual del puntero del archivo, que es desde el inicio hasta la posición actual f.seek(posicion); desplaza el puntero n bytes tomando como origen el del archivo (byte 0) long x=.f.length(); regresa el tamaño actual del archivo, número de bytes que ocupa o longitud que tiene f.setLength(n); permite establecer de antemano el tamaño del archivo, n es el número de bytes que se requiere que se reserve para los datos del archivo, cuando ya sabemos de antemano la cantidad máxima de elementos que contendrá nuestra aplicación, hacemos uso de este método, por ejemplo, si se va a utilizar el archivo para guardar los datos de algún control de reservación de habitaciones de un hotel, de un teatro, de un restauran, asientos de un avión, reservar una computadora en algún cyber o en el laboratorio de cómputo, por mencionar algunas aplicaciones f.seek(f.length()); nos coloca al final del archivo f.seek(i*tamaño); nos va colocando en cada bloque de memoria definido para un registro de datos, el tamaño nosotros lo definimos a través de la sumatoria de la cantidad de bytes que va a ser necesario para almacenar cada dato que compondrá nuestro registro (objeto), i es una variable en este caso de tipo contador, que se ira incrementando en 1, para accesar al primer elemento del archivo, i = 0. Para obtener el numero de elementos (registros) se hace la operación siguiente: Nregs= (int) Math.ceil ( (double)f.length() / (double)tamaño); Para el manejo de los datos, es decir para la escritura o lectura, tiene los mismos métodos que las clases DataInputStream y DataOutputStream. Ejemplos Clase File import java.util.*; // se necesita para la clase Date, que convierte un valor numérico a un formato de fecha en este caso import java.io.*; Maria Eugenia Puga Nathal Página 11 17/09/2015
- 12. Archivos class EjemFile2 {public staticvoid main (String arg[]) {String directorio; if (arg.length>0) {directorio=arg[0];} // el nombre del directorio se introduce al momento de ejecutar el programa else {directorio=".";} // directorio actual File actual=new File(directorio);// creo objeto que se enlaza con el directorio if (actual.exists()) // se verifica la existencia del archivo o del directorio {if (actual.isFile()) // se verifica si es archivo, si se regresa true si lo es, en caso contrario se trata de un directorio {System.out.println("Es un archivo");} else { System.out.println("El directorio es:"); try {System.out.println(actual.getCanonicalPath());} catch(IOException e){} System.out.println("Su contenido es:"); File archivos[]=actual.listFiles(); // obtienen el contenido del directorio for (int i=0;i<archivos.length && archivos!=null;i++) // presenta el contenido del directorio {System.out.print(archivos[i].getName()); if (archivos[i].isFile()) {System.out.print("t"+archivos[i].length()); System.out.print("t"+(new Date(archivos[i].lastModified()))); } System.out.println(); } } } else {System.out.println("no existe el directorio o el archivo");} } } Archivos secuenciales Archivos de texto LECTURA Clase FileReader Ejemplo de la lectura de un archivo de texto, caracter por caracter: import java.io.*; class lectura_archivo_car {public static void main(String arg[]) throws IOException { // introduzco el nombre del archivo desde el teclado al momento de ejecutar // el programa, es capturado por el parámetro arg del método main String archivo=arg[0]; String cad=""; int car=0; // se crea un objeto de la clase FileReader, lo que significa que el archivo //esta abierto en modo lectura FileReader ent=new FileReader(archivo); try { car=ent.read(); // se lee el primer caracter del archivo while(car!=-1) // se verifica que no sea fin de archivo {cad=cad+(char)car; //opcional, formo una cadena con los caracteres leídos del archivo System.out.print((char)car); // se imprime el caracter leído car=ent.read(); // se lee el siguiente caracter del archivo, se almacena -1 cuando se haya llegado al final de éste } System.out.println("nnnSe imprime la cadena formada por los caracteres leídos del"); System.out.println("archivo lo anterior se imprimió caracter por caracter."); System.out.println(cad); //opcional, imprimo la cadena formada con los caracteres leidos del archivo ent.close(); // Se cierra el archivo Maria Eugenia Puga Nathal Página 12 17/09/2015
- 13. Archivos } catch (IOException e) {//por si se genera algún problema en la lectura del archivo // por el momento la dejo en blanco } } } Ejemplo de la lectura de un archivo de texto donde lectura de éste es cadena (línea) por cadena(línea): import java.io.*; class lectura_archivo {public static void main(String arg[]) throws IOException { // introduzco el nombre del archivo desde el teclado al momento de ejecutar // el programa, es capturado por el parámetro arg del método main String archivo=arg[0]; String cad=null; // creo un objeto de la clase BufferedReader para obtener la cadena // completa del archivo, línea por línea, es decir al momento de encontrar // los carcateres rn (enter+salto de línea) se forma una primera cadena // (línea de texto), se envía como parámetro un objeto anónimo de la clase // FileReader, la cual es utilizada como fuente de donde se obtendrán las // cadenas, al momento de crear este objeto anónimo, se está dando la // apertura al archivo en modo de lectura BufferedReader ent=new BufferedReader(new FileReader(archivo)); try { cad=ent.readLine(); // se lee la primera cadena (o línea de texto) del archivo while(cad!=null) // se verifica que no sea fin de archivo {System.out.println(cad); // se imprime la cadena leída desde del archivo cad=ent.readLine(); // se lee la siguiente línea del archivo } ent.close(); // se cierra el flujo del objeto que contiene el control del flujo del archivo } catch (EOFException e) {// por si se genera algún problema en la lectura del archivo // por el momento la dejo en blanco } } } Si la aplicación que se está desarrollando requiere la lectura de un archivo de texto, pero que a su vez vaya listando el número de línea, se puede utilizar la clase LineNumberReader, la cual es una extensión de la clase BufferedReader, es decir hereda los métodos y atributos de la clase, agregando otros como getLineNumber(), el cual permite obtener el número de una línea, setLineNumber(int NumeroLinea). Ejemplo de la lectura de un archivo de texto línea por línea, además de enumerar cada línea leída: import java.io.*; class lectura_archivo_linea {public static void main(String arg[]) throws IOException { // introduzco el nombre del archivo desde el teclado al momento de ejecutar // el programa, es capturado por el parámetro arg del método main String archivo=arg[0]; String cad=null; int nl=0; // creo un objeto de la clase LineNumberReader para obtener la cadena (línea) y número de línea // completa del archivo, línea por línea, se envía como parámetro un objeto // anónimo de la clase FileReader, la cual es utilizada como fuente de donde // se obtendrán las cadenas, al momento de crear este objeto anónimo, se está dando la // apertura al archivo en modo de lectura LineNumberReader ent=new LineNumberReader(new FileReader(archivo)); Maria Eugenia Puga Nathal Página 13 17/09/2015
- 14. Archivos try { cad=ent.readLine();// se lee el primera línea de texto del archivo while(cad!=null) // se verifica fin de archivo {nl=ent.getLineNumber(); // se obtiene el numero de línea System.out.println(nl+" "+cad); //se imprime numero de línea y contenido de la línea cad=ent.readLine(); // se lee la siguiente línea de texto } ent.close();// se cierra el flujo del objeto que contiene el control del flujo del archivo } catch (IOException e) {// por si se genera algún problema en la lectura del archivo // por el momento la dejo en blanco } } } Clase FileInputStream Ejemplo de la lectura de un archivo de texto, caracter por caracter: import java.io.*; class lectura_archivo_car_2 {public static void main(String arg[]) throws IOException { // introduzco el nombre del archivo desde el teclado al momento de ejecutar // el programa, es capturado por el parámetro arg del método main String archivo=arg[0]; String cad=""; int car=0; // se crea un objeto de la clase FileReader, lo que significa que el archivo //esta abierto en modo lectura FileInputStream ent=new FileInputStream(archivo); try { car=ent.read(); // se lee el primer caracter del archivo while(car!=-1) // se verifica que no sea fin de archivo {cad=cad+(char)car; //opcional, formo una cadena con los caracteres leídos del archivo System.out.print((char)car); // se imprime el caracter leído car=ent.read(); // se lee el siguiente caracter del archivo, se almacena -1 cuando se haya llegado al final de éste } System.out.println("nnnSe imprime la cadena formada por los caracteres leídos del"); System.out.println("archivo lo anterior se imprimió caracter por caracter."); System.out.println(cad); //opcional, imprimo la cadena formada con los caracteres leídos del archivo ent.close(); // Se cierra el archivo } catch (IOException e) {// por si se genera algún problema en la lectura del archivo // por el momento la dejo en blanco } } } Ejemplo de la lectura de un archivo de texto línea por línea: import java.io.*; class lectura_archivo_2 {public static void main(String arg[]) throws IOException { // introduzco el nombre del archivo desde el teclado al momento de ejecutar // el programa, es capturado por el parámetro arg del método main String archivo=arg[0]; String cad=null; // creo un objeto de la clase BufferedReader para obtener la cadena // completa del archivo, línea por línea, es decir al momento de encontrar // los carcateres rn (enter+salto de línea) se forma una primera cadena Maria Eugenia Puga Nathal Página 14 17/09/2015
- 15. Archivos // (línea detexto), se envía como parámetro un objeto anónimo de la clase // FileInputStream para convertir el flujo de bytes a caracteres, a su vez, // éste tendrá como parámetro un objeto anónimo de la clase FileInputStream, // la cual es utilizada como fuente de donde se obtendrán las cadenas, al // momento de crear este objeto anónimo, se está dando la apertura al archivo en modo de lectura BufferedReader ent=new BufferedReader(new InputStreamReader(new FileInputStream(archivo))); try { cad=ent.readLine(); // se lee la primera cadena (o línea de texto) del archivo while(cad!=null) // se verifica que no sea fin de archivo {System.out.println(cad); // se imprime la cadena leída desde del archivo cad=ent.readLine(); // se lee la siguiente línea del archivo } ent.close(); // se cierra el flujo del objeto que contiene el control del flujo del archivo } catch (EOFException e) {// por si se genera algún problema en la lectura del archivo // por el momento la dejo en blanco } } } Clase RandomAccessFile Ejemplo de la lectura de un archivo de texto cadena por cadena (para que funcione de manera correcta, el archivo se debió de haber creado con la clase RandomAccessFile): import java.io.*; class aleatorio_texto_lect {public static void main(String arg[]) throws IOException { // introduzco el nombre del archivo desde el teclado al momento de ejecutar // el programa, es capturado por el parámetro arg del método main String archivo=arg[0]; String cad=""; // se crea un objeto de la clase RandomAccessFile, en modo lectura (r) RandomAccessFile arch=new RandomAccessFile(archivo,"r"); try {// se genera un ciclo infinito donde se estarán leyendo los datos del // archivo, el ciclo se rompe al momento en que no hay elementos en el // archivo, y se lanza la excepción EOFException while(true) {cad=arch.readUTF(); // se lee la cadena en formato UTF System.out.println(cad); // se imprime la cadena leída } } catch(EOFException fin) {System.out.println("fin de archivo "+ fin.getMessage()); arch.close(); } } } ESCRITURA Clase FileWriter Ejemplo de la generación de un archivo de texto, caracter por caracter import java.io.*; class escritura_archivo_car {public static void main(String arg[]) throws IOException {// introduzco el nombre del archivo desde el teclado al momento de ejecutar // el programa, es capturado por el parámetro arg del método main String arch=arg[0]; Maria Eugenia Puga Nathal Página 15 17/09/2015
- 16. Archivos // se creaun objeto de la clase FileWriter, lo que significa que el archivo // está abierto en modo escritura, el valor de true indica, que tantas veces ejecute // el programa podré agregar datos al mismo archivo, si en un momento dado, quiero // que cada vez que ejecute el programa y sea el mismo archivo, tenga nuevos datos éste, // se elimina el valor booleano y la coma, dejando solo el nombre (o variable) del archivo FileWriter escribe=new FileWriter(arch,true); char car=' '; try {System.out.println("dar * para terminar"); while(car!='*') { car=(char)System.in.read(); if (car!='*') {escribe.write(car);} // se escribe o graba el caracter en el archivo System.in.skip(System.in.available()); } escribe.close(); // se cierra el archivo } catch(IOException e) {} finally {escribe.close();} // es otra parte del try, esta se realiza se produzca o no una excepción } } Ejemplo de la generación de un archivo de texto, cadena por cadena import java.io.*; class escritura_archivo_cad {public static void main(String arg[]) throws IOException {// introduzco el nombre del archivo desde el teclado al momento de ejecutar // el programa, es capturado por el parámetro arg del método main String arch=arg[0]; BufferedReader ent=new BufferedReader(new InputStreamReader(System.in)); // se crea un objeto de la clase FileWriter, lo que significa que el archivo // está abierto en modo escritura, el valor de true indica, que tantas veces ejecute // el programa podré agregar datos al mismo archivo, si en un momento dado, quiero // que cada vez que ejecute el programa y sea el mismo archivo, tenga nuevos datos éste, // se elimina el valor booleano y la coma, dejando solo el nombre (o variable) del archivo FileWriter escribe=new FileWriter(arch,true); String cad=""; try {System.out.println("dar fin para terminar"); while(cad.equalsIgnoreCase("fin")!=true) { cad=ent.readLine(); if (cad.equalsIgnoreCase("fin")!=true) {escribe.write(cad);} // se escribe o graba la cadena en el archivo } escribe.close(); // se cierra el archivo } catch(IOException e) {} finally {escribe.close();} // es otra parte del try, esta se realiza se produzca o no una excepción } } Ejemplo de la generación de un archivo de texto, línea por línea import java.io.*; class escritura_archivo {public static void main(String arg[]) throws IOException {// introduzco el nombre del archivo desde el teclado al momento de ejecutar // el programa, es capturado por el parámetro arg del método main String arch=arg[0]; Maria Eugenia Puga Nathal Página 16 17/09/2015
- 17. Archivos BufferedReader ent=new BufferedReader(newInputStreamReader(System.in)); // se crea un objeto de la clase PrintWriter para que me permita grabar // una cadena e incorpore el salto de línea, esto a través del método println, // cuando se crea el objeto se manda como parámetro el objeto anónimo de la clase // FileWriter, el cual se tomará como destino, además con la creación de este objeto // anónimo se da la apertura al archivo, el valor de true indica, que tantas veces ejecute // el programa podré agregar datos al mismo archivo, si en un momento dado, quiero // que cada vez que ejecute el programa y sea el mismo archivo, tenga nuevos datos éste, // se elimina el valor booleano y la coma, dejando solo el nombre (o variable) del archivo PrintWriter escribe=new PrintWriter(new FileWriter(arch,true)); String cad=""; try {System.out.println("dar fin para terminar"); while(cad.equalsIgnoreCase("fin")!=true) { cad=ent.readLine(); if (cad.equalsIgnoreCase("fin")!=true) {escribe.println(cad);} // se escribe o graba la línea de texto (cadena) en el archivo } escribe.close(); // se cierra el flujo del objeto que contiene el flujo del archivo } catch(IOException e) {} finally {escribe.close();} // es otra parte del try, ésta se realiza se produzca o no una excepción } } Clase FileOutputStream Ejemplo de la generación de un archivo de texto, caracter por caracter import java.io.*; class escritura_archivo_car_2 {public static void main(String arg[]) throws IOException {// introduzco el nombre del archivo desde el teclado al momento de ejecutar // el programa, es capturado por el parametro arg del metodo main String arch=arg[0]; // se crea un objeto de la clase FileOutputStream, lo que significa que el archivo // está abierto en modo escritura, el valor de true indica, que tantas veces ejecute // el programa podré agregar datos al mismo archivo, si en un momento dado, quiero // que cada vez que ejecute el programa y sea el mismo archivo, tenga nuevos datos éste, // se elimina el valor booleano y la coma, dejando solo el nombre (o variable) del archivo FileOutputStream escribe=new FileOutputStream(arch,true); char car=' '; try {System.out.println("dar * para terminar"); while(car!='*') { car=(char)System.in.read(); if (car!='*') {escribe.write((byte)car);} // se escribe o graba el caracter en el archivo, con un valor explixito de tipo byte System.in.skip(System.in.available()); } escribe.close(); // se cierra el archivo } catch(IOException e) {} finally {escribe.close();} // es otra parte del try, esta se realiza se produzca o no una excepción } } Ejemplo de la generación de un archivo de texto, línea por línea import java.io.*; Maria Eugenia Puga Nathal Página 17 17/09/2015
- 18. Archivos class escritura_archivo_2 {public staticvoid main(String arg[]) throws IOException {// introduzco el nombre del archivo desde el teclado al momento de ejecutar // el programa, es capturado por el parámetro arg del método main String arch=arg[0]; BufferedReader ent=new BufferedReader(new InputStreamReader(System.in)); // se crea un objeto de la clase PrintStream para que me permita grabar // una cadena e incorpore el salto de línea, esto a través del método println, // cuando se crea el objeto se manda como parámetro el objeto anónimo de la clase // FileOutputStream, el cual se tomará como destino, además con la creación de este objeto // anónimo se da la apertura al archivo, el valor de true indica, que tantas veces ejecute // el programa podré agregar datos al mismo archivo, si en un momento dado, quiero // que cada vez que ejecute el programa y sea el mismo archivo, tenga nuevos datos éste, // se elimina el valor booleano y la coma, dejando solo el nombre (o variable) del archivo PrintStream escribe=new PrintStream(new FileOutputStream(arch,true)); String cad=""; try {System.out.println("dar fin para terminar"); while(cad.equalsIgnoreCase("fin")!=true) { cad=ent.readLine(); if (cad.equalsIgnoreCase("fin")!=true) {escribe.println(cad);} // se escribe o graba la línea de texto (cadena) en el archivo } escribe.close(); // se cierra el flujo del objeto que contiene el flujo del archivo } catch(IOException e) {} finally {escribe.close();} // es otra parte del try, esta se realiza se produzca o no una excepción } } Clase RandomAccessFile Ejemplo de la generación de una archivo de texto, cadena por cadena: import java.io.*; class aleatorio_texto_escr {public static void main(String arg[]) throws IOException { // introduzco el nombre del archivo desde el teclado al momento de ejecutar // el programa, es capturado por el parametro arg del metodo main String archivo=arg[0]; long tam; String cad; // se crea un objeto de la clase RandomAccessFile, lo que significa que el archivo // está abierto en modo lectura/escritura (rw), esto permite tanto escribir datos en // el archivo como leerlo, para este caso solo lo voy a utilizar para la escritura, // si en un momento dado se necesitará modificar algún dato del archivo, bajo este // modo se puede hacer, sin necesidad de primer abrir el archivo en modo de lectura // y después en modo escritura para hacer éste cambio. RandomAccessFile arch=new RandomAccessFile(archivo,"rw"); tam=arch.length(); // obtiene el tamaño del archivo, en bytes arch.seek(tam); // coloca el puntero del archivo en la última posición, esto es por // si ya existen datos en el archivo no se pierdan, y que los nuevos // datos queden hasta el final de éste, en caso contrario los encimaría for (int i=1;i<arg.length;i++) {// introduzco las cadenas desde el teclado al momento de ejecutar // el programa, son capturadas por el parámetro arg del método main cad=arg[i]; // se graban los datos en el archivo arch.writeUTF(cad); // una cadena, en formato UTF Maria Eugenia Puga Nathal Página 18 17/09/2015
- 19. Archivos } arch.close(); } } Archivo de datos LECTURA ClaseFileInputStream Ejemplo de un archivo de lectura de datos: import java.io.*; class lectura_datos_1 {public static void main(String arg[]) throws IOException { String cad=""; int len=0; double oper=0; char car=' '; // se crea un objeto de la clase DataInputStream con la finalidad de que me // permita leer del archivo datos de diferentes tipos, toma como parámetro // el objeto anónimo de la clase FileInputStream, que es la fuente de donde // se tomarán los datos, este objeto indica la apertura del archivo en modo lectura. DataInputStream arch=new DataInputStream(new FileInputStream("datos1.dat")); try {// se genera un ciclo infinito donde se estarán leyendo los datos del // archivo, el ciclo se rompe al momento en que no hay elementos en el // archivo, y se lanza la excepción EOFException while(true) {// se leen los datos del archivo cad=arch.readUTF(); // se lee una cadena en formato UTF len=arch.readInt(); // se lee un valor tipo int oper=arch.readDouble(); // se lee un valor tipo double car=arch.readChar(); // se lee un caracter // se imprimen los datos que se leyeron del archivo System.out.println(cad+" "+len+" "+oper+" "+car); } } catch(EOFException fin) // capta excepción fin de archivo {System.out.println("fin de archivo "+ fin.getMessage()); arch.close(); // cierra el flujo que está relacionado con el archivo } } } Clase RandomAccessFile Ejemplo de un archivo de lectura de datos: import java.io.*; class lectura_datos_2 {public static void main(String arg[]) throws IOException { String cad=""; int len=0; double oper=0; char car=' '; // se crea un objeto de la clase RandomAccessFile, en modo lectura (r) RandomAccessFile arch=new RandomAccessFile("datos2.dat","r"); try {// se genera un ciclo infinito donde se estarán leyendo los datos del // archivo, el ciclo se rompe al momento en que no hay elementos en el // archivo, y se lanza la excepción EOFException while(true) Maria Eugenia Puga Nathal Página 19 17/09/2015
- 20. Archivos { // seleen los datos del archivo cad=arch.readUTF(); // se lee una cadena en formato UTF len=arch.readInt(); // se lee un valor de tipo int oper=arch.readDouble(); // se lee un valor de tipo double car=arch.readChar(); // se lee un caracter // se imprimen los datos leídos del archivo System.out.println(cad+" "+len+" "+oper+" "+car); } } catch(EOFException fin) {System.out.println("fin de archivo "+ fin.getMessage()); arch.close(); // se cierra el flujo de entrada del archivo } } } ESCRITURA Clase FileOutputStream Ejemplo de un archivo de escritura de datos: import java.io.*; class escritura_datos_1 {public static void main(String arg[]) throws IOException { String archivo="datos1.dat"; long tam; String cad; int len; double oper; char car; // se crea un objeto de la clase DataOutputStream con la finalidad de que me // permita escribir en el archivo datos de diferentes tipos, toma como parámetro // el objeto anónimo de la clase FileOutputStream, que es la destino en donde // se escribirán los datos, este objeto indica la apertura del archivo en modo //escritura, el valor booleano indica que cada vez que se ejecute el programa, // los nuevos datos se agregaran al final del archivo, si se quita este valor, // indica que cada vez que se ejecute el programa se borraran los datos y se // escribirá de nueva cuenta en el archivo. DataOutputStream arch=new DataOutputStream(new FileOutputStream(archivo,true)); for (int i=0;i<arg.length;i++) {// introduzco las cadenas desde el teclado al momento de ejecutar // el programa, son capturadas por el parámetro arg del método main cad=arg[i]; len=cad.length(); oper=Math.random()*len; car=cad.charAt(0); // se graban los datos en el archivo arch.writeUTF(cad); // una cadena, en formato UTF arch.writeInt(len); // un valor de tipo int arch.writeDouble(oper); // un valor de tipo double arch.writeChar(car); // un caracter } arch.close(); // se cierra el flujo que depende del archivo } } Clase RandomAccessFile Ejemplo de un archivo de escritura de datos: Maria Eugenia Puga Nathal Página 20 17/09/2015
- 21. Archivos import java.io.*; class escritura_datos_2 {publicstatic void main(String arg[]) throws IOException { String archivo="datos2.dat"; long tam; String cad; int len; double oper; char car; // se crea un objeto de la clase RandomAccessFile, lo que significa que el archivo // está abierto en modo lectura/escritura (rw), esto permite tanto escribir datos en // el archivo como leerlo, para este caso solo lo voy a utilizar para la escritura, // si en un momento dado se necesitará modificar algún dato del archivo, bajo este // modo se puede hacer, sin necesidad de primer abrir el archivo en modo de lectura // y despues en modo escritura para hacer éste cambio. RandomAccessFile arch=new RandomAccessFile(archivo,"rw"); tam=arch.length(); // obtiene el tamaño del archivo, en bytes arch.seek(tam); // coloca el puntero del archivo en la última posición, esto es por // si ya existen datos en el archivo no se pierdan, y que los nuevos // datos queden hasta el final de éste, en caso contrario los encimaría for (int i=0;i<arg.length;i++) {// introduzco las cadenas desde el teclado al momento de ejecutar // el programa, son capturadas por el parámetro arg del método main cad=arg[i]; len=cad.length(); oper=Math.random()*len; car=cad.charAt(0); // se graban los datos en el archivo arch.writeUTF(cad); // una cadena, en formato UTF arch.writeInt(len); // un valor de tipo int arch.writeDouble(oper); // un valor de tipo double arch.writeChar(car); // un caracter } arch.close(); // se cierra el flujo de salida del archivo } } Almacenar Objetos en un archivo Clase del objeto que implementa la interface Serializable // datos que conformaran el objeto, debe de implementar la interface Serializable // la cual es una interface vacia, es decir no contiene métodos, pero es un requisito // para que un objeto se pueda serializar (convertir a un flujo de bytes (o bits) o deserializar // (convertir un flujo de bytes (o bits) a un objeto en particular), los atributos y métodos que // tengan los modificadores de tipo static o transient no serán serializados, el resto // del objeto si import java.io.*; public class Datos implements Serializable {String cad; int len; double oper; char car; } Clase ObjectInputStream (entrada(lectura) import java.io.*; Maria Eugenia Puga Nathal Página 21 17/09/2015
- 22. Archivos class fileobjetos1_1 {public staticvoid main(String arg[]) throws IOException {// se crea un objeto de la clase ObjectInputStream con la finalidad de que me // permita leer del archivo datos un objeto completo en lugar de cada uno de sus atributos, // además de permitir leer tipos de datos primitivos (los mismos que DataInputStream), toma // como parámetro para este caso, el objeto anónimo de la clase FileInputStream, que es la // fuente de donde se tomarán los datos, este objeto indica la apertura del archivo en modo lectura. ObjectInputStream objeto=new ObjectInputStream(new FileInputStream("objetos.dat")); Datos datos=new Datos(); // se crea un objeto de la clase datos try {while(true) // ciclo para la lectura de los datos del archivo { // se lee el objeto del archivo, y el flujo obtenido se convierte a través de // un cast (conversión explícita) al tipo de objeto en particular a obtener, es decir se // deserializa (conversión de un flujo de bytes (o bits) a un objeto en particular) datos=(Datos) objeto.readObject(); // se imprimien los datos del objeto System.out.println(datos.cad+" "+datos.len+" "+datos.oper+" "+datos.car); } } catch(EOFException fin) // se captura la excepción de fin de archivo {System.out.println(fin.getMessage()+" fin de archivo"); objeto.close(); // se cierra flujo de entrada del archivo } catch(Exception e) // captura algún problema (excepción) con el objeto {System.out.println("error al leer el objeto");} } } Clase ObjectOutputStream (salida/escritura) import java.io.*; class fileobjetos1 {public static void main(String arg[]) throws IOException { // se crea un objeto de la clase ObjectOutputStream con la finalidad de que me // permita escribir en el archivo un objeto completo en lugar de ir grabando // atributo por atributo, también me permite escribir (grabar) datos de diferentes // tipos como lo hace la clase DataOutputStream, toma como par metro el objeto // anónimo de la clase FileOutputStream, que es la destino en donde se escribir n // los datos, este objeto indica la apertura del archivo en modo escritura, el valor // booleano indica que cada vez que se ejecute el programa, los nuevos datos se agregaran // al final del archivo, si se quita este valor, indica que cada vez que se ejecute el // programa se borraran los datos y se escribir de nueva cuenta en el archivo. ObjectOutputStream objeto=new ObjectOutputStream(new FileOutputStream("objetos.dat",true)); Datos datos=new Datos(); // se crea un objeto de la clase Datos for (int i=0;i<arg.length;i++) // de acuerdo a las cadenas que se proporcionaron al ejecutar // el programa, serán los objetos a almacenar en el archivo {datos=new Datos(); datos.cad=arg[i]; datos.len=datos.cad.length(); datos.oper=Math.random()*datos.len; datos.car=datos.cad.charAt(0); // se graba (escribe) el objeto en el archivo, pero para esto lo serializar, es decir lo // convierte en un flujo de bytes (o bits) objeto.writeObject(datos); } objeto.close(); // se cierra el flujo de salida del archivo } } Maria Eugenia Puga Nathal Página 22 17/09/2015
- 23. Archivos Archivos aleatorios Clase RandomAccessFile ESCRITURA importjava.io.*; class escritura_aleatorio {public static void main(String arg[]) throws IOException { String cad; int len; double oper; char car; StringBuffer cadmod; int tam=22+4+8+2; // se calcula el tamaño del registro de datos // se crea un objeto de la clase RandomAccessFile, lo que significa que el archivo // está abierto en modo lectura/escritura (rw), esto permite tanto escribir datos en // el archivo como leerlo, para este caso solo lo voy a utilizar para la escritura, // si en un momento dado se necesitará modificar algún dato del archivo, bajo este // modo se puede hacer, sin necesidad de primer abrir el archivo en modo de lectura // y despues en modo escritura para hacer éste cambio. RandomAccessFile arch=new RandomAccessFile("datos3.dat","rw"); // se calcula el total de los elementos almacenados en el archivo con la finalidad de // colocarnos en la siguiente posición válida para almacenar el nuevo elemento del archivo, // una posición mas adelante de la última long total=arch.length()/tam; if (total!=0) {total+=1;} System.out.println("tamaño "+tam+" total "+total); for (int i=0;i<arg.length;i++) {// introduzco las cadenas desde el teclado al momento de ejecutar // el programa, son capturadas por el parámetro arg del método main cad=arg[i]; // debido a que un archivo de acceso aleatorio requiere de registros de tamaño uniforme, // obligo a que la cadena tenga una longitud fija, en este caso de 10 caracteres, para esto // me auxilio de la clase StringBuffer y su método setLength() que permite fijar una // longitud a la cadena, para esto creo un objeto de la clase StringBuffer pasando como // parámetro la cadena a modificar, se establece el nuevo tamaño, una vez que se tiene esto, // se hace una conversión a través del método toString() de un objeto StringBuffer a un objeto String cadmod=new StringBuffer(cad); // se crea el objeto cadmod.setLength(10); // se establece la longitud cad=cadmod.toString(); // se convierte a objeto String len=cad.length(); oper=Math.random()*len; car=cad.charAt(0); arch.seek(tam*(i+total)); // posición donde se grabara el nuevo registro de datos // se graban los datos arch.writeUTF(cad); // una cadena en formato UTF arch.writeInt(len); // un valor de tipo int arch.writeDouble(oper); // un valor de tipo double arch.writeChar(car); // un caracter } arch.close(); // se cierra el flujo de salida del archivo } } LECTURA Maria Eugenia Puga Nathal Página 23 17/09/2015
- 24. Archivos Ejemplo 1 import java.io.*; classlectura_aleatorio_1 {public static void main(String arg[]) throws IOException { String cad=""; int len=0; double oper=0; char car=' '; int tam=22+4+8+2;// se calcula el tamaño del registro de datos int cont=0; // se crea un objeto de la clase RandomAccessFile, en modo lectura (r) RandomAccessFile arch=new RandomAccessFile("datos3.dat","r"); try {// se genera un ciclo infinito donde se estarán leyendo los datos del // archivo, el ciclo se rompe al momento en que no hay elementos en el // archivo, y se lanza la excepción EOFException while(true) {arch.seek(tam*cont); // se posiciona el puntero en el byte donde se // localiza el registro de los datos que se comenzarán a leer // se leen los datos del archivo, en este ejemplo los leo e imprimo directamente, // pero pueden primero asignarse los valores a las varianles que están declaradas // al inicio del método y después imprimirlas System.out.println(arch.readUTF()); // una cadena en formato UTF System.out.println(arch.readInt()); // un valor int System.out.println(arch.readDouble()); // un valor double System.out.println(arch.readChar()); // un caracter cont++; // esto lo puse con la finalidad de poder visualizar los datos leidos System.in.read(); System.in.skip(System.in.available()); } } catch(EOFException fin) // se capura la excepción de fin de archivo (EOFException) {System.out.println("fin de archivo "+ fin.getMessage()); arch.close(); // se cierra el flujo de entrada del archivo } catch(IOException e) {System.out.println("fin de archivo "+ e.getMessage()); } } } Ejemplo 2 import java.io.*; class lectura_aleatorio_2 {public static void main(String arg[]) throws IOException { String cad=""; int len=0; double oper=0; char car=' '; int tam=22+4+8+2; // se calcula el tamaño del registro de datos long cont=0; // se crea un objeto de la clase RandomAccessFile, en modo lectura (r) RandomAccessFile arch=new RandomAccessFile("datos3.dat","r"); // se calcula el total de los elementos almacenados en el archivo long total=arch.length()/tam; if (total!=0) {total+=1;} Maria Eugenia Puga Nathal Página 24 17/09/2015
- 25. Archivos try { for (cont=0;cont<total;cont++) {//posición donde se grabara el nuevo registro de datos se graban los datos arch.seek(tam*cont); // se leen los datos del archivo, en este ejemplo los leo e imprimo directamente, // pero pueden primero asignarse los valores a las varianles que están declaradas // al inicio del método y después imprimirlas System.out.println(arch.readUTF()); // una cadena en formato UTF System.out.println(arch.readInt()); // un valor tipo int System.out.println(arch.readDouble()); // un valor tipo double System.out.println(arch.readChar()); // un caracter // esto lo puse con la finalidad de poder visualizar los datos leídos System.in.read(); System.in.skip(System.in.available()); } arch.close(); // se cierra el flujo de entrada del archivo } catch(EOFException fin) // se capura la excepción de fin de archivo (EOFException) {System.out.println("fin de archivo "+ fin.getMessage()); arch.close(); // se cierra el flujo de entrada del archivo } catch(IOException e) {System.out.println("fin de archivo "+ e.getMessage()); } } } Maria Eugenia Puga Nathal Página 25 17/09/2015