学习Java IO流操作

Java IO流是Java语言中重要的工具之一，是用来读写数据的机制。IO流用于从外部设备（例如磁盘、网络等）进/出读取数据，也用于将数据输出到外部设备。Java IO API提供了用于读取和写入数据的各种类和接口。IO流操作是Java编程中必须掌握的内容之一。

一、IO流概述

IO流是Java语言中重要的工具之一，是用来读写数据的机制。Java IO API提供了许多类和接口来实现IO流操作。在Java中，IO流被分为输入流和输出流。输入流用于从外部设备进读取数据，输出流用于将数据输出到外部设备。

Java IO流主要用于文件处理、网络编程等方面。Java IO流比较灵活，具有丰富的功能。它可以读取和写入不同类型的数据，例如字符、字节等。Java IO流还可以对读写数据进行编码和解码，来处理不同类型的数据。

二、Java IO流分类

1.字节流和字符流

根据读写的数据类型，Java IO流被分为字节流和字符流。字节流主要用于处理二进制数据，如图像、音频等；字符流则主要用于处理文本数据，例如UTF-8编码的文本文件。Java提供了两套API，分别是字节流API和字符流API，可以根据实际需要选择使用。

2.节点流和处理流

根据数据流向，Java IO流被分为节点流和处理流。节点流可以直接从外部设备进行读写操作，处理流则基于节点流进行封装，在节点流的基础上提供了更高级别的功能。Java IO API提供了诸如缓冲流、对象流、打印流等处理流，可以方便地进行操作。

3.输入流和输出流

根据数据流向，Java IO流被分为输入流和输出流。输入流用于从外部设备（例如磁盘、网络等）进读取数据，输出流用于将数据输出到外部设备。Java IO API提供了各种输入流和输出流的实现类，可以方便地进行操作。

三、Java IO流实例

1.文件读取

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

public class FileReadExample {
    public static void main(String[] args) {
        File file = new File("/path/to/file.txt");
        FileInputStream fis = null;
        try {
            fis = new FileInputStream(file);
            int content;
            while ((content = fis.read()) != -1) { // 读取数据
                System.out.print((char) content); // 转换为char输出
            }
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            try {
                if (fis != null) {
                    fis.close(); // 关闭文件输入流
                }
            } catch (IOException ex) {
                ex.printStackTrace();
            }
        }
    }
}

2.文件写入

import java.io.File;
import java.io.FileOutputStream;
import java.io.IOException;

public class FileWriteExample {
    public static void main(String[] args) {
        File file = new File("/path/to/file.txt");
        FileOutputStream fos = null;
        try {
            fos = new FileOutputStream(file);
            String content = "Hello World!";
            fos.write(content.getBytes()); // 写入数据
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            try {
                if (fos != null) {
                    fos.close(); // 关闭文件输出流
                }
            } catch (IOException ex) {
                ex.printStackTrace();
            }
        }
    }
}

3.缓冲流读写数据

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

public class BufferedStreamExample {
    public static void main(String[] args) {
        File inputFile = new File("/path/to/input.txt");
        File outputFile = new File("/path/to/output.txt");
        BufferedReader reader = null;
        BufferedWriter writer = null;
        try {
            reader = new BufferedReader(new FileReader(inputFile));
            writer = new BufferedWriter(new FileWriter(outputFile));
            String line;
            while ((line = reader.readLine()) != null) { // 读取数据
                writer.write(line); // 写入数据
                writer.newLine(); // 换行
            }
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            try {
                if (reader != null) {
                    reader.close(); // 关闭文件输入流
                }
                if (writer != null) {
                    writer.close(); // 关闭文件输出流
                }
            } catch (IOException ex) {
                ex.printStackTrace();
            }
        }
    }
}

4.对象读写

import java.io.*;

public class ObjectStreamExample {
    public static void main(String[] args) {
        FileOutputStream fos = null;
        FileInputStream fis = null;
        ObjectOutputStream oos = null;
        ObjectInputStream ois = null;
        try {
            fos = new FileOutputStream("/path/to/file.txt");
            oos = new ObjectOutputStream(fos);
            oos.writeObject(new Student("Alice", 18)); // 写入对象
            fis = new FileInputStream("/path/to/file.txt");
            ois = new ObjectInputStream(fis);
            Student student = (Student) ois.readObject(); // 读取对象
            System.out.println(student.getName() + " " + student.getAge()); // 输出对象
        } catch (IOException e) {
            e.printStackTrace();
        } catch (ClassNotFoundException e) {
            e.printStackTrace();
        } finally {
            try {
                if (fos != null) {
                    fos.close();
                }
                if (fis != null) {
                    fis.close();
                }
                if (oos != null) {
                    oos.close();
                }
                if (ois != null) {
                    ois.close();
                }
            } catch (IOException ex) {
                ex.printStackTrace();
            }
        }
    }
}

class Student implements Serializable {
    private String name;
    private int age;

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

    public String getName() {
        return name;
    }

    public int getAge() {
        return age;
    }
}

本文对Java IO流的概念、分类和实例进行了详细介绍，涵盖了常见应用场景。作为Java开发者，掌握好IO流操作技巧是非常重要的。希望读者能够通过本文更好地理解和掌握Java IO流操作。