博主18年的互联网软件开发经验，从一名程序员小白逐步成为了一名架构师，我想通过平台将经验分享给大家，因此博主每天会在各个大牛网站点赞量超高的博客等寻找该技术栈的资料结合自己的经验，晚上进行用心精简、整理、总结、定稿，每天都会整理到12点，为了就是能让大家能够真正了解该技术栈的真正原理，最终从程序员成为一名真正的架构师，写的不一定是全站做好的，但是是全站最用心的~。

以后我会推出一些列的文章，每天都会更新，每天进步一点点，发布顺序【java的api基础、应用、实战】->【java开源技术栈及源码分析】->【java开源技术栈整合】->【java低代码开发平台的建设】

关注【架构师成长之道】 输入“架构师视频课程”，即可免费获得全套架构师全套课程

一、java.io

1.39 ObjectInput

ObjectInput 接口是 Java 中用于读取对象的输入流的一部分。它位于 java.io 包下，是 ObjectInputStream 的父接口。以下是 ObjectInput 接口的基本介绍：

ObjectInput 介绍：

所有字段：

• 无特定字段。

构造方法：

• 无构造方法，因为接口不能有构造方法。

方法摘要：

• int available()： 返回在没有阻塞的情况下可以读取的字节数。

• void close()： 关闭流。在关闭流之后，不能再调用读取操作。

• int read()： 读取单个字节的数据。

• int read(byte[] b)： 将字节数组中的数据读入到一个字节数组中。

• int read(byte[] b, int off, int len)： 从输入流中读取字节数组的一部分。

• Object readObject()： 从输入流中读取一个对象。

• long skip(long n)： 跳过并丢弃输入流中的数据。

简单使用例子：

javaCopy code
import java.io.*;
​
public class ObjectInputExample {
​
    public static void main(String[] args) {
        String fileName = "data.bin";
​
        // 模拟从文件加载对象
        loadObjectFromFile(fileName);
    }
​
    private static void loadObjectFromFile(String fileName) {
        try (ObjectInputStream inputStream = new ObjectInputStream(new FileInputStream(fileName))) {
            Object object = inputStream.readObject();
            if (object instanceof MyClass) {
                MyClass myObject = (MyClass) object;
                System.out.println("Loaded object: " + myObject);
            }
        } catch (IOException | ClassNotFoundException e) {
            e.printStackTrace();
        }
    }
​
    static class MyClass implements Serializable {
        private String data;
​
        public MyClass(String data) {
            this.data = data;
        }
​
        @Override
        public String toString() {
            return "MyClass{" +
                    "data='" + data + '\'' +
                    '}';
        }
    }
}

在这个例子中，我们创建了一个 ObjectInputExample 类，其中包含了一个静态内部类 MyClass，它实现了 Serializable 接口。在 loadObjectFromFile 方法中，我们使用 ObjectInputStream 从文件中读取一个对象，并判断它是否是 MyClass 的实例，然后输出加载的对象。请注意，此示例仅演示了 ObjectInput 的基本使用。在实际项目中，可能需要更复杂的数据处理逻辑和异常处理。

应用场景

ObjectInput 接口通常用于从输入流中读取对象，它的实现类 ObjectInputStream 为我们提供了对象的反序列化功能。以下是一些可能的应用场景及相应的代码实现：

应用场景 1: 从文件中读取对象

javaCopy code
import java.io.*;
​
public class ObjectInputFileExample {
​
    public static void main(String[] args) {
        String fileName = "data.bin";
​
        // 模拟从文件加载对象
        loadObjectFromFile(fileName);
    }
​
    private static void loadObjectFromFile(String fileName) {
        try (ObjectInputStream inputStream = new ObjectInputStream(new FileInputStream(fileName))) {
            Object object = inputStream.readObject();
            if (object instanceof MyClass) {
                MyClass myObject = (MyClass) object;
                System.out.println("Loaded object: " + myObject);
            }
        } catch (IOException | ClassNotFoundException e) {
            e.printStackTrace();
        }
    }
​
    static class MyClass implements Serializable {
        private String data;
​
        public MyClass(String data) {
            this.data = data;
        }
​
        @Override
        public String toString() {
            return "MyClass{" +
                    "data='" + data + '\'' +
                    '}';
        }
    }
}

在这个例子中，我们通过 ObjectInputStream 从文件中读取一个对象（MyClass 类的实例）。

应用场景 2: 从网络流中读取对象

