一文了解IO流

主要是背八股太枯燥了，而且目前很少用这个知识点，所以总结一下，方便记忆。

IO流（输入/输出流）在Java中是一个核心概念，广泛用于数据的读取和写入。IO流主别用于处理所有输入和输出操作，无论数据来源是文件、内存、网络还是其他任何数据源。主要的应用场景包括：

文件读写：这是IO流最常见的用途之一。使用IO流，可以从文件中读取数据（文本文件、二进制文件等），也可以向文件中写入数据。例如，FileInputStream和FileOutputStream用于处理文件的二进制数据，而FileReader和FileWriter则用于处理字符数据。

//使用字节流读文件
import java.io.BufferedReader;
import java.io.FileReader;
import java.io.IOException;

public class ReadFileExample {
    public static void main(String[] args) {
        String filePath = "path/to/your/file.txt";
        
        try (BufferedReader reader = new BufferedReader(new FileReader(filePath))) {
            String line;
            while ((line = reader.readLine()) != null) {
                System.out.println(line);
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}
//使用字节流写入文件
import java.io.BufferedWriter;
import java.io.FileWriter;
import java.io.IOException;

public class WriteFileExample {
    public static void main(String[] args) {
        String filePath = "path/to/your/output.txt";
        String content = "Hello, World!";
        
        try (BufferedWriter writer = new BufferedWriter(new FileWriter(filePath))) {
            writer.write(content);
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

网络通信：在网络通信中，IO流用于发送和接收数据。例如，当使用套接字（Socket）进行网络编程时，可以通过获取套接字的输入流和输出流来接收和发送数据。

//网络通信客户端
import java.io.BufferedReader;
import java.io.InputStreamReader;
import java.io.PrintWriter;
import java.net.Socket;

public class SimpleClient {
    public static void main(String[] args) {
        String hostname = "localhost";
        int port = 12345;

        try (Socket socket = new Socket(hostname, port);
             PrintWriter out = new PrintWriter(socket.getOutputStream(), true);
             BufferedReader in = new BufferedReader(new InputStreamReader(socket.getInputStream()))) {
            out.println("Hello from the client!");
            String response = in.readLine();
            System.out.println("Server: " + response);
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}
//网络通信服务器
import java.io.BufferedReader;
import java.io.InputStreamReader;
import java.io.PrintWriter;
import java.net.ServerSocket;
import java.net.Socket;

public class SimpleServer {
    public static void main(String[] args) {
        int port = 12345;

        try (ServerSocket serverSocket = new ServerSocket(port);
             Socket clientSocket = serverSocket.accept();
             PrintWriter out = new PrintWriter(clientSocket.getOutputStream(), true);
             BufferedReader in = new BufferedReader(new InputStreamReader(clientSocket.getInputStream()))) {
            String request = in.readLine();
            System.out.println("Client: " + request);
            out.println("Hello from the server!");
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

内存操作：IO流也可以用来操作内存中的数据。例如，ByteArrayInputStream和ByteArrayOutputStream可以分别从内存数组读取数据和向内存数组写入数据。

缓冲：为了提高IO操作的效率，Java提供了缓冲流（如BufferedReader、BufferedWriter、BufferedInputStream、BufferedOutputStream），它们使用缓冲区来减少实际进行物理读写操作的次数。

数据转换：IO流还可以用于在不同格式之间转换数据。例如，InputStreamReader和OutputStreamWriter可以将字节流转换为字符流，支持不同的字符编码。

序列化：对象序列化和反序列化也是IO流的一个重要应用，允许将对象的状态保存到文件中或通过网络发送，然后再恢复。ObjectInputStream和ObjectOutputStream是专门用于对象序列化的流。

//序列化
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.ObjectOutputStream;
import java.io.Serializable;

public class SerializeExample {
    static class Person implements Serializable {
        private static final long serialVersionUID = 1L;
        String name;
        int age;

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

    public static void main(String[] args) {
        Person person = new Person("John Doe", 30);
        try (FileOutputStream fileOut = new FileOutputStream("person.ser");
             ObjectOutputStream out = new ObjectOutputStream(fileOut)) {
            out.writeObject(person);
        } catch (IOException i) {
            i.printStackTrace();
        }
    }
}
//反序列化
import java.io.FileInputStream;
import java.io.IOException;
import java.io.ObjectInputStream;

public class DeserializeExample {
    public static void main(String[] args) {
        Person person = null;
        try (FileInputStream fileIn = new FileInputStream("person.ser");
             ObjectInputStream in = new ObjectInputStream(fileIn)) {
            person = (Person) in.readObject();
        } catch (IOException i) {
            i.printStackTrace();
            return;
        } catch (ClassNotFoundException c) {
            System.out.println("Person class not found");
            c.printStackTrace();
            return;
        }

        System.out.println("Deserialized Person...");
        System.out.println("Name: " + person.name);
        System.out.println("Age: " + person.age);
    }

    static class Person implements Serializable {
        private static final long serialVersionUID = 1L;
        String name;
        int age;
    }
}

管道通信：Java IO提供了管道相关的流（PipedInputStream和PipedOutputStream），允许在不同线程之间进行数据传输，实现线程间的通信。

IO流根据处理数据的类型可以分为字节流（以InputStream和OutputStream为基础）和字符流（以Reader和Writer为基础）。字节流主要用于处理二进制数据，如文件和网络数据；字符流则专门用于处理文本数据。根据数据流向的不同，IO流又可以分为输入流和输出流。

使用IO流时，需要注意资源管理，确保在使用完毕后及时关闭流，以释放相关资源。Java 7引入的try-with-resources语句提供了一种简便的资源管理方法，可以自动关闭实现了AutoCloseable接口的资源。