Programación interactiva

Oscar Bedoya
oscarbed@eisc.univalle.edu.co
Archivos
 Archivos

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
 Archivos

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
 Archivos

• 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”);

 Archivos

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
 Archivos

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

 Archivos

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

PruebaFile
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(); Se utilizan los métodos
File objeto = new File(nombreArchivo);
de la clase File
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 );
}

}
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
 Archivos

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
 Archivos

• 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
 Archivos

• 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

TraductorX
 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
TraductorX
 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
avanza a la siguiente línea
String linea = new String();
String palabra = TFPalabra.getText();

try{
Se crea un objeto de
RandomAccessFile archivo = new RandomAccessFile("data.txt", "r"); RandomAccessFile
linea = archivo.readLine(); para leer del archivo
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();
}
}
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()) ){ • Si el token coincide con la

encontrado=1; palabra a traducir se muestra
TFTraduccion.setText(tokens.nextToken());
}
en el campo de texto.
else • Sino, se avanza a la siguiente
linea=archivo.readLine(); 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)
File nombreArchivo=selectorArchivo.getSelectedFile();
 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
JFileChooser selectorArchivo= new JFileChooser();
int resultado = selectorArchivo.showOpenDialog(this);

if (resultado == JFileChooser.CANCEL_OPTION) Se muestra el FileChooser. Se

System.out.println("No seleccionó ningún archivo"); considera el caso en que no
seleccione 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"); }
}
}
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() ; Se maneja el caso en que
if (nombreArchivo==null || nombreArchivo.getName().equals(""))
no escriba un nombre de
JOptionPane.showMessageDialog(null, "Nombre de archivo incorrecto”); archivo válido
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"); }
}
}
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); Cada línea del archivo se
datos.addElement(linea); guarda temporalmente
linea = r.readLine(); en un vector
}
r.close();
}
catch(IOException e){ System.out.println("Error al abrir el archivo"); }
}
}
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
completar el traductor
 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

flujoSalida = new PrintStream(new FileOutputStream(nombreArchivo) );
 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

flujoSalida = new PrintStream(new FileOutputStream(nombreArchivo) );
 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
ver parte del oyente para guardar
 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.

Se separa por TAB (tabulación) los datos de cada estudiante

 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
ver método buscarEstudiante
 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
file.close();
 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

Archivos2
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; Estudiante
}
public String obtenerCodigo(){ String codigo, nombre;
return codigo; int edad;
} double promedio;
public String obtenerNombre(){ Estudiante()
return nombre; public String obtenerCodigo()
} public String obtenerNombre()
public int obtenerEdad(){ public int obtenerEdad()
return edad; public double obtenerPromedio()
}
public double obtenerPromedio(){
return promedio;
}
}
datos

unEstudiante unEstudiante unEstudiante

10066043 6106787 9709555

Sarah Meyer OsCaR Sophie
25 27 18
4.5 4.6 4.0
public void cargarDatos()
{

try{
RandomAccessFile file = new RandomAccessFile("estudiantes.txt", "r");
String linea = file.readLine();

while(linea!=null){
Se llama a este método
StringTokenizer tokens = new StringTokenizer(linea, "\t"); en el constructor
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");
}
}
Archivos

Adicionar un estudiante
consiste en agregarlo al vector

Archivos2
ver oyente adicionar, buscar y eliminar
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
vector
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 );

Se modifica el método
windowClosing para que haga el
llamado al método guardarDatos()