Post on 23-Dec-2015
description
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