java-File类与IO流

已于 2024-12-06 14:59:21 修改
阅读量139 收藏 2
点赞数 6
CC 4.0 BY-SA版权
分类专栏： java基础 文章标签： java 开发语言
于 2024-12-02 09:27:34 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/bugnotfound/article/details/144179901

File类与IO流

File类

  • File类用于表示文件和目录的路径名抽象。
  • File类的一个对象对应于操作系统下的一个文件或一个目录
  • 通过File类，可以创建、删除、重命名文件或目录，也可以检查文件属性，如文件大小、最后修改时间等。

常用方法

  • 创建文件或目录：
    • boolean createNewFile()：创建一个新文件。
    • boolean mkdir()：创建一个目录。
    • boolean mkdirs()：创建多级目录。
  • 删除文件或目录：
    • boolean delete()：删除文件或目录。
  • 判断文件或目录是否存在：
    • boolean exists()：判断文件或目录是否存在。
  • 获取文件或目录信息：
    • String getName()：获取文件或目录的名称。
    • String getPath()：获取文件或目录的路径。
    • boolean isFile()：判断是否为文件。
    • boolean isDirectory()：判断是否为目录。
    • long lastModified()：获取最后修改时间。
    • long length()：获取文件长度。
  • 遍历目录：
    • String[] list()：列出目录下的文件和目录名。
    • File[] listFiles()：列出目录下的文件和目录。
  • 重命名文件或目录：
    • boolean renameTo(File dest)：重命名文件或目录。
  • 其他常用方法：
    • boolean canRead()：判断是否可读。
    • boolean canWrite()：判断是否可写。
    • boolean isHidden()：判断是否隐藏文件。
    • boolean setReadOnly()：设置文件为只读。
import java.io.File;
import java.io.IOException;

public class FileExample {
    public static void main(String[] args) {
        // 创建一个File对象
        File file = new File("example.txt");

        try {
            // 创建新文件
            if (file.createNewFile()) {
                System.out.println("File created: " + file.getName());
            } else {
                System.out.println("File already exists.");
            }

            // 获取文件路径
            System.out.println("File path: " + file.getAbsolutePath());

            // 删除文件
            if (file.delete()) {
                System.out.println("File deleted: " + file.getName());
            } else {
                System.out.println("Failed to delete the file.");
            }

        } catch (IOException e) {
            System.out.println("An error occurred.");
            e.printStackTrace();
        }finally{
            file.close();
        }
    }
}

IO流

IO流原理以及流的分类

  • java程序中，对于数据的输入输出操作以“流”的方式进行，可以看作是一种数据的流动。
  • 将io流可理解为光的粒子性，将bit数据看作是一个一个的光子而io流则是光本身
  • 字节流（Byte Stream）
    • 字节流以字节为单位进行操作，适用于处理二进制数据或者字节流数据。在Java中，InputStream和OutputStream是字节流的基本类，分别用于处理输入和输出字节流。
    • InputStream：用于从输入流中读取字节数据。
    • OutputStream：用于向输出流中写入字节数据。
  • 字符流（Character Stream）
    • 字符流以字符为单位进行操作，适用于处理文本数据。在Java中，Reader和Writer是字符流的基本类，分别用于处理输入和输出字符流。
    • Reader：用于从输入流中读取字符数据。
    • Writer：用于向输出流中写入字符数据。
  • IO流的工作原理
    • 打开流：首先需要打开一个输入流或输出流，连接到相应的数据源或目的地。
    • 读取或写入数据：根据流的类型，可以通过流对象读取或写入数据。
    • 关闭流：在操作完成后，应该关闭流以释放资源。
  • 按照各种角度分类IO流
  1. 数据流向分类：
    • 输入流（Input Stream）：用于从数据源（如文件、网络、内存等）读取数据。
    • 例如：InputStream、Reader 等。
    • 输出流（Output Stream）：用于向目标（如文件、网络、内存等）写入数据。
    • 例如：OutputStream、Writer 等。
  2. 处理方式分类：
    • 节点流（Node Stream）：直接与数据源或目标进行交互，不依赖其他流的装饰。
    • 例如：FileInputStream、FileOutputStream、FileReader、FileWriter 等。
    • 处理流（Processing Stream）：基于其他流进行功能增强或处理，可以通过装饰器模式来组合多个流。
    • 例如：BufferedInputStream、BufferedOutputStream、BufferedReader、BufferedWriter 等。
  3. 功能分类：
    • 字节流（Byte Streams）：以字节为单位读写数据。
    • 例如：InputStream、OutputStream。
    • 字符流（Character Streams）：以字符为单位读写数据，处理字符编码。
    • 例如：Reader、Writer。
    • 对象流（Object Streams）：用于序列化和反序列化对象。
    • 例如：ObjectInputStream、ObjectOutputStream。
    • 数组流（Array Streams）：直接操作数组作为数据源或目标。
    • 例如：ByteArrayInputStream、ByteArrayOutputStream。

