Universidad Abierta y a Distancia de

Mxico.

Programacin orientada a objetos III

Actividad 2. Programa con streams

Profesora: Oralia Gomez Almaraz

Domingo 11 de Mayo del 2014

Actividad 2. Programa con streams

Esta actividad tiene la finalidad de crear un programa en el cual se creen
diferentes streams para realizar un programa con comunicacin en red.
Propsito: Distinguir el funcionamiento y la estructura de los streams para
realizar programas en red.
Instrucciones:
1. Identifica la estructura algortmica (pasos) y sintctica (cdigo) para la
creacin de streams de los bloques de cdigo presentados en el material
proporcionado para esta unidad.
2. Crea un proyecto en NetBeans donde coloques las clases correspondientes al
programa y crees al menos dos diferentes streams. El programa puede basarse en
cualquier problemtica que se presente en tu entorno.
3. Redacta en un archivo de texto una breve descripcin de las caractersticas y
funciones de tu programa.
4. Guarda el archivo de texto y el programa en una carpeta comprimida con el
nombre DPO3_U3_A2_XXYZ. Sustituye las XX por las dos primeras letras del
primer nombre, la Y por la inicial del apellido paterno y la Z por la inicial del
apellido materno.
5. Enva el archivo al facilitador(a) para recibir retroalimentacin.
6. No olvides consultar los criterios de evaluacin de la actividad.

Stream
Para poder leer o escribir depsitos de datos de un computador de origen a
otro de destino lo hacemos por medio de los llamado Streams que son secuencias
ordenadas de datos que poseen un origen o un destino.

En la jerarqua simple del manejo de stream de que nos proporcion la

librera IO contamos con stream para la manipulacin de bytes y stream
utilizados para manipular caracteres, como se pudo apreciar en el documento de
la plataforma esto nos proporciona lo siguiente:

- Flujo de bytes: Nos proporciona un medio adecuado para el manejo de entradas y

salidas de bytes y su uso lgicamente est orientado a la lectura y
escritura de datos binarios.
- Flujo de caracteres: Proporciona un medio adecuado para el manejo de entradas
y salidas de caracteres.
Por consiguiente podemos decir que si vamos a trabajar con archivos que
podemos entender o que son legibles por las personas como los archivos de texto,
entonces trabajaremos con Stream de caracteres, en cambio si vamos a trabajar
con archivos que no podamos entender ya que son compuestos por bytes al ser
ledos como los videos o imgenes entonces se utilizara los stream de bytes.
En el caso de los Stream de caracteres aproveche el ejemplo que haba
mandado en el primer foro de la primera unidad de la materia debido al poco
tiempo con el que cuento, pero a grandes rasgos dentro las clases principales
para leer y escribir de estos stream de caracteres hago uso de de BufferedReader
y BufferedWrite, es decir, este stream de caracteres sirve para leer o escribir
datos de una fuente de una computadora por ejemplo a un destino en otra
computadora determinada, en este caso la escritura y lectura se da en la misma
computadora.
Stream de Caracteres
Cdigo
package stream;
import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.IOException;
import java.nio.charset.Charset;
import java.nio.charset.StandardCharsets;
import java.nio.file.Files;
import java.nio.file.Path;
import java.nio.file.Paths;
public class StreamCaracteres {
public static void main(String[] args) throws IOException {
Path fuenteDatos =
Paths.get("/home/garras021/NetBeansProjects/StreamCaracteres/unadm/miTexto.txt");
Files.createDirectories(fuenteDatos.getParent());

Charset utf8 = StandardCharsets.UTF_8;

try(BufferedWriter escribir = Files.newBufferedWriter(fuenteDatos,utf8)){
escribir.write("Mi escritores favoritos son:\n");
escribir.write("-Stephen King\n");
escribir.write("-H. P. Lovecraft\n");
escribir.write("-Robin Cook\n");
}catch(IOException e){
System.out.println(e.toString());
}
try(BufferedReader leer = Files.newBufferedReader(fuenteDatos,utf8)){
String line = null;
while((line = leer.readLine())!= null){
System.out.println(line);
}
}catch(IOException e){
System.out.println(e.toString());
}
}
}

