TIPOS DE STREAMS EN JAVA

Publicado el 21 diciembre, 2012 por admin

Las aplicaciones java usan un sistema de streams para leer y escribir informacin. A ellos se accede desde el
paquete java.io, donde se encuentran varias clases de entrada y salida, que permiten manejar caracteres, bytes, objetos o
datos primitivos.
Loa streams en java son secuencias de informacin que soportan diferentes tipos de fuentes y destinos como, el teclado, la
consola, ficheros, pginas web. Por tanto, en esta entrada vamos a conocer de manera bsica las principales clases
I/O que actan para gestionar estas operaciones.
Podemos clasificar los streams segn el tipo de datos con los que trabajan en:

Streams de bytes
Todas las clases que permiten gestionar entradas y salidas de bytes (8 bits) heredan de las clases abstractasInputStream y
OutputStream. Las del primer tipo son utilizadas para leer, mientras las segundas para escribir. Su uso est orientado al
trabajo con formatos binarios, por ejemplo, archivos de audio y vdeo. Algunas subclases principales son:
InputStream ( lectura )
FileInputStream

 FilterInputStream
StringBufferInputStream
ObjectInputStream
BufferedInputStream
DataInputStream
OutputStream ( escritura )
FileOutputStream
FilterOutputStream
ObjectOutputStream
BufferedOutputStream
DataOutputStream

Character Streams

Permiten el flujo de caracteres ( 16 bits ), por tanto, a menudo se usan con archivos de texto. Las diferentes clases
disponibles en java para su manejo heredan de Reader y Writer. Las primeras, como su nombre indica sirven para leer
informacin y las ltimas para escribirla. Algunas de las subclases ms importantes son:
Reader ( lectura )
FileReader
FilterReader
BufferedReader
InputStreamReader
Writer ( escritura )
FileWriter
FilterWriter
BufferedWriter
StringWriter

El mtodo close ()

Un stream se cierra cuando ya no es necesaria su utilizacin. Esto se consigue mediante una llamada al mtodo close (). De
este modo, podemos evitar importantes perdidas de recursos.
Nota. A partir de Java 7 ya no es necesario usar el mtodo close(). El nuevo bloque try ( ) { }catch{ } permite cerrar el
stream de manera automtica.

Cambiar de byte a character

Tambin encontramos 2 clases en java.io para cambiar el tipo de stream:
InputStreamReader: lee bytes y los convierte a caracteres.
OutputStreamWriter: pasa de caracteres a bytes.

Ficheros de texto
1) Crea un fichero de texto con el nombre y contenido que tu quieras. Ahora crea una aplicacin que lea este fichero de texto carcter a carcter y
muestre su contenido por pantalla sin espacios. Por ejemplo, si un fichero tiene el siguiente texto Esto es una prueba, deber mostrar
Estoesunaprueba.
Captura las excepciones que veas necesario.
SeleccionarEsconder

Spoiler
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22

import java.io.FileReader;
import java.io.IOException;
public class Ejercicio1App {
public static void main(String[] args) {
final String nomFichero="D:\\pruebas.txt";
try(FileReader fr=new FileReader (nomFichero)){
int valor=fr.read();
while(valor!=-1){
//Si el caracter es un espacio no lo escribe
if(valor!=32){
System.out.print((char)valor);
}
valor=fr.read();
}
}catch(IOException e){
System.out.println("Problemas con el E/S "+e);
}
}

2) Crea una aplicacin donde pidamos la ruta de un fichero por teclado y un texto que queramos a escribir en el fichero. Debers mostrar por
pantalla el mismo texto pero variando entre maysculas y minsculas, es decir, si escribo Bienvenido deber devolver bIENVENIDO. Si se
escribe cualquier otro carcter, se quedara tal y como se escribi.
Debers crear un mtodo para escribir en el fichero el texto introducido y otro para mostrar el contenido en maysculas.
IMPORTANTE: cuando pidas por teclado una ruta con JOptionPane, no es necesario que insertes caracteres de escape.
SeleccionarEsconder

