Notas de estudio de JAVA: flujo IO

Mobile 2023-10-06 09:39:57 views: null

Estilo de E/S

concepto de flujo

  • Un canal para transferir datos entre memoria y dispositivos de almacenamiento.

Agua (equivale a datos) -> tuberías que transmiten agua (equivale a flujo) -> lavabo (equivale a memoria)

Agua sanitaria -> entrada

Aguas residuales domésticas -> salida

Clasificación de flujos

Por dirección 【Puntos clave】

  • Flujo de entrada: lea el contenido de <dispositivo de almacenamiento> en <memoria>
  • Flujo de salida: escriba el contenido de <memoria> en <dispositivo de almacenamiento>

por unidad

  • Flujo de bytes: en bytes, todos los datos se pueden leer y escribir
  • Flujo de caracteres: en unidades de caracteres, solo se pueden leer y escribir datos de texto

por función

  • Flujo de nodo: tiene las funciones de lectura y escritura para transferir datos
  • Flujo de filtro: funcionalidad mejorada basada en el flujo de nodos

flujo de bytes

Clase principal del flujo de bytes (clase abstracta)

//InputStream 字节输入流
public int read(){
    
    }
public int read(byte[] b){
    
    }
public int read(byte[] b, int off, int len){
    
    }

// OutputStream 字节输出流
public void write(int n){
    
    }
public void write(byte[] b){
    
    }
public void write(byte[] b, int off, int len){
    
    }

flujo de bytes de archivo

flujo de entrada de archivos

//文件字节输入流
public static void main(String[] args) throws Exception{
    
    
    //1. 创建FileInputStream,并指定文件路径
    FileInputStream file = new FileInputStream("路径/a.txt");
    //2. 读取文件
    //2.1 单字节读取
    int data = 0;
    while((data=file.read())!=-1){
    
    
        System.out.print((char) data);
    }
    //2.2.1 一次读取多个字节
    byte[] buf = new byte[3];
    int count = file.read(buf);
    System.out.println(new String(buf));
    System.out.println(count);
    int count2 = file.read(buf);
    System.out.println(new String(buf));
    System.out.println(count2);
   
    //2.2.1 一次读取多个字节
    byte[] buf = new byte[1024];
    int count = 0;
    while ((count=file.read(buf))!=-1){
    
    
        System.out.println(new String(buf,0,count));
    }
    //3. 关闭
    file.close();
    System.out.println("\n执行完毕");
}

flujo de salida de archivos

//FileOutputStream
public static void main(String[] args) throws Exception{
    
    
    //1. 创建FileOutputStream,并指定文件路径
    FileOutputStream fos = new FileOutputStream("路径/b.txt",true);
  	//true 不覆盖
    //2. 输出文件
    fos.write(97);
    fos.write('b');
    fos.write('c');
    String str = "helloworld";
    fos.write(str.getBytes());
    //3. 关闭
    fos.close();
    System.out.println("执行完毕");
}

Caso de copia de imagen

public static void main(String[] args) throws Exception {
    
    
    //使用文件字节流实现文件的复制
    // 1 创建流
    // 1.1 文件字节输入流
    FileInputStream fis = new FileInputStream("路径/a.jpg");
    // 1.2 文件字节输出流
    FileOutputStream fos = new FileOutputStream("路径/b.jpg");
    // 2 边读边写
    byte[] buf = new byte[1024];
    int count = 0;
    while((count=fis.read(buf))!=-1){
    
    
        fos.write(buf,0,count);
    }
    // 3 关闭
    fis.close();
    fos.close();
}

flujo de búfer de bytes

Flujo almacenado en búfer: BufferedInputStream/ BufferedOutputStream

  • Mejore la eficiencia de IO y reduzca la cantidad de accesos al disco
  • Los datos se almacenan en el búfer. Flush escribe el contenido del búfer en el archivo. También puede cerrarlo directamente.
    //BufferedInputStream
    public static void main(String[] args) throws Exception{
    
    
        //1. 创建BufferedInputStream
        FileInputStream fis = new FileInputStream("路径/a.txt");
        BufferedInputStream bis = new BufferedInputStream(fis);
        //2. 读取
        int data = 0;
        while((data=bis.read())!=-1){
    
    
            System.out.print((char)data);
        }
        //自己创建缓冲区
        byte[] buf = new byte[1024];
        int count = 0;
        while((count=bis.read(buf))!=-1){
    
    
            System.out.println(new String(buf,0,count));
        }
        //3. 关闭
        bis.close();
        System.out.println("\n执行完毕");
    }

