09 Curso de Java OO. Stream y Archivos

Resumen
Se estudiara conceptos de lectura y escritura desde consola, la lectura y escritura de archivos de texto, lectura y escritura de archivos de datos y listar el contenido de un directorio

1. STREAM
1.1. Definiciones iniciales
- Cualquier cosa que sea leida o escrita hacia un dispositivo es un stream.
- Ejemplos de dispositivos: Consola, File, Pipes, Red, Memoria.
- Ejemplos de cosas a leerse o escribirse: Caracteres, Objetos java, sonido, imágenes...
- Para la lectura siempre se ha usado este modelo de programación
- El modelo se asemeja al flujo de agua en un rio.



abrir stream

mientras existan datos

leer o escribir datos

cerrar strem

- Un stream es un flujo de datos y puede estar compuesto por archivos de texto, datos ingresados por teclado, datos descargados desde Internet.

1.2. java.io.InputStream y java.io.OutputStream
- Las clases java estan agrupadas según su funcionalidad
- Las que tratan de la lectura heredan de InputStream.java
- Las que tratan de la escritura heredan de OutputStream.java
- Un flujo de datos binarios pueden provenir de un file, un pipe o de un objeto java.
- FileInputStream.java por ejemplo es para el manejo de archivos.

java.io.InputStream

FileInputStream
AudioInputStream
ObjectInputStream
FilterInputStream

BufferedInputStream

java.io.OutputStream

FileOutputStream
ByteArrayOutputStream
ObjectOutputStream ...
FilterOutputStream

BufferedOutputStream

- Tanto java.io.InputStream y java.io.OutputStream transmiten datos en forma de bytes (8 bits)

1.3. java.io.Writer y java.io.Reader
- Con una variación las clases InputStream y OutputStream.
- Transmiten datos en forma de caracteres (16 bits)
- Las clases Writer y Reader fueron desarrolladas posteriormente y son más veloces que InputStream y OutputStream.
- Se cuenta con clases que permiten actualizar las clases antiguas.
- InputStreamReader convierte un InputStream a Reader
- OutputStreamWriter convierte un OutputStream a Writer

java.io.Reader

BufferedReader
InputStreamReader

FileReader

StringReader

java.io.Writer

BufferedWriter
PrintWriter
OutputStreamWriter

FileWriter

2. ENTRADA Y SALIDA ESTANDAR
2.1. System.out
- El metodo System.out.println tambien es un stream que muestra datos en consola.
- System es una clase
- out es un atributo de System
- out es una clase es del tipo java.io.PrintStream
- out es una variable de instancia, publica y estatica.
- java.io.PrintStream hereda de java.io.OutputStream.
- println es un método
- El atributo out de la clase System cuenta con el metodo println que conforman el conocido System.out.println

2.2. System.in
- La entrada estandar de la consola se representa por System.in
- in es un objeto del tipo InputStream con limitaciones en la lectura por teclado.
- Su método read no permite leer una linea completa, ni un numero.
- Se usa el método read en caso requiera realizar una pausa en el programa.
try { System.in.read(); } catch ...
- Cuando requiera leer el teclado debe enmascarar System.in
- Requiere de las clases InputStreamReader y BufferedReader para realizar la mascara.

3. LECTURA DE ARCHIVOS
Ejemplo:
Este programa pide el nombre del archivo para leer su contenido y finalmente indicar cuantas líneas tiene. Ingrese por teclado un archivo java.


import java.io.*;
public class TestStreamReader {

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

String lineaJava;
int lineas = 1;
try {

System.out.print("Que archivo desea analizar?");

// Se define una variable del tipo BufferedReader que
// permite almacenar datos en memoria Buffer.
BufferedReader teclado;

// System.in es la entrada de la consola, el teclado
// InputStreamReader es un stream de lectura (de teclado)
// El constructor BufferedReader direcciona
// la lectura del teclado al buffer en memoria.

teclado = new BufferedReader(new
InputStreamReader(System.in));

// Se lee el stream hasta un ENTER.
// El nombre del archivo se encuentra la variable String.
String archivoJava = teclado.readLine();

// Se define una variable del tipo BufferedReader que
// permite almacenar datos en memoria Buffer. 
BufferedReader archivo;

// FileReader es un stream de lectura (de archivos)
// El constructor BufferedReader direcciona
// la lectura del archivo al buffer en memoria.
archivo = new BufferedReader( new FileReader(archivoJava));

// Este ciclo se realizara hasta que
// ya no existan lineas por leer.
while (( lineaJava = archivo.readLine()) != null)

lineas++;

System.out.println("El archivo " + archivoJava +
" contiene " + lineas + " lineas.");

} catch (IOException ex) {

System.err.println(ex);
System.out.println("Asegurese de haber proporcionado " +
" la extension del archivo (\".java\")");

} finally {

System.out.println("");
System.out.println("Asi funcionan los Streams!");

}

}

}

Ejercicio:
Modifique el programa anterior para que se muestre la cantidad de de llaves “{“ o “}” en el archivo.

