java notas de estudio: Secuencia de IO (entrada y salida corrientes)

A, IO corriente Resumen y Clasificación
1 Overview: IO corriente de procesamiento de transferencia de datos entre dispositivos, las operaciones de Java en el flujo de datos por medio de, objetos Java para el flujo de operación en el paquete IO
2, corriente IO clasificación
de acuerdo con el flujo de datos

flujo de entrada	flujo de salida
Leer datos	datos de escritura

De acuerdo con los tipos de datos

flujo de bytes	flujo de caracteres
Usted puede leer y escribir archivos de cualquier tipo, tales como archivo de texto de audio y vídeo	Usted puede leer y escribir archivos de texto
clase base abstracta flujo de bytes: InputStream, OutputStream	corrientes carácter de clase base abstracta: Lector, escritor
Byte InputStream flujo de entrada, de salida de bytes OutputStream corriente	Carácter de entrada de corriente del lector, el personaje-escritor salida de flujo

Nota : Esto se deriva de cuatro clase base abstracta es un nombre de subclase como un sufijo al nombre del nombre de su padre subclase.
En segundo lugar, el flujo de caracteres
1, los datos de escritura FileOutputStream

①, constructor de
FileOutputStream (Archivo) // crear un archivo para escribir el archivo de datos representado por el objeto del archivo especificado en la secuencia de salida.
FileOutputStream (String nombre) // crear una grabación de datos en un archivo con el nombre especificado de la corriente del archivo de salida.
②, el método de escritura de tres FileOutputStream ()
de escritura public void (int b): a escribir byte más de un byte frente a la corte bytes
pública de escritura vacío (byte [] b ): Escribir una matriz de bytes
pública de escritura nula (byte [] b, int off , int len): escribir una matriz de bytes parte
③, los datos FileOutputStream escritura escritura adicional implementar y avance de línea

ventanas	Linux	Mac
\ R \ n	\norte	\ r

FileOutputStream (String name, append boolean) , parámetro 2 que representa si la escritura adicional
ejemplo: FileOutputStream cabo = new FileOutputStream ( " b.txt", true); // true representa escritura adicional

public class MyIODemo {
    public static void main(String[] args) throws IOException {
      //参2 代表是否追加写入
      //FileOutputStream(String name, boolean append)
      //创建一个向具有指定 name 的文件中写入数据的输出文件流。
      FileOutputStream out = new FileOutputStream("b.txt",true);//true 表示追加写入
      out.write(97); //一次写入一个字节
      out.write(98);
      //写入一个字节数组
      out.write("\r\n".getBytes());//换行
      out.write("像我这样优秀的人，本该灿烂过一生".getBytes());
      out.write("\r\n".getBytes());
      //写入字节数组的一部分 从某个索引开始，写多少个字节
      out.write("怎么二十多年到头来，还在人海里浮沉".getBytes(),0,27);
      out.write("\r\n".getBytes());
      //流使用完毕之后，必须释放资源
      out.close();
    }
}

3, FileInputStream leer datos
①, el byte de entrada se obtiene del sistema de archivos, un archivo
②, FileInputStream (String name)
conectado a un archivo real que ser creado por la apertura de una FileInputStream, el archivo a través de la ruta de acceso de sistema de archivos nombre especificado.
③, FileInputStream (Archivo)
Crea un FileInputStream abriendo una conexión con el archivo existente, el archivo especificado por el archivo de objetos de archivos del sistema de archivos.
④, flujo de entrada de archivos, se informa de error si hay no está asociado
int leer (): leer un byte, ineficiente
byte [] bytes = new nuevo byte [1024];
int len = in.read (bytes) ; // leer una vez el valor de retorno es una matriz de bytes que lea el número de bytes del válida
Nota: después de la corriente después de su uso, los recursos deben ser liberados
4 byte de entrada y salida de la eficiencia del flujo
BufferedOutputStream (OutputStream a cabo) Crear un nuevo corriente de salida con buffer de datos de escritura con la corriente de salida subyacente especificado.
BufferedInputStream (InputStream in) Crea un BufferedInputStream y salva a su argumento, el flujo de entrada en, para su uso posterior.
Sustancialmente el mismo uso eficiente de la entrada y salida corrientes sustancialmente byte corriente
5, Case

