大多数基本类型的高效二进制序列化

在Java中，可以使用Java序列化库或者第三方库来实现大多数基本类型的高效二进制序列化。以下是使用Java序列化库的示例代码：

import java.io.*;

public class BinarySerializationExample {
    public static void main(String[] args) {
        // 序列化对象
        serializeObject("data.bin", 10, 3.14, "Hello World");

        // 反序列化对象
        Object obj = deserializeObject("data.bin");
        if (obj instanceof DataObject) {
            DataObject dataObject = (DataObject) obj;
            System.out.println("Integer value: " + dataObject.getIntValue());
            System.out.println("Double value: " + dataObject.getDoubleValue());
            System.out.println("String value: " + dataObject.getStringValue());
        }
    }

    public static void serializeObject(String filename, int intValue, double doubleValue, String stringValue) {
        try {
            FileOutputStream fileOut = new FileOutputStream(filename);
            ObjectOutputStream objectOut = new ObjectOutputStream(fileOut);

            // 创建包含基本类型数据的对象
            DataObject dataObject = new DataObject(intValue, doubleValue, stringValue);

            // 序列化对象
            objectOut.writeObject(dataObject);

            objectOut.close();
            fileOut.close();
            System.out.println("Object has been serialized to " + filename);
        } catch (IOException e) {
            e.printStackTrace();
        }
    }

    public static Object deserializeObject(String filename) {
        try {
            FileInputStream fileIn = new FileInputStream(filename);
            ObjectInputStream objectIn = new ObjectInputStream(fileIn);

            // 反序列化对象
            Object obj = objectIn.readObject();

            objectIn.close();
            fileIn.close();
            System.out.println("Object has been deserialized from " + filename);
            return obj;
        } catch (IOException | ClassNotFoundException e) {
            e.printStackTrace();
            return null;
        }
    }
}

// 自定义数据对象
class DataObject implements Serializable {
    private int intValue;
    private double doubleValue;
    private String stringValue;

    public DataObject(int intValue, double doubleValue, String stringValue) {
        this.intValue = intValue;
        this.doubleValue = doubleValue;
        this.stringValue = stringValue;
    }

    public int getIntValue() {
        return intValue;
    }

    public double getDoubleValue() {
        return doubleValue;
    }

    public String getStringValue() {
        return stringValue;
    }
}

上述代码使用了java.io.Serializable接口来标记自定义数据对象DataObject可以被序列化和反序列化。serializeObject函数将DataObject对象序列化到文件中，deserializeObject函数从文件中反序列化对象。

除了Java序列化库，你还可以使用第三方库，如Google的Protocol Buffers或JSON库（如Jackson、Gson等），它们提供了更高效和可扩展的二进制序列化方案。以下是使用Google的Protocol Buffers的示例代码：

import com.google.protobuf.InvalidProtocolBufferException;

public class ProtobufSerializationExample {
    public static void main(String[] args) {
        // 创建数据对象
        DataObjectProto.DataObject dataObject = DataObjectProto.DataObject.newBuilder()
                .setIntValue(10)
                .setDoubleValue(3.14)
                .setStringValue("Hello World")
                .build();

        // 序列化对象
        byte[] serializedData = dataObject.toByteArray();

        // 反序列化对象
        try {
            DataObjectProto.DataObject deserializedData = DataObjectProto.DataObject.parseFrom(serializedData);
            System.out.println("Integer value: " + deserializedData.getIntValue());
            System.out.println("Double value: " + deserializedData.getDoubleValue());
            System.out.println("String value: " + deserializedData.getStringValue());
        } catch (InvalidProtocolBufferException e) {
            e.printStackTrace();
        }
    }
}

上述代码使用了Google的Protocol Buffers库来定义数据对象的结构，并使用toByteArray方法将对象序列化为字节数组。使用parseFrom方法从字节数组中反序列化对象。

无论使用Java序列化库还是第三方库，都可以根据具体的需求选择适合的二进制序列化方案。