【Java 基础】带你学习 Java IO流

旧城等待， 2024-05-04 08:05 71阅读 0赞

![在这里插入图片描述][a9245b922eaa49c4a617ff8110f1fd8a.png]

> ?**博主介绍**： 博主从事应用安全和大数据领域，有8年研发经验，5年面试官经验，Java技术专家，WEB架构师，阿里云专家博主，华为云云享专家，51CTO 专家博主

⛪️ 个人社区：[个人社区][Link 1]  
? 个人主页：[个人主页][Link 2]  
? 专栏地址： ✅ [Java 进阶之路][Java]  
?八股文专题：[剑指大厂，手撕 Java 八股文][Java 1]

#### 文章目录 ####

*   *   *  一、File类对文件的操作
         *   *  1.1、案例
         *  二、lO流的概述和分类
         *  三、标准输入输出流FileOutputStream和FilelnputStream
         *  四、文件读写FileWriter和FileReader
         *  五、字符缓冲流的使用BufferedInputStream和BufferedOutputStream

#### 一、File类对文件的操作 ####

File类是Java中用于对文件和目录进行操作的类。它提供了一系列方法来创建、删除、重命名、获取文件属性等操作。

下面是一些常用的File类方法介绍：

1.  `boolean createNewFile()` ：创建一个新文件。如果文件已存在，则返回false。
2.  `boolean delete()` ：删除文件或目录。如果删除成功，则返回true。如果删除的是目录且目录不为空，则删除失败并返回false。
3.  `boolean exists()` ：判断文件或目录是否存在。
4.  `boolean isDirectory()` ：判断当前File对象是否表示一个目录。
5.  `boolean isFile()` ：判断当前File对象是否表示一个文件。
6.  `String[] list()` ：返回目录中的文件和子目录的名称数组。
7.  `boolean mkdir()` ：创建一个新目录。
8.  `boolean mkdirs()` ：创建一个新目录，包括任何必需但不存在的父目录。
9.  `boolean renameTo(File dest)` ：将当前File对象所表示的文件或目录重命名为指定的目标文件或目录。
10. `long length()` ：获取文件的大小（字节数）。

这些方法可以帮助我们在Java中对文件和目录进行操作。需要注意的是，File类只提供了对文件和目录的基本操作，如果需要更复杂的文件操作（如读写文件内容），可以使用其他相关的类和方法，如InputStream、OutputStream、Reader、Writer等。

##### 1.1、案例 #####

File类的案例：

import java.io.File;
    
    public class FileExample {
        
        public static void main(String[] args) {
        
            // 创建一个File对象，表示文件或目录的路径
            File file = new File("D:/myfolder/myfile.txt");
             // 判断文件或目录是否存在
            if (file.exists()) {
        
                System.out.println("文件或目录存在");
                 // 判断是否是目录
                if (file.isDirectory()) {
        
                    System.out.println("这是一个目录");
                     // 获取目录中的文件和子目录的名称数组
                    String[] fileList = file.list();
                    for (String name : fileList) {
        
                        System.out.println(name);
                    }
                } else {
        
                    System.out.println("这是一个文件");
                     // 获取文件的大小
                    long fileSize = file.length();
                    System.out.println("文件大小为：" + fileSize + "字节");
                }
            } else {
        
                System.out.println("文件或目录不存在");
            }
        }
    }

在上面的例子中，我们创建了一个File对象来表示路径为"D:/myfolder/myfile.txt"的文件。然后使用exists()方法判断文件是否存在，如果存在则判断是文件还是目录。如果是目录，则使用list()方法获取目录中的文件和子目录的名称数组，并打印出来。如果是文件，则使用length()方法获取文件的大小，并打印出来。

这只是File类的一个简单示例，File类还提供了其他一些方法，如创建文件或目录、删除文件或目录、重命名文件或目录等。根据具体需求，可以使用不同的方法来操作文件和目录。

#### 二、lO流的概述和分类 ####

IO流（Input/Output Stream）是Java中用于处理输入和输出操作的机制。它提供了一种统一的方式来处理不同来源和目的地的数据流。IO流可以分为输入流和输出流，根据数据流向的不同，又可以分为字节流和字符流。

1.  字节流（Byte Stream）：

*  InputStream：字节输入流的抽象基类，用于从各种数据源（如文件、网络连接等）读取字节数据。
 *  OutputStream：字节输出流的抽象基类，用于向各种目的地（如文件、网络连接等）写入字节数据。

1.  字符流（Character Stream）：

*  Reader：字符输入流的抽象基类，用于从各种数据源读取字符数据。
 *  Writer：字符输出流的抽象基类，用于向各种目的地写入字符数据。

字节流和字符流的区别在于处理的数据单位不同。字节流以字节为单位进行读写操作，适用于处理二进制数据或者文本数据。字符流以字符为单位进行读写操作，适用于处理文本数据，可以自动处理字符编码和解码的问题。

此外，IO流还可以按照数据处理的方式进行分类：