FileReader和FileWriter

FileReader

FileReader 类用于读取字符文件。它继承自 InputStreamReader 类，可以读取字符流。你可以使用 FileReader 来读取文本文件中的字符数据。

FileReader fileReader = new FileReader("file.txt");
int character;
while ((character = fileReader.read()) != -1) {
    System.out.print((char) character);
}
fileReader.close();

FileWriter

FileWriter 类用于写入字符到文件。它继承自 OutputStreamWriter 类，可以写入字符流。你可以使用 FileWriter 来将字符写入文件中。

FileWriter fileWriter = new FileWriter("output.txt");
fileWriter.write("Hello, World!");
fileWriter.close();

完整例子

import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;

public class FileCopyExample {
    public static void main(String[] args) {
        FileReader fileReader = null;
        FileWriter fileWriter = null;

        try {
            fileReader = new FileReader("input.txt");
            fileWriter = new FileWriter("output.txt");

            int character;
            while ((character = fileReader.read()) != -1) {
                fileWriter.write(character);
            }

            System.out.println("File copied successfully!");
        } catch (IOException e) {
            System.err.println("Error reading/writing the file: " + e.getMessage());
        } finally {
            try {
                if (fileReader != null) {
                    fileReader.close();
                }
                if (fileWriter != null) {
                    fileWriter.close();
                }
            } catch (IOException e) {
                System.err.println("Error closing the file: " + e.getMessage());
            }
        }
    }
}

FileInputStream和FileOutputStream的使用

  • FileInputStream类用于从文件系统中的文件读取字节。它继承自InputStream类，可以用来读取字节流。
  • FileOutputStream类用于向文件系统中的文件写入字节。它继承自OutputStream类，可以用来写入字节流。
  • 这两个类通常与其他类一起使用，例如BufferedInputStream和BufferedOutputStream，以提高读写文件的性能。在使用这两个类时，记得在结束时关闭文件流以释放资源，可以使用close()方法来关闭文件流。
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;

public class FileCopyExample {
    public static void main(String[] args) {
        try (FileInputStream fis = new FileInputStream("input.txt");
             FileOutputStream fos = new FileOutputStream("output.txt")) {

            byte[] buffer = new byte[1024];
            int length;
            while ((length = fis.read(buffer)) > 0) {
                fos.write(buffer, 0, length);
            }

            System.out.println("File copied successfully.");
        } catch (IOException e) {
            e.printStackTrace();
        }finally{
            fis.close();
            fos.close();
        }
    }
}

缓冲流

BufferedInputStream与BufferedOutputStream

  • BufferedInputStream：
    • BufferedInputStream继承自FilterInputStream，它提供了一个缓冲区来读取输入流。通过缓冲数据，它可以减少与底层文件系统的交互次数，从而提高读取性能。
  • BufferedOutputStream：
    • BufferedOutputStream继承自FilterOutputStream，它提供了一个缓冲区来写入输出流。通过缓冲数据，它可以减少与底层文件系统的交互次数，提高写入性能。
  • 可以看作内部维护了一个缓冲区（byte 数组），调用 read() 方法时，它会尽可能多地从底层输入流中读取数据到缓冲区，然后逐步从缓冲区中返回数据，减少了对底层输入流的实际读取次数
import java.io.*;

public class BufferedStreamExample {
    public static void main(String[] args) {
        try (BufferedInputStream bis = new BufferedInputStream(new FileInputStream("input.txt"));
             BufferedOutputStream bos = new BufferedOutputStream(new FileOutputStream("output.txt"))) {

            int data;
            while ((data = bis.read()) != -1) {
                bos.write(data);
            }
        } catch (IOException e) {
            e.printStackTrace();
        }finally{
            bis.close();
            bos.close();
        }
    }
}

BufferedReader与BufferedWriter

  • BufferedReader：
    • BufferedReader继承自Reader类，它提供了缓冲字符输入的功能，可以一次读取一行字符数据，提高读取文本文件的效率。
  • BufferedWriter：
    • BufferedWriter继承自Writer类，它提供了缓冲字符输出的功能，可以一次写入一行字符数据，提高写入文本文件的效率。
  • 内部维护了一个缓冲区（byte 数组），当你调用 read() 方法时，它会尽可能多地从底层输入流中读取数据到缓冲区，然后逐步从缓冲区中返回数据，减少了对底层输入流的实际读取次数