public static void main(String[] args) throws Exception{
    
    
    //1. 创建BufferedOutputStream 字节输出缓冲流
    FileOutputStream fos = new FileOutputStream("路径/b2.txt");
    BufferedOutputStream bos = new BufferedOutputStream(fos);
    //2. 写入文件
    for(int i=0;i<10;i++){
    
    
        bos.write("helloworld\n".getBytes());//写入缓冲区，没超过8K缓冲区
        bos.flush();//刷新到硬盘
    }
    //3. 关闭
    bos.close();
    System.out.println("\n执行完毕");
}

flujo de objetos

  • Funcionalidad de búfer mejorada
  • Funciones mejoradas de lectura y escritura de 8 tipos de datos y cadenas básicos
  • Funcionalidad mejorada para leer y escribir objetos.
    • readObject()Leer un objeto de la secuencia
    • writeObject(Object obj)Escribir un objeto en la secuencia

El proceso de utilizar objetos de transmisión se llama serialización y deserialización.

Serialización y deserialización

Publicación por entregas

  • La clase de serialización debe implementar la interfaz serializable.
//实现接口 标记接口
public class Student implements Serializable {
    
    }

//使用ObjectOutputStream 实现对象的序列化
public static void main(String[] args) throws Exception{
    
    
        //1. 创建对象流
        FileOutputStream fos = new FileOutputStream("路径/stu.bin");
        ObjectOutputStream oos = new ObjectOutputStream(fos);
        //2. 序列化（写入操作）
        Student s1 = new Student("zhangsan",20);
        oos.writeObject(s1);
        //3. 关闭
        oos.close();
        System.out.println("执行完毕");
}

Deserialización

// 使用ObjectInputSteam实现反序列化（读取重构对象）
public static void main(String[] args) throws Exception{
    
    
        //1. 创建对象流
        FileInputStream fis = new FileInputStream("路径/stu.bin");
        ObjectInputStream ois = new ObjectInputStream(fis);
        //2. 读取文件（反序列化）
        Student s = (Student) ois.readObject();
        //关闭
        ois.close();
        System.out.println("执行完毕");
        System.out.println(s.toString());//Student{name='zhangsan', age=20}
}

Precauciones

  1. Para ser serializada, una clase debe implementar la interfaz Serializable.
  2. Las propiedades de los objetos en las clases de serialización requieren la implementación de la interfaz serializable.
  3. ID del número de versión de serialización, lo que garantiza que la clase serializada y la clase deserializada sean la misma clase
  4. Utilice el atributo de modificación transitorio (transitorio), este atributo no se puede serializar
  5. Las propiedades estáticas no se pueden serializar
  6. La serialización de múltiples objetos se puede lograr con la ayuda de colecciones.

El proceso de serialización específico es el siguiente:

Durante la operación de serialización, el sistema escribirá el serialVersionUID de la clase actual en el archivo de serialización. Al deserializar, el sistema detectará el serialVersionUID en el archivo para determinar si es consistente con el serialVersionUID de la clase actual. Si es así Si es consistente, se explicará la secuencia: la versión de la clase deserializada es la misma que la versión de la clase actual y la deserialización puede tener éxito; de lo contrario, fallará.

//序列化多个对象，可以借助集合来实现
//2. 序列化（写入操作）
Student s1 = new Student("zhangsan",20);
Student s2 = new Student("lisi",25);
ArrayList<Student> list = new ArrayList<>();
list.add(s1);
list.add(s2);
oos.writeObject(list);

//2. 读取文件（反序列化）
//Student s = (Student) ois.readObject();
ArrayList<Student> list = (ArrayList<Student>) ois.readObject();
//关闭
ois.close();
System.out.println("执行完毕");
System.out.println(list.toString());
//[Student{name='zhangsan', age=0}, Student{name='lisi', age=0}]

Codificación

  • ISO-8859-1 incluye además de ASCII, también incluye símbolos de texto correspondientes a Europa occidental, griego, tailandés, árabe y hebreo.
  • Codificación de caracteres de longitud variable UTF-8 para la tabla de códigos Unicode
  • GB2312 Chino simplificado
  • GBK Chino simplificado, extendido
  • BIG5 Taiwán, chino tradicional

