14.java基础&IO流总结

掌握Java I/O流：打开编程的新大门 🚀📂

嗨，各位编程小伙伴们！在编程的世界里，I/O流（Input/Output Streams）是我们处理数据的利器。今天，我们一起来深入探讨Java I/O流，解锁编程的新境界！

🌐 字节流 vs 字符流：编码解码的奇妙之处

首先，让我们认识一下字节流和字符流。字节流处理二进制数据，而字符流则专注于文本数据，自动处理字符的编码和解码。这是我们与计算机交流的一种精妙方式。（详细内容可学习分析一下前两篇，有问题欢迎后台私信交流）

// 字节流示例

FileInputStream fis = new FileInputStream("example.txt");
int data;
while ((data = fis.read()) != -1) {
    // 处理二进制数据
}

fis.close();

// 字符流示例

FileReader reader = new FileReader("example.txt");
int charData;
while ((charData = reader.read()) != -1) {
    // 处理文本数据
}
reader.close();

📁 节点流 vs 处理流：基础和增强

节点流直接连接到数据源或目的地，是基本的I/O流。而处理流通过封装节点流，提供了额外的功能，例如缓冲以提高性能。

// 节点流示例

FileInputStream fis = new FileInputStream("example.txt");
// ...

// 处理流示例

BufferedInputStream bis = new BufferedInputStream(new FileInputStream("example.txt"));
// ...

📄 文件读写：开启数据之旅

处理文件是I/O流的常见任务。通过文件输入流和输出流，我们可以轻松地读取和写入文件。

// 文件读取

FileInputStream fis = new FileInputStream("example.txt");
// ...

// 文件写入

FileOutputStream fos = new FileOutputStream("output.txt");
fos.write("Hello, World!".getBytes());
fos.close();

📝 缓冲流：提高效率的秘密武器

缓冲流是处理流的一种，通过在内存中缓存数据，提高了读写的效率。BufferedReader和BufferedWriter是它们的代表。

// 缓冲读取

BufferedReader bufferedReader = new BufferedReader(new FileReader("example.txt"));
// ...

// 缓冲写入

BufferedWriter bufferedWriter = new BufferedWriter(new FileWriter("output.txt"));
// ...

🔄 对象序列化：数据的新形态

有时我们需要将对象保存到文件或通过网络传输。这就是对象序列化的用武之地。

// 对象序列化

ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream("object.dat"));
// ...

// 对象反序列化

ObjectInputStream ois = new ObjectInputStream(new FileInputStream("object.dat"));
// ...

🤹‍♀️ 异常处理：万事开头难

在编码过程中，I/O操作可能会抛出IOException等异常。记得适时地进行异常处理，保证代码的健壮性。

（1）使用 try-catch 块

try {
    // 可能会抛出异常的 I/O 操作
    FileInputStream fis = new FileInputStream("example.txt");
    // ...
} catch (IOException e) {
    // 处理异常情况
    e.printStackTrace();
}

（2）使用 finally 块关闭资源

确保在处理完 I/O 操作后，关闭相应的资源。使用 finally 块可以确保资源在发生异常时也会被关闭。

FileInputStream fis = null;
try {
    fis = new FileInputStream("example.txt");
    // ...
} catch (IOException e) {
    e.printStackTrace();
} finally {
    try {
        if (fis != null) {
            fis.close();
        }
    } catch (IOException e) {
        e.printStackTrace();
    }
}

（3）使用 try-with-resources（Java 7+）

在 Java 7 及更高版本中引入了 try-with-resources 语句，可以更简洁地处理资源的关闭，而不需要显式使用 finally 块。确保实现了 AutoCloseable 接口的资源会在 try 块结束时自动关闭。

try (FileInputStream fis = new FileInputStream("example.txt")) {
    // ...
} catch (IOException e) {
    e.printStackTrace();
}

（4）抛出异常：

在某些情况下，你可能希望让调用者处理 I/O 异常，而不是在当前方法中处理。这时可以在方法签名中使用 throws 关键字声明方法可能抛出的异常。

public void readFile() throws IOException {
    FileInputStream fis = new FileInputStream("example.txt");
    // ...
}

（5）多异常捕获：

在一个 catch 块中捕获多个异常，以便根据具体情况采取不同的处理方式

try {
    // I/O 操作
} catch (FileNotFoundException | IOException e) {
    // 处理异常
    e.printStackTrace();
}

（6）日志记录：

使用日志记录框架（如 log4j、SLF4J 等）记录异常信息，以便更好地了解发生异常的原因。

try {
    // I/O 操作
} catch (IOException e) {
    // 记录异常信息
    logger.error("I/O异常发生", e);
}

根据实际情况选择合适的异常处理方法。在处理 I/O 异常时，注意要及时关闭资源，避免资源泄漏。同时，详细的异常信息可以帮助调试和排查问题，但在生产环境中要确保不泄漏敏感信息。

提供几个案例：（仅供参考）

1.文件的读取和写入

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


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


            int data;
            while ((data = reader.read()) != -1) {
                // 处理读取的字符数据
                writer.write(data);
            }


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

2.缓冲流的使用

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


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();
        }
    }
}

3.对象的序列化和反序列化：

import java.io.*;


class MyClass implements Serializable {
    // 类的成员和方法
}


public class ObjectSerializationExample {
    public static void main(String[] args) {
        // 对象序列化
        try (ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream("object.dat"))) {
            MyClass obj = new MyClass();
            oos.writeObject(obj);
        } catch (IOException e) {
            e.printStackTrace();
        }


        // 对象反序列化
        try (ObjectInputStream ois = new ObjectInputStream(new FileInputStream("object.dat"))) {
            MyClass obj = (MyClass) ois.readObject();
            // 处理反序列化得到的对象
        } catch (IOException | ClassNotFoundException e) {
            e.printStackTrace();
        }
    }
}

通过这篇推文，希望你对Java I/O流有了更深入的了解。它是编程世界中连接数据的桥梁，也是我们探索新知识、打开编程大门的关键之一。欢迎分享你的经验和看法，让我们一同在编程的海洋中航行吧！💻✨ #Java编程 #IO流探索

欢迎讨论：