Universidad Abierta y a Distancia de

México.

Programación orientada a objetos III

Actividad 2. Programa con streams

Profesora: Oralia Gomez Almaraz

Domingo 11 de Mayo del 2014

1

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 comunicación en red.

Propósito: Distinguir el funcionamiento y la estructura de los streams para

realizar programas en red.

Instrucciones:

1. Identifica la estructura algorítmica (pasos) y sintáctica (código) para la

creación de streams de los bloques de código 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 problemática que se presente en tu entorno.

3. Redacta en un archivo de texto una breve descripción de las características 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. Envía el archivo al facilitador(a) para recibir retroalimentación.

6. No olvides consultar los criterios de evaluación de la actividad.

2

Stream

Para poder leer o escribir depósitos 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 jerarquía simple del manejo de stream de que nos proporcionó la

librería IO contamos con stream para la manipulación de bytes y stream

utilizados para manipular caracteres, como se pudo apreciar en el documento de

la plataforma esto nos proporciona lo siguiente:

3

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

salidas de bytes y su uso lógicamente 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

leídos como los videos o imágenes entonces se utilizara los stream de bytes.

En el caso de los Stream de caracteres aproveche el ejemplo que había

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

Código

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());

4

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

5

Explicación.

Cabe mencionar que aprovecho la explicación que ya había puesto en el

primer foro para ahorrar tiempo.

En la primera parte de este código creo una variable del tipo Path llamada

fuenteDatos y con el método 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 método 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.

6

Dentro de un bloque try/catch hacemos la creación 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 paréntesis le

podemos pasar la definición de nuestro archivo con el método newBufferedWriter

de las clase Files que toma como argumentos una ruta al archivo que queremos

crear y también la codificación de nuestro archivo así que le pasamos una

codificación 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 método 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 específica cada uno de

ellos, cabe mencionar que al pasarle la definición de nuestro archivo al inicio

del try ya no es necesario cerrar la comunicación con nuestro archivo cuando se

escribe sobre el mismo ya que algunas clases como BufferedWriter al pasarlas al

inicio entre paréntesis en el try estas cerrarán automáticamente la conexión 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 código 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 paréntesis creamos un variable del tipo

BufferedReader a la que le llamamos leer y dentro de esta con el método

newBufferedReader de la clase Files le pasamos como argumento la ruta a la

fuente de datos que queremos leer así como la codificación del mismo, ya dentro

del bloque try leemos el archivo con al ayuda del método readLine de nuestra

variable “leer” que leerá las líneas 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, sólo resta imprimir nuestros resultados en pantalla.

Stream de Bytes

Código

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;

7

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

8

Explicación

Al igual que en el ejemplo anterior de stream de caracteres para ahorrar tiempo

aproveche el ejemplo que había 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 impresión 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

método 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 paréntesis 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 método 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

9

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

cuestión esto con la ayuda del método read(), después los imprimimos en pantalla y

verificamos mediante un if si ya no hay mássbytes en el archivo de imagen en caso de

ya no haber más 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 impresión 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 números.

Al igual que en los ejemplos anteriores dentro de un try/catch hacemos la

creación de nuestra imagen mediante los bytes que obtuvimos, así es que

primeramente para cerrar automáticamente la conexión, después del try entre

paréntesis 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 método newOutPutStream de la clase Files, solo queda recorrer

dentro de un ciclo for el arreglo de bytes y con la ayuda del método write escribirlos

uno por uno en nuestro archivo para crear la representación de la imagen.

10