小型POJO数据集的查询数据结构选型及持久化方案（Java/Kotlin）

我有一组小型Java POJO，每个对象包含若干固定字段（不会动态新增字段），数据集规模很小，属于应用状态数据。数据载体类定义如下：

class MyObject
{
    private int a;
    private String b;
    private boolean c;
}

我需要一种数据结构，支持按单个字段值查询数据（如a=5、b="abc"或c=true，暂无需复杂查询）。当前直接方案是使用多个Map：

Map<Integer, MyObject> aMap = new HashMap<>();
Map<String, MyObject> bMap = new HashMap<>();
Map<Boolean, MyObject> cMap = new HashMap<>();

提出的问题 #

1. 在最新版Java中是否有更优实现方式？
2. 在Kotlin中是否有更优实现方式？
3. 若需持久化该集合以支持应用重启后保留数据，该如何处理？

1. 最新版Java的更优实现 #

可以用**记录类（Record）**简化POJO定义，同时封装一个统一的索引管理类，避免分散的Map散落在代码中：

// 用Record替代传统POJO，自动生成构造器、equals、hashCode等方法
record MyObject(int a, String b, boolean c) {}

// 封装索引管理类，统一维护所有查询索引
class ObjectIndex {
    private final Map<Integer, MyObject> aIndex = new HashMap<>();
    private final Map<String, MyObject> bIndex = new HashMap<>();
    private final Map<Boolean, MyObject> cIndex = new HashMap<>();

    // 添加对象时同步更新所有索引
    public void add(MyObject obj) {
        aIndex.put(obj.a(), obj);
        bIndex.put(obj.b(), obj);
        cIndex.put(obj.c(), obj);
    }

    // 提供按字段查询的方法
    public MyObject getByA(int a) {
        return aIndex.get(a);
    }

    public MyObject getByB(String b) {
        return bIndex.get(b);
    }

    public MyObject getByC(boolean c) {
        return cIndex.get(c);
    }

    // 可选：删除对象时同步清理所有索引
    public void remove(MyObject obj) {
        aIndex.remove(obj.a());
        bIndex.remove(obj.b());
        cIndex.remove(obj.c());
    }
}

如果字段值可能重复（比如多个MyObject的c字段都是true），可以将Map的value改为List<MyObject>，比如Map<Boolean, List<MyObject>> cIndex，查询时返回对应列表即可。

对于小规模数据，直接维护同步索引的效率更高、代码更直观，Java 16+的Stream API可辅助批量构建索引，但无需过度设计。

2. Kotlin的更优实现 #

Kotlin可以利用**数据类（data class）**简化POJO，同时结合封装类或扩展函数让代码更简洁：

方案1：封装索引管理类（适合动态更新场景） #

data class MyObject(val a: Int, val b: String, val c: Boolean)

class ObjectIndex {
    private val aIndex = mutableMapOf<Int, MyObject>()
    private val bIndex = mutableMapOf<String, MyObject>()
    private val cIndex = mutableMapOf<Boolean, MyObject>()

    fun add(obj: MyObject) {
        aIndex[obj.a] = obj
        bIndex[obj.b] = obj
        cIndex[obj.c] = obj
    }

    fun getByA(a: Int) = aIndex[a]
    fun getByB(b: String) = bIndex[b]
    fun getByC(c: Boolean) = cIndex[c]

    fun remove(obj: MyObject) {
        aIndex.remove(obj.a)
        bIndex.remove(obj.b)
        cIndex.remove(obj.c)
    }
}

方案2：利用associateBy快速构建索引（适合静态只读数据集） #

如果数据集是一次性加载、几乎不修改的，可以直接用Kotlin集合的扩展函数生成索引：

val objects = listOf(
    MyObject(1, "foo", true),
    MyObject(2, "bar", false)
)

val aIndex = objects.associateBy { it.a }
val bIndex = objects.associateBy { it.b }
val cIndex = objects.associateBy { it.c }

这种方式代码极简，适合只读或修改极少的场景。

3. 持久化处理方案 #

针对小规模应用状态数据，优先选择轻量级方案：

方式1：JSON序列化到本地文件 #

用Jackson、Gson等JSON库将对象集合序列化后写入本地文件（如app-state.json），重启时读取文件反序列化，再重建索引。示例（Java + Jackson）：

// 保存数据
ObjectMapper mapper = new ObjectMapper();
mapper.writeValue(new File("app-state.json"), objectsList); // objectsList为所有MyObject的集合

// 加载数据
List<MyObject> objectsList = mapper.readValue(
    new File("app-state.json"),
    new TypeReference<List<MyObject>>() {}
);
// 重建索引
ObjectIndex index = new ObjectIndex();
objectsList.forEach(index::add);

这种方式文件可读、兼容性好，是小规模数据持久化的首选。

方式2：嵌入式关系型数据库 #

用SQLite或H2这类嵌入式数据库，将MyObject的字段映射为数据库表列，查询时通过简单SQL语句（如SELECT * FROM my_objects WHERE a = 5）获取数据。适合数据规模可能扩大、或未来需要复杂查询的场景，可通过JDBC或Spring Data JPA简化操作。

方式3：本地键值存储 #

用LevelDB等本地键值存储，将每个字段索引单独存储（如a_5对应MyObject的序列化值），但对于小规模数据来说属于过度设计，不如JSON文件简洁。

内容的提问来源于stack exchange，提问作者MiamiBeach