Java 入门指南：初识 Java IO

Java IO

Java IO（Input/Output）是 Java 编程语言中用于处理输入和输出的标准库，它提供了一组类和接口，用于在程序和外部世界（如文件、网络连接、内存等）之间进行数据传输。

IO，即 in 和 out，也就是输入和输出，即应用程序和外部设备之间的数据传递，常见的外部设备包括文件、管道、网络连接。Java IO库被设计为两个主要层次：字节流和字符流，每种流都适用于不同的数据处理场景。

Java 是通过流处理IO 的，流（Stream），是指一连串的数据（字符或字节），以先进先出的方式发送信息的通道。当程序需要读取数据的时候，就会开启一个通向数据源的流，这个数据源可以是文件，内存，或是网络连接。类似的，当程序需要写入数据的时候，就会开启一个通向目的地的流。这样就形象的类比为数据好像在这其中“流”动一样。

Java IO 流

Java IO流是处理输入和输出数据的抽象概念，它允许程序与外部设备进行数据交换。IO流根据数据的流向可以分为输入流（Input Stream）和输出流（Output Stream），同时根据处理数据的单位不同，可以分为字节流（Byte Stream）和字符流（Character Stream）。

Java IO主要由两个包组成：java.io 和 javax.io。其中，java.io 包提供了基础的输入输出流类，而 javax.io 包则提供了更高级的流处理功能。

Java IO的核心类包括：

• InputStream：代表输入流的抽象基类。
• OutputStream：代表输出流的抽象基类。
• Reader：代表字符输入流的抽象基类。
• Writer：代表字符输出流的抽象基类。

字节流与字符流

字节流

• 字节流以字节为单位进行数据的读写操作，适用于处理二进制数据或不需要进行字符编码转换的场景。
• 主要的字节流类包括InputStream和OutputStream及其子类，如：
  • FileInputStream
  • FileOutputStream
  • BufferedInputStream
  • BufferedOutputStream
• 应用场景：读取和写入文件、网络传输二进制数据等。

字符流

• 字符流以字符为单位进行数据的读写操作，适用于处理文本数据并支持字符编码转换。
• 主要的字符流类包括Reader和Writer及其子类，如
  • FileReader
  • FileWriter
  • BufferedReader
  • BufferedWriter
• 应用场景：读取和写入文本文件、处理字符串数据、处理图像、音频等二进制文件等。

常用 Java IO 流类

文件流

• FileInputStream / FileOutputStream：用于读取和写入文件。

• FileReader/FileWriter：用于读取和写入文本文件。

读取文本文件

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