Spoiler
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22

import
import
import
import
public

java.io.FileWriter;
java.io.FileReader;
java.io.IOException;
javax.swing.JOptionPane;
class Ejercicio2App {

public static void main(String[] args) {

String ruta=JOptionPane.showInputDialog("Introduce la ruta del fichero");
String texto=JOptionPane.showInputDialog("Introduce el texto que quieras escribir en el
fichero");
escribirFichero(ruta, texto);
mostrarFicheroMay(ruta);
}
public static void escribirFichero(String nomFich, String texto){
try(FileWriter fw=new FileWriter(nomFich);){
//Escribimos el texto en el fichero
fw.write(texto);
}catch(IOException e){
System.out.println("Problemas en la escritura E/S "+e);

23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51

public static void mostrarFicheroMay(String nomFich){

try(FileReader fr=new FileReader (nomFich)){
int valor=fr.read();
while(valor!=-1){

}
}

//Solo cambiara el caracter si es una minuscula o una mayuscula

char caracter=(char)valor;
if(caracter>=97 && caracter<=122){
caracter-=32;
}else if(caracter>=65 && caracter<=90){
caracter+=32;
}
System.out.print(caracter);
valor=fr.read();

}catch(IOException e){
System.out.println("Problema con la E/S "+e);
}

3) Crea una aplicacin que pida la ruta de dos ficheros de texto y de una ruta de destino (solo la ruta, sin fichero al final). Debes copiar el
contenido de los dos ficheros en uno, este tendr el nombre de los dos ficheros separados por un guion bajo, este se guardara en la ruta donde le
hayamos indicado por teclado.
Para unir los ficheros en uno, crea un mtodo donde le pases como parmetro todas las rutas. En este mtodo, aparte de copiar debe comprobar
que si existe el fichero de destino, nos muestre un mensaje informndonos de si queremos sobrescribir el fichero. Te recomiendo usar la clase File
y JOptionPane.
Por ejemplo, si tengo un fichero A.txt con ABC como contenido, un fichero B.txt con DEF y una ruta de destino D:\, el resultado sera un
fichero llamado A_B.txt en la ruta D:\ con el contenidoABCDEF.
Puedes crear submtodos para realizar la copia de ficheros, piensa tambin como podrias optimizar esta copia, si los ficheros tuvieran mucho
contenido.
Recuerda que debes controlar las excepciones que puedan aparecer. En caso de error, mostrar una ventana de dialogo con informacin del error.
SeleccionarEsconder

Spoiler

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

import java.io.*;
import javax.swing.JOptionPane;
public class Ejercicio5App {
public static void main(String[] args) {
//Introducimos los datos
String rutaFichero1=JOptionPane.showInputDialog("Indica la ruta del primer fichero");
String rutaFichero2=JOptionPane.showInputDialog("Indica la ruta del segundo fichero");
String rutaDestino=JOptionPane.showInputDialog("Indica la ruta donde quieres guardarlo");
//Creamos dos objetos File para que nos sea mas sencillo manejarlos
File fichero1=new File(rutaFichero1);
File fichero2=new File(rutaFichero2);
//Troceamos el el nombre del primer fichero para que se quede sin extension
String primerFichero=fichero1.getName().substring(0, fichero1.getName().length()-4);

16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46

//Crear el nombre de salida del fichero

String nombreFicheroFinal=primerFichero+"_"+fichero2.getName();
rutaDestino+=nombreFicheroFinal;
File destino=new File(rutaDestino);
UneFicheros(fichero1, fichero2, destino);
}
public static void UneFicheros (File fich1, File fich2, File destino){
try (BufferedReader br=new BufferedReader(new FileReader(fich1));
BufferedReader br2=new BufferedReader(new FileReader(fich2))){
int eleccion=-1;
if(destino.exists()){
eleccion=JOptionPane.showConfirmDialog(null, "El fichero ya existe, Quieres sobrescribir el fichero
"+destino.getName()+"?",
"Sobrescribir",
JOptionPane.OK_CANCEL_OPTION, JOptionPane.INFORMATION_MESSAGE);
}
if(eleccion!=JOptionPane.CANCEL_OPTION){
/*
* Lo creamos aqu, ya que si lo hacemos arriba
* siempre existira porque se crea al abrir el Stream
*/
BufferedWriter bw=new BufferedWriter(new FileWriter(destino));
//Copiamos el contenido al fichero destino
copiar(bw, br);

47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73

copiar(bw, br2);
}
}catch(IOException e){
JOptionPane.showMessageDialog(null, e.getMessage(), "Error", JOptionPane.ERROR_MESSAGE);
}
}
private static void copiar(BufferedWriter bw, BufferedReader br) throws IOException{
String linea=br.readLine();
while(linea!=null){
bw.write(linea);
linea=br.readLine();
}
}
}

Ficheros binarios

4) Crea una aplicacin que copie un fichero binario a otra localizacin. En lugar de leer y escribir byte a byte, crea un array de bytes con el tamao
del fichero de origen (utiliza el mtodo available()), copia el contenido del fichero a este array y escribe a partir de este array.
Recuerda que debes controlar las excepciones que puedan aparecer. En caso de error, mostrar una ventana de dialogo con informacin del error.
SeleccionarEsconder

Spoiler
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25

import java.io.*;
import javax.swing.JOptionPane;
public class Ejercicio6App {
public static void main(String[] args) {
//Pedimos las rutas
String origen=JOptionPane.showInputDialog("Escribe la ruta del origen");
String destino=JOptionPane.showInputDialog("Escribe la ruta del destino");
copiaFicheros(origen, destino);
}
public static void copiaFicheros (String origen, String destino){
try(FileInputStream fis=new FileInputStream(origen);
FileOutputStream fos=new FileOutputStream(destino)){
//Creamos un array de bytes con el tamao del fichero de origen
byte byteA[]=new byte[fis.available()];
//Copia todos los bytes del fichero al array
fis.read(byteA);
//Escribe todos los bytes en el fichero de destino
fos.write(byteA);
}catch(IOException e){

26
27
28
29
30
31
32
33
34

JOptionPane.showMessageDialog(null, e.getMessage(), "Error",

JOptionPane.ERROR_MESSAGE);
}
}
}

5) Crea una aplicacin que pida por teclado un nmero de nmeros aleatorios enteros positivos y la ruta de un fichero. Este fichero contendr la
cantidad de nmeros aleatorios enteros positivos que se ha pedido por teclado.
Escribe los nmeros usando un DataOutputStream y muestra por pantalla estos nmeros leyndolos con un DataInputStream.
El rango de los nmeros aleatorios estar entre 0 y 100, incluyendo el 100.
Cada vez que ejecutemos la aplicacin aadiremos nmeros al fichero sin borrar los anteriores, es decir, si cuando creo el fichero aado 10
nmeros y despus aado otros 10 al mismo, en el fichero habr 20 nmeros que sern mostrados por pantalla.
SeleccionarEsconder

Spoiler
1
2
3
4
5
6
7
8
9

import java.io.*;
import javax.swing.JOptionPane;
public class Ejercicio7App {
public static void main(String[] args) {
String ruta=JOptionPane.showInputDialog("Escribe la ruta del fichero");
String numeros=JOptionPane.showInputDialog("Escribe el numero de numeros aleatorios");
int numNumerosAleatorios=Integer.parseInt(numeros);

10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40

//Abrimos el fichero desde el final

try(DataOutputStream dos=new DataOutputStream (new FileOutputStream (ruta, true));
DataInputStream dis=new DataInputStream(new FileInputStream (ruta))){
escribeFichero(dos, numNumerosAleatorios);
leeFichero(dis);
}catch(EOFException e){
System.out.println("Fin del fichero");
}catch(IOException e){
JOptionPane.showMessageDialog(null, "Error: "+e.getMessage() , "Error",
JOptionPane.ERROR_MESSAGE);
}
}
public static void escribeFichero (DataOutputStream dos, int numNumerosAleatorios) throws
IOException{
//Escribimos los numeros
for (int i=0;i<numNumerosAleatorios;i++){
int numero=generaNumerosAleatorios();
dos.writeInt(numero);
}
//Guardamos los cambios
dos.flush();
}
public static void leeFichero (DataInputStream dis) throws IOException{
//Leemos los numeros hasta el final del fichero
while(true){
System.out.println(dis.readInt());

41
42
43
44
45
46
47
48
49
50
51
52
53

}
}
public static int generaNumerosAleatorios(){
int numero=(int)Math.floor(Math.random()*101);
return numero;
}
}

6) Crea una aplicacin que almacene los datos bsicos de un vehculo como la matricula(String), marca (String), tamao de deposito (double) y
modelo (String) en ese orden y de uno en uno usando la clase DataInputStream.
Los datos anteriores datos se pedirn por teclado y se irn aadiendo al fichero (no se sobrescriben los datos) cada vez que ejecutemos la
aplicacin.
El fichero siempre sera el mismo, en todos los casos.
Muestra todos los datos de cada coche en un cuadro de dialogo, es decir, si tenemos 3 vehculos mostrara 3 cuadros de dialogo con sus
respectivos datos. Un ejemplo de salida de informacin puede ser este:

SeleccionarEsconder

Spoiler
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30

import javax.swing.JOptionPane;
import java.io.*;
public class Ejercicio9App {
public static void main(String[] args) {
final String RUTA="D:\\vehiculos.ddr";
String
String
String
double
String

matricula=JOptionPane.showInputDialog("Introduce la matricula");
marca=JOptionPane.showInputDialog("Introduce la marca");
texto=JOptionPane.showInputDialog("Introduce el tamao del deposito");
tamaoDeposito=Double.parseDouble(texto);
modelo=JOptionPane.showInputDialog("Introduce el modelo");

try(DataOutputStream dos=new DataOutputStream(new FileOutputStream(RUTA,true));

DataInputStream dis=new DataInputStream(new FileInputStream(RUTA))){
introduceDatos(dos, matricula, marca, tamaoDeposito, modelo);
muestraDatos(dis);
}catch(EOFException e){
}catch(IOException e){
JOptionPane.showMessageDialog(null, "Error: "+e.getMessage() , "Error",
JOptionPane.ERROR_MESSAGE);
}
}
public static void introduceDatos(DataOutputStream dos,
String matricula,
String marca,
double tamaoDeposito,

31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53

String modelo) throws IOException{

dos.writeUTF(matricula);
dos.writeUTF(marca);
dos.writeDouble(tamaoDeposito);
dos.writeUTF(modelo);
}
public static void muestraDatos(DataInputStream dis) throws IOException {
//Cuando se acabe el fichero saltara la excepcion
while(true){
JOptionPane.showMessageDialog(null, "El vehiculo tiene una matricula "+dis.readUTF()+
", su marca es "+dis.readUTF()+", el tamao del deposito es de "+dis.readDouble()+" " +
"litros y su modelo es "+dis.readUTF());
}
}
}