分别使用使用高效字节流和基本字节流复制文件   
 public class MyDemo3 {
     public static void main(String[] args) throws IOException { 
        long start = System.currentTimeMillis();
        copy2(); //耗时18542毫秒  耗时13802毫秒
        copy1();  //耗时14046毫秒 耗时14331毫秒
        long end = System.currentTimeMillis();
        System.out.println("耗时"+(end-start)+"毫秒");
    }
    private static void copy2() throws IOException {
        FileInputStream in = new FileInputStream("E:\\我的图片和音乐\\疯狂动物城.mp4");
        FileOutputStream out = new FileOutputStream("D:\\疯狂动物城.mp4");
        //创建一个数组缓冲区
        byte[] bytes = new byte[1024*8];
        int len = 0; //记录读取到的有效的字节个数
        while ((len = in.read(bytes)) != -1) {
            out.write(bytes, 0, len);
            out.flush();
        }
        in.close();
        out.close();
    }
    private static void copy1() throws IOException {
        BufferedInputStream in = new BufferedInputStream(new FileInputStream("E:\\我的图片和音乐\\疯狂动物城.mp4"));
        BufferedOutputStream out = new BufferedOutputStream(new FileOutputStream("D:\\疯狂动物城.mp4"));
        byte[] bytes = new byte[1024*8];
        int len=0;
        while ((len=in.read(bytes))!=-1){
            out.write(bytes,0,len);
        }
        out.close();
        in.close();
    }
    }

En tercer lugar, el flujo de caracteres
1 a causa de flujo de caracteres aparece : operaciones en China debido corriente de bytes no es particularmente conveniente, por lo tanto, Java proporciona un flujo de caracteres.
= + Tabla Byte flujo de caracteres código de corriente
2, que codifica clase String y la decodificación de los problemas en
la codificación : la cadena se convierte en una matriz de byte, la lectura puede leer en el

• public byte [] getBytes (); el uso conjunto de caracteres por defecto de codificación de la plataforma es el byte Cadena esta secuencia, almacenando el resultado en una nueva matriz de bytes.
• public byte [] getBytes (cadena charsetName) utilizando el conjunto de caracteres especificado de codificación de esta cadena es la secuencia de bytes, y almacenando el resultado en un nuevo conjunto de bytes.

La decodificación de : convertir la matriz de bytes en una cadena, en la lectura puede comprender

• public String (byte [] bytes): Especifica el conjunto de caracteres por defecto mediante el uso de la matriz de bytes Internet decodificada, una nueva cadena de constructo.
• public String (byte [] bytes, cadena charsetName) matriz de bytes especificado utilizando la decodificación charset especificado, la construcción de una nueva cadena.

3, el uso de conmutaciones OutputStreamWriter
①, OutputStreamWriter
es un personaje puente arroyos para flujo de bytes: la tabla de códigos se puede utilizar para especificar el código de carácter escrito a la corriente en bytes. Se utiliza el conjunto de caracteres puede especificarse por su nombre o explícitamente dado, de lo contrario, aceptar el conjunto de caracteres por defecto de la plataforma.
②, el constructor
a: OutputStreamWriter (OutputStream a cabo) // crear el OutputStreamWriter de caracteres por defecto de codificación.
b: OutputStreamWriter (OutputStream a cabo, juego de caracteres cs) // Crea un conjunto de caracteres OutputStreamWriter dado.
Nota: El archivo asociado con la corriente de salida, y si no, el sistema creará automáticamente
③, 5 Zhong caracteres de escritura Los flujos de datos vías

