flujo de bytes uso de Java

InputStream es la clase padre de Java para todos los flujos de entrada de bytes, el OutputStream es la clase padre para toda clase de flujo de salida de bytes de Java, que es una clase abstracta, por lo tanto subclase hereda quieren redefinir la clase padre abstracta.

A continuación se describen los dos primeros métodos comunes para proporcionar la clase padre, y cómo utilizarlos subclases de entrada y salida de flujo de bytes, incluyendo el tipo ByteArrayInputStream, tipo ByteArrayOutputStream, la clase y la FileOutputStream clase FileInputStream.

flujo de entrada de bytes

clase InputStream y sus subclases la representación de flujo de entrada de objeto de bytes, comúnmente clase InputStream subclase es como sigue.

	ByteArrayInputStream 类：将字节数组转换为字节输入流，从中读取字节。
	
	FileInputStream 类：从文件中读取数据。
	
	PipedInputStream 类：连接到一个 			PipedOutputStream（管道输出流）。
	
	SequenceInputStream 类：将多个字节输入流串联成一个字节输入流。
	
	ObjectInputStream 类：将对象反序列化。

clase InputStream usando uno o un método por lotes puede leer bytes de la corriente.

método común de clase InputStream

nombre del método y tipo de valor de retorno	explicación
int read ()	Una corriente de leer de la entrada de bytes de 8 bits, y la convierte en un número entero de 0 a 255, y finalmente devuelve el entero. Volver -1 indica que se ha llegado al final de la corriente de entrada. Con el fin de mejorar la eficiencia de las operaciones de E / S, se recomienda utilizar el método read () de las otras dos formas
int leer (byte [] b)	Varios bytes leídos de la corriente de entrada, y guardarlos en el parámetro b especifica una matriz de bytes. Devuelve el método del número de bytes leídos. Volver -1 indica el final de la secuencia de entrada ha alcanzado el
int leer (byte [] b, int off, int len)	Varios bytes leídos de la corriente de entrada, y guardarlos en el parámetro b especifica una matriz de bytes. En donde, fuera empiece a guardar los datos de índice a partir designados en la matriz de bytes; Len especificar el número de bytes leídos. Devuelve el método del número de bytes realmente leer. Volver -1 indica el final de la secuencia de entrada ha alcanzado el
void close ()	Cierra el flujo de entrada. Después de la operación de lectura se ha completado, usted debe apagar el flujo de entrada, el sistema liberará relevantes a esta entrada de flujo de recursos. Nota, la clase InputStream mismo método close () no hace nada, pero muchos de su subclase sobreescribe el método close ()
int disponible ()	Devuelve el número de bytes que se puede leer desde el flujo de entrada
largo omitir (larga n)	Saltar parámetro n especifica el número de bytes desde el flujo de entrada. El método devuelve el número de bytes para saltar
marca de vacío (int readLimit)	Bandera de inicio se establece en la posición actual de la corriente de entrada, readLimit parámetro especifica el número máximo de bytes se establece etiquetado
boolean markSupported ()	Determina si la bandera actual está configurado para permitir el flujo de entrada, devuelve verdadero, falso en caso contrario
void reset ()	El puntero del flujo de entrada del inicio de la bandera de retorno se establece en

prestar atención: Antes de utilizar el método de marca () y el método reset (), es necesario determinar si el sistema de archivos es compatible con ambos métodos.

flujo de salida Byte

clase OutputStream objeto y sus subclases representa un flujo de salida de bytes. subclase común de OutputStream sigue.

	ByteArrayOutputStream 类：向内存缓冲区的字节数组中写数据。
	
	FileOutputStream 类：向文件中写数据。
	
	PipedOutputStream 类：连接到一个 		PipedlntputStream（管道输入流）。
	
	ObjectOutputStream 类：将对象序列化。

Uso de clase OutputStream o método se pueden escribir en un número de bytes de la corriente.

método común de OutputStream

