Resumen de los conceptos básicos de flujo de E / S

El concepto de transmisión IO

Flujo: lineal, direccional.
IO: entrada (entrada) y salida (salida).

Clasificación del flujo IO en JAVA:

Imágenes de internet

Flujo de bytes:

  La transmisión de nivel más bajo de Java puede leer y escribir cualquier archivo (texto plano, video, imagen, sonido ...), en bytes.
Porque: todo es "byte"
A). Flujo de salida: OutputStream (clase abstracta)
B). Flujo de entrada: InputStream (clase abstracta)

Secuencia de caracteres:

  Basado en el flujo de bytes, es muy conveniente leer y escribir archivos de "texto plano", con caracteres como la unidad, y leer múltiples bytes a la vez. (Siempre que se procesen datos de texto plano, se da prioridad al uso de flujos de caracteres. Además del uso de flujos de bytes.)
   A). Flujo de salida:
   B). Flujo de entrada:

IO stream_byte output stream_FileOutputStream:

Método de construcción:
  1) nuevo FileOutputStream (String name): (sobrescribir) crea un flujo de salida de archivo y lo escribe en el archivo con el nombre especificado.
  2) .FileOutputStream (String name, boolean append) (Append) Cree una secuencia de salida de archivo y escríbala en el archivo con el nombre especificado.
  3). FileOutputStream (archivo de archivo): (sobrescribir) crea una secuencia de salida de archivo para escribir en el archivo representado por el objeto de archivo especificado.
  4). FileOutputStream (archivo File, boolean append) (Append) Crea una secuencia de salida de archivo para escribir en el archivo representado por el objeto File especificado.
Nota: Cuando todas las "secuencias de salida" se construyen en Java, es posible que el archivo no exista y que se cree uno automáticamente;

Método de escritura de bytes (salida): (tres tipos)
   A) .write (int b): genera un byte;
   B) .write (byte [] byteArray): genera una matriz de bytes;
  C) .write ( byte [] byteArray, int off, int len): genera una parte de la matriz de bytes;
   1). byteArray: la matriz que se va a escribir;
   2). off: el índice de posición inicial;
    3). len: el número de salidas;

public static void main(String[] args) throws IOException {
    //1.构造方法：
    FileOutputStream out = new FileOutputStream("demo.txt",false);

    //2.输出的方法：
    //2-1:write(int b):输出一个字节
    out.write(97);//97 --> 转换为二进制: 0110 0001 --> 写入文件：0110 0001
    out.write(999997);//999997 -->转换为二进制：111101000010 0011 1101 --> 取最低的一个字节：写入文件：0011 1101

    //2-2:write(byte[] byteArray):输出多个字节
    byte[] byteArray = {97, 98, 99, 100};
    out.write(byteArray);
     //间接的输出一个“字符串” 
     out.write("大家好，呵呵".getBytes());
     //输出一个换行符：
     out.write("\r\n".getBytes());


    //2-3:write(byte[] byteArray,int offset,int len):
    //例如：写入byteArray数组中的99，100
    out.write(byteArray,2,2);
    //关闭流--释放资源
     out.close();
}

IO stream_byte input stream_FileInputStream:

 1) Método de construcción:
   1. FileInputStream (String name) Cree un FileInputStream abriendo la conexión con el archivo real, el nombre del archivo se denomina por la ruta en el sistema de archivos.
   2.FileInputStream (archivo de archivo) Cree un FileInputStream abriendo la conexión con el archivo real, el archivo es nombrado por el archivo de objeto File en el sistema de archivos.
Nota: Durante la construcción de todas las "secuencias de entrada" en Java, el archivo debe existir, de lo contrario se generará una excepción;
 el método de lectura:
  1) .public int read (): lee un byte
  2) .public int read (byte [ ] byteArray): lee varios bytes y los encapsula en la matriz de parámetros.

	public class Demo {
    	public static void main(String[] args) throws IOException {
        File file = new File("demo.txt");
        if (!file.exists()) {
            file.createNewFile();
        }
        FileInputStream in = new FileInputStream(file);

        //读一个字节
        /*int b = 0;
        while ((b = in.read()) != -1) {
            System.out.println((char)b);
        }*/

        //读取多个字节：3个
        byte[] byteArray = new byte[3];
        int len = 0;
        while ((len = in.read(byteArray)) != -1) {
            //将 byte[]数组转换为String
            String str = new String(byteArray,0,len);
            System.out.println("转换为String后：" + str);
        }
    }
}