public class CharStreamExample {
    public static void main(String[] args) {
        try (FileReader fr = new FileReader("example.txt")) {
            int data;
            while ((data = fr.read()) != -1) {
                System.out.print((char) data);
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

• 目的：读取一个文本文件中的字符，并打印出来。
• 步骤：
  • 使用FileReader类创建一个字符输入流，指向名为example.txt的文件。
  • 通过调用read()方法逐字符读取文件内容。
  • 如果read()返回-1，表示已到达文件末尾，读取结束。
  • 将读取到的字符打印出来。

写入文本文件

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

public class CharStreamExample {
    public static void main(String[] args) {
        try (FileWriter fw = new FileWriter("example.txt")) {
            String text = "Hello, World!";
            fw.write(text);
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

• 目的：将字符串写入到一个文本文件中。
• 步骤：
  • 使用FileWriter类创建一个字符输出流，指向名为example.txt的文件。
  • 将字符串"Hello, World!"写入文件。
  • 文件关闭后，内容将保存在磁盘上。

缓冲流

• BufferedInputStream / BufferedOutputStream：为字节流提供缓冲功能，提高读写速度。
• BufferedReader / BufferedWriter：为字符流提供缓冲功能，提高读写速度。

使用缓冲流读取文件

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

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

• 目的：使用缓冲流读取文本文件中的内容，并按行打印出来。
• 步骤：
  • 使用FileReader创建一个字符输入流，指向名为example.txt的文件。
  • 使用BufferedReader包装FileReader，以提高读取效率。
  • 通过调用readLine()方法逐行读取文件内容。
  • 如果readLine()返回null，表示已到达文件末尾，读取结束。
  • 将读取到的每一行打印出来。

使用缓冲流写入文件

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

public class BufferedStreamExample {
    public static void main(String[] args) {
        try (BufferedWriter bw = new BufferedWriter(new FileWriter("example.txt"))) {
            bw.write("Hello, World!");
            bw.newLine();
            bw.write("This is a test.");
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

• 目的：使用缓冲流将字符串写入到一个文本文件中。
• 步骤：
  • 使用FileWriter创建一个字符输出流，指向名为example.txt的文件。
  • 使用BufferedWriter包装FileWriter，以提高写入效率。
  • 将字符串"Hello, World!"写入文件。
  • 使用newLine()方法写入换行符。
  • 再次写入字符串"This is a test."。
  • 文件关闭后，内容将保存在磁盘上。

数据流

• DataInputStream/DataOutputStream：用于读取和写入基本数据类型。

读取基本数据类型

import java.io.DataInputStream;
import java.io.FileInputStream;
import java.io.IOException;

public class DataStreamExample {
    public static void main(String[] args) {
        try (DataInputStream dis = new DataInputStream(new FileInputStream("data.dat"))) {
            int intValue = dis.readInt();
            double doubleValue = dis.readDouble();
            System.out.println("Int value: " + intValue);
            System.out.println("Double value: " + doubleValue);
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

• 目的：从一个二进制文件中读取整型和双精度浮点型数据，并打印出来。
• 步骤：
  • 使用FileInputStream创建一个字节输入流，指向名为data.dat的文件。
  • 使用DataInputStream包装FileInputStream，以便读取基本数据类型。
  • 通过调用readInt()方法读取一个整型数据。
  • 通过调用readDouble()方法读取一个双精度浮点型数据。
  • 打印读取到的数据。

写入基本数据类型

import java.io.DataOutputStream;
import java.io.FileOutputStream;
import java.io.IOException;

public class DataStreamExample {
    public static void main(String[] args) {
        try (DataOutputStream dos = new DataOutputStream(new FileOutputStream("data.dat"))) {
            int intValue = 42;
            double doubleValue = 3.14;
            dos.writeInt(intValue);
            dos.writeDouble(doubleValue);
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

• 目的：将整型和双精度浮点型数据写入到一个二进制文件中。
• 步骤：
  • 使用FileOutputStream创建一个字节输出流，指向名为data.dat的文件。
  • 使用DataOutputStream包装FileOutputStream，以便写入基本数据类型。
  • 将整型数据42写入文件。
  • 将双精度浮点型数据3.14写入文件。
  • 文件关闭后，内容将保存在磁盘上。

对象流

• ObjectInputStream / ObjectOutputStream：用于序列化和反序列化对象。

序列化对象

import java.io.FileOutputStream;
import java.io.ObjectOutputStream;
import java.io.IOException;

public class ObjectStreamExample {
    public static void main(String[] args) {
        Person person = new Person("Alice", 25);

        try (ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream("person.dat"))) {
            oos.writeObject(person);
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

class Person implements java.io.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 +
                '}';
    }
}

• 目的：将一个对象序列化为二进制格式，并保存到文件中。
• 步骤：
  • 创建一个Person对象。
  • 使用FileOutputStream创建一个字节输出流，指向名为person.dat的文件。
  • 使用ObjectOutputStream包装FileOutputStream，以便写入对象。
  • 通过调用writeObject()方法将Person对象写入文件。
  • 文件关闭后，内容将保存在磁盘上。

反序列化对象

import java.io.FileInputStream;
import java.io.ObjectInputStream;
import java.io.IOException;

public class ObjectStreamExample {
    public static void main(String[] args) {
        try (ObjectInputStream ois = new ObjectInputStream(new FileInputStream("person.dat"))) {
            Person person = (Person) ois.readObject();
            System.out.println(person);
        } catch (IOException | ClassNotFoundException e) {
            e.printStackTrace();
        }
    }
}

• 目的：从一个二进制文件中反序列化一个对象，并打印出来。
• 步骤：
  • 使用FileInputStream创建一个字节输入流，指向名为person.dat的文件。
  • 使用ObjectInputStream包装FileInputStream，以便读取对象。
  • 通过调用readObject()方法从文件中读取一个对象。
  • 将读取到的对象转换为Person类型，并打印出来。

处理字节数组的特殊流

ByteArrayInputStream 和 ByteArrayOutputStream 是 Java 中用于处理字节数组的特殊流类。它们可以让你将字节数组视为输入输出流，从而可以在内存中直接进行读写操作，而无需涉及到磁盘文件。

ByteArrayInputStream

ByteArrayInputStream 是一个可以从字节数组中读取数据的输入流。它可以用来模拟从字节数组读取数据的过程，就像从文件或网络连接读取数据一样。

import java.io.ByteArrayInputStream;
import java.io.IOException;

public class ByteArrayInputStreamExample {
    public static void main(String[] args) {
        // 创建一个字节数组
        byte[] data = "Hello, World!".getBytes();

        // 创建 ByteArrayInputStream 对象
        ByteArrayInputStream bis = new ByteArrayInputStream(data);

        // 读取数据
        try {
            int b;
            while ((b = bis.read()) != -1) {
                System.out.print((char) b);
            }
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            // 不需要关闭 ByteArrayInputStream，因为它不会占用系统资源
        }
    }
}

• 创建字节数组：我们首先创建了一个包含字符串“Hello, World!”的字节数组data。
• 创建 ByteArrayInputStream：使用字节数组data创建了一个ByteArrayInputStream对象bis。
• 读取数据：通过调用read()方法逐字节读取字节数组中的数据。如果read()返回-1，表示已到达字节数组的末尾。
• 打印数据：将读取到的字节转换为字符并打印出来。

ByteArrayOutputStream

ByteArrayOutputStream 是一个可以将数据写入到字节数组的输出流。它主要用于在内存中收集数据，然后一次性处理整个字节数组，而不是写入到磁盘文件或其他外部存储。

import java.io.ByteArrayOutputStream;
import java.io.IOException;

public class ByteArrayOutputStreamExample {
    public static void main(String[] args) {
        // 创建 ByteArrayOutputStream 对象
        ByteArrayOutputStream bos = new ByteArrayOutputStream();

        // 写入数据
        try {
            bos.write("Hello, World!".getBytes());
            bos.write(10);  // 写入换行符
            bos.write("This is a test.".getBytes());
        } catch (IOException e) {
            e.printStackTrace();
        }

        // 获取字节数组
        byte[] result = bos.toByteArray();

        // 打印结果
        System.out.println(new String(result));
    }
}

• 创建 ByteArrayOutputStream：创建了一个ByteArrayOutputStream对象bos。
• 写入数据：使用write(byte[])方法将字符串"Hello, World!"转换为字节数组并写入到bos中。接着使用write(int)方法写入一个换行符（ASCII码为10），最后再写入字符串"This is a test."。
• 获取字节数组：调用toByteArray()方法获取写入的所有数据组成的字节数组。
• 打印结果：将字节数组转换为字符串并打印出来。

异常处理

Java IO 操作可能会引发多种异常，如 IOException、FileNotFoundException 等。因此，在进行IO操作时，需要进行适当的异常处理，通常是通过 try-catch 语句来捕获并处理这些异常。

Java NIO

从Java 7开始，Java引入了 NIO（New IO）库，它提供了更高效的IO操作方式，如通道（Channel）和缓冲区（Buffer），适用于处理大量数据和非阻塞IO。NIO 的出现进一步丰富了Java的IO操作体系，为开发者提供了更多的选择和灵活性。

总结

Java IO 是Java编程中不可或缺的一部分，它提供了丰富的类和接口来处理输入和输出操作。通过理解和掌握 Java IO 流的相关知识，开发者可以更加高效地进行数据交换和处理。无论是处理文件、网络通信还是其他IO操作，Java IO 都能提供强大的支持。