nombre del método y tipo de valor de retorno	explicación
escritura vacío (int b)	Escribir un byte en el flujo de salida. Donde los argumentos son de tipo int, pero se permite el uso de la expresión, sin el molde de tipo byte. método con el fin de mejorar la eficiencia de las operaciones de E / S, se recomienda hacer uso de escritura () de las otras dos formas
vacío de escritura (byte [] b)	El parámetro B especifica todos los bytes de la matriz de bytes escritos en el flujo de salida
vacío de escritura (byte [] b, int off, int len)	El parámetro b especifica un número de bytes en la matriz de bytes escritos en el flujo de salida. En el que, fuera de la matriz de bytes especificado índice de partida, denota len el número de elementos
void close ()	Cerrar el flujo de salida. Después de la operación de escritura se ha completado, se debe cerrar el flujo de salida. El sistema liberará los recursos asociados con el flujo de salida. Nota, clase OutputStream mismo método close () no hace nada, pero muchos de su subclase sobreescribe el método close ()
ras vacío ()	Para mejorar la eficiencia, cuando los datos se escriben en el flujo de salida, los datos normalmente se guardan en el búfer de memoria, la memoria intermedia sólo cuando los datos llegan a un cierto nivel, los datos de la memoria intermedia se escribirá en el flujo de salida . Uso flush () método puede ser obligado a amortiguar los datos escritos en el flujo de salida, y para vaciar el búfer

flujo de entrada matriz de bytes

ByteArrayInputStream datos de la clase pueden ser leídos desde la matriz de bytes en la memoria, los siguientes dos sobrecargas constructor de la clase .

	ByteArrayInputStream(byte[] buf)：创建一个字节数组输入流，字节数组类型的数据源由参数 buf 指定。
	
	ByteArrayInputStream(byte[] buf,int offse,int length)：创建一个字节数组输入流，其中，参数 buf 指定字节数组类型的数据源，offset 指定在数组中开始读取数据的起始下标位置，length 指定读取的元素个数。

implementos clase de uso ByteArrayInputStream una matriz de bytes leídos de los datos, y luego convertidos a un int y de salida. Código es el siguiente:

public class test {
    public static void main(String[] args) {
        byte[] b = new byte[] { 1, -1, 25, -22, -5, 23 }; // 创建数组
        ByteArrayInputStream bais = new ByteArrayInputStream(b, 0, 6); // 创建字节数组输入流
        int i = bais.read(); // 从输入流中读取下一个字节，并转换成int型数据
        while (i != -1) { // 如果不返回-1，则表示没有到输入流的末尾
            System.out.println("原值=" + (byte) i + "\t\t\t转换为int类型=" + i);
            i = bais.read(); // 读取下一个
        }
    }
}

En la realización, el flujo de entrada de bytes 4 bytes Bais para iniciar la lectura de un primer elemento de la matriz de bytes elemento b, y la convierte a un int 4 bytes de datos, y finalmente los rendimientos.

rápido: Además del ejemplo anterior para imprimir el valor de i, pero también imprimir el valor (byte) i, ya que el valor de i es la conversión de datos de tipo byte terminado, por lo uso (byte) i puedo obtener el byte de datos original.

Resultados de operación del programa son los siguientes:

原值=1   转换为int类型=1
原值=-1   转换为int类型=255
原值=25   转换为int类型=25
原值=-22   转换为int类型=234
原值=-5   转换为int类型=251
原值=23   转换为int类型=23

A partir de los resultados, después de la conversión a un byte de datos de tipo int 1 y los datos 255 y 234 se convierte en -22, la interpretación de este resultado es el siguiente:

	字节类型的 1，二进制形式为 00000001，转换为 int 类型后的二进制形式为 00000000 00000000 0000000000000001，对应的十进制数为 1。
	
	字节类型的 -1，二进制形式为 11111111，转换为 int 类型后的二进制形式为 00000000 00000000 0000000011111111，对应的十进制数为 255。

Visto desde la conversión en el número de bytes de tipo de tipo int, si es positivo, entonces el valor sin cambios; si es negativo, ya que la conversión, directamente en frente de forma binaria complemento de 0 24, cambiando así el original representado grupos de dos negativas forma de complemento, se cambia el valor, es decir, se convierte en positivo.

rápido: Forma binaria negativa en presencia de la forma de complemento , tal como -1, que en forma binaria se vienen: primero adquirido primitiva 000000011, seguido por la operación anti-código, en 0,0 1 se convierte en 1, de modo que para dar 11111110, operación finalmente complemento, que está en el extremo de los bits invertidos más 1, de modo que se convierte en 11111111.

ByteArrayOutputStream

ByteArrayOutputStream clase puede escribir en la matriz de bytes en la memoria, hay dos sobrecargas constructor de la clase que sigue.

	ByteArrayOutputStream()：创建一个字节数组输出流，输出流缓冲区的初始容量大小为 32 字节。
	
	ByteArrayOutputStream(int size)：创建一个字节数组输出流，输出流缓冲区的初始容量大小由参数 size 指定。