Serializacion
7) Vamos a realizar el mismo ejercicio pero con serializacin, para ello, crea una simple clase Vehiculo con los atributos matricula, marca, tamao
del deposito y modelo, con sus respectivos mtodos get y el constructor se invocara con todos los atributos.
El atributo tamaoDeposito no se incluir en el fichero (aun as debemos pedirlo), debemos indicarlo en la clase (recuerda el uso de transient).

Recuerda que al usar la clase ObjectOutputStream, si vamos a aadir varios objetos en distintas ejecuciones, debemos crear nuestra propia
versin de ObjectOutputStream. (Serializacin de objetos en Java)
SeleccionarEsconder

Spoiler
Clase Vehiculo
import java.io.Serializable;
1

2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27

/**
* Clase Vehiculo
*
* Contiene informacion de un vehiculo
*
* @author DiscoDuroderoer
* @version 1.0
*/
public class Vehiculo implements Serializable{
private static final long serialVersionUID = 7695874286508524707L;
//Atributos
/**
* Matricula del vehiculo
*/
private String matricula;
/**
* Marca del vehiculo
*/
private String marca;
/**
* Tamao del deposito del vehiculo
* No se transfiere en la serializacion
*/
transient private double tamaoDeposito;

28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58

/**
* Modelo del vehiculo
*/
private String modelo;
//Mtodos
/**
* Devuelve la matricula
* @return matricula del vehiculo
*/
public String getMatricula() {
return matricula;
}
/**
* Devuelve la marca
* @return marca del vehiculo
*/
public String getMarca() {
return marca;
}
/**
* Devuelve el tamao del deposito
* @return tamalos del deposito del vehiculo
*/
public double getTamaoDeposito() {
return tamaoDeposito;
}
/**
* Devuelve el modelo
* @return modelo del vehiculo
*/
public String getModelo() {

59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87

return modelo;

//Constructor
/**
* Constructor con 4 parametros
* @param matricula
* @param marca
* @param tamaoDeposito
* @param modelo
*/
public Vehiculo (String matricula, String marca, double tamaoDeposito, String modelo){
this.matricula=matricula;
this.tamaoDeposito=tamaoDeposito;
this.marca=marca;
this.modelo=modelo;
}
}

Clase MiObjectOutputStream

import java.io.*;

2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21

//Esta clase hereda sus propiedades de ObjectOutputStream

public class MiObjectOutputStream extends ObjectOutputStream

//Sobrescribimos el mtodo que crea la cabecera

protected void writeStreamHeader() throws IOException
{
// No hacer nada.
}
//Constructores

public MiObjectOutputStream () throws IOException{

super();
}
public MiObjectOutputStream(OutputStream out) throws IOException
{
super(out);
}

Clase ejecutable

1
2
3
4
5
6
7
8
9
10

import javax.swing.JOptionPane;
import java.io.*;
public class Ejercicio10App {
public static void main(String[] args) {
File fichero=new File("D:\\vehiculos.ddr");
String matricula=JOptionPane.showInputDialog("Introduce la matricula");
String marca=JOptionPane.showInputDialog("Introduce la marca");

11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41

String texto=JOptionPane.showInputDialog("Introduce el tamao del deposito");

double tamaoDeposito=Double.parseDouble(texto);
String modelo=JOptionPane.showInputDialog("Introduce el modelo");
/*
* No creamos los objetos para manejar objetos,
* ya que sino siempre existiria el fichero
*/
try{
Vehiculo vehiculo=new Vehiculo(matricula, marca, tamaoDeposito ,modelo);
//Si el fichero existe, usamos nuestra clase de Object y sino usamos la original
if(fichero.exists()){
MiObjectOutputStream moos=new MiObjectOutputStream(new FileOutputStream(fichero,
true));

moos.writeObject(vehiculo);
moos.close();
}else{
ObjectOutputStream oos=new ObjectOutputStream(new FileOutputStream(fichero));
oos.writeObject(vehiculo);
oos.close();
}

el fichero

//Creamos despues este objeto para asegurarnos que no de un error, en caso de no existir
ObjectInputStream ois=new ObjectInputStream(new FileInputStream(fichero));
muestraDatos(ois);

}catch(ClassNotFoundException e){
}catch(EOFException e){
System.out.println("fin");
}catch(IOException e){
JOptionPane.showMessageDialog(null, "Error: "+e.getMessage() , "Error",
JOptionPane.ERROR_MESSAGE);

42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60

public static void muestraDatos(ObjectInputStream ois) throws IOException, ClassNotFoundException {

//Cuando se acabe el fichero saltara la excepcion EOFException
while(true){
Vehiculo ref=(Vehiculo)ois.readObject();
JOptionPane.showMessageDialog(null, "El vehiculo tiene una matricula "+ref.getMatricula()

+
}

", su marca es "+ref.getMarca()+" y su modelo es "+ref.getModelo());

}
}

Espero que os sea de ayuda. Si tenis dudas, preguntad. Estamos para ayudarte.