javaCopy code
import java.io.*;
import java.net.Socket;
​
public class ObjectInputNetworkExample {
​
    public static void main(String[] args) {
        // 模拟从网络流加载对象
        loadObjectFromNetwork();
    }
​
    private static void loadObjectFromNetwork() {
        try (Socket socket = new Socket("localhost", 8080);
             ObjectInputStream inputStream = new ObjectInputStream(socket.getInputStream())) {
​
            Object object = inputStream.readObject();
            if (object instanceof MyClass) {
                MyClass myObject = (MyClass) object;
                System.out.println("Loaded object from network: " + myObject);
            }
        } catch (IOException | ClassNotFoundException e) {
            e.printStackTrace();
        }
    }
​
    static class MyClass implements Serializable {
        private String data;
​
        public MyClass(String data) {
            this.data = data;
        }
​
        @Override
        public String toString() {
            return "MyClass{" +
                    "data='" + data + '\'' +
                    '}';
        }
    }
}

在这个例子中，我们通过 ObjectInputStream 从网络流中读取一个对象。

应用场景 3: 从其他输入流中读取对象

javaCopy code
import java.io.*;
​
public class ObjectInputOtherStreamExample {
​
    public static void main(String[] args) {
        // 模拟从其他输入流加载对象
        loadObjectFromOtherStream(new ByteArrayInputStream("Hello".getBytes()));
    }
​
    private static void loadObjectFromOtherStream(InputStream input) {
        try (ObjectInputStream inputStream = new ObjectInputStream(input)) {
​
            Object object = inputStream.readObject();
            if (object instanceof MyClass) {
                MyClass myObject = (MyClass) object;
                System.out.println("Loaded object from other stream: " + myObject);
            }
        } catch (IOException | ClassNotFoundException e) {
            e.printStackTrace();
        }
    }
​
    static class MyClass implements Serializable {
        private String data;
​
        public MyClass(String data) {
            this.data = data;
        }
​
        @Override
        public String toString() {
            return "MyClass{" +
                    "data='" + data + '\'' +
                    '}';
        }
    }
}

在这个例子中，我们通过 ObjectInputStream 从其他输入流（这里是 ByteArrayInputStream）中读取一个对象。

这些例子展示了 ObjectInput 在不同场景下的应用，包括从文件、网络流和其他输入流中读取对象。在实际项目中，你可能需要根据具体的业务需求选择合适的应用场景。

实战例子

以下是一个简单的项目实战例子，演示了如何使用 ObjectInput 接口和 ObjectInputStream 类从文件中加载并展示存储的用户对象信息。

项目实战例子：用户信息存储和加载

假设你的应用程序需要存储用户对象信息，并在需要时从文件中加载这些信息。以下是一个简单的实例：

javaCopy code
import java.io.*;
import java.util.ArrayList;
import java.util.List;
​
public class UserStorageProject {
​
    public static void main(String[] args) {
        String fileName = "user_data.ser";
​
        // 模拟保存用户信息到文件
        saveUsersToFile(fileName);
​
        // 模拟加载用户信息并展示
        loadAndDisplayUsers(fileName);
    }
​
    private static void saveUsersToFile(String fileName) {
        List<User> users = new ArrayList<>();
        users.add(new User("John", 25));
        users.add(new User("Alice", 30));
​
        try (ObjectOutputStream outputStream = new ObjectOutputStream(new FileOutputStream(fileName))) {
            outputStream.writeObject(users);
            System.out.println("Users saved to file successfully.");
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
​
    private static void loadAndDisplayUsers(String fileName) {
        try (ObjectInputStream inputStream = new ObjectInputStream(new FileInputStream(fileName))) {
            Object object = inputStream.readObject();
            if (object instanceof List) {
                List<User> loadedUsers = (List<User>) object;
                System.out.println("Loaded users:");
                for (User user : loadedUsers) {
                    System.out.println(user);
                }
            }
        } catch (IOException | ClassNotFoundException e) {
            e.printStackTrace();
        }
    }
​
    static class User implements Serializable {
        private String name;
        private int age;
​
        public User(String name, int age) {
            this.name = name;
            this.age = age;
        }
​
        @Override
        public String toString() {
            return "User{" +
                    "name='" + name + '\'' +
                    ", age=" + age +
                    '}';
        }
    }
}

在这个例子中，我们定义了一个 User 类实现了 Serializable 接口，表示用户信息。我们使用 ObjectOutputStream 将包含 User 对象的列表写入文件，并使用 ObjectInputStream 从文件中读取列表。最后，我们展示了加载的用户信息。

请注意，这只是一个简单的示例，实际项目中可能需要更复杂的数据处理逻辑和错误处理。