Además de la secuencia de salida ByteArrayOutputStream clase de bytes métodos comunes descritos en lo anterior, otros dos métodos son los siguientes.

	intsize()：返回缓冲区中的当前字节数。
	
	byte[] toByteArray()：以字节数组的形式返回输出流中的当前内容。

ByteArrayOutputStream implementado utilizando la salida de datos matriz de bytes clase, el código se muestra a continuación.

public class Test {
    public static void main(String[] args) {
        ByteArrayOutputStream baos = new ByteArrayOutputStream();
        byte[] b = new byte[] { 1, -1, 25, -22, -5, 23 }; // 创建数组
        baos.write(b, 0, 6); // 将字节数组b中的前4个字节元素写到输出流中
        System.out.println("数组中一共包含：" + baos.size() + "字节"); // 输出缓冲区中的字节数
        byte[] newByteArray = baos.toByteArray(); // 将输出流中的当前内容转换成字节数组
        System.out.println(Arrays.toString(newByteArray)); // 输出数组中的内容
    }
}

La salida del programa son los siguientes:

数组中一共包含：6字节
[1, -1, 25, -22, -5, 23]

flujo de entrada de archivo

flujo de Java FileInputStream se utiliza comúnmente como una comparación, que recupera bytes de entrada desde un archivo en el sistema de archivos. FileInputStream se puede acceder mediante el uso de un archivo de bytes, un grupo de bytes o la totalidad del expediente.

Cuando se crea una clase de objeto FileInputStream, si no puede encontrar el archivo especificado arrojará FileNotFoundException excepción, que debe ser capturado o sentencia throw.

métodos de construcción convencional FileInputStream son principalmente las siguientes dos formas sobrecargados.

	FileInputStream(File file)：通过打开一个到实际文件的连接来创建一个 FileInputStream，该文件通过文件系统中的 File 对象 file 指定。
	
	FileInputStream(String name)：通过打开一个到实际文件的链接来创建一个 FileInputStream，该文件通过文件系统中的路径名 name 指定。

Ejemplo del método FileInputStream () de la utilización de dos de configuración.

try {
    // 以File对象作为参数创建FileInputStream对象
    FileInputStream fis1 = new FileInputStream(new File("F:/mxl.txt"));
    
    // 以字符串值作为参数创建FilelnputStream对象
    FileInputStream fis2 = new FileInputStream("F:/mxl.txt");
} catch(FileNotFoundException e) {
    System.out.println("指定的文件找不到!");
}

Supongamos que tenemos una D: \ MYJAVA archivo \ HelloJava.java, utilizando la siguiente clase de lectura FileInputStream y dar salida a los contenidos del archivo. Código es el siguiente:

public class Test {
    public static void main(String[] args) {
        File f = new File("D:/myJava/HelloJava.java");
        FileInputStream fis = null;
        try {
            // 因为File没有读写的能力,所以需要有个InputStream
            fis = new FileInputStream(f);
            // 定义一个字节数组
            byte[] bytes = new byte[1024];
            int n = 0; // 得到实际读取到的字节数
            System.out.println("D:\\myJava\\HelloJava.java文件内容如下：");
            // 循环读取
            while ((n = fis.read(bytes)) != -1) {
                String s = new String(bytes, 0, n); // 将数组中从下标0到n的内容给s
                System.out.println(s);
            }
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            try {
                fis.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }
}

A medida que el código anterior, el principal método de clase FileInputDemo () crea primero un objeto File F, el punto objeto archivo D: \ MYJAVA \ HelloJava.java. A continuación, un FileInputStream objetos creados usando la clase el constructor FileInputStream fis, y declarar una longitud de 1024 byte tipo de matriz, y luego utiliza el FileInputStream el método read () lee el archivo de datos a la matriz de bytes HelloJava.java en bytes, y emite los datos. Y, finalmente, cerca de la FileInputStream flujo de entrada por último comunicado.

D: Documento \ MYJAVA \ HelloJava.java dice lo siguiente:

/*
*第一个java程序
*/
public class HelloJava {
    // 这里是程序入口
    public static void main(String[] args) {
        // 输出字符串
        System.out.println("你好 Java");
    }
}

prestar atención: Clase FileInputStream anula la clase padre InputStream leer método (), omita el método (), disponible () método y el método close () método no marca apoyo () método y reset ().

flujo de salida del archivo

hereda OutputStream FileOutputStream clase de clase, reescritura y aperos de todos los métodos de la clase padre. El objeto representa una corriente de salida del archivo FileOutputStream clase de bytes a ser escrito en un byte o un grupo de bytes con la corriente. Cuando se crea una clase de objeto FileOutputStream, si el archivo especificado no existe, crear un nuevo archivo, si el archivo ya existe, borrar el contenido del archivo original reescrito.

clase constructor de FileOutputStream son principalmente los siguientes cuatro sobrecargas.

	FileOutputStream(File file)：创建一个文件输出流，参数 file 指定目标文件。
	
	FileOutputStream(File file,boolean append)：创建一个文件输出流，参数 file 指定目标文件，append 指定是否将数据添加到目标文件的内容末尾，如果为 true，则在末尾添加；如果为 false，则覆盖原有内容；其默认值为 false。
	
	FileOutputStream(String name)：创建一个文件输出流，参数 name 指定目标文件的文件路径信息。
	
	FileOutputStream(String name,boolean append)：创建一个文件输出流，参数 name 和 append 的含义同上。

prestar atención: Uso constructor de FileOutputStream (String nombre, append booleano) crea un objeto de flujo de salida de archivo, será de datos adjuntas al final del archivo existente. El nombre de la cadena especificada en el documento original, aunque sólo sea por los datos adicionales en lugar de sobrescribir los datos existentes, parámetro de tipo de agregación de Boole debe ser verdad.

Una corriente de salida del archivo después de cuatro instrucciones:
1. archivo de destino especificada en el constructor del archivo de destino FileOutputStream clase puede no existir.

2. El nombre del archivo de destino puede ser arbitraria, por ejemplo, D: \ abc, D: \ abc.de y D: \ abc.de.fg por lo que puede, puede utilizar herramientas como el Bloc de notas para abrir y ver el contenido de estos archivos .

3. El directorio de destino donde debe existir el archivo, de lo contrario se producirá una java.io.FileNotFoundException excepción.

4. El nombre del archivo no puede ser un directorio existente. Tales como la unidad D carpeta Java existente, no se puede utilizar Java como el nombre del archivo que no se puede utilizar D: \ Java, java.io.FileNotFoundException de otro modo una excepción.

Leer D: \ archivo HelloJava.java MYJAVA \ content, donde el uso implementación de la clase FileInputStream, a continuación, escribir el contenido del nuevo archivo D: \ MYJAVA \ HelloJava.txt en. código específico de la siguiente manera:

public class Test {
    public static void main(String[] args) {
        FileInputStream fis = null; // 声明FileInputStream对象fis
        FileOutputStream fos = null; // 声明FileOutputStream对象fos
        try {
            File srcFile = new File("D:/myJava/HelloJava.java");
            fis = new FileInputStream(srcFile); // 实例化FileInputStream对象
            File targetFile = new File("D:/myJava/HelloJava.txt"); // 创建目标文件对象，该文件不存在
            fos = new FileOutputStream(targetFile); // 实例化FileOutputStream对象
            byte[] bytes = new byte[1024]; // 每次读取1024字节
            int i = fis.read(bytes);
            while (i != -1) {
                fos.write(bytes, 0, i); // 向D:\HelloJava.txt文件中写入内容
                i = fis.read(bytes);
            }
            System.out.println("写入结束！");
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            try {
                fis.close(); // 关闭FileInputStream对象
                fos.close(); // 关闭FileOutputStream对象
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }
}

A medida que el código anterior, la unidad D: \ contenido del archivo MYJAVA \ HelloJava.java se escribe en el documento D a través de las corrientes de entrada / salida: archivo \ MYJAVA \ HelloJava.txt. Debido a que el archivo no existe HelloJava.txt, por lo que en la ejecución de este programa va a crear un nuevo archivo y escribir el contenido.

Ejecutar el programa, después de la salida de voluntad éxito "fin de escritura!" En la consola. En este punto, abra el archivo D: \ MYJAVA \ HelloJava.txt encontrará su contenido con el contenido del archivo HelloJava.java misma.

rápido: Cuando se crea un objeto FileOutputStream, si el parámetro de agregación se establece en true, puede agregar datos al final de los contenidos del archivo de destino, entonces el archivo de destino todavía puede existir temporalmente.