AI 助理
备案控制台
开发者社区 开发与运维 文章 正文

【Java IO流】流的分类，API使用，文件操作

2023-12-25 116
版权
版权声明：
本文内容由阿里云实名注册用户自发贡献，版权归原作者所有，阿里云开发者社区不拥有其著作权，亦不承担相应法律责任。具体规则请查看《 阿里云开发者社区用户服务协议》和 《阿里云开发者社区知识产权保护指引》。如果您发现本社区中有涉嫌抄袭的内容，填写 侵权投诉表单进行举报，一经查实，本社区将立刻删除涉嫌侵权内容。
简介： 【Java IO流】流的分类，API使用，文件操作


中秋特供啦 🥮

提前祝大家 中秋 | 国庆 快乐 🥮🥮🥮

Java Io 🍔

什么是流

I: Input | 输入

O: Output | 输出

流的分类

  • 按照数据的流向
  • 输入流：读数据
  • 输出流：写数据
  • 按照数据类型来分
  • 字节流
  • 字节输入流
  • 字节输出流
  • 字符流
  • 字符输入流
  • 字符输出流

输入流,输出流

字节流,字符流

文件字节输入流

FileInputStream

package FileInput;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.IOException;
/**
 * Author: _LJaXi
 * @author ASUS
 */
class FileInput {
    public static void main(String[] args) throws IOException {
        try {
            FileInputStream fis = new FileInputStream("d:\\aaa.txt");
            // 一次读取多个字节,存到数组中
            // 创建一个长度为3的数组 / 字节类型
            byte[] buf = new byte[3];
            int count = 0;
            // 条件判断循环
            while ((count = fis.read(buf)) != -1) {
                System.out.print(new String(buf,0,count));
            }
            // 3. 关闭
            fis.close();
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        }
    }
}

1. 条件循环解决

package main.java.com.mycode;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.IOException;
/**
 * Author: _LJaXi
 * @author ASUS
 */
class MyIo {
  public static void main(String[] args) throws IOException {
    try {
      FileInputStream fis = new FileInputStream("d:\\aaa.txt");
      // 读取
      System.out.println(fis.read());
      int data = 0;
      // 循环打印字节
      while ((data = fis.read()) != -1) {
        System.out.print((char) data);
      }
      // 3. 关闭
      fis.close();
    } catch (FileNotFoundException e) {
      e.printStackTrace();
    }
  }
}
1 (2) 读取特性
package main.java.com.mycode;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.IOException;
/**
 * Author: _LJaXi
 * @author ASUS
 */
class MyIo {
  public static void main(String[] args) throws IOException {
    try {
      FileInputStream fis = new FileInputStream("d:\\aaa.txt");
      // 一次读取多个字节,存到数组中
      // 创建一个长度为3的数组 / 字节类型
      byte[] buf = new byte[3];
      // 返回实例读取的个数
      int count = fis.read(buf);
      // 打印字符串 buf
      System.out.println(new String(buf));
      System.out.println(count);
      // 多次读取
      int count2 = fis.read(buf);
      System.out.println(new String(buf));
      System.out.println(count2);
      int count3 = fis.read(buf);
      System.out.println(new String(buf));
      System.out.println(count3);
      // 若文件内字符太短，可能会出现读取数组you多余元素问题，那是你的上次buf数组没有清空导致的
      // 可以使用
      // System.out.println(new String(buf, index(索引), count3)); 来清理多余的元素
      // new String(buf)参数：
      // 1. param1 是一个字节数组，用于构建新的字符串对象
      // 2. param2 是偏移量（offset），表示从 param1 的索引为 param2 的位置开始构建字符串
      // 3. param3 是长度（length），表示构建字符串的长度
      // 3. 关闭
      fis.close();
    } catch (FileNotFoundException e) {
      e.printStackTrace();
    }
  }
}

2. 数组存储解决

package main.java.com.mycode;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.IOException;
/**
 * Author: _LJaXi
 * @author ASUS
 */
class MyIo {
  public static void main(String[] args) throws IOException {
    try {
      FileInputStream fis = new FileInputStream("d:\\aaa.txt");
      // 一次读取多个字节,存到数组中
      // 创建一个长度为3的数组 / 字节类型
      byte[] buf = new byte[3];
     int count = 0;
     // 条件判断循环
     while ((count = fis.read(buf)) != -1) {
         System.out.print(new String(buf,0,count));
     }
      // 3. 关闭
      fis.close();
    } catch (FileNotFoundException e) {
      e.printStackTrace();
    }
  }
}

文件字节输出流

FileOutputStream

package main.java.com.mycode;
import java.io.FileOutputStream;
/**
 * Author: _LJaXi
 * @author ASUS
 */
public class FileOutput {
  public static void main (String[] args) throws Exception {
    // 1. 创建文件字节输出流对象
    // 若不想覆盖原本内容，将构造方法append，设置为true
    FileOutputStream fos = new FileOutputStream("d://aaa.txt", true);
    // 2. 写入文件
    // fos.write(97);
    // fos.write('b');
    // fos.write('c');
    String str = "helloworld";
    // 获取字符串所对应的字节数组
    fos.write(str.getBytes());
    // 3. 关闭
    fos.close();
    System.out.println("执行完毕");
  }
}
输出流构造方法
// 某个构造方法有个形参 append，这个构造方法的 append 若为true 表明不覆盖原本内容
public FileOutputStream(String name, boolean append)
        throws FileNotFoundException
    {
        this(name != null ? new File(name) : null, append);
    }