public void write(int c) 写一个字符
public void write(char[] cbuf) 写一个字符数组
public void write(char[] cbuf,int off,int len) 写一个字符数组的 一部分
public void write(String str) 写一个字符串
public void write(String str,int off,int len) 写一个字符串的一部分
举例：
public class MyDemo {
public static void main(String[] args) throws IOException {
    OutputStreamWriter out = new OutputStreamWriter(new FileOutputStream("a.txt"));
    //往文件中写入数据
    out.write('尼'); //一次写入一个字符
    out.write("\r\n");
    out.flush();
    out.write("我爱学java");
    out.write("\r\n");
    out.flush();
    out.write("路慢慢慢其修远兮，吾将上下而求索", 0, 8);
    out.write("\r\n");
    out.flush();
    out.write(new char[]{'a', '9', 98, 'e'});
    out.write("\r\n");
    out.write(new char[]{'我', '爱', '你', '们'}, 2, 2);
    out.write("\r\n");
    //字符流 需要将数据从缓冲区刷新过去
    out.flush();
    out.close(); //刷新并关闭
 }
}

4, la conversión usando la corriente InputStreamReader
① constructor
InputStreamReader (InputStream es): la lectura de la codificación por defecto (GBK) datos
InputStreamReader (InputStream es decir, cadena charsetName) : leer los datos codificados con el especifican
dos clases de lectura ②, el flujo de caracteres forma de los datos
int público leer () para leer un carácter
int público de lectura (char [] cbuf ) lee una matriz de caracteres o -1 si no se lee

  public class CopyFile2 {
    public static void main(String[] args) throws IOException {
        InputStreamReader in = new InputStreamReader(new FileInputStream("a.txt"));
       OutputStreamWriter out = new OutputStreamWriter(newFileOutputStream("b.txt"));
        //创建一个字符缓冲区
        char[] chars = new char[100];  
        int len = 0; //len 是记录 你每次读取到的有效的字符个数
        while ((len=in.read(chars)) != -1) {
            out.write(chars, 0, len);//
            out.flush(); //字符流记得刷新一下
        }
        //释放资源
        in.close();
        out.close();
    }
}

5, convenientes clases flujo de caracteres
debido a que el nombre es de conversión de flujo demasiado tiempo, y que no es necesario para desarrollar el juego de caracteres, en general, por lo java darnos fácil conversión correspondiente a la clase de secuencia. El único inconveniente es que no se puede especificar la codificación.

flujo de conversión	clase de conveniencia
OutputStreamWriter	FileWriter
InputStreamReader	FileReade

FileWriter (Archivo de archivos); construye un objeto FileWriter dado un objeto File.
FileWriter (String filename); configurado objeto FileWriter da un nombre de archivo.
6, un personaje eficiente flujo de entrada libro
①, corriente de salida eficiente: BufferedWriter // Escribir datos
constructor: BufferedWriter pública, (escritor W)
②, la corriente de entrada de caracteres eficiente: // BufferedReader datos leídos
constructor: BufferedReader pública (lector e)
función especial ③, carácter búfer de la secuencia
BufferedWriter: public void nuevaLinea (): el sistema determina el sistema de avance de línea línea de ruptura que tiene compatibilidad.
BufferedReader: String readLine pública (): una vez leer una línea de datos se leen de nueva línea de nueva línea está marcada en la envoltura podía leer declaraciones de datos nulos.

举例：//使用高效的字符流，采用读取一行，写入一行的方式来复制文本文件
public class MyDemo8 {
    public static void main(String[] args) throws IOException {
        BufferedReader in = new BufferedReader(new FileReader("a.txt"));
        //BufferedWriter(Writer out)
        //创建一个使用默认大小输出缓冲区的缓冲字符输出流。
        BufferedWriter out = new BufferedWriter(new FileWriter("b.txt"));
        String line=null; //记录每次读取到的一行文本
        while ((line=in.readLine())!=null){ //这里注意读取不到返回null
            out.write(line);
            out.newLine(); //写入一个换行符
            out.flush();//刷新
        }
        //释放资源
        out.close();
        in.close();
    }
}