Bienvenidos a un nuevo post dedicado a
los Streams, en esta entrada vamos a ver como leer un archivo como byte. Este
tipo de Streams no solo maneja
archivos de texto, sino, cualquier otro tipo de archivos cuya utilidad es
enviar y recibir información desde un programa Java. Cualquier tipo de archivo
es susceptible de convertirse en una sucesión de bytes, archivos de texto,
documentos pdf, videos, imágenes, etc., Para trabajar con los Streams como
bytes se utiliza la clase FileInputStream
que a su vez dispone del método read()
y close() y la clase FileOutStreams que dispone del método write() y close().
Para ver todo esto mejor con un ejemplo
que vamos a dividir en dos partes, la primera parte va a consistir en leer un
archivo de imagen, una vez que la hemos leído escribir en la misma carpeta o en
otra diferente un archivo nuevo que puede ser una copia de la imagen que hemos
leído.
La imagen la tengo creada dentro de una carpeta stream_byte que está ubicada en el escritorio, la imagen es la siguiente:
Para ver esto nos creamos un nuevo
archivo llamado Lectura_Escritura.java:
package secuencias;
import java.io.*;
public class Lectura_Escritura
{
public static void main(String[] args) {
// TODO
Auto-generated method stub
}
}
Dentro del método main lo primero que vamos a hacer es leer la imagen por lo que nos
creamos una instancia de la clase FileInputStream
esta clase lanza un error de tipo IOException
por lo que hay que meterla dentro de un bucle try… catch
try {
FileInputStream
archivo_lectura = new
FileInputStream("C:/Users/usuario/Desktop/stream_byte/imagen.jpg");
}catch(IOException e) {
}
A continuación creamos una variable de
tipo boolean a la que vamos a llamar final_archivo que la vamos a
inicializar como false:
try {
FileInputStream
archivo_lectura = new
FileInputStream("C:/Users/usuario/Desktop/stream_byte/imagen.jpg");
boolean final_archivo = false;
Posteriormente creamos un bucle while:
while(!final_archivo) {
int byte_entrada = archivo_lectura.read();
}
Le indicamos que mientras la variable final_archivo sea verdadera nos tiene
que guardar en una variable de tipo entero byte a byte la información de la imagen que estamos
leyendo. Recordad que al final de la información del archivo se muestra un -1
para indicar que ya no hay más información que leer cuando se imprima este -1
se lo podemos indicar después de la variable byte_entrada con un condicional if que no imprima el -1:
if(byte_entrada==-1)
final_archivo=true;
Pasamos la variable booleana a true para indicar que ya estamos al
final de la información.
Finalmente le indicamos mediante un System.out que nos muestre byte a byte
lo que va leyendo.
System.out.println(byte_entrada);
Nos queda por cerrar el flujo de datos
que lo hacemos mediante el método close()
antes de la cláusula catch:
archivo_lectura.close();
}catch(IOException
e) {
Probamos:
Nos ha leído la imagen byte por byte y
nos lo muestra en consola.
Para el siguiente ejemplo necesitamos
saber cuántos bytes forma el archivo en este caso la imagen, tenemos que saber cuántas
veces se recorre el while para eso
nos creamos un contador. Antes de la cláusula try creamos una variable de tipo entero a la que llamamos contador y la inicializamos en 0:
int contador =
0;
A cada vuelta del bucle while la incrementamos en 1, la
incrementamos después del System.out:
contador++;
Después de la cláusula catch le indicamos que nos imprima la
variable contador para saber los
bytes que tiene el archivo:
System.out.println(contador+" bytes.");
Probamos:
Una vez que tenemos el total de los
bytes tenemos de alguna forma que cogerlos y crear un nuevo archivo con ellos,
si todo va bien debería crearnos una imagen igual a la que estamos leyendo.
Para ello necesitamos almacenar todos los bytes que forman la imagen, por
ejemplo, en un array, antes de la cláusula try
nos creamos un array de tipo entero y le vamos a indicar el total de bytes:
int datos_entrada[]=new int[37592];
Y ahora dentro del while:
while(!final_archivo) {
int byte_entrada = archivo_lectura.read();
if(byte_entrada!=-1)
datos_entrada[contador]=byte_entrada;
else
final_archivo=true;
System.out.println(datos_entrada[contador]);
contador++;
}
Creamos un condicional if indicándole que si byte_entrada es diferente a -1 tienes
que guardar en el array la posición de turno. Si la condición del condicional if es falso, es decir, ha llegado al
final del archivo se ejecuta lo que hay dentro del else convirtiendo la variable final_archivo
en true. Sustituimos lo que hay dentro del System.out
por lo que va a ver en cada posición del array.
Os espero en el próximo post. Hasta
pronto!
12.4 USANDO BUFFERS << >>
12.6 ESCRIBIENDO ARCHIVOS CON BYTE
No hay comentarios:
Publicar un comentario