Pantalla

Explicacin.
Cabe mencionar que aprovecho la explicacin que ya haba puesto en el
primer foro para ahorrar tiempo.
En la primera parte de este cdigo creo una variable del tipo Path llamada
fuenteDatos y con el mtodo get de la clase Paths que se encuentra dentro del
paquete java.nio creo una ruta a donde este o se desee crear una fuente de datos
como un archivo de texto.
Posteriormente con el mtodo createDirectories de la clase Files que
tambien se encuentra en el paquete java.io le pasamos como argumento la ruta al
directorio que deseamos crear en este caso la optnemos con el metodo getParent()
en nuestra variable de ruta que se creo anteriormente llamada fuenteDatos.

Dentro de un bloque try/catch hacemos la creacin y escritura del archivo

ya que se pueden presentar algunos errores como por ejemplo en los permisos de
escritura.y necesitamos atrapar los mismos, en el mismo try entre parntesis le
podemos pasar la definicin de nuestro archivo con el mtodo newBufferedWriter
de las clase Files que toma como argumentos una ruta al archivo que queremos
crear y tambin la codificacin de nuestro archivo as que le pasamos una
codificacin utf8 y la misma la guardamos en una variable del tipo
BufferedWriter a la cual le llamamos escribir, ya dentro del cuerpo del try con
el mtodo write de nuestra variable escribir le pasamos como argumento el
texto que queremos escribir en el archivo de texto, y ya en el catch atrapamos
los errores que puedan surgir ya sea de forma general o especfica cada uno de
ellos, cabe mencionar que al pasarle la definicin de nuestro archivo al inicio
del try ya no es necesario cerrar la comunicacin con nuestro archivo cuando se
escribe sobre el mismo ya que algunas clases como BufferedWriter al pasarlas al
inicio entre parntesis en el try estas cerrarn automticamente la conexin ya
que internamente implementan
la
interface
Closeable que cierra
automaticamente la conexion por lo tanto ya no es necesario especificarlo.
En la segunda parte del cdigo tenemos la parte de la lectura, por lo que
al igual que en la parte de escritura ocupamos un bloque try/catch, por lo tanto
en la parte del try entre parntesis creamos un variable del tipo
BufferedReader a la que le llamamos leer y dentro de esta con el mtodo
newBufferedReader de la clase Files le pasamos como argumento la ruta a la
fuente de datos que queremos leer as como la codificacin del mismo, ya dentro
del bloque try leemos el archivo con al ayuda del mtodo readLine de nuestra
variable leer que leer las lneas de nuestro archivo de texto hasta
completarlo por lo que lo guardaremos en una variable llamada line misma que
nos servir para comprobar si ya no hay datos en el archivo con la ayuda de un
bucle while, slo resta imprimir nuestros resultados en pantalla.

Stream de Bytes
Cdigo
package stream;
import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.nio.file.Files;
import java.nio.file.Path;
import java.nio.file.Paths;