flujo de personajes

public static void main(String[] args) throws Exception{
    
    
    //1. 创建FileInputStream对象
    FileInputStream fis = new FileInputStream("路径/hello.txt");
    //2. 读取
    int data = 0;
    while((data = fis.read())!=-1){
    
    
        System.out.print((char)data);
    }
    //3. 关闭
    fis.close();
}

Clase principal del flujo de caracteres (clase abstracta)

readerflujo de entrada de caracteres

  • public int read(){}
  • public int read(char[] c){}
  • public int read(char[] b, int off, int len){}

Writerflujo de salida de caracteres

  • public void write(int n){}
  • public void write(String str){}
  • public void write(char[] c){}
//使用FileReader读取文件
public static void main(String[] args) throws Exception {
    
    
    //1. 创建FileReader 文件字符输入流
    FileReader fr = new FileReader("路径/hello.txt");
    //2. 读取
    //2.1 单个字符读取
    /*
    int data = 0;
    while ((data = fr.read()) != -1) {
        System.out.print((char) data);
    }

     */
    //2.2 字符缓冲区
    char[] buf = new char[1024];
    int count = 0;
    while((count=fr.read(buf))!=-1){
    
    
        System.out.println(new String(buf,0,count));
    }
  	//3. 关闭
    fr.close();
    System.out.println("执行完毕");
}

//使用FileWriter读取文件
public static void main(String[] args) throws Exception {
    
    
        //1. 创建FileWriter对象
        FileWriter fw = new FileWriter("/Users/xay/Desktop/编程/JAVA-FullStack/JavaSE/JavaBasics/src/Demo15/write.txt");
        //2. 写入
        for (int i = 0; i < 10; i++) {
    
    
            fw.write("java是世界上最好的语言\n");
            fw.flush();
        }
        //3. 关闭
        fw.close();
        System.out.println("执行完毕");
}

Caso de secuencia de caracteres (copie el texto usando lo anterior)

  • No se pueden copiar imágenes ni archivos binarios. Cualquier archivo se puede copiar mediante flujos de bytes.
  • Cualquier archivo se puede copiar utilizando un flujo de bytes.
  • Las secuencias de caracteres pueden copiar archivos de texto
public static void main(String[] args) throws Exception {
    
    
    //1. 创建FileReader FileWriter
    FileReader fr = new FileReader("路径/write.txt");
    FileWriter fw = new FileWriter("路径/write2.txt");
    //2. 读写
    int data = 0;
    while((data=fr.read())!=-1){
    
    
        fw.write(data);
        fw.flush();
    }
    //3. 关闭
    fr.close();
    fw.close();
    System.out.println("执行完毕");
}

flujo de buffer de caracteres

Lector en búfer/Escritor en búfer

Lectura y escritura eficientes, admite la entrada de nuevas líneas y puede escribir una línea y leer una línea a la vez.

//BufferedReader 使用字符缓冲流读取文件
public static void main(String[] args) throws Exception{
    
    
    //创建缓冲流
    FileReader fr = new FileReader("路径/write.txt");
    BufferedReader br = new BufferedReader(fr);
    //2. 读取
    //2.1 第一种方式
    char[] buf = new char[1024];
    int count = 0;
    while((count=br.read(buf))!=-1){
    
    
        System.out.print(new String(buf,0,count));
    }
    //2.2 第二种方式，一行一行读取
    String line = null;
    while((line = br.readLine())!=null){
    
    
        System.out.println(line);
    }
    //3. 关闭
    br.close();
    System.out.println("执行结束");
}

//BufferedWriter 使用字符缓冲流写入文件
public static void main(String[] args) throws Exception{
    
    
    //1. 创建BufferedWriter对象
    FileWriter fw = new FileWriter("路径/buffer.txt");
    BufferedWriter bw = new BufferedWriter(fw);
    //2. 写入
    for(int i=0;i<10;i++){
    
    
        bw.write("好好学习，天天向上");
        bw.newLine();//换行符
        bw.flush();
    }
    //3. 关闭
    bw.close();
    System.out.println("执行完毕");
}

