clase de archivo java y flujo IO

clase de archivo

La representación abstracta de archivos y carpetas (rutas de archivos) se utiliza específicamente para identificar archivos o carpetas en el disco.

Método de construcción

método

retorno booleano

crearNuevoArchivo()

Generar un archivo si y sólo si no existe un archivo con ese nombre

public class Demo02 {

    public static void main(String[] args) throws IOException {
        File file = new File("C:\\Users\\Air\\Desktop\\test\\2.txt");
        // 生成一个2.txt文件
        System.out.println(file.createNewFile());
    }
}

mkdir() / mkdirs()

Generar directorio

public class Demo02 {

    public static void main(String[] args) throws IOException {
        File file1 = new File("C:\\Users\\Air\\Desktop\\test\\aa");
       // 生成目录   生成一个aa目录
        System.out.println(file1.mkdir());
    }
}

eliminar() elimina archivos y directorios vacíos

isFile() determina si es un archivo

isDirectory() determina si es un directorio

isHidden() determina si es un archivo oculto

isAbsoute() determina si es una ruta absoluta

existe() determina si existe un archivo o carpeta

Cadena de retorno

getName() obtiene el nombre de un archivo o directorio

getPath() obtiene la ruta del objeto actual

getParent() Obtiene el directorio de nivel superior del objeto de archivo actual

yo

Carga y descarga de archivos

concepto de buffer

La computadora lee los datos del archivo en el disco a través de la memoria de la CPU, leyendo 1 byte a la vez. Pero puedes agregar el concepto de almacenamiento en búfer y leer 4kb cada vez. La eficiencia será mayor.

Clasificación del flujo IO: flujo de entrada y flujo de salida

Flujo de entrada: leer del disco a la memoria

Flujo de salida: escrito desde la memoria al disco

flujo de entrada

El flujo de entrada se divide en flujo de entrada de bytes y flujo de entrada de caracteres.

Flujo de entrada de bytes [Importante]

Hay un archivo 1.txt en el disco, ahora necesitamos leer el contenido del archivo 1.txt en la memoria (código Java)

Flujo de entrada de archivos FileInputStream (flujo de entrada de bytes)

Flujo de búfer BufferedInputStream()

public class Demo {
    public static void main(String[] args) throws IOException {
        // 找到 文件
        File file = new File("C:\\Users\\Air\\Desktop\\test\\1.txt");
        // 将我们找到的文件转为字节输入流的形式  ，之后可以按照流的形式写入到内存中  FileInputStream 不具备缓冲效果
        FileInputStream fis = new FileInputStream(file);
        // 加上缓冲效果
        // BufferedInputStream为另一个输入流添加了功能，即缓冲输入和支持mark和reset方法的功能。 当创建BufferedInputStream时，将创建一个内部缓冲区数组。
        BufferedInputStream bis = new BufferedInputStream(fis);
    }
}

public class Demo02 {
    public static void main(String[] args) throws IOException {
        // 创建File对象
        File file = new File("C:\\Users\\Air\\Desktop\\test\\1.txt");
        // 创建字节流对象
        FileInputStream fileInputStream = new FileInputStream(file);
        // 缓冲
        BufferedInputStream bis = new BufferedInputStream(fileInputStream);
        // 声明一个缓冲数组
        byte[] bytes = new byte[1024 * 4];

        // 开始使用 read 读取
        int length ;
        while ((length = bis.read(bytes))!= -1) {
            // 打印
            System.out.println(new String(bytes,0,length));
        }
        // 关闭流
        bis.close();
        fileInputStream.close();
    }
}

Flujo de entrada de caracteres [no se usa con frecuencia]

También es un flujo de entrada que lee un archivo del disco a la memoria (en código Java).

FileReader() flujo de entrada de archivos (flujo de entrada de caracteres)

BufferedReader() flujo almacenado en buffer

Es una clase conveniente para leer archivos de caracteres y está especialmente diseñada para manejar archivos de caracteres, como archivos txt. El audio, el vídeo y las imágenes no pueden utilizar esta transmisión.

public class Demo06 {
    public static void main(String[] args) throws IOException {
        File file = new File("C:\\Users\\Air\\Desktop\\test\\11.txt");
        // 新建一个字符流对象
        FileReader fr = new FileReader(file);
        // 添加缓冲效果
        BufferedReader br = new BufferedReader(fr);
        // 添加字符数组
        char[] chars = new char[4 * 1024];

        int length = -1;

        while ((length = br.read(chars)) != -1) {
            System.out.println(new String(chars,0,length));
        }
        br.close();
        fr.close();
    }
}

flujo de salida

Flujo de salida de bytes [Importante]

Escribir datos en java al disco (en archivo)

Utilice write() para escribir. Después de escribir, debe actualizar la secuencia y luego cerrarla. Abrir primero, luego cerrar, luego abrir y luego cerrar. La secuencia no se puede estropear.

Flujo de entrada del archivo FileOutputStream

Búfer BufferedOutputStream

import java.io.*;

public class Demo {
    public static void main(String[] args) throws IOException {
        File file = new File("C:\\Users\\Air\\Desktop\\test\\2.txt");
        // 实例化字节流输出对象
        FileOutputStream fos = new FileOutputStream(file);
        // 添加缓冲效果
        BufferedOutputStream bos = new BufferedOutputStream(fos);
        // 将字符串写入文件中
        String str = "hello world";
        // 将字符串转为字节数组
        byte[] bytes = str.getBytes();
        bos.write(bytes);
        // 写完后一定要刷新流然后关闭流
        bos.flush();   // 没有实际意义，可以不写
        //关闭流
        // 先开的后关 后开的先关 顺序不能乱
        bos.close();
        fos.close();
    }
}

Flujo de salida de caracteres [no se usa con frecuencia]

Escribir datos en java al disco (en archivo)

Flujo de salida de caracteres FileWriter

public class Demo07 {
    public static void main(String[] args) throws IOException {

        File file = new File("C:\\Users\\Air\\Desktop\\test\\22.txt");
        // 创建字符输出流对象
        FileWriter fw = new FileWriter(file);
        // 缓冲效果
        BufferedWriter bw = new BufferedWriter(fw);

        String str = "hello world 你好 世界";

        // 将字符串转为 chat类型数组 toCharArray
        char[] chars = str.toCharArray();

        bw.write(chars);

        // 关闭流
        bw.close();
        fw.close();
    }
}