public class StreamBytes {

public static void main(String[] args){
Path fuenteDatos = Paths.get("/home/garras021/NetBeansProjects/StreamCaracteres/unadm/feliz.gif");
try(InputStream leer = Files.newInputStream(fuenteDatos)){
boolean finalFuenteDatos = false;
while(!finalFuenteDatos){
int contenidoFuente = leer.read();
System.out.print(contenidoFuente+", ");
if(contenidoFuente == -1){
finalFuenteDatos=true;
}
}
}catch(IOException e){
System.out.println(e.toString());
}
Path rutaGuardarImagen =
Paths.get("/home/garras021/NetBeansProjects/StreamCaracteres/unadm/feliz_nueva_imagen.gif");
int[] imagenCaritaFelizNueva = {71, 73, 70, 56, 57, 97, 15, 0, 15, 0, 195, 0, 1, 0, 0, 0, 255, 255, 0, 255, 255,
255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 33, 255,
11, 78, 69, 84, 83, 67, 65, 80, 69, 50, 46, 48, 3, 1, 0, 0, 0, 33, 249, 4, 1, 40, 0, 15, 0, 44, 0, 0, 0, 0, 15, 0, 15, 0, 3, 4,
50, 240, 73, 9, 106, 157, 248, 213, 192, 249, 197, 64, 39, 122, 83, 56, 142, 0, 117, 162, 90, 183, 121, 102, 240, 202,
241, 60, 175, 110, 140, 195, 187, 152, 154, 58, 25, 169, 5, 179, 184, 74, 187, 20, 40, 248, 201, 104, 44, 202, 9, 0, 33,
249, 4, 1, 40, 0, 15, 0, 44, 3, 0, 5, 0, 9, 0, 2, 0, 3, 4, 6, 48, 200, 57, 129, 173, 22, 0, 33, 249, 4, 1, 40, 0, 15, 0, 44, 3,
0, 5, 0, 9, 0, 2, 0, 3, 4, 9, 240, 1, 240, 234, 124, 161, 234, 26, 0, 0, 33, 249, 4, 1, 25, 0, 15, 0, 44, 4, 0, 5, 0, 8, 0, 2, 0,
3, 4, 7, 48, 0, 16, 234, 148, 212, 2, 0, 33, 249, 4, 1, 25, 0, 15, 0, 44, 3, 0, 5, 0, 9, 0, 2, 0, 3, 4, 7, 16, 128, 64, 101,
157, 151, 2, 0, 33, 249, 4, 1, 25, 0, 15, 0, 44, 3, 0, 5, 0, 9, 0, 2, 0, 3, 4, 7, 48, 4, 0, 158, 164, 183, 102, 0, 33, 249, 4,
1, 25, 0, 15, 0, 44, 3, 0, 5, 0, 9, 0, 2, 0, 3, 4, 7, 16, 128, 64, 101, 157, 151, 2, 0, 33, 249, 4, 1, 25, 0, 15, 0, 44, 2, 0, 5,
0, 11, 0, 8, 0, 3, 4, 20, 48, 200, 73, 37, 184, 243, 130, 202, 131, 254, 96, 248, 121, 226, 102, 133, 214, 169, 89, 0, 0,
33, 249, 4, 1, 10, 0, 15, 0, 44, 3, 0, 9, 0, 9, 0, 3, 0, 3, 4, 10, 80, 60, 33, 233, 124, 56, 235, 89, 229, 3, 0, 33, 249, 4, 1,
10, 0, 15, 0, 44, 3, 0, 9, 0, 9, 0, 3, 0, 3, 4, 7, 16, 200, 73, 235, 12, 22, 4, 0, 33, 249, 4, 1, 10, 0, 15, 0, 44, 3, 0, 9, 0, 9,
0, 3, 0, 3, 4, 10, 80, 60, 33, 233, 124, 56, 235, 89, 229, 3, 0, 33, 249, 4, 1, 10, 0, 15, 0, 44, 3, 0, 9, 0, 9, 0, 3, 0, 3, 4,
7, 16, 200, 73, 235, 12, 22, 4, 0, 33, 249, 4, 1, 10, 0, 15, 0, 44, 3, 0, 9, 0, 9, 0, 3, 0, 3, 4, 10, 80, 60, 33, 233, 124, 56,
235, 89, 229, 3, 0, 33, 249, 4, 1, 10, 0, 15, 0, 44, 3, 0, 9, 0, 9, 0, 3, 0, 3, 4, 7, 16, 200, 73, 235, 12, 22, 4, 0, 33, 249,
4, 1, 10, 0, 15, 0, 44, 3, 0, 9, 0, 9, 0, 3, 0, 3, 4, 10, 80, 60, 33, 233, 124, 56, 235, 89, 229, 3, 0, 33, 249, 4, 1, 10, 0,
15, 0, 44, 3, 0, 9, 0, 9, 0, 3, 0, 3, 4, 7, 16, 200, 73, 235, 12, 22, 4, 0, 33, 249, 4, 1, 10, 0, 15, 0, 44, 3, 0, 9, 0, 9, 0, 3,
0, 3, 4, 10, 80, 60, 33, 233, 124, 56, 235, 89, 229, 3, 0, 33, 249, 4, 1, 40, 0, 15, 0, 44, 2, 0, 5, 0, 11, 0, 8, 0, 3, 4, 19,
48, 4, 0, 228, 172, 150, 102, 108, 187, 255, 96, 40, 113, 163, 71, 157, 153, 8, 0, 0, 59};
try(OutputStream escribir = Files.newOutputStream(rutaGuardarImagen)){
for(int i=0; i<imagenCaritaFelizNueva.length; i++){
escribir.write(imagenCaritaFelizNueva[i]);
}
}catch(IOException e){
System.out.println(e.toString());
}
}
}