import java.io.*;

public class BufferedReadWriteExample {
    public static void main(String[] args) {
        try (BufferedReader reader = new BufferedReader(new FileReader("input.txt"));
             BufferedWriter writer = new BufferedWriter(new FileWriter("output.txt"))) {

            String line;
            while ((line = reader.readLine()) != null) {
                writer.write(line);
                writer.newLine(); // 写入换行符
            }
        } catch (IOException e) {
            e.printStackTrace();
        }finally{
           reader.close();
           writer.close();
        }
    }
}

转换流

  • 转换流是用来在字节流和字符流之间进行转换的流。常用的转换流有InputStreamReader和OutputStreamWriter。

InputStreamReader:

  • InputStreamReader是字节流到字符流的桥梁，它将字节流转换为字符流。可以指定字符编码来读取字节流并将其转换为字符流。
FileInputStream fis = new FileInputStream("input.txt");//创建字节流
InputStreamReader isr = new InputStreamReader(fis, "UTF-8");//将字节流转换为utf-8
BufferedReader reader = new BufferedReader(isr);//将转换流包装一个buffer

String line;
while ((line = reader.readLine()) != null) {
    System.out.println(line);
}

reader.close();

OutputStreamWriter:

  • OutputStreamWriter是字符流到字节流的桥梁，它将字符流转换为字节流。同样可以指定字符编码来将字符流转换为字节流。
FileOutputStream fos = new FileOutputStream("output.txt");//
OutputStreamWriter osw = new OutputStreamWriter(fos, "UTF-8");
BufferedWriter writer = new BufferedWriter(osw);

writer.write("Hello, World!");
writer.newLine();
writer.close();

对象流

  • Java中的对象流是指用于在Java中进行对象序列化和反序列化的流。对象流包括ObjectInputStream和ObjectOutputStream。
  • ObjectInputStream：用于从输入流中读取对象。它可以读取通过ObjectOutputStream写入的对象，并将其转换回Java对象。
  • ObjectOutputStream：用于将对象写入输出流。它可以将Java对象转换为字节流，并写入输出流，以便可以在需要时进行反序列化。

对象的序列化机制

  • Java 中的对象序列化机制允许将对象转换为字节流，以便在网络上传输或保存到文件中。
  • 对象序列化的主要作用是将对象的状态保存为字节流的形式，以便在需要时可以重新创建对象。
  • 在 Java 中，对象序列化主要通过 java.io.Serializable 接口和 ObjectOutputStream、ObjectInputStream 类来实现。
  • 要使一个类支持序列化，需要让该类实现 Serializable 接口，这是一个标记接口，没有任何需要实现的方法。一旦一个类实现了 Serializable 接口，就可以使用 ObjectOutputStream 类将对象序列化为字节流，以便保存到文件或发送到网络。相应地，可以使用 ObjectInputStream 类将字节流反序列化为对象。
  • 在序列化过程中，Java 将对象转换为字节流，并将对象的状态保存在字节流中，包括对象的数据和类信息。在反序列化过程中，Java 根据字节流重新创建对象，并恢复对象的状态。
  • 需要注意的是，序列化并不保存静态变量，因为静态变量属于类而不是对象。此外，如果一个类的父类没有实现 Serializable 接口，那么子类在序列化时会调用父类的无参构造方法来创建父类对象，而不会序列化父类的状态。
  • 如果不声明serialVersionUID,系统会自动声明一个针对于当前类的serialVersionUID如果修改此类的话，会导致serialVersionUID变化，进而导致反序列化时出现InvalidClassException
  • 自定义类进行序列化时对于引用数据类型的属性也要实现Serializable接口
import java.io.*;

// 定义一个简单的Java类，用于序列化和反序列化
class Person implements Serializable {
    private String name;
    private int age;

    public Person(String name, int age) {
        this.name = name;
        this.age = age;
    }

    @Override
    public String toString() {
        return "Person{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }
}

public class ObjectStreamExample {
    public static void main(String[] args) {
        // 创建一个Person对象
        Person person = new Person("Alice", 30);

        // 序列化对象并写入文件
        try (ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream("person.ser"))) {
            oos.writeObject(person);
            System.out.println("Person对象已序列化并写入文件");
        } catch (IOException e) {
            e.printStackTrace();
        }

        // 从文件中读取对象并反序列化
        try (ObjectInputStream ois = new ObjectInputStream(new FileInputStream("person.ser"))) {
            Person deserializedPerson = (Person) ois.readObject();
            System.out.println("从文件中读取的Person对象: " + deserializedPerson);
        } catch (IOException | ClassNotFoundException e) {
            e.printStackTrace();
        }
    }
}
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值