Java IO流：读写文件的基础操作

# 1. Java IO流简介

## 1.1 IO流的概念

IO即Input/Output，是指输入和输出。在Java中，IO流用于处理设备之间的数据传输。输入流用于从设备读取数据，输出流用于向设备写入数据。

## 1.2 IO流的分类

IO流可以根据数据流向分为输入流和输出流，根据处理数据类型分为字节流和字符流。

- 输入流：用于从外部读取数据的流，如InputStream、Reader等。
- 输出流：用于向外部写入数据的流，如OutputStream、Writer等。
- 字节流：以字节为单位进行数据操作的流，如InputStream、OutputStream。
- 字符流：以字符为单位进行数据操作的流，如Reader、Writer。

## 1.3 IO流的基本原理

IO流通过将数据封装成流的形式进行传输，数据源可以是文件、网络连接、内存等。在流中，数据按照FIFO（先进先出）的顺序传输，读取和写入的操作分别对应读取和写入流的操作。

# 2. 文件读取操作

在Java中，我们可以使用IO流来进行文件的读取操作。文件读取的过程是将文件中的数据读取到程序中进行处理的过程。下面将介绍几种常用的文件读取操作方法。

#### 2.1 使用InputStream读取文件

import java.io.File;
import java.io.FileInputStream;
import java.io.IOException;
import java.io.InputStream;