Pantalla

Explicacin
Al igual que en el ejemplo anterior de stream de caracteres para ahorrar tiempo
aproveche el ejemplo que haba enviado al foro en la primera unidad.
En este caso a diferencia del anterior pongo un archivo ya creado en este caso
una imagen ya que as nos va a permitir ver la impresin de los bytes mismo que
ocuparemos en la segunda parte para crear la misma imagen a partir de esos bytes. Por
lo tanto en la primera parte creamos una variable que llamamos fuenteDatos que es del
tipo Path que va a ser igual a la ruta en este caso de nuestra imagen con la ayuda del
mtodo get de la clase Paths.
Posteriormente dentro de un bloque try/catch hacemos la lectura del archivo ya
que se pueden presentar algunos errores al internarlo y ser necesario atraparlos, al
igual que en el ejemplo de caracteres en la parte de try en parntesis creamos una
variable del tipo InputStream a la cual llamamos leer a la cual se le pasara la ruta a
nuestra imagen como argumento en el mtodo newInputStream de la clase Files.
Posteriormente dentro del bloque try creamos una variable boleana llamada
finalFuenteDatos que ser igualada a false para saber si se ha llegado al final de la
lectura de los bytes de nuestra imagen, y con la ayuda de un bucle while los leemos

hasta que ya no haya nada que leer en el archivo o imagen en este caso, as es que
dentro del bucle creamos una variabe del tipo int que llamamos contenidoFuente la
cual contendr en cada momento cada uno de los bytes que representan a la imagen en
cuestin esto con la ayuda del mtodo read(), despus los imprimimos en pantalla y
verificamos mediante un if si ya no hay mssbytes en el archivo de imagen en caso de
ya no haber ms la variable finalFuenteDatos pasa a verdadera y se termina el bucle.
Y por ltimo en la parte del catch imprimos los posibles errores que pudieran
haber surgido. Como se puede ver en la parte de abaja de la imagen esta la impresin de
esos bytes que representa a la imagen.
En la segunda parte creamos una nueva ruta con el nombre que le queremos poner
a nuestra imagen en este caso para que no sobreescriba la anterior ya que ser la
misma imagen solo le cambiamos el nombre en la misma ruta. Y a partir de lo bytes que
nos imprimi en la primera parte al leer la imagen, creamos un arreglo de tipo int
para guardar estos nmeros.
Al igual que en los ejemplos anteriores dentro de un try/catch hacemos la
creacin de nuestra imagen
mediante los bytes que obtuvimos, as es que
primeramente para cerrar automticamente la conexin, despus del try entre
parntesis creamos una variable llamada escribir que va ha ser del tipo OutputStream
a la cual le pasaremos la ruta con el nombre del nuevo archivo que deseamos crear
como un argumento del mtodo newOutPutStream de la clase Files, solo queda recorrer
dentro de un ciclo for el arreglo de bytes y con la ayuda del mtodo write escribirlos
uno por uno en nuestro archivo para crear la representacin de la imagen.

10