Imprenta

  • El método encapsulado print() / println()admite el ajuste de línea después de escribir
  • Admite la impresión de datos tal como está
//PrintWriter 的使用
public static void main(String[] args) throws Exception {
    
    
    //1. 创建打印流
    PrintWriter pw = new PrintWriter("路径/print.txt");
    //2. 打印
    pw.println(97);//97
    pw.println(true);//true
    pw.println(3.14);//3.14
    pw.println('a');//a
    //3. 关闭
    pw.close();
    System.out.println("执行结束");
}

Flujo de conversión

  • Flujo de conversión de puentesInputStreamReader / OutputStreamWriter
  • Convertir flujo de bytes en flujo de caracteres
  • Método de codificación de caracteres configurable
//InputStreamReader 的使用 读取文件，指定使用的编码
public static void main(String[] args) throws Exception {
    
    
    //1. 创建InputStreamReader 对象
    FileInputStream fis = new FileInputStream("路径/write.txt");
    InputStreamReader isr = new InputStreamReader(fis,"utf-8");
    //2. 读取文件
    int data = 0;
    while((data=isr.read())!=-1){
    
    
        System.out.print((char)data);
    }
    //3. 关闭
    isr.close();
    System.out.println("执行完毕");
}

//OutputStreamWriter 写入文件，使用指定编码
public static void main(String[] args) throws Exception {
    
    
    //1. 创建OutputStreamWriter对象
    FileOutputStream fos = new FileOutputStream("路径/info.txt");
    OutputStreamWriter osw = new OutputStreamWriter(fos, "utf-8");
    //2. 写入
    for (int i = 0; i < 10; i++) {
    
    
        osw.write("你好中国");
        osw.flush();
    }
    //3. 关闭
    osw.close();
    System.out.println("执行成功");
}

clase de archivo

Concepto: representa un archivo o carpeta en una letra de unidad física

Uso de la clase de archivo

  1. delimitador
  2. Operaciones de archivos
  3. Operaciones de carpeta

Interfaz de filtro de archivos

  • interfaz pública FileFilter
    • booleano aceptar (nombre de ruta del archivo)
  • Al llamar al método listFiles () en la clase Archivo, admite pasar la clase de implementación de la interfaz FileFIlter para filtrar los archivos obtenidos. Solo los archivos que cumplan las condiciones pueden aparecer en el valor de retorno de listFiles ().
public class Demo01 {
    
    
    /*
File类的使用
    1. 分隔符
    2. 文件操作
    3. 文件夹操作
    */
    public static void main(String[] args) throws Exception {
    
    
        separator();
        fileOpe();
        directoryOpe();
    }

    // 1. 分隔符
    public static void separator() {
    
    
        System.out.println("路径分隔符" + File.pathSeparator);//:
        System.out.println("名称分隔符" + File.separator);///
    }

    // 2. 文件操作
    public static void fileOpe() throws Exception {
    
    
        // 1. 创建文件
        File file = new File("路径/file.txt");
        System.out.println(file.toString());
        if (!file.exists()) {
    
    
            boolean b = file.createNewFile();
            System.out.println("创建结果：" + b);//创建结果：true
        }
        // 2. 删除文件
        // 2.1 直接删除
        //System.out.println("删除的结果：" + file.delete());
        // 2.2 使用jvm退出时删除
        //ile.deleteOnExit();
        //Thread.sleep(5000);
        // 3. 获取文件信息
        System.out.println("获取绝对路径：" + file.getAbsolutePath());
        System.out.println("获取路径：" + file.getPath());
        System.out.println("获取文件名称：" + file.getName());
        System.out.println("获取父目录：" + file.getParent());
        System.out.println("获取文字长度：" + file.length());
        System.out.println("文件创建时间：" + new Date(file.lastModified()).toLocaleString());

        // 4. 判断
        System.out.println("是否可写：" + file.canWrite());
        System.out.println("是否是文件：" + file.isFile());
        System.out.println("是否隐藏：" + file.isHidden());
    }