public class FileInputStreamExample {
    public static void main(String[] args) {
        File file = new File("test.txt");
        try (InputStream inputStream = new FileInputStream(file)) {
            int data;
            while ((data = inputStream.read()) != -1) {
                System.out.print((char) data);
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

代码解析：

- 首先创建一个File对象，指定要读取的文件路径。
- 然后创建一个FileInputStream对象，并将File对象传入其中。
- 使用InputStream的`read()`方法读取文件内容，每次读取一个字节，并将其转换成字符输出。
- 当读取到文件末尾时，`read()`方法会返回-1，循环结束。

#### 2.2 使用BufferedInputStream提高读取效率

import java.io.BufferedInputStream;
import java.io.File;
import java.io.FileInputStream;
import java.io.IOException;
import java.io.InputStream;

public class BufferedInputStreamExample {
    public static void main(String[] args) {
        File file = new File("test.txt");
        try (InputStream inputStream = new BufferedInputStream(new FileInputStream(file))) {
            byte[] buffer = new byte[1024];
            int bytesRead;
            while ((bytesRead = inputStream.read(buffer)) != -1) {
                System.out.print(new String(buffer, 0, bytesRead));
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

代码解析：

- 首先创建一个File对象，指定要读取的文件路径。
- 接着创建一个FileInputStream对象，并将File对象传入其中。
- 再将FileInputStream对象传入BufferedInputStream的构造函数中，创建一个BufferedInputStream对象。
- 使用BufferedInputStream的`read(byte[] buffer)`方法读取文件内容，每次读取一定长度的字节，并将其转换成字符串输出。
- 当读取到文件末尾时，`read()`方法会返回-1，循环结束。

#### 2.3 使用FileReader和BufferedReader读取文本文件

import java.io.BufferedReader;
import java.io.File;
import java.io.FileReader;
import java.io.IOException;

public class BufferedReaderExample {
    public static void main(String[] args) {
        File file = new File("test.txt");
        try (BufferedReader reader = new BufferedReader(new FileReader(file))) {
            String line;
            while ((line = reader.readLine()) != null) {
                System.out.println(line);
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

代码解析：

- 首先创建一个File对象，指定要读取的文件路径。
- 接着创建一个FileReader对象，并将File对象传入其中。
- 再将FileReader对象传入BufferedReader的构造函数中，创建一个BufferedReader对象。
- 使用BufferedReader的`readLine()`方法逐行读取文件内容，并将每行内容输出。
- 当读取到文件末尾时，`readLine()`方法会返回null，循环结束。

#### 2.4 使用Scanner读取文件内容

import java.io.File;
import java.io.FileNotFoundException;
import java.util.Scanner;

public class ScannerExample {
    public static void main(String[] args) {
        File file = new File("test.txt");
        try (Scanner scanner = new Scanner(file)) {
            while (scanner.hasNextLine()) {
                String line = scanner.nextLine();
                System.out.println(line);
            }
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        }
    }
}

代码解析：

- 首先创建一个File对象，指定要读取的文件路径。
- 接着创建一个Scanner对象，并将File对象传入其中。
- 使用Scanner的`hasNextLine()`方法判断文件是否还有下一行内容。
- 使用Scanner的`nextLine()`方法读取文件的下一行内容，并将其输出。
- 当读取到文件末尾时，`hasNextLine()`方法返回false，循环结束。

以上是几种常用的文件读取操作方法，根据不同的需求，可以选择使用合适的方法来读取文件内容。

# 3. 文件写入操作

文件写入操作是IO流操作中的重要部分，可以通过不同的方式将数据写入到文件中。下面将介绍几种常见的文件写入操作及其使用方法。

#### 3.1 使用OutputStream写入文件

在Java中，可以使用OutputStream来写入文件，这是一种字节流写入方式。下面是一个简单的示例：

public class WriteFileWithOutputStream {
    public static void main(String[] args) {
        String content = "Hello, this is a sample content to be written into the file.";

        try (OutputStream outputStream = new FileOutputStream("output.txt")) {
            byte[] bytes = content.getBytes();
            outputStream.write(bytes);
            System.out.println("Data has been written to the file.");
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

在上面的示例中，我们创建了一个OutputStream并指定了要写入的文件名，然后将内容转换为字节数组并写入文件。需要注意的是，使用完OutputStream后需要手动关闭流。

#### 3.2 使用BufferedOutputStream提高写入效率

为了提高写入效率，可以使用BufferedOutputStream进行包装。下面是一个使用BufferedOutputStream的示例：

public class WriteFileWithBufferedOutputStream {
    public static void main(String[] args) {
        String content = "Hello, this is a sample content to be written into the file.";

        try (OutputStream outputStream = new BufferedOutputStream(new FileOutputStream("output.txt"))) {
            byte[] bytes = content.getBytes();
            outputStream.write(bytes);
            System.out.println("Data has been written to the file.");
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

通过BufferedOutputStream可以提高写入效率，因为它会在内存中缓存一定量的数据，然后一次性写入文件。

#### 3.3 使用FileWriter和BufferedWriter写入文本文件

除了使用字节流进行文件写入外，还可以使用字符流来写入文本文件。下面是使用FileWriter和BufferedWriter的示例：

public class WriteFileWithBufferedWriter {
    public static void main(String[] args) {
        String content = "Hello, this is a sample content to be written into the file.";

        try (BufferedWriter writer = new BufferedWriter(new FileWriter("output.txt"))) {
            writer.write(content);
            System.out.println("Data has been written to the file.");
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

使用字符流进行文件写入时可以直接操作字符串，更加方便快捷。

#### 3.4 使用PrintWriter写入文件内容

PrintWriter是一个方便的打印流，可以用于写入文本数据到文件中。下面是一个使用PrintWriter写入文件内容的示例：

public class WriteFileWithPrintWriter {
    public static void main(String[] args) {
        String content = "Hello, this is a sample content to be written into the file.";

        try (PrintWriter writer = new PrintWriter("output.txt")) {
            writer.println(content);
            System.out.println("Data has been written to the file.");
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        }
    }
}

使用PrintWriter可以直接使用println来写入一行文本内容，非常方便实用。

通过以上介绍，我们可以选择合适的方式进行文件写入操作，根据实际需求来提高效率或者简化操作。

# 4. 文件操作实例

#### 4.1 读取文件内容并显示在控制台

在这个示例中，我们将演示如何使用Java的IO流读取文件内容并将其显示在控制台上。

import java.io.*;

public class ReadFileExample {
    public static void main(String[] args) {
        File file = new File("example.txt");
        try (FileReader reader = new FileReader(file);
             BufferedReader br = new BufferedReader(reader)) {
            String line;
            while ((line = br.readLine()) != null) {
                System.out.println(line);
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

代码解释：
- 首先创建一个File对象来表示要读取的文件。
- 使用FileReader和BufferedReader来按行读取文件内容，并将每行内容输出到控制台。
- 在最后使用try-with-resources语句来自动关闭文件资源，避免资源泄露。

代码总结：通过上述代码，我们可以实现对文件内容的逐行读取，并在控制台上进行显示。

结果说明：运行该程序，将会在控制台上逐行显示文件的内容。

#### 4.2 在文件末尾追加内容

在此示例中，我们将展示如何在Java中使用IO流在已有文件的末尾追加内容。

import java.io.*;

public class AppendToFileExample {
    public static void main(String[] args) {
        File file = new File("example.txt");
        try (FileWriter writer = new FileWriter(file, true);
             BufferedWriter bw = new BufferedWriter(writer);
             PrintWriter out = new PrintWriter(bw)) {
            out.println("This line is appended to the end of the file.");
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

代码解释：
- 创建File对象表示要进行操作的文件。
- 使用FileWriter和BufferedWriter来向文件中写入内容，设置FileWriter的第二个参数为true表示追加内容到文件末尾。
- 使用PrintWriter来实现向文件中写入内容的功能。
- 使用try-with-resources语句自动关闭文件资源，避免资源泄露。

代码总结：上述代码演示了如何向文件末尾追加内容。

结果说明：运行程序后，文件example.txt的末尾将追加一行内容。

#### 4.3 复制文件

在这个例子中，我们将学习如何使用Java的IO流来复制一个文件。

import java.io.*;

public class CopyFileExample {
    public static void main(String[] args) {
        File sourceFile = new File("source.txt");
        File destFile = new File("destination.txt");
        try (InputStream in = new FileInputStream(sourceFile);
             OutputStream out = new FileOutputStream(destFile)) {
            byte[] buffer = new byte[1024];
            int length;
            while ((length = in.read(buffer)) > 0) {
                out.write(buffer, 0, length);
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

代码解释：
- 创建源文件和目标文件的File对象。
- 使用FileInputStream和FileOutputStream来实现文件的复制操作。
- 通过循环从源文件读取数据，并将数据写入目标文件。
- 使用try-with-resources语句自动关闭文件资源。

代码总结：上述代码实现了文件的复制操作。

结果说明：运行程序后，源文件source.txt的内容将被复制到目标文件destination.txt中。

#### 4.4 删除文件

在这个例子中，我们会展示如何使用Java的IO流来删除文件。

import java.io.*;

public class DeleteFileExample {
    public static void main(String[] args) {
        File file = new File("toBeDeleted.txt");
        if(file.delete()){
            System.out.println(file.getName() + " 文件已被删除！");
        }else{
            System.out.println("文件删除失败。");
        }
    }
}

代码解释：
- 创建File对象表示要删除的文件。
- 使用File的delete()方法来删除文件。
- 根据delete()的返回值来判断文件是否成功被删除。

代码总结：上述代码演示了如何在Java中使用IO流来删除文件。

结果说明：运行该程序后，将会在控制台输出文件是否成功被删除。

以上就是文件操作实例的内容，包括读取文件内容、在文件末尾追加内容、复制文件和删除文件等常见操作。

# 5. 异常处理与资源关闭

在文件操作过程中，可能会出现各种IO异常，如文件不存在、权限不足等，因此在进行IO操作时需要对异常进行处理。另外，为了确保程序正常运行并释放资源，需要及时关闭IO流。

### 5.1 IO异常的处理

在Java中，IO异常通常需要使用try-catch语句进行处理。以下是一个简单的文件读取示例，并对可能出现的IO异常进行了处理：

import java.io.*;

public class FileReadExample {
    public static void main(String[] args) {
        try {
            File file = new File("example.txt");
            FileReader reader = new FileReader(file);
            BufferedReader br = new BufferedReader(reader);

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

            br.close();
        } catch (IOException e) {
            System.out.println("出现IO异常：" + e.getMessage());
        }
    }
}

在上面的示例中，我们使用try-catch语句捕获可能出现的IOException。这样可以在出现异常时进行相应的处理，比如打印异常信息或者进行其他操作。

### 5.2 try-with-resources语句简化资源关闭

除了使用try-catch语句外，Java 7引入了try-with-resources语句，可以简化资源关闭的操作。使用try-with-resources语句可以自动关闭实现了AutoCloseable接口的资源，无需显式调用close()方法。以下是一个使用try-with-resources语句的示例：

import java.io.*;

public class TryWithResourcesExample {
    public static void main(String[] args) {
        File file = new File("example.txt");
        try (BufferedReader br = new BufferedReader(new FileReader(file))) {
            String line;
            while ((line = br.readLine()) != null) {
                System.out.println(line);
            }
        } catch (IOException e) {
            System.out.println("出现IO异常：" + e.getMessage());
        }
    }
}

在上面的示例中，我们使用try-with-resources语句声明了BufferedReader，当try块执行完毕时，会自动调用BufferedReader的close()方法关闭资源，无需手动调用close()方法。

通过合理处理IO异常和及时关闭资源，可以保证程序的稳定性和安全性。

# 6. NIO中的文件操作

### 6.1 NIO概述

Java NIO（New IO）是一个提供了非阻塞IO操作的新API，在Java 1.4版本中引入。相比传统的IO流，NIO提供了更高效的文件读写操作以及更好的可扩展性。

NIO主要包括以下几个核心组件：
- 通道（Channel）：负责数据的读取和写入，可以与多个缓冲区进行交互。
- 缓冲区（Buffer）：用于存储数据，可以读取和写入数据。
- 选择器（Selector）：用于监听多个通道的事件，实现多路复用。

NIO的特点包括：
- 非阻塞IO：可以在同一个线程内同时处理多个连接。
- 可选择的文件读写：可以指定读写的位置。
- 内存映射文件：可以直接在内存中读写文件。

### 6.2 使用Channel和Buffer进行文件读写

在NIO中，文件读写主要通过Channel和Buffer来完成。下面是一个简单的示例代码：

import java.io.FileInputStream;
import java.nio.ByteBuffer;
import java.nio.channels.FileChannel;

public class FileReadExample {
    public static void main(String[] args) {
        try {
            // 创建文件输入流
            FileInputStream fis = new FileInputStream("test.txt");
            // 获取文件通道
            FileChannel channel = fis.getChannel();
            // 创建缓冲区
            ByteBuffer buffer = ByteBuffer.allocate(1024);
            // 读取文件数据到缓冲区
            int bytesRead = channel.read(buffer);
            while (bytesRead != -1) {
                // 切换到读取模式
                buffer.flip();
                // 从缓冲区读取数据并输出到控制台
                while (buffer.hasRemaining()) {
                    System.out.print((char) buffer.get());
                }
                // 清空缓冲区
                buffer.clear();
                // 继续读取文件数据到缓冲区
                bytesRead = channel.read(buffer);
            }
            // 关闭文件通道和输入流
            channel.close();
            fis.close();
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

代码解析：
1. 创建一个文件输入流。
2. 获取文件通道。
3. 创建一个缓冲区，设置缓冲区大小为1024字节。
4. 从文件通道读取数据到缓冲区，并返回读取的字节数。
5. 循环遍历缓冲区中的数据，将其转换为字符并输出到控制台。
6. 清空缓冲区。
7. 继续读取文件数据到缓冲区，直到读取到末尾。
8. 关闭文件通道和输入流。

### 6.3 文件操作实例

下面是一个使用NIO进行文件复制的实例代码：

import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.nio.ByteBuffer;
import java.nio.channels.FileChannel;

public class FileCopyExample {
    public static void main(String[] args) {
        try {
            // 创建文件输入流和输出流
            FileInputStream fis = new FileInputStream("source.txt");
            FileOutputStream fos = new FileOutputStream("target.txt");

            // 获取输入流和输出流的通道
            FileChannel sourceChannel = fis.getChannel();
            FileChannel targetChannel = fos.getChannel();

            // 创建缓冲区
            ByteBuffer buffer = ByteBuffer.allocate(1024);

            // 从输入流通道读取数据到缓冲区
            int bytesRead = sourceChannel.read(buffer);

            while (bytesRead != -1) {
                // 切换到读取模式
                buffer.flip();

                // 从缓冲区读取数据并写入到输出流通道
                while (buffer.hasRemaining()) {
                    targetChannel.write(buffer);
                }

                // 清空缓冲区
                buffer.clear();

                // 继续从输入流通道读取数据到缓冲区
                bytesRead = sourceChannel.read(buffer);
            }

            // 关闭输入流通道和输出流通道
            sourceChannel.close();
            targetChannel.close();

            // 关闭输入流和输出流
            fis.close();
            fos.close();

        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

代码解析：
1. 创建一个文件输入流和文件输出流。
2. 获取输入流和输出流的通道。
3. 创建一个缓冲区，设置缓冲区大小为1024字节。
4. 从输入流通道读取数据到缓冲区，并返回读取的字节数。
5. 循环遍历缓冲区中的数据，将其写入到输出流通道。
6. 清空缓冲区。
7. 继续从输入流通道读取数据到缓冲区，直到读取到末尾。
8. 关闭输入流通道和输出流通道。
9. 关闭输入流和输出流。

这样，我们就通过NIO完成了一个文件复制的操作。

本章介绍了Java NIO中的文件操作，包括使用Channel和Buffer进行文件读写以及一个文件复制的实例。NIO提供了更高效、可选择的文件读写方式，适用于对IO性能要求较高的场景。