4. ESCRITURA DE ARCHIVOS Ejemplo:
Este programa lee un archivo java y lo modifica para escribirlo en otro archivo.

import java.io.*;
public class TestWriter {

public static void main(String[] args) {

try {

// Se define el stream para leer codigo fuente
// de un archivo java
BufferedReader archivoEntrada;
archivoEntrada = new BufferedReader(

new FileReader("C:\\TestWriter.java"));

String lineaArchivo;
String fuenteArchivo = new String();

// El archivo se lee linea a linea y se agrega en una Cadena
// readLine() retorna nulo cuando no haya mas lineas.
// \n significa fin de linea, retorno de carro.
while ((lineaArchivo = archivoEntrada.readLine()) != null)

fuenteArchivo += lineaArchivo + "\n";

// Se cierra el stream de lectura.
archivoEntrada.close();

// Se define el stream en memoria (BufferedReader)
// para leer datos del teclado (InputStreamReader)
// que se digitan en la consola (System.in)
BufferedReader teclado = new BufferedReader(

new InputStreamReader(System.in));

// Se lee el teclado y se agrega a la Cadena
System.out.print("Introduzca algun dato: ");
fuenteArchivo += "Agrego \" " + teclado.readLine()

+ " \" en la consola";

// Para guardar datos en un archivo
// Se define el stream en memoria (BufferedReader)
// para leer datos de un String (StringReader)
// que se encuentra en una variable (fuenteArchivo)
BufferedReader fuenteSalida;
fuenteSalida = new BufferedReader(

new StringReader(fuenteArchivo));

// Se define un stream de salida (PrintWriter)
// que tomara los datos de memoria (BufferedWriter)
// y los escribira en un archivo (FileWriter)
PrintWriter archivoSalida;
archivoSalida = new PrintWriter(

new BufferedWriter(

new FileWriter("C:\\TestWriterNew.java")));

// Se lee linea a linea la Cadena (fuenteSalida)
// si no se tiene mas lineas, la lectura devuelve NULL
// Se escribe en el archivo el numero de linea
// y el texto de la Cadena
int lineaNo = 1;
while ((lineaArchivo = fuenteSalida.readLine()) != null)

archivoSalida.println(lineaNo++  + ": " + lineaArchivo);

// Se cierra el stream de salida
archivoSalida.close();

} catch (EOFException e) {

System.out.println("Final de Stream");

} catch (IOException e) {

System.out.println("Excepcion Entrada/Salida");

}
finally {

System.out.println("Revise C:\\TestWriterNew.java");

}

}

}

Ejercicio: 
Modifique el programa anterior para que el nuevo archivo java no tenga comentarios.

4.1. Escritura de objetos
Para escribir objetos en archivos se debe usar la clase ObjectOutputStream y ObjectInputStream usando objetos que implementan la interface java.io.Serializable.

Producto.java
public class Producto implements java.io.Serializable {

// La serialización de un objeto permite
// escribir el estado de un objeto a un flujo de bytes.
private String nombre;
private int cantidad;
private float precio;
public Producto(String nombre, int cantidad, float precio) {

this.nombre = nombre;
this.cantidad = cantidad;
this.precio = precio;

}
public String toString(){

return ("Nombre: "+nombre+" Cantidad: "+cantidad+
" Precio: "+precio);

}

}

TestObjectStream.java
import java.io.*;
public class TestObjectStream {

public static void main(String[] args) {

try {

escribirProductos();
leerProductos();

}
catch (Exception e) {

e.printStackTrace(System.err);

}

}

public static void escribirProductos() throws Exception {

// Crear objectos productos
Producto pan = new Producto("Pan", 6, 1.2f);
Producto leche = new Producto("Leche", 2, 2.5f);
Producto manzanas = new Producto("Manzanas", 5, 3f);
Producto brocoli = new Producto("Brocoli", 2, 5f);
Producto carne = new Producto("Carne", 2, 20f);
// Definir archivo de productos
ObjectOutputStream archivoProductos =
new ObjectOutputStream(
new FileOutputStream("productos.obj"));
// Escribir los productos en el archivo
archivoProductos.writeObject(pan);
archivoProductos.writeObject(leche);
archivoProductos.writeObject(manzanas);
archivoProductos.writeObject(brocoli);
archivoProductos.writeObject(carne);
// Cerrar el archivo
archivoProductos.close();

}

public static void leerProductos() throws Exception {

// Definir archivo de productos
ObjectInputStream archivoProductos =
new ObjectInputStream(
new FileInputStream("productos.obj"));
// Leer los productos del archivo
try {

while (true) {

Producto producto =
(Producto)archivoProductos.readObject();
System.out.println(producto);

}

}
catch (EOFException e) {

// Cerrar el archivo
archivoProductos.close();

}

}

}

5. LA CLASE FILE
5.1. Archivos
- La clase File se usa para representar un archivo o un conjunto de archivos (directorio)
File f1 = new File ("/");
File f1 = new File ("/","etc/passwd");
File f1 = new File ("config.sys");
- Puede obtener atributos del archivo mediante la clase File.
Si existe, si se puede leer, si se puede escribir.
Cuando fue la ultima vez modificado, cual es su tamaño.
- Con File puede crear y borrar archivos.
- Otros métodos se encuentran en:

TestFile.java
import java.io.*;
public class TestFile {

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

if( args.length > 0 )
{

for( int i=0; i < args.length; i++ )
{

File f = new File( args[i] );
System.out.println( "Nombre: "+f.getName() );
System.out.println( "Ruta : "+f.getPath() );
if( f.exists() )
{

System.out.print( "El archivo existe." );
System.out.print( (f.canRead() ?
" y se puede Leer" : "" ) );
System.out.print( (f.canWrite() ?
" y se puede Escribir" : "" ) );
System.out.println( "." );
System.out.println( "La longitud del archivo es "+
f.length()+" bytes" );

}
else  System.out.println( "El archivo no existe." );

}

}
else  System.out.println( "Debe indicar un archivo." );

}

}

Ejercicio: Modifique el programa y muestre la siguientes características del archivo.
boolean isDirectory() , boolean isHidden() , String getParent()

5.2. Directorios
- El método list() de la clase File muestra los archivos de un directorio.
- La interfase FileNameFilter se usa para obtener un subconjunto de archivos

TestFilenameFilter.java
import java.io.*;
public class TestFilenameFilter{

public static void main( String args[] ) {

// Buscar en el raiz del disco C
// Se coloca doble slash puesto que es un caracter de escape.
// en literales cadenas en java se realiza:
// \n -> retorno de carro
// \t -> tabulador
// \\ -> slash
// \" -> comillas
String directorio = "c:\\";

// el directorio es un archivo del sistema operativo
// fileDirectorio es este archivo en el programa
File fileDirectorio = new File(directorio);

// se crea un filtro de archivos que contengan java.
FilenameFilter filtro = new FilterJava("java");

// se aplica el filtro al directorio.
String [] contenido = fileDirectorio.list(filtro);
for (int i=0; i < contenido.length; i++) {

System.out.println(contenido[i]);

}

}

}

FilterJava.java
import java.io.*;
public class FilterJava implements FilenameFilter {

// Esta clase implementa un filtro de archivos
// usando la interface FilenameFilter
// mediante el método accept
String mascara;
FilterJava(String mascara) {

this.mascara = mascara;

}
public boolean accept(File directorio, String nombre) {

return nombre.indexOf(mascara) != -1;

}

}

Ejercicio: Modifique y muestre todos los archivos java del disco duro y su ubicación.

TestFilenameFilterRecursivo.java
import java.io.*;
public class TestFilenameFilterRecursivo{

public static void main( String args[] ) {

String directorio = "c:\\";
filtrarDirectorio(directorio);

}
public static void filtrarDirectorio(String directorio) {

// el directorio es un archivo del sistema operativo
// fileDirectorio es este archivo en el programa
File fileDirectorio = new File(directorio);

// se crea un filtro de archivos que contengan java.
FilenameFilter filtro = new FilterJava("java");

// se aplica el filtro al directorio.
String [] contenido = fileDirectorio.list(filtro);

// en caso no tenga contenido no se procesara
if (contenido==null) return;

// se muestra todos los archivos con java
if ( contenido.length > 0 )

System.out.println(directorio);

for (int i=0; i < contenido.length; i++) {

System.out.println(" "+contenido[i]);

}
// se recorre todo el directorio para
// obtener sus subdirectorios
String [] lista = fileDirectorio.list();

for (int i=0; i < lista.length; i++) {

// se crea un objeto file del subdirectorio
File fileSubDirectorio = new File(fileDirectorio,
lista[i]);
if (fileSubDirectorio.isDirectory()) {

// se llama recursivamente la función
filtrarDirectorio(fileSubDirectorio.
getAbsolutePath());

}

}

}

}

6. LABORATORIO

PARTE 1
Con el siguiente archivo parametros.ini; implemente el método en la clase Manager.java que lea una variable del archivo y la devuelva como String

parametros.ini
ip=190.200.3.45
url=www.uni.edu.pe
user=integrador
password=200SCAMOF
mail=salvor.hardin@enciclopedia.com
default=*.map
...
...(y mas parámetros)
...
ruta=/home/rafael/bin

Manager.java
import java.io.*;
public class Manager
{

// Método para leer una clave del archivo parámetros.ini
public static String leerParametro(String clave)...

}

Test.java
public class TestManager {

public static void main (String[] args) {

String parametro = Manager.leerParametro("user");
System.out.println(parametro );

}

}

C:\> java TestManager
integrador

PARTE 2
Agregue un método a manager que cargue todos los parámetros en un HashMap.

Manager.java
import java.io.*;
public class Manager
{

// Método para leer todas las claves del archivo parametros.ini
public static HashMap leerParametros()...

}

TestManagerHashMap.java
public class TestManagerHashMap { public static void main (String[] args) {

HashMap parametros = Manager.leerParametro();
// Mostrar aqui todos los parametros

}

}