    // 3. 文件夹操作
    public static void directoryOpe() throws Exception {
    
    
        // 1. 创建文件夹
        File dir = new File("路径/a/b/c");
        System.out.println(dir.toString());
        if (!dir.exists()) {
    
    
            //dir.mkdir();//只能创建单级目录
            boolean b = dir.mkdirs();//创建多级目录
            System.out.println("创建结果：" + b);
        }
        // 2. 删除文件夹
        // 2.1 直接删除
        //System.out.println("删除结果："+dir.delete());// 只能删除最底层空目录
        // 2.2 使用jvm删除
        //dir.deleteOnExit();

        // 3. 获取文件夹信息
        System.out.println("获取绝对路径：" + dir.getAbsolutePath());
        System.out.println("获取路径：" + dir.getPath());
        System.out.println("获取文件夹名称：" + dir.getName());//最底层文件夹名称
        System.out.println("获取父目录：" + dir.getParent());
        System.out.println("获取创建时间：" + new Date(dir.lastModified()).toLocaleString());

        // 4. 判断
        System.out.println("是否是文件夹：" + dir.isDirectory());
        System.out.println("是否隐藏：" + dir.isHidden());

        // 5. 遍历文件夹
        File dir2 = new File("路径/Demo16");
        String[] files = dir2.list();
        for(String file :files){
    
    
            System.out.println(file.toString());
        }

        // FileFilter接口的使用
        File[] files2 = dir2.listFiles(new FileFilter() {
    
    
            @Override
            public boolean accept(File pathname) {
    
    
                if(pathname.getName().endsWith(".txt")){
    
    
                    return true;
                }
                return false;
            }
        });
        for(File file : files2){
    
    
            System.out.println(file.getName());
        }
    }
}

Recorrer carpetas de forma recursiva

//递归遍历文件夹
public static void main(String[] args) throws Exception {
    
    
    listDir(new File("/Users/xay/Desktop/编程/JAVA-FullStack/JavaSE/JavaBasics/src"));
}

public static void listDir(File dir) {
    
    
    File[] files = dir.listFiles();
    System.out.println(dir.getName());
    if (files != null && files.length > 0) {
    
    
        for(File file : files){
    
    
            if(file.isDirectory()){
    
    
                listDir(file);
            }else {
    
    
                System.out.println(file.getName());
            }
        }
    }
}

Eliminar carpetas de forma recursiva

public static void deleteDir(File dir){
    
    
    File[] files = dir.listFiles();
    if(files!=null && files.length>0){
    
    
        for(File file : files){
    
    
            if(file.isDirectory()){
    
    
                deleteDir(file);
            }else {
    
    
                //删除文件
                System.out.println(file.getAbsolutePath()+"删除"+file.delete());
            }
        }
    }
    System.out.println(dir.getAbsolutePath()+"删除"+dir.delete());
}

Propiedades

  • Propiedades: colección de propiedades
  • Características
    1. Almacenar nombres de atributos y valores de atributos
    2. El nombre del atributo y el valor del atributo son ambos tipos de cadena.
    3. sin genéricos
    4. relacionado con el flujo
//Properties集合的使用
public static void main(String[] args) throws Exception{
    
    
    //1. 创建集合
    Properties properties = new Properties();
    //2. 添加数据
    properties.setProperty("username","zhangsan");
    properties.setProperty("age","20");
    System.out.println(properties.toString());
    //3. 遍历
    //3.1 keyset
    //3.2 entrySet
    //3.3 stringPropertyNames()
    Set<String> pronames = properties.stringPropertyNames();
    for(String pro : pronames){
    
    
        System.out.println(pro + "-" + properties.get(pro));
    }

    //和流有关的方法
    //4.1 list方法
    PrintWriter pw =new PrintWriter("路径/print.txt");
    properties.list(pw);
    pw.close();
    //4.2 store方法 保存
    FileOutputStream fos = new FileOutputStream("路径/print.properties");
    properties.store(fos,"注释");
    fos.close();
    //4.3 load方法 加载
    Properties properties2 = new Properties();
    FileInputStream fis = new FileInputStream("路径/print.properties");
    properties2.load(fis);
    fis.close();
    System.out.println(properties2.toString());
}

Supongo que te gusta

Origin blog.csdn.net/weixin_42823298/article/details/128646455
Recomendado
Clasificación
Diario
Más
2024-04-26(22)
2024-04-25(34)
2024-04-24(31)
2024-04-23(29)
2024-04-22(5)
2024-04-21(0)
2024-04-20(6)
2024-04-19(5)
2024-04-18(0)
2024-04-17(30)

Code World

© 2018 codetd.com