IO stream_character stream_output stream FileWriter

(Solo se puede usar el juego de caracteres predeterminado del sistema)
Método de construcción:
1) FileWriter (String fileName) construye un objeto FileWriter con un nombre de archivo.
2). FileWriter (String fileName, boolean append) construye un objeto FileWriter, dando un nombre de archivo con un valor booleano, que indica si se deben agregar los datos escritos.
3). FileWriter (archivo File) Construye un objeto FileWriter para un objeto File.
4). FileWriter (archivo File, boolean append) (agregar) a un objeto File para construir un objeto FileWriter.
Método de salida:
 1) .write (int c): salida de un carácter;
 2) .write (char [] chArray): salida de una matriz de caracteres;
 3) .write (char [] chArray, int off, int len): salida Parte de la matriz de caracteres;
  4) .write (String str): genera una cadena;
  5) .write (String str, int off, int len): parte de la cadena de salida;

public static void main(String[] args) throws IOException {
        //注意：构造时，文件可以不存在，会自动创建
        FileWriter out = new FileWriter("demo.txt");

        //**********五个输出的方法*************************************//
        //1.write(int c):输出一个字符
        out.write(98);
        //2.write(char[] chArray):输出一个字符数组
        char[] chArray = {'a','b','你','好','呵','呵'};
        out.write(chArray);

        //3.write(char[] chArray,int off,int len("输出字符数组的一部分；
        out.write(chArray,4,2);

        //4.write(String s):输出一个字符串
        out.write("我爱IO");

        //5.write(String s,int off,int len):输出字符串的一部分
        String str = "北京天安门前";
        out.write(str,4,3);

        //*******************输出换行************************//
        out.write("\r\n");
        out.write("你好");
        //刷新缓存区
//        out.flush();
	   //注意："字符流"内部自带缓存区，write()之后一定要flush()/close()才能
	   //将缓存区的数据写入到文件。
        out.close();//相当于：flush() + close()
    }

Flujo de caracteres flujo de entrada FileReader:

Método de construcción:
1) .FileReader (String fileName) Crea un nuevo FileReader, dado el nombre del archivo a leer.
2). FileReader (archivo de archivo) Cree un nuevo FileReader y dele un archivo para leer.
Método de lectura:
1) .int read (): lee un carácter; el valor de retorno es la "codificación" del carácter de lectura
2) .int read (char [] chArray): lee varios caracteres y los almacena En la matriz
El valor de retorno es el "número" de caracteres leídos.

public static void main(String[] args) throws IOException {
    FileReader in = new FileReader("demo03.txt");
    //一次读取一个字符
    /*int c = 0;
    while ((c = in.read()) != -1) {
        System.out.println("读取的字符：" + (char)c);
    }*/
    
    //一次读取一个字符数组
    char[] chArray = new char[2];
    int len = 0;
    while ((len = in.read(chArray)) != -1) {
        //可以将一个字符数组的一部分转换为String
        String str = new String(chArray,0,len);
        System.out.println(str);
    }
    in.close();
}

Conversión de secuencia de caracteres y secuencia de bytes

Características del flujo de conversión:

1. Es un puente entre la secuencia de caracteres y la secuencia de bytes
2. Los datos de bytes leídos
se pueden convertir en caracteres a través de una codificación especificada 3. Los datos de caracteres leídos se pueden convertir en bytes a través de una codificación especificada

¿Cuándo usar el flujo de conversión?
1. Cuando hay una acción de conversión entre bytes y caracteres;
2. Cuando los datos de la operación de flujo necesitan ser codificados o decodificados.
3. Manifestación específica del objeto:
InputStreamReader: puente de byte a carácter
OutputStreamWriter: puente de carácter a byte
Estos dos objetos de flujo son miembros del sistema de caracteres, tienen un efecto de conversión y son flujos de caracteres, por lo que están construidos A veces necesita pasar el objeto de flujo de bytes.