Java函数库中的输入输出流函数

Java 的函数库中提供了大量的输入输出流函数，用于方便地进行文件操作或网络通信。这些函数具有广泛的应用场景，比如读写文件、网络连接、数据传输等。下面将详细介绍几种常见的输入输出流函数。

1. FileInputStream 和 FileOutputStream

FileInputStream 和 FileOutputStream 分别用于文件的读取和写入。这两个类的构造函数都需要指定要读取或写入的文件名。如果文件不存在，则会抛出 FileNotFoundException 异常。下面是一个读取文件的例子：

try {
    FileInputStream fis = new FileInputStream("myfile.txt");
    int c;

    while ((c = fis.read()) != -1) {
        System.out.print((char) c);
    }

    fis.close();
} catch (IOException e) {
    System.out.println("Read file error");
}

上面的代码首先创建了一个 FileInputStream 对象，并将文件名指定为 myfile.txt，然后通过 read 方法读取文件的内容，每次读取一个字节，并将其强制转换为 char 类型输出。最后关闭文件流。

写文件的操作和读文件类似。下面是一个写文件的例子：

try {
    FileOutputStream fos = new FileOutputStream("myfile.txt");
    String str = "Hello World!";
    byte[] b = str.getBytes();

    fos.write(b);
    fos.close();
} catch (IOException e) {
    System.out.println("Write file error");
}

上面的代码首先创建了一个 FileOutputStream 对象，并将文件名指定为 myfile.txt，然后将字符串 "Hello World!" 转换成字节数组并写入文件流中。最后同样需要关闭文件流。

2. BufferedReader 和 BufferedWriter

BufferedReader 和 BufferedWriter 主要用于读写文本文件。它们可以提高读写文件的效率，因为它们会缓存一定数量的数据，减少了与磁盘的交互次数。下面是一个读文本文件的例子：

try {
    BufferedReader br = new BufferedReader(new FileReader("myfile.txt"));
    String line;

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

    br.close();
} catch (IOException e) {
    System.out.println("Read file error");
}

上面的代码首先创建了一个 BufferedReader 对象，并将 FileReader 对象传递给它作为参数。然后使用 readLine 方法逐行读取文件的内容，并输出到控制台上。最后同样需要关闭文件流。

写文本文件的操作和读文件类似。下面是一个写文本文件的例子：

try {
    BufferedWriter bw = new BufferedWriter(new FileWriter("myfile.txt"));
    String str = "Hello World!";

    bw.write(str);
    bw.newLine();
    bw.close();
} catch (IOException e) {
    System.out.println("Write file error");
}

上面的代码首先创建了一个 BufferedWriter 对象，并将 FileWriter 对象传递给它作为参数。然后使用 write 方法将字符串写入文件流中，并且使用 newLine 方法换行。最后同样需要关闭文件流。

3. Socket 和 ServerSocket

Socket 和 ServerSocket 可以用于网络通信，Socket 用于客户端，ServerSocket 用于服务器端。客户端通过 Socket 连接到服务器端，通过输入输出流传输数据。下面是一个客户端的例子：

try {
    Socket socket = new Socket("localhost", 8080);
    OutputStream os = socket.getOutputStream();
    InputStream is = socket.getInputStream();
    String str = "Hello World!";
    byte[] b = str.getBytes();

    os.write(b);
    os.close();

    byte[] buffer = new byte[1024];
    int count = is.read(buffer);
    String response = new String(buffer, 0, count);
    System.out.println("Response: " + response);

    is.close();
    socket.close();
} catch (IOException e) {
    System.out.println("Connect error");
}

上面的代码首先创建了一个 Socket 对象，并将主机名和端口号指定为 localhost 和 8080。然后通过 getOutputStream 方法获取输出流，将字符串 "Hello World!" 转换成字节数组并写入输出流中。接着通过 getInputStream 方法获取输入流，从输入流中读取服务器端返回的数据，并输出到控制台上。最后同样需要关闭输入输出流和 Socket 连接。

服务器端通过 ServerSocket 能够监听指定端口号的客户端连接请求，并创建 Socket 对象与客户端进行通信。下面是一个服务器端的例子：

try {
    ServerSocket serverSocket = new ServerSocket(8080);
    Socket socket = serverSocket.accept();
    InputStream is = socket.getInputStream();
    OutputStream os = socket.getOutputStream();

    byte[] buffer = new byte[1024];
    int count = is.read(buffer);
    String request = new String(buffer, 0, count);
    System.out.println("Request: " + request);

    String response = "Got it!";
    byte[] b = response.getBytes();
    os.write(b);
    os.close();

    is.close();
    socket.close();
} catch (IOException e) {
    System.out.println("Listen error");
}

上面的代码首先创建了一个 ServerSocket 对象，并将端口号指定为 8080。然后通过 accept 方法等待客户端的连接请求，并创建 Socket 对象与客户端进行通信。接着通过 getInputStream 方法获取输入流，从输入流中读取客户端发送的数据，并输出到控制台上。然后通过 getOutputStream 方法获取输出流，将字符串 "Got it!" 转换成字节数组并写入输出流中，最后同样需要关闭输入输出流和 Socket 连接。

4. ObjectInputStream 和 ObjectOutputStream

ObjectInputStream 和 ObjectOutputStream 可以用于对象的传输。它们可以将 Java 对象序列化为字节流，并在需要的时候反序列化回原本的对象。下面是一个简单的例子：

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

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

    public void display() {
        System.out.println("Name: " + name);
        System.out.println("Age: " + age);
    }
}

try {
    ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream("person.ser"));
    Person person = new Person("Jack", 30);

    oos.writeObject(person);
    oos.close();

    ObjectInputStream ois = new ObjectInputStream(new FileInputStream("person.ser"));
    Person p = (Person) ois.readObject();
    p.display();

    ois.close();
} catch (IOException e) {
    System.out.println("IO exception");
} catch (ClassNotFoundException e) {
    System.out.println("Class not found");
}

上面的代码创建了一个名为 Person 的类，并实现了 Serializable 接口。然后通过 ObjectOutputStream 类将对象逆序列化为字节流，并通过 writeObject 方法写入文件流中。然后通过 ObjectInputStream 类的 readObject 方法从文件流中读取数据并转换为 Person 对象，最后调用 display 方法输出对象的属性。

总结

Java 的输入输出流函数库提供了大量强大的功能，使得程序可以进行文件操作和网络通信。在实际开发中，不同的应用场景需要使用不同的输入输出流函数，程序员需要了解这些类的特点和使用方法，以便能够快速编写需要的程序。