1.  节点流（Node Stream）：直接与数据源或目的地进行交互，例如FileInputStream、FileOutputStream等。
2.  处理流（Filter Stream）：对已有的流进行包装，提供额外的功能，例如BufferedInputStream、BufferedOutputStream等。

处理流可以提供缓冲、压缩、加密等功能，以提高读写的效率和安全性。  
IO流是Java中进行输入和输出操作的重要机制，它提供了丰富的类和方法来满足不同的需求。在使用IO流时，需要注意正确地打开、关闭流，以避免资源泄露和数据丢失的问题。

可以学习这篇文章：[https://jiliu.blog.csdn.net/article/details/131105195][https_jiliu.blog.csdn.net_article_details_131105195]

#### 三、标准输入输出流FileOutputStream和FilelnputStream ####

FileOutputStream和FileInputStream是Java中用于文件输入输出的类。它们分别用于向文件写入数据和从文件读取数据。

1.  **FileOutputStream**：  
    FileOutputStream是OutputStream的子类，用于向文件写入数据。它可以创建一个输出流，将数据写入到指定的文件中。以下是使用FileOutputStream的示例：

import java.io.FileOutputStream;
    import java.io.IOException;
    
    public class FileOutputStreamExample {
        
        public static void main(String[] args) {
        
            try {
        
                // 创建一个FileOutputStream对象，指定文件路径
                FileOutputStream fos = new FileOutputStream("D:/myfolder/myfile.txt");
                 // 写入数据
                String data = "Hello, World!";
                byte[] bytes = data.getBytes();
                fos.write(bytes);
                 // 关闭流
                fos.close();
                 System.out.println("数据写入成功！");
            } catch (IOException e) {
        
                e.printStackTrace();
            }
        }
    }

我们创建了一个FileOutputStream对象来写入数据到文件"D:/myfolder/myfile.txt"中。首先，我们将要写入的数据转换为字节数组，然后使用write()方法将字节数组写入到文件中。最后，我们关闭流。

1.  **FileInputStream**：  
    FileInputStream是InputStream的子类，用于从文件中读取数据。它可以创建一个输入流，从指定的文件中读取数据。以下是使用FileInputStream的示例：

import java.io.FileInputStream;
    import java.io.IOException;
    
    public class FileInputStreamExample {
        
        public static void main(String[] args) {
        
            try {
        
                // 创建一个FileInputStream对象，指定文件路径
                FileInputStream fis = new FileInputStream("D:/myfolder/myfile.txt");
                 // 读取数据
                byte[] bytes = new byte[1024];
                int length = fis.read(bytes);
                 // 将字节数组转换为字符串并输出
                String data = new String(bytes, 0, length);
                System.out.println("读取的数据为：" + data);
                 // 关闭流
                fis.close();
            } catch (IOException e) {
        
                e.printStackTrace();
            }
        }
    }

我们创建了一个FileInputStream对象来从文件"C:/myfolder/myfile.txt"中读取数据。我们首先创建一个字节数组来存储读取的数据，然后使用read()方法读取数据到字节数组中，并返回读取的字节数。最后，我们将字节数组转换为字符串并输出。最后，我们关闭流。

#### 四、文件读写FileWriter和FileReader ####

FileWriter和FileReader是Java中用于文件读写的类。它们分别用于向文件写入数据和从文件读取数据。

1.  FileWriter：  
    FileWriter是Writer的子类，用于向文件写入数据。它可以创建一个输出流，将数据写入到指定的文件中。以下是使用FileWriter的示例：

import java.io.FileWriter;
    import java.io.IOException;
    
    public class FileWriterExample {
        
        public static void main(String[] args) {
        
            try {
        
                // 创建一个FileWriter对象，指定文件路径
                FileWriter writer = new FileWriter("D:/myfolder/myfile.txt");
                 // 写入数据
                String data = "Hello, World!";
                writer.write(data);
                 // 关闭流
                writer.close();
                 System.out.println("数据写入成功！");
            } catch (IOException e) {
        
                e.printStackTrace();
            }
        }
    }

我们创建了一个FileWriter对象来写入数据到文件"D:/myfolder/myfile.txt"中。首先，我们将要写入的数据存储在一个字符串变量中，然后使用write()方法将数据写入到文件中。最后，我们关闭流。

1.  **FileReader**：  
    FileReader是Reader的子类，用于从文件中读取数据。它可以创建一个输入流，从指定的文件中读取数据。以下是使用FileReader的示例：

import java.io.FileReader;
    import java.io.IOException;
    
    public class FileReaderExample {
        
        public static void main(String[] args) {
        
            try {
        
                // 创建一个FileReader对象，指定文件路径
                FileReader reader = new FileReader("D:/myfolder/myfile.txt");
                 // 读取数据
                char[] buffer = new char[1024];
                int length = reader.read(buffer);
                 // 将字符数组转换为字符串并输出
                String data = new String(buffer, 0, length);
                System.out.println("读取的数据为：" + data);
                 // 关闭流
                reader.close();
            } catch (IOException e) {
        
                e.printStackTrace();
            }
        }
    }

我们创建了一个FileReader对象来从文件"C:/myfolder/myfile.txt"中读取数据。我们首先创建一个字符数组来存储读取的数据，然后使用read()方法读取数据到字符数组中，并返回读取的字符数。最后，我们将字符数组转换为字符串并输出。最后，我们关闭流。

#### 五、字符缓冲流的使用BufferedInputStream和BufferedOutputStream ####

BufferedInputStream和BufferedOutputStream是Java中用于字符缓冲流的类。它们分别用于对输入流和输出流进行缓冲操作，提高读写性能。

1.  **BufferedInputStream**：  
    BufferedInputStream是InputStream的子类，用于对输入流进行缓冲操作。它可以创建一个输入流，并对其进行缓冲，从而提高读取数据的效率。以下是使用BufferedInputStream的示例：

import java.io.BufferedInputStream;
    import java.io.FileInputStream;
    import java.io.IOException;
    
    public class BufferedInputStreamExample {
        
        public static void main(String[] args) {
        
            try {
        
                // 创建一个FileInputStream对象，指定文件路径
                FileInputStream fileInputStream = new FileInputStream("D:/myfolder/myfile.txt");
                 // 创建一个BufferedInputStream对象，传入FileInputStream对象
                BufferedInputStream bufferedInputStream = new BufferedInputStream(fileInputStream);
                 // 读取数据
                int data;
                while ((data = bufferedInputStream.read()) != -1) {
        
                    System.out.print((char) data);
                }
                 // 关闭流
                bufferedInputStream.close();
            } catch (IOException e) {
        
                e.printStackTrace();
            }
        }
    }

我们创建了一个FileInputStream对象来读取文件"D:/myfolder/myfile.txt"。然后，我们创建一个BufferedInputStream对象，并将FileInputStream对象传递给它。接下来，我们使用read()方法从缓冲区中读取数据，并将其转换为字符后输出。最后，我们关闭流。

1.  **BufferedOutputStream**：  
    BufferedOutputStream是OutputStream的子类，用于对输出流进行缓冲操作。它可以创建一个输出流，并对其进行缓冲，从而提高写入数据的效率。以下是使用BufferedOutputStream的示例：

import java.io.BufferedOutputStream;
    import java.io.FileOutputStream;
    import java.io.IOException;
    
    public class BufferedOutputStreamExample {
        
        public static void main(String[] args) {
        
            try {
        
                // 创建一个FileOutputStream对象，指定文件路径
                FileOutputStream fileOutputStream = new FileOutputStream("D:/myfolder/myfile.txt");
                 // 创建一个BufferedOutputStream对象，传入FileOutputStream对象
                BufferedOutputStream bufferedOutputStream = new BufferedOutputStream(fileOutputStream);
                 // 写入数据
                String data = "Hello, World!";
                bufferedOutputStream.write(data.getBytes());
                 // 关闭流
                bufferedOutputStream.close();
                 System.out.println("数据写入成功！");
            } catch (IOException e) {
        
                e.printStackTrace();
            }
        }
    }

我们创建了一个FileOutputStream对象来写入文件"D:/myfolder/myfile.txt"。然后，我们创建一个BufferedOutputStream对象，并将FileOutputStream对象传递给它。接下来，我们使用write()方法将数据写入缓冲区。最后，我们关闭流。

>  精彩专栏推荐订阅：在下方专栏??  
>  ✅ [2023年华为OD机试真题（A卷&B卷）+ 面试指导 ][2023_OD_A_B_ _]  
>  ✅ [ 精选100套 Java 项目案例 ][_100_ Java _]  
>  ✅ [面试需要避开的坑（活动）][Link 3]  
>  ✅ [你找不到的核心代码][Link 4]  
>  ✅ [带你手撕 Spring][Spring]

> ?? 本文由激流原创，原创不易，希望大家关注、点赞、收藏，给博主一点鼓励，感谢！！！

![在这里插入图片描述][7b7478e55aa24a948b358051ef941b6a.webp_pic_center]

[a9245b922eaa49c4a617ff8110f1fd8a.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/05/04/81a612fd84d84987a9aa3b38e435560f.png
[Link 1]: https://bbs.csdn.net/forums/45c04d3f41cc4dadaf312be1d1379b45?category=10003
[Link 2]: https://jiliu.blog.csdn.net/
[Java]: https://blog.csdn.net/qq_37967783/category_9902143.html
[Java 1]: https://blog.csdn.net/qq_37967783/article/details/130940512
[https_jiliu.blog.csdn.net_article_details_131105195]: https://jiliu.blog.csdn.net/article/details/131105195
[2023_OD_A_B_ _]: https://blog.csdn.net/qq_37967783/category_12389634.html
[_100_ Java _]: https://blog.csdn.net/qq_37967783/category_12388267.html
[Link 3]: https://blog.csdn.net/qq_37967783/category_12380337.html
[Link 4]: https://blog.csdn.net/qq_37967783/category_12391346.html
[Spring]: https://blog.csdn.net/qq_37967783/category_12391987.html
[7b7478e55aa24a948b358051ef941b6a.webp_pic_center]: https://img-blog.csdnimg.cn/7b7478e55aa24a948b358051ef941b6a.webp#pic_center