字节流复制文件

package CopyFile;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
/*
* 使用文件字节流实现文件的复制
* */
public class CopyFile {
    public static void main(String[] args) throws IOException {
        // 1. 先用文件字节输入流读到内存中
        FileInputStream fis = new FileInputStream("C:\\Users\\ASUS\\Desktop\\凌波.png");
        // 2. 再用一个文件字节输出流写入到硬盘
        FileOutputStream fos = new FileOutputStream("C:\\Users\\ASUS\\Desktop\\凌波丽.jpg");
        // 3. 一边读 一边写
        byte[] buf = new byte[1024];
        int count = 0;
        while((count=fis.read(buf)) != -1) {
            fos.write(buf,0,count);
        }
        // 4. 关闭流
        fis.close();
        fos.close();
        System.out.print("复制完毕");
    }
}

字节缓冲流

BufferedInputStream / Buffered0utputStream

提高IO效率，减少访问磁盘的次数;

数据存储在缓冲区中，flush是将缓存区的内容写入文件中，也可以直接close;

BufferedInputStream

package Buffered;
import java.io.FileInputStream;
import java.io.BufferedInputStream;
import java.io.IOException;
/*
* 使用字节缓冲流读取
* BufferedInputStream
* @Tip 我想和 符韬_(pinegg) 一起玩
* */
public class BufferedStream {
    public static void main(String[] args) throws IOException {
        // 1. 创建BufferedInputStream
        FileInputStream fis = new FileInputStream("d:\\aaa.txt");
        // 增强底层流
        BufferedInputStream bis = new BufferedInputStream(fis);
        // 2. 读取 bis 读文件会放在缓冲区，提高效率
        int count = 0;
        // bis.read() 并不是读一个字节，先把一部分数据读到bis缓冲区内，调用已经读了8k了
        // private static int DEFAULT_BUFFER_SIZE = 8192;
        while ((count=bis.read()) != -1) {
            System.out.print((char) count);
        }
        // 3. 关闭
        bis.close(); // 缓冲流close之后, 会自动帮你关闭输入流 fis.close()
    }
}

BufferedInputStream 自定义读取部分数据

package Buffered;
import java.io.FileInputStream;
import java.io.BufferedInputStream;
import java.io.IOException;
/*
* 使用字节缓冲流读取
* BufferedInputStream
* @author 符韬是谁？
* */
public class BufferedStream {
    public static void main(String[] args) throws IOException {
        // 1. 创建BufferedInputStream
        FileInputStream fis = new FileInputStream("d:\\aaa.txt");
        // 增强底层流
        BufferedInputStream bis = new BufferedInputStream(fis);
        // 2. 读取 bis 读文件会放在缓冲区，提高效率
        int count = 0;
        // bis.read() 并不是读一个字节，先把一部分数据读到bis缓冲区内，调用已经读了8k了
        // private static int DEFAULT_BUFFER_SIZE = 8192;
        // 当然你也可以自己定义把一部分数据读取到缓冲区, 下方注释写法
        byte[] buf = new byte[6000];
        while ((count=bis.read(buf)) != -1) {
            System.out.print(new String(buf, 0, count));
        }
        // 3. 关闭
        bis.close(); // 缓冲流close之后, 会自动帮你关闭输入流 fis.close()
    }
}

BufferedOutputStream

package Buffered;
import java.io.*;
/*
 * 使用字节缓冲流写入
 * BufferedOutputStream
 * @time 2023年9月11日14:19:47
 * @author _LJaXi
 * @tip 想秀阿卡丽
 * */
public class OutputStream {
    public static void main(String[] args) {
        try {
            FileOutputStream fos = new FileOutputStream("d:\\aaa.txt", true);
            BufferedOutputStream bos = new BufferedOutputStream(fos);
            String data = "LOL";
            bos.write(data.getBytes()); // 写入 8k 到缓冲区
            fos.flush(); // 刷新到硬盘
            /*---------------------------------------------------------------
            * bos.flush()的作用是将缓冲区中的数据立即刷新（写入）到硬盘中
            * 当使用BufferedOutputStream写入数据时，数据通常会先被存储在内部的缓冲区中，直到缓冲区达到一定的容量或者手动调用flush()方法
            * ---------------------------------------------------------------
            * flush()方法的使用是为了确保数据被及时写入硬盘，而不是一直停留在缓冲区
            * 在调用flush()方法后，任何未写入的数据将被立即写入到硬盘中，这样可以避免数据丢失的风险
            * ---------------------------------------------------------------
            * 在流关闭之前或发生异常时，也会自动调用flush()方法，确保所有数据都被写入硬盘
            * ---------------------------------------------------------------*/
            bos.close(); // 内部也会调用 flush() 方法
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

对象流

  1. 增强了缓冲区功能
  2. 增强了读写8种基本数据类型和字符串功能
  3. 增强了读写对象的功能 {

readObject() 从流中读取一个对象

writeObject(Object obj) 向流中写入一个对象

}

使用流传输对象的过程称为序列化(写入)、反序列化(读取)

Student 类

package ObjectStream;
import java.io.Serializable;
// 要想序列化，类必须实现一个接口，为标记接口
public class Student implements Serializable {
    private String name;
    private int age;
    public Student() {
    }
    public Student(String name, int age) {
        super();
        this.name = name;
        this.age = age;
    }
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    public int getAge() {
        return age;
    }
    public void setAge(int age) {
        this.age = age;
    }
    // this is 重写 toString 方法
    @Override
    public String toString() {
        return "Student{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }
}

ObjectOutStream

package ObjectStream;
import java.io.*;
/*
* 序列化类必须要实现 Serializable 接口(标记接口)
* ObjectOutputStream
* @time 2023年9月14日13:49:52
* @author _LJaXi
* @tip 阿卡丽5连败
* */
public class OutStream {
    public static void main(String[] args)throws IOException {
        // 1. 创建对象流
        FileOutputStream fos = new FileOutputStream("d:\\aaa.bin");
        ObjectOutputStream oos = new ObjectOutputStream(fos);
        // 2. 序列化（写入操作）
        Student zs = new Student("张三", 20);
        oos.writeObject(zs);
        // 3. 关闭
        oos.close();
        System.out.println("序列化完毕");
    }
}

ObjectInputSteam

package ObjectStream;
import java.io.*;
/*
* ObjectInputStream 反序列化(读取重构成对象)
* @time 2023年9月14日23:31:23
* @author _LJaXi
* @tip 阿卡丽排位3连胜
* */
public class InputStream {
    public static void main(String[] args) throws IOException, ClassNotFoundException {
        // 1. 创建对象流
        FileInputStream fis = new FileInputStream("d:\\aaa.bin");
        ObjectInputStream ois = new ObjectInputStream(fis);
        // 2. 读取文件(反序列化)
        Student s = (Student)ois.readObject();
        // Student s2 = (Student)ois.readObject(); // 不能读取多次
        // 3. 关闭
        ois.close();
        System.out.println("执行完毕");
        System.out.println(s.toString());
    }
}
序列化和反序列化注意点

序列化类必须实现 Serializable 接口

序列化类中对象属性要求实现 Serializable 接口

序列化类中对象属性要求实现 Serializable 接口意思为：

public class Student implements Serializable {
    private String name;
    private int age;
    private Class class; // Class类要实现 Serializable 接口
    // ... 其他内容
}
serialVersionUlD 警告

警告: 添加一个 serialVersionUlD 常量(Java内置,可在设置中打开)

The serializable class Student does not declare a static final serialVersionUlD field of type long

在类中添加:

private static final long serialVersionUID = 100L;

意义： 序列化版本号ID

作用：保证序列化的类和反序列化的类是同一个类

对于没有显式声明 serialVersionUID 的类，Java会自动生成一个默认值

transient 禁止序列化某属性

若不相信序列化类中的某个属性,可使用 transient(瞬间的, 瞬时的) 关键字修饰

// Student
package ObjectStream;
import java.io.Serializable;
public class Student implements Serializable {
    private String name;
    private transient int age; // age禁止被序列化
    public Student() {
    }
    // ....其他操作
}
序列化读取多次

序列化可写入多个对象，在反序列化时读取多个即可

// 序列化
public class OutStream {
    public static void main(String[] args)throws IOException {
        // 1. 创建对象流
        FileOutputStream fos = new FileOutputStream("d:\\aaa.bin");
        ObjectOutputStream oos = new ObjectOutputStream(fos);
        // 2. 序列化（写入操作）
        Student zs = new Student("张三", 20);
        Student ls = new Student("李四", 20); // 定义ls对象 ⭕
        oos.writeObject(zs);
        oos.writeObject(ls); // 写入ls ⭕
        // 3. 关闭
        oos.close();
        System.out.println("序列化完毕");
    }
}
// 反序列化
public class InputStream {
    public static void main(String[] args) throws IOException, ClassNotFoundException {
        // 1. 创建对象流
        FileInputStream fis = new FileInputStream("d:\\aaa.bin");
        ObjectInputStream ois = new ObjectInputStream(fis);
        // 2. 读取文件(反序列化)
        Student s = (Student)ois.readObject();
        Student s2 = (Student)ois.readObject(); // 读取多次 ⭕
        // 3. 关闭
        ois.close();
        System.out.println("执行完毕");
        System.out.println(s.toString());
    }
}
借助集合实现多个对象的序列化
// 序列化
public class OutStream {
    public static void main(String[] args)throws IOException {
        // 1. 创建对象流
        FileOutputStream fos = new FileOutputStream("d:\\aaa.bin");
        ObjectOutputStream oos = new ObjectOutputStream(fos);
        ArrayList<Student> list = new ArrayList<>(); // ⭕定义集合
        // 2. 序列化（写入操作）
        Student zs = new Student("张三", 20);
        Student ls = new Student("李四", 20);
        // ⭕ 添加元素
        list.add(zs);
        list.add(ls);
        oos.writeObject(list); // ⭕写入
        // oos.writeObject(zs);
        // oos.writeObject(ls);
        // 3. 关闭
        oos.close();
        System.out.println("序列化完毕");
    }
}
// 反序列化
public class InputStream {
    public static void main(String[] args) throws IOException, ClassNotFoundException {
        // 1. 创建对象流
        FileInputStream fis = new FileInputStream("d:\\aaa.bin");
        ObjectInputStream ois = new ObjectInputStream(fis);
        // 2. 读取文件(反序列化)
        ArrayList<Student> l = (ArrayList<Student>) ois.readObject();  // ⭕强转
        // Student s = (Student)ois.readObject();
        // Student s2 = (Student)ois.readObject();
        // 3. 关闭
        ois.close();
        System.out.println("执行完毕");
        // System.out.println(s.toString());
        System.out.println(list.toString()); // ⭕打印
    }
}

字符流

字符流以字符为单位读写数据，提供了更高层次的操作，能够方便地处理文本数据

文件字符输入流 FileReader

package FileReaderAndWriter;
import java.io.FileReader;
public class FileRead {
    public static void main(String[] args)throws Exception {
        // 1. 创建 FileReader 文件字符输入流
        FileReader fr = new FileReader("d:\\aaa.txt");
        // 2. 读取
        // int data = 0;
        // while((data = fr.read()) != -1) {
        //     System.out.print((char) data);
        // }
        // 创建缓冲区
        char[] buf = new char[1024];
        int count = 0;
        while((count = fr.read(buf)) != -1) {
            System.out.print(new String(buf, 0, count));
        }
        // 3. 关闭
        fr.close();
    }
}

文件字符输出流 FileWriter

package FileReaderAndWriter;
import java.io.FileWriter;
public class FileWrite {
    public static void main(String[] args)throws Exception {
        // 1. 创建文件字符输出流
        FileWriter fw = new FileWriter("d:\\write.txt");
        // 2. 写入
        for (int i = 0; i < 10; i++) {
            fw.write("Java是世界上最好的语言\r\n"); // 换行写入 \r\n
            fw.flush();
        }
        // 3. 关闭
        fw.close();
    }
}

使用 FileReader 和 FileWriter 复制文本文件

package FileReaderAndWriter;
import java.io.FileReader;
import java.io.FileWriter;
/*
* 使用 FileReader 和 FileWriter 复制文本文件，不能复制图片或者二进制文件
* =============== 使用字节流才可以复制任何文件 =================
* @author _LJaXi
* */
public class CopyFile {
    public static void main(String[] args)throws Exception {
        // 1. 创建 FileReader FileWriter
        FileReader fr = new FileReader("d://write.txt");
        FileWriter fw = new FileWriter("d://write2.txt");
        // 2. 读写
        int data = 0;
        while((data = fr.read()) != -1) {
            fw.write(data);
        }
        // 3. 关闭
        fr.close();
        fw.close();
        System.out.println("执行完毕");
    }
}

字符缓冲流 BufferedReader \ BufferedWriter

高效读取， 高效写入

字符缓冲流读取文件 BufferedReader
package FileReaderAndWriter;
import java.io.BufferedReader;
import java.io.FileReader;
/*
* 使用字符缓冲流读取文件
* 高效读取
* BufferedReader
* */
public class BufferedReaderStream {
    public static void main(String[] args)throws Exception {
        // 1. 创建缓冲流
        FileReader fr = new FileReader("d:\\write.txt");
        BufferedReader br = new BufferedReader(fr);
        // 2. 读取
        // char[] buf = new char[1024];
        // int count = 0;
        // while ((count = br.read(buf)) != -1) {
        //     System.out.println(new String(buf, 0, count));
        // }
        // 2.1 第二种方式 一行一行的读取
        // readLine() BufferedReader提供的API
        String line = null;
        while ((line = br.readLine()) != null) {
            System.out.println(line);
        }
        // 3. 关闭
        br.close();
    }
}
字符缓冲流写入文件 BufferedWriter
package FileReaderAndWriter;
import java.io.BufferedWriter;
import java.io.FileWriter;
/*
* 字符缓冲流
* BufferedWriter
* */
public class BufferedWriterStream {
    public static void main(String[] args)throws Exception {
        FileWriter fw = new FileWriter("d:\\buffer.txt");
        BufferedWriter bw = new BufferedWriter(fw);
        // 2. 写入
        for (int i = 0; i < 10; i++) {
            bw.write("好好学习。");
            bw.newLine(); // 换行符，等同于 \r\n
            bw.flush();
        }
        // 3. 关闭
        bw.close();
    }
}

打印流

package PrintWriterStream;
import java.io.PrintWriter;
/*
* PrintWriter
* */
public class Print {
    public static void main(String[] args)throws Exception {
        // 1. 新建 打印流
        PrintWriter pw = new PrintWriter("d:\\print.txt");
        // 2. 打印
        pw.println(97);
        pw.println(true);
        pw.println(3.14);
        pw.println('a');
        // 3. 关闭
        pw.close();
    }
}

转换流

InputStreamReader 和 OutputStreamWriter 是用于处理字符流（文本）的桥接类, 它们将字节流转换为字符流

使用 InputStreamReader 读取指定文件并指定使用的编码

import java.io.*;
public class InputStreamReaderExample {
    public static void main(String[] args) {
        try {
            // 创建 InputStreamReader 指定编码读取文件
            FileInputStream fileInputStream = new FileInputStream("input.txt"); // 指定文件路径
            InputStreamReader inputStreamReader = new InputStreamReader(fileInputStream, "UTF-8"); // 指定编码
            BufferedReader bufferedReader = new BufferedReader(inputStreamReader); // BufferedReader 字符缓冲流读取文件
            String line;
            while ((line = bufferedReader.readLine()) != null) {
                System.out.println(line);
            }
            // 关闭资源
            bufferedReader.close();
            inputStreamReader.close();
            fileInputStream.close();
        } catch (IOException e) {
            e.printStackTrace();
        }
        // e.printStackTrace()方法会将异常的堆栈跟踪信息打印到标准错误流（System.err）。堆栈跟踪信息包含了异常发生的位置、方法调用的轨迹以及导致异常的原因等详细信息，有助于开发者定位和解决问题。
    }
}

使用 OutputStreamWriter 写入文件并指定使用的编码

import java.*;
public class OutputStreamWriterExample {
  public static void main(String[] args) {
    // 输出流
    FileOutputSteam fps = new FileOutputSteam("output.txt");
    OutputStreamWriter osw = new OutputStreamWriter(fps, "UTF-8");
    // 写入
    for (int i = 0; i < 10; i++) {
      osw.write("OutputStreamWriterExample\r\n");
      osw.flush();
    }
    // 关闭流
    osw.close();
  }
}

File 类

java.io.File 是 Java 标准类库中用于表示文件和目录路径的类。它提供了一组方法，可以操作文件和目录，如 创建、删除、重命名、检查文件属性等

API 作用
createNewFile() 创建一个新文件
mkdir() 创建一个新目录
delete() 删除文件或空目录
exists() 判断File对象所代表的对象是否存在
getAbsolutePath() 获取文件的绝对路径
getName() 取得名字
getParent() 获取文件 / 目录所在的目录
isDirectory() 是否是目录
isFile 是否为文件
length() 获得文件的长度
listFiles() 列出目录中的所有内容
renameTo() 修改文件名

获取文件路径分隔符和名称分隔符

import java.io.File;
public class GetSeparator {
  public static void main(String[] args) {
    separator();
  }
  public static void separator() {
    // 获取路径分隔符
    System.out.print("路径分隔符" + File.pathSeparator);
    // 获取名称分隔符
    System.out.print("路径分隔符" + File.separator);
  }
}

文件操作

创建文件

import java.io.File;
public class FileOpe {
  public static void main(String[] args) throw Exception {
    fileOp();
  }
  public static void fileOp() throw Exception {
    File file = new File("D:\\file.txt");
    // System.out.print(file.toString()); // d:\file.txt
    if(file.exists()) {
      boolean b = file.createNewFile();
      System.out.print("创建结果" + b);
    }
  }
}

删除文件

import java.io.File;
public class FileOpe {
  public static void main(String[] args) throw Exception {
    fileOp();
  }
  public static void fileOp() throw Exception {
    File file = new File("D:\\file.txt");
    if(file.exists()) {
      boolean b = file.createNewFile();
      System.out.print("创建结果" + b);
    }
    // 删除文件
    // 1. 直接删除
    // file.delete();
    // 2. jvm退出时删除
    file.deleteOnExit();
    Thread.sleep(5000);
  }
}

获取文件信息

import java.io.File;
public class FileOpe {
  public static void main(String[] args) throw Exception {
    fileOp();
  }
  public static void fileOp() throw Exception {
    File file = new File("D:\\file.txt");
    if(file.exists()) {
      boolean b = file.createNewFile();
      System.out.print("创建结果" + b);
    }
    // 获取文件信息
    System.out.print("文件名称" + file.getName());
    System.out.print("获取父目录" + file.getParent());
    System.out.print("获取长度" + file.length());
    System.out.print("获取文件绝对路径" + file.getAbsolutePath());
    System.out.print("获取路径" + file.getPath());
    System.out.print("获取文件创建时间" + new Date(file.lastModified()).toLocaleString());
  }
}

判断文件信息

import java.io.File;
public class FileOpe {
  public static void main(String[] args) throw Exception {
    fileOp();
  }
  public static void fileOp() throw Exception {
    File file = new File("D:\\file.txt");
    if(file.exists()) {
      boolean b = file.createNewFile();
      System.out.print("创建结果" + b);
    }
    // 判断
    System.out.print("文件是否可写" + file.canWrite());
    System.out.print("是否为文件" + file.isFile());
    System.out.print("文件是否隐藏" + file.isHidden());
  }
}

文件夹操作

创建文件夹

import java.io.File;
public class FileOpe {
  public static void main(String[] args) throw Exception {
    directoryOpe();
  }
  public static void directoryOpe() throw Exception {
    File dir = new File("d:\\aaa\\bbb\\ccc");
    // System.out.print(dir.toString()); // d:\aaa\bbb\ccc
    if (!dir.exists()) {
      // dir.mkdir(); // 只能创建单级目录
      System.out.print("创建状态: " + dir.mkdirs()); // true
    }
  }
}

删除文件夹

import java.io.File;
public class FileOpe {
  public static void main(String[] args) throw Exception {
    directoryOpe();
  }
  public static void directoryOpe() throw Exception {
    File dir = new File("d:\\aaa\\bbb\\ccc");
    // System.out.print(dir.toString()); // d:\aaa\bbb\ccc
    if (!dir.exists()) {
      // dir.mkdir(); // 只能创建单级目录
      System.out.print("创建状态: " + dir.mkdirs()); // true
    }
    // 1. 直接删除
    // System.out.print("删除结果" + dir.delete()); // 注意删除空目录
    // 2. 使用jvm删除
    dir.deleteOnExit();
    Thread.sleep(5000);
  }
}

获取文件夹信息

import java.io.File;
public class FileOpe {
  public static void main(String[] args) throw Exception {
    directoryOpe();
  }
  public static void directoryOpe() throw Exception {
    File dir = new File("d:\\aaa\\bbb\\ccc");
    // System.out.print(dir.toString()); // d:\aaa\bbb\ccc
    if (!dir.exists()) {
      // dir.mkdir(); // 只能创建单级目录
      System.out.print("创建状态: " + dir.mkdirs()); // true
    }
    // 获取文件信息
    System.out.print("文件名称" + dir.getName());
    System.out.print("获取父目录" + dir.getParent());
    System.out.print("获取文件绝对路径" + dir.getAbsolutePath());
    System.out.print("获取路径" + dir.getPath());
    System.out.print("获取文件创建时间" + new Date(dir.lastModified()).toLocaleString());
  }
}

判断文件夹信息

import java.io.File;
public class FileOpe {
  public static void main(String[] args) throw Exception {
    directoryOpe();
  }
  public static void directoryOpe() throw Exception {
    File dir = new File("d:\\aaa\\bbb\\ccc");
    // System.out.print(dir.toString()); // d:\aaa\bbb\ccc
    if (!dir.exists()) {
      // dir.mkdir(); // 只能创建单级目录
      System.out.print("创建状态: " + dir.mkdirs()); // true
    }
    // 判断
    System.out.print("是否为文件夹" + dir.isDirectory());
    System.out.print("文件夹是否隐藏" + dir.isHidden());
  }
}

遍历文件夹内容

import java.io.File;
public class FileOpe {
  public static void main(String[] args) throw Exception {
    directoryOpe();
  }
  public static void directoryOpe() throw Exception {
    File dir = new File("d:\\aaa\\bbb\\ccc");
    // System.out.print(dir.toString()); // d:\aaa\bbb\ccc
    if (!dir.exists()) {
      // dir.mkdir(); // 只能创建单级目录
      System.out.print("创建状态: " + dir.mkdirs()); // true
    }
    // 遍历文件夹
    File dir2 = new File("d:\\图片");
    String[] files = dir2.list();
    for(String item : files ) {
      System.out.println(item);
    }
  }
}

FileFilter 接口

FileFilter 接口 是 Java 标准库中的一个接口，位于 java.io 包下. 它用于筛选文件列表的方法，使得可以选择性地选择需要的文件.

FileFilter 接口 是一个函数式接口，只有一个抽象方法 accept(File pathname)，该方法接收一个待测试的文件对象（File类型）作为参数，返回一个布尔值. 如果文件符合条件，返回 true，否则返回 false.

public interface FileFilter 
  - boolean accept(File pathname)
import java.io.File;
import java.io.FileFilter;
public class FileFilterExample {
    public static void main(String[] args) {
        File directory = new File("path/to/directory");
        // 创建一个 FileFilter 匿名内部类来筛选以 ".txt" 结尾的文件
        FileFilter txtFileFilter = new FileFilter() {
            @Override
            public boolean accept(File pathname) {
              // endsWith 字符串方法筛选文件是否以 txt 结尾 
                return pathname.isFile() && pathname.getName().endsWith(".txt");
            }
        };
        // 获取目录下所有满足筛选条件的文件
        File[] txtFiles = directory.listFiles(txtFileFilter);
        // 输出结果
        for (File file : txtFiles) {
            System.out.println(file.getName());
        }
    }
}

递归遍历和递归删除

递归遍历

import java.*;
public class FileDemo {
  public static void main(String[] args) throw Exception {
    FileOpe(new File("d:\\demo"));
  }
  /**
  * @ File dir 接收一个 File 类型参数, 用于递归判断
  */
  public static void FileOpe(File dir) throw Exception {
    File[] files = dir.listFile();
    // 如果数组不为 null 并且 数组不为 []
    if (files != null && files.length > 0) {
      for(File file : files) {
        if (file.isDerectory()) {
          FileOpe(file); // 如果某一项为文件夹，那就对某个文件夹进行递归操作
        } else {
          System.out.print(file.getAbsolutePath());
        }
      }
    }
  }
}

递归删除

找 chatGPT 改了一下，懒得手敲了

import java.io.*;
public class FileDemo {
    public static void main(String[] args) throws Exception {
        FileOpe(new File("d:\\demo"));
    }
    /**
     * @param dir 接收一个 File 类型参数，用于递归判断
     */
    public static void FileOpe(File dir) throws Exception {
        File[] files = dir.listFiles();
        // 如果数组不为 null 并且数组不为空
        if (files != null && files.length > 0) {
            for (File file : files) {
                if (file.isDirectory()) {
                    FileOpe(file); // 如果某一项为文件夹，那就对该文件夹进行递归操作
                } else {
                    System.out.println(file.getAbsolutePath());
                    file.delete(); // 删除文件
                }
            }
        }
        dir.delete(); // 删除文件夹
    }
}

Properties

Java 的 Properties 是一种用于管理配置信息的类

它继承自 Hashtable 类，因此它具有 Hashtable 的所有特性和方法

Properties 类以键值对的形式存储配置数据，其中键和值都是字符串类型

遍历Properties集合

import java.*;
public class PropertiesDemo {
  public static void main(String[] args) {
    // 创建 Properties
    Proerties p = new Properties();
    // 添加key value 
    p.setProperty("name", "Jerry");
    p.setProperty("age", "3");
    // 遍历
    Set<String> propNames = p.stringPropertyNames();
    for(String pro : propNames) {
      System.out.println(pro + " === " + p.getProperty(pro));
    }
    // 和流有关的方法
    PrintWriter pw = new PrintWriter("d:\\a.txt");
    p.list(pw);
    pw.close();
    // store 方法
    // store() 是 Properties 类的一个方法，用于将属性列表存储到输出流中
    // 第一个参数是输出流对象，可以是 FileOutputStream、BufferedOutputStream 等
    // 第二个参数是一个字符串，表示对存储的属性列表进行注释
    FileOutputStream fos = new FileOutputStream("d:\\a.txt");
    p.store(fos, "注释");
    fos.close();
    // load 方法加载
    Properties p2 = new Properties();
    FileInputStream fis = new FileInputStream("d:\\config.properties");
    p2.load(fis);
    fis.close();
    System.out.println(p2.toString());
  }
}

完结傻花

❀❀❀❀❀❀❀❀❀❀❀❀❀❀❀❀❀❀

文章标签：
Java
API
存储
缓存
关键词：
分类API
Java API
Java IO
io分类
Java分类
東方幻想鄉
目录
相关文章
API小知识
|
2月前
|
Java API Maven
如何使用Java开发抖音API接口？
在数字化时代，社交媒体平台如抖音成为生活的重要部分。本文详细介绍了如何用Java开发抖音API接口，从创建开发者账号、申请API权限、准备开发环境，到编写代码、测试运行及注意事项，全面覆盖了整个开发流程。
API小知识
258 10
喜欢猪猪
|
2月前
|
监控 Java 应用服务中间件
高级java面试---spring.factories文件的解析源码API机制
【11月更文挑战第20天】Spring Boot是一个用于快速构建基于Spring框架的应用程序的开源框架。它通过自动配置、起步依赖和内嵌服务器等特性，极大地简化了Spring应用的开发和部署过程。本文将深入探讨Spring Boot的背景历史、业务场景、功能点以及底层原理，并通过Java代码手写模拟Spring Boot的启动过程，特别是spring.factories文件的解析源码API机制。
喜欢猪猪
93 2
API小知识
|
5天前
|
JSON 供应链 搜索推荐
淘宝APP分类API接口：开发、运用与收益全解析
淘宝APP作为国内领先的购物平台，拥有丰富的商品资源和庞大的用户群体。分类API接口是实现商品分类管理、查询及个性化推荐的关键工具。通过开发和使用该接口，商家可以构建分类树、进行商品查询与搜索、提供个性化推荐，从而提高销售额、增加商品曝光、提升用户体验并降低运营成本。此外，它还能帮助拓展业务范围，满足用户的多样化需求，推动电商业务的发展和创新。
API小知识
24 5
爱专研的技术土狗
|
6天前
|
API 数据处理 开发者
获取淘宝分类详情：深入解析taobao.cat_get API接口
淘宝开放平台推出的`taobao.cat_get` API接口，帮助开发者和商家获取淘宝、天猫的商品分类详情。该接口支持获取类目列表、属性及父类目信息，通过指定分类ID（cid）实现精准查询，并提供灵活的参数设置和高效的数据处理。使用流程包括注册账号、创建应用、获取App Key/Secret、构造请求、发送并解析响应。示例代码展示了如何用Python调用此API。开发者可借此为电商项目提供数据支持。
爱专研的技术土狗
25 5
互联网课堂
|
16天前
|
JSON Java Apache
Java基础-常用API-Object类
继承是面向对象编程的重要特性，允许从已有类派生新类。Java采用单继承机制，默认所有类继承自Object类。Object类提供了多个常用方法，如`clone()`用于复制对象，`equals()`判断对象是否相等，`hashCode()`计算哈希码，`toString()`返回对象的字符串表示，`wait()`、`notify()`和`notifyAll()`用于线程同步，`finalize()`在对象被垃圾回收时调用。掌握这些方法有助于更好地理解和使用Java中的对象行为。
互联网课堂
43 8
API小知识
|
30天前
|
算法 Java API
如何使用Java开发获得淘宝商品描述API接口？
本文详细介绍如何使用Java开发调用淘宝商品描述API接口，涵盖从注册淘宝开放平台账号、阅读平台规则、创建应用并申请接口权限，到安装开发工具、配置开发环境、获取访问令牌，以及具体的Java代码实现和注意事项。通过遵循这些步骤，开发者可以高效地获取商品详情、描述及图片等信息，为项目和业务增添价值。
API小知识
63 10
Java开发者
|
1月前
|
存储 Java 数据挖掘
Java 8 新特性之 Stream API：函数式编程风格的数据处理范式
Java 8 引入的 Stream API 提供了一种新的数据处理方式，支持函数式编程风格，能够高效、简洁地处理集合数据，实现过滤、映射、聚合等操作。
Java开发者
63 6
Java开发者
|
2月前
|
Java
java 中 IO 流
Java中的IO流是用于处理输入输出操作的机制，主要包括字节流和字符流两大类。字节流以8位字节为单位处理数据，如FileInputStream和FileOutputStream；字符流以16位Unicode字符为单位，如FileReader和FileWriter。这些流提供了读写文件、网络传输等基本功能。
Java开发者
57 9
叫个什么名字
|
1月前
|
Java API 开发者
Java中的Lambda表达式与Stream API的协同作用
在本文中，我们将探讨Java 8引入的Lambda表达式和Stream API如何改变我们处理集合和数组的方式。Lambda表达式提供了一种简洁的方法来表达代码块，而Stream API则允许我们对数据流进行高级操作，如过滤、映射和归约。通过结合使用这两种技术，我们可以以声明式的方式编写更简洁、更易于理解和维护的代码。本文将介绍Lambda表达式和Stream API的基本概念，并通过示例展示它们在实际项目中的应用。
叫个什么名字
36 3
Skyund
|
2月前
io流分类
按流向分类： 输入流：用于从数据源（如文件、键盘）读取数据。 输出流：用于向目标（如文件、屏幕）写入数据。 按操作类型分类： 字节流：以字节为单位进行操作，适用于所有类型的数据。 字符流：以字符为单位进行操作，更便于处理文本数据。
Skyund
17 4

热门文章

最新文章

  • 1
    小红书详情API接口的获取与应用
  • 2
    Python调用API接口的方法
  • 3
    实时获取小红书详情 API 数据
  • 4
    淘宝实时 API 接口丨淘宝商品详情接口（Taobao.item_get）
  • 5
    基于百炼平台qwen-max的api 打造一套 检索增强 图谱增强 基于指令的智能工具调用决策 智能体
  • 6
    GLM-4V-Flash：智谱 AI 免费开放的图像理解大模型 API 接口
  • 7
    基于百炼平台qwen-max的api 打造一套 检索增强 图谱增强 智能工具调用决策的智能体
  • 8
    API 数据接口使用与安全指南
  • 9
    使用Zabbix API
  • 10
    API接口是什么？(一篇文章全知道)
  • 1
    Java一分钟之-Java IO流：文件读写基础
    163
  • 2
    t-io websocket的聊天功能学习记录（二）
    117
  • 3
    t-io websocket的聊天功能学习记录（一）
    133
  • 4
    LabVIEW报错“仪器IO助手未正确安装”
    110
  • 5
    LabVIEW编程LabVIEW开发高级数据采集技术 操作数字IO 例程与相关资料
    105
  • 6
    LabVIEW编程LabVIEW开发 PXI-6259多功能IO模块 例程与相关资料
    77
  • 7
    【C++入门到精通】C++的IO流（输入输出流） [ C++入门 ]
    154
  • 8
    【探索Linux】P.12（文件描述符 | 重定向 | 基础IO）
    83
  • 9
    【探索Linux】P.11（基础IO，文件操作）
    46
  • 10
    Java IO 流详解
    59

    • 相关课程

    更多
  • Java面试疑难点解析 - 面试技巧及语言基础
  • Java面试疑难点解析 - Java Web开发
  • Java面试疑难点解析 - 系统架构及项目设计
  • Java编程入门
  • Java面向对象编程
  • Java高级编程

    • 相关电子书

    更多
  • Spring Cloud Alibaba - 重新定义 Java Cloud-Native
  • The Reactive Cloud Native Arch
  • JAVA开发手册1.5.0

    • 相关实验场景

    更多
  • 基于Assistant Api的旅游助手
  • 快速体验智能体API应用
  • 阿里云平台上进行Java程序的编译与运行
  • 使用Java面向对象编写网络通信程序应用
  • 手动部署Java Web环境（Alibaba Cloud Linux 2）
  • 搭建Java Web开发环境（Anolis OS）
    • 下一篇
    开通oss服务