Oscar Bedoya
[email protected]
Clase File
•
Resulta útil para recuperar
información
acerca de un archivo o
directorio, entre la que se encuentra
-Longitud del archivo en bytes
-Fecha y hora de la última modificación
-La ruta absoluta
-En caso de ser un directorio, se puede conocer una lista con
los nombres de archivos que contiene
Además, cuando se tiene solo una referencia a un archivo o un
directorio, se puede conocer cuál de los dos es. También se puede
saber si realmente existe tal archivo o directorio
Archivos
Método Descripción
boolean canRead() Devuelve true si se puede leer el archivo, en caso contrario devuelve false
boolean canWrite() Devuelve true si se puede escribir el archivo, en caso contrario devuelve false
boolean exists() Devuelve true si el nombre especificado como argumento en el constructor de File es un archivo o un directorio; en caso contrario devuelve false
boolean isFile() Devuelve true si el nombre especificado como argumento en el constructor es un archivo
boolean isDirectory() Devuelve true si el nombre especificado como argumento en el constructor es un directorio
String getAbsolutePath() Devuelve un String con la ruta absoluta del archivo o directorio String getName() Devuelve un String con el nombre del archivo o directorio
long length() Devuelve la longitud de un archivo en bytes. Si el objeto File representa a un directorio, se devuelve 0
long lastModified() Devuelve una representación de la hora en la que se hizo la última modificación
String[] List() Devuelve un arreglo de cadenas que representan el contenido del directorio. Devuelve null si el objeto File no es un directorio
Clase File
•
Los objetos File no abren archivos ni proporcionan herramientas
para procesar archivos
•
Realmente, los objetos File se utilizan frecuentemente con objetos
de otras clases de java.io para especificar los archivos o directorios
que se van a manipular
•
Para crear un objeto de la clase File se especifica el nombre del
archivo o directorio que se quiere asociar
File objeto = new File(“datos.txt”);
•
En caso de que el archivo se encuentre dentro de un directorio, se
utiliza un constructor que tiene dos parámetros, la ruta y el nombre
del archivo
File objeto = new File(“interativa/”, “ejemplo.dat”);
Archivos
•
Para especificar un directorio se pasa su nombre al constructor
File objeto = new File(“directorio”);
Para
leer el contenido
de un archivo se debe tener en cuenta lo
siguiente:
•
La clase
FileReader
se puede utilizar para abrir un archivo
•
Sin embargo, la clase FileReader no sabe cómo leer líneas de texto
•
La clase
BufferedReader
proporciona la funcionalidad de leer líneas
de texto, pero no sabe cómo abrir un archivo
•
Se deben utilizar las clases FileReader y BufferedReader en
conjunto para leer la información contenida en un archivo. Esto se
conoce como envoltura de objetos de flujo
Para envolver un objeto FileReader en un objeto BufferedReader se
pasa el objeto FileReader al constructor de BufferedReader
BufferedReader
entrada
=new BufferedReader(new FileReader(objeto));
Luego, se puede usar la referencia entrada para leer del archivo
El archivo se lee por líneas. El método readLine devuelve en un String
el contenido de la línea y avanza a la siguiente línea. En caso de que
llegue al final del archivo, readLine devuelve null
File objeto = new File(“datos.txt”);
BufferedReader entrada=new BufferedReader(
new FileReader(objeto));
while ((texto=entrada.readLine()) != null )
areatexto.append("\n" + texto );
Archivos
Archivos
Si es un archivo se
muestra la ruta, la
ruta absoluta y el
contenido del archivo
String nombreArchivo = campo.getText(); File objeto = new File(nombreArchivo);
if ( objeto.exists() ) {
areatexto.setText("\nRuta:” + objeto.getPath() + "\nRuta absoluta: " + objeto.getAbsolutePath() ); if ( objeto.isFile() ) {
try {
BufferedReader entrada = new BufferedReader(new FileReader( objeto ) ); String texto;
areatexto.append( "\n\nCONTENIDO DEL ARCHIVO: \n" ); while ( ( texto = entrada.readLine() ) != null )
areatexto.append("\n" + texto ); }
catch( IOException excepcion ) {
JOptionPane.showMessageDialog( this, "ERROR EN ARCHIVO", "ERROR EN ARCHIVO", JOptionPane.ERROR_MESSAGE ); }
String nombreArchivo = campo.getText(); File objeto = new File(nombreArchivo);
if ( objeto.exists() ) {
areatexto.setText("\nRuta:” + objeto.getPath() + "\nRuta absoluta: " + objeto.getAbsolutePath() ); if ( objeto.isFile() ) {
try {
BufferedReader entrada = new BufferedReader(new FileReader( objeto ) ); String texto;
areatexto.append( "\n\nCONTENIDO DEL ARCHIVO: \n" ); while ( ( texto = entrada.readLine() ) != null )
areatexto.append("\n" + texto ); }
catch( IOException excepcion ) {
JOptionPane.showMessageDialog( this, "ERROR EN ARCHIVO", "ERROR EN ARCHIVO", JOptionPane.ERROR_MESSAGE ); }
}
Se utilizan los métodos
de la clase File
Archivos
Si es un directorio, se
muestra su contenido
if ( objeto.isDirectory() ) {
String directorio[] = objeto.list();
areatexto.append( "\n\nContenido del directorio:\n"); for ( int i = 0; i < directorio.length; i++ )
areatexto.append( directorio[ i ] + "\n" ); }
El método list devuelve un
arreglo de Strings con los
nombres de los subdirectorios y
archivos. Se muestra cada
elemento del arreglo
Manejo de archivos con RandomAccessFile
La clase RandomAccessFile proporciona todas las herramientas de las
clases FileInputStream, FileOutputStream, DataInputStream y
DataOutputStream que permiten escribir en un archivo
•
Para
abrir
un archivo por medio de la clase RandomAccessFile se
pasa al constructor el nombre del archivo y el tipo de permiso
RandomAccessFile archivo= new RandomAccessFile(nombre, permiso);
donde permiso es un String que puede ser “r” para indicar que es de
solo lectura, “w” para escritura y “rw” para lectura y escritura
•
Para leer de un archivo por medio de la clase RandomAccessFile se
utiliza el método readLine()
String linea;
linea = archivo.readLine();
Archivos
Problema
: Desarrollar un traductor de tal forma que las palabras se
almacenen en un archivo. El proceso de búsqueda de una palabra se
realiza sobre el archivo
Archivos
Problema
: Desarrollar un traductor de tal forma que las palabras se
almacenen en un archivo. El proceso de búsqueda de una palabra se
realiza sobre el archivo
El formato que se selecciona para
almacenar los datos, consiste en colocar
la palabra en español, seguido del
carácter “#” y luego la palabra en inglés
Archivos
Problema
: Desarrollar un traductor de tal forma que las palabras se
almacenen en un archivo. El proceso de búsqueda de una palabra se
realiza sobre el archivo
El formato que se selecciona para
almacenar los datos, consiste en colocar
la palabra en español, seguido del
carácter “#” y luego la palabra en inglés
Archivos
•
La clase StringTokenizer permite descomponer un String en tokens. Se pasa
al constructor una cadena de caracteres y el símbolo que separa los tokens
StringTokenizer tokens = new StringTokenizer(
linea,simbolo
);
•
Para conocer el siguiente token, se utiliza el método nextToken()
actual = tokens.nextToken();
•
Para saber si se tienen más tokens se hace;
tokens.hasMoreTokens()
Archivos
Suponga que se tiene lo siguiente:
String linea = “LIBRO#BOOK”;
StringTokenizer tokens = new StringTokenizer(
linea,”#”
);
System.out.println( tokens.nextToken() );
System.out.println( tokens.nextToken() );
Muestra los dos tokens LIBRO y BOOK
Archivos
Se toma la palabra del campo de texto
TFPalabra y se compara con el primer
token
de la línea. Si coinciden se
muestra el siguiente token, sino, se
String linea = new String();
String palabra = TFPalabra.getText(); try{
RandomAccessFile archivo= new RandomAccessFile("data.txt", "r"); linea = archivo.readLine();
int encontrado=0;
while(linea!=null && encontrado==0){
StringTokenizer tokens = new StringTokenizer(linea, "#"); while (tokens.hasMoreTokens()){
String actual = tokens.nextToken();
if (actual.equals(palabra.toUpperCase()) ){ encontrado=1; TFTraduccion.setText(tokens.nextToken()); } else linea=archivo.readLine(); } }
Se crea un objeto de
RandomAccessFile
para leer del archivo
String linea = new String();
String palabra = TFPalabra.getText(); try{
RandomAccessFile archivo = new RandomAccessFile("data.txt", "r"); linea = archivo.readLine();
int encontrado=0;
while(linea!=null && encontrado==0){
StringTokenizer tokens = new StringTokenizer(linea, "#"); while (tokens.hasMoreTokens()){
String actual = tokens.nextToken();
if (actual.equals(palabra.toUpperCase()) ){ encontrado=1; TFTraduccion.setText(tokens.nextToken()); } else linea=archivo.readLine(); } }
•
Si el token coincide con la
palabra a traducir se muestra
en el campo de texto.
•
Sino, se avanza a la siguiente
línea
Archivos
Incorporando JFileChooser para el manejo de archivos
Archivos +
data.txt
Archivos
Para mostrar el cuadro de dialogo se utiliza el método showOpenDialog
JFileChooser selectorArchivo = new JFileChooser();
int resultado = selectorArchivo.
showOpenDialog
(this);
if (resultado == JFileChooser.CANCEL_OPTION)
System.out.println("No seleccionó ningun archivo");
if (resultado == JFileChooser.APPROVE_OPTION)
Archivos
Para mostrar el cuadro de dialogo se utiliza el método showOpenDialog
JFileChooser selectorArchivo = new JFileChooser();
int resultado = selectorArchivo.
showOpenDialog
(this);
if (resultado == JFileChooser.CANCEL_OPTION)
System.out.println("No seleccionó ningun archivo");
if (resultado == JFileChooser.APPROVE_OPTION)
//procesar informacion
El método
showOpenDialog
devuelve un número entero.
Para saber si se hizo clic en Cancelar se utiliza la
constante JFileChooser.CANCEL_OPTION y cuando se
selecciona un archivo se tiene la constante
JFileChooser.APPROVE_OPTION
JFileChooserselectorArchivo= new JFileChooser(); int resultado = selectorArchivo.showOpenDialog(this);
if (resultado == JFileChooser.CANCEL_OPTION) System.out.println("No seleccionó ningún archivo"); if (resultado == JFileChooser.APPROVE_OPTION)
{
File nombreArchivo = selectorArchivo.getSelectedFile() ;
if (nombreArchivo==null || nombreArchivo.getName().equals(""))
JOptionPane.showMessageDialog(null, "Nombre de archivo incorrecto”);
else {
try {
RandomAccessFile r = new RandomAccessFile( nombreArchivo , "r"); String linea=r.readLine(); while (linea!=null){ areatexto.append("\n" + linea); datos.addElement(linea); linea = r.readLine(); } r.close(); }
catch(IOException e){ System.out.println("Error al abrir el archivo"); } }
}
Se muestra el FileChooser. Se
considera el caso en que no
JFileChooser selectorArchivo= new JFileChooser(); int resultado = selectorArchivo.showOpenDialog(this);
if (resultado == JFileChooser.CANCEL_OPTION) System.out.println("No seleccionó ningún archivo"); if (resultado == JFileChooser.APPROVE_OPTION)
{
File nombreArchivo = selectorArchivo.getSelectedFile() ;
if (nombreArchivo==null || nombreArchivo.getName().equals(""))
JOptionPane.showMessageDialog(null, "Nombre de archivo incorrecto”);
else {
try {
RandomAccessFile r = new RandomAccessFile( nombreArchivo , "r"); String linea=r.readLine(); while (linea!=null){ areatexto.append("\n" + linea); datos.addElement(linea); linea = r.readLine(); } r.close(); }
catch(IOException e){ System.out.println("Error al abrir el archivo"); } }
}
Se maneja el caso en que
no escriba un nombre de
JFileChooser selectorArchivo= new JFileChooser(); int resultado = selectorArchivo.showOpenDialog(this);
if (resultado == JFileChooser.CANCEL_OPTION) System.out.println("No seleccionó ningún archivo"); if (resultado == JFileChooser.APPROVE_OPTION)
{
File nombreArchivo = selectorArchivo.getSelectedFile() ;
if (nombreArchivo==null || nombreArchivo.getName().equals(""))
JOptionPane.showMessageDialog(null, "Nombre de archivo incorrecto”);
else {
try {
RandomAccessFile r = new RandomAccessFile( nombreArchivo , "r"); String linea=r.readLine(); while (linea!=null){ areatexto.append("\n" + linea); datos.addElement(linea); linea = r.readLine(); } r.close(); }
catch(IOException e){ System.out.println("Error al abrir el archivo"); } }
}
Cada línea del archivo se
guarda temporalmente
Archivos
Procesar muestra la información
del archivo separando cada línea
que lo compone por el carácter “-”
if (evento.getSource()==procesar) {
areatexto.append("\n\n * Análisis *\n"); for (int i=0 ; i<datos.size() ; i++) {
String linea = (String.valueOf(datos.elementAt(i))); areatexto.append(" - " + linea);
} }
Archivos
Guardar los cambios efectuados en
el área de texto. Se pueden
adicionar más palabras para
Archivos
Una forma de almacenar datos en un archivo es por medio de un flujo
(PrintStream)
•
Se declara el flujo
PrintStream flujoSalida = null;
•
Se muestra el dialogo para guardr el archivo
int resultado = selectorArchivo.showSaveDialog(this);
•
Se guardar en un objeto File el nombre del archivo
File nombreArchivo = selectorArchivo.getSelectedFile();
•
Se crea el flujo de salida
Archivos
Una forma de almacenar datos en un archivo es por medio de un flujo
(PrintStream)
•
Se declara el flujo
PrintStream flujoSalida = null;
•
Se muestra el dialogo para guardr el archivo
int resultado = selectorArchivo.
showSaveDialog
(this);
•
Se guarda en un objeto File el nombre del archivo
File nombreArchivo = selectorArchivo.getSelectedFile();
•
Se crea el flujo de salida
Archivos
Una forma de almacenar datos en un archivo es por medio de un flujo
(PrintStream)
•
Para escribir en el flujo se utiliza el método println
flujoSalida.println( areatexto.getText() );
•
Cuando se termine de escribir, se debe cerrar el archivo
flujoSalida.close();
Archivos
Archivos
Problema
: Desarrollar una aplicación Java que permita manejar los datos
de los estudiantes. La aplicación debe permitir la búsqueda, adición y
consulta de los estudiantes. La información se debe almacenar en un
archivo
Archivos1 +
estudiantes.txt
Archivos
Considere el siguiente formato para almacenar la información de los
estudiantes.
Archivos
Para la búsqueda, se digita el código y se oprime Buscar.
Se busca en el archivo llamado estudiantes.txt
-En caso de que se encuentre, se completan los
campos de textos con la información respectiva
-Si no se encuentra se muestra un mensaje
Archivos1
Archivos
Para adicionar los datos de un nuevo estudiante, se utilizará ahora una
forma alternativa de escribir en un archivo
Se hará completamente utilizando la clase RandomAccesseFile.
Específicamente, utilizando un método que permite ubicarse en la
última línea del mismo para escribir allí
Archivos
•
Crear la referencia al archivo
RandomAccessFile file = new RandomAccessFile("estudiantes.txt", "rw");
•
Ubicarse en el ultimo registro del archivo
file.
seek
(file.length());
•
Escribir en el archivo
file.
writeBytes
(datosEstudiante);
•
Cerrar el archivo
Archivos
•
Crear la referencia al archivo
RandomAccessFile file = new RandomAccessFile("estudiantes.txt", "rw");
•
Ubicarse en el ultimo registro del archivo
file.
seek
(file.length());
•
Escribir en el archivo
file.
writeBytes
(datosEstudiante);
•
Cerrar el archivo
file.close();
•seek
permite ubicarse en la
posición indicada
•writeBytes
permite escribir
en un archivo RandomAccessFile
Archivos
Cuando un programa necesita manipular el conjunto de datos
almacenado previamente en un archivo, resulta más eficiente hacer una
copia del archivo en un Vector
Cuando inicia la aplicación se copia la información a un vector, se
realizan las modificaciones sobre el vector y cuando el usuario vaya a
cerrar la aplicación, se pasa el contenido del vector al archivo
Actualizar y Eliminar son
operaciones que requieren
mayor control sobre el
conjunto de datos
public class Estudiante
{
private String codigo, nombre; private int edad;
private double promedio;
public Estudiante(String c, String n, int e, double p){ codigo = c;
nombre = n; edad = e; promedio = p; }
public String obtenerCodigo(){ return codigo; }
public String obtenerNombre(){ return nombre;
}
public int obtenerEdad(){ return edad; }
public double obtenerPromedio(){ return promedio; }
}
Estudiante String codigo, nombre; int edad;
double promedio; Estudiante()
public String obtenerCodigo() public String obtenerNombre() public int obtenerEdad()
unEstudiante 10066043 Sarah Meyer 25 4.5 unEstudiante 6106787 OsCaR 27 4.6 unEstudiante 9709555 Sophie 18 4.0 datos
public void cargarDatos() {
try{
RandomAccessFile file = new RandomAccessFile("estudiantes.txt", "r"); String linea = file.readLine();
while(linea!=null){
StringTokenizer tokens = new StringTokenizer(linea, "\t"); while (tokens.hasMoreTokens()){
String codigo = String.valueOf(tokens.nextToken()); String nombre = String.valueOf(tokens.nextToken()); int edad = Integer.parseInt(tokens.nextToken());
double promedio = Double.parseDouble(tokens.nextToken());
Estudiante objeto = new Estudiante(codigo, nombre, edad, promedio);
datos.addElement(objeto); }
linea=file.readLine(); }
}
catch(IOException e){ System.out.println("Error al abrir el archivo"); }
}
Se llama a este método
en el constructor
Archivos
Adicionar un estudiante
consiste en agregarlo al vector
Archivos2
public static void guardarDatos() {
try{
flujo= new PrintStream(new FileOutputStream("estudiantes.txt") ); }
catch (IOException e) { System.out.println("Error al abrir el archivo"); } try{
for (int i=0 ; i<datos.size() ; i++) { String linea; linea = ((Estudiante)datos.elementAt(i)).obtenerCodigo() + "\t" + ((Estudiante)datos.elementAt(i)).obtenerNombre() + "\t" + ((Estudiante)datos.elementAt(i)).obtenerEdad() + "\t" + ((Estudiante)datos.elementAt(i)).obtenerPromedio() ; flujo.println(linea); }
} catch(Exception e) {System.out.println("Error al abrir el archivo");} flujo.flush();
flujo.close();
}
Para guardar los datos, se escribe,
línea por línea, el contenido del
public static void main(String[] args) {
Archivos2 aplicacion = new Archivos2(); WindowListener l = new WindowAdapter() {
public void windowClosing(WindowEvent e) { guardarDatos(); System.exit(0); } }; aplicacion.addWindowListener(l); aplicacion.setDefaultCloseOperation( JFrame.EXIT_ON_CLOSE ); }
