Android Studio中Java单键多值数据永久存储的实现方法

方案一：使用SharedPreferences（轻量首选） #

SharedPreferences是Android原生的键值对存储方案，适合这种小体量的持久化需求，可通过两种方式实现1key对应4个值的存储：

方式1：Key加后缀区分多值 #

直接给每个key的四个值添加后缀，比如key1_v1、key1_v2，操作简单无需额外依赖：

// 获取SharedPreferences实例
SharedPreferences sp = getSharedPreferences("MultiValueStorage", MODE_PRIVATE);

// 存储完整的4个值
sp.edit()
   .putString("key1_v1", "value1")
   .putString("key1_v2", "value2")
   .putString("key1_v3", "value3")
   .putString("key1_v4", "value4")
   .apply();

// 读取值到变量
String var1 = sp.getString("key1_v1", "默认值");
String var2 = sp.getString("key1_v2", "默认值");
String var3 = sp.getString("key1_v3", "默认值");
String var4 = sp.getString("key1_v4", "默认值");

// 修改单个值（比如key1的v1）
sp.edit().putString("key1_v1", "new value").apply();

方式2：封装对象转JSON存储 #

如果需要更结构化的管理，可把4个值封装成对象，用Gson转成字符串存储（需在build.gradle添加Gson依赖：implementation 'com.google.code.gson:gson:2.10.1'）：

// 定义数据类
public class KeyData {
    public String value1;
    public String value2;
    public String value3;
    public String value4;

    // 空构造函数（Gson序列化必需）
    public KeyData() {}

    public KeyData(String v1, String v2, String v3, String v4) {
        this.value1 = v1;
        this.value2 = v2;
        this.value3 = v3;
        this.value4 = v4;
    }
}

// 存储对象
Gson gson = new Gson();
KeyData key1Data = new KeyData("v1", "v2", "v3", "v4");
String json = gson.toJson(key1Data);
sp.edit().putString("key1", json).apply();

// 读取对象并赋值到变量
String key1Json = sp.getString("key1", null);
KeyData data = gson.fromJson(key1Json, KeyData.class);
if (data != null) {
    String var1 = data.value1;
    String var2 = data.value2;
    // ... 其他变量赋值
}

// 修改单个值
data.value1 = "new value";
sp.edit().putString("key1", gson.toJson(data)).apply();

方案二：内部存储JSON文件（结构化场景） #

如果需要管理大量key，或者后续可能扩展存储结构，可使用内部存储的JSON文件统一管理：

public class FileStorageHelper {
    private static final String STORAGE_FILE = "key_values.json";

    // 存储单个key的4个值
    public static void saveKeyData(Context context, String key, String v1, String v2, String v3, String v4) {
        try {
            JSONObject allData = loadAllData(context);
            JSONObject keyData = new JSONObject();
            keyData.put("v1", v1);
            keyData.put("v2", v2);
            keyData.put("v3", v3);
            keyData.put("v4", v4);
            allData.put(key, keyData);
            
            // 写入文件
            FileOutputStream fos = context.openFileOutput(STORAGE_FILE, Context.MODE_PRIVATE);
            fos.write(allData.toString().getBytes());
            fos.close();
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

    // 加载所有存储数据
    private static JSONObject loadAllData(Context context) {
        try {
            FileInputStream fis = context.openFileInput(STORAGE_FILE);
            BufferedReader reader = new BufferedReader(new InputStreamReader(fis));
            StringBuilder sb = new StringBuilder();
            String line;
            while ((line = reader.readLine()) != null) {
                sb.append(line);
            }
            fis.close();
            return new JSONObject(sb.toString());
        } catch (Exception e) {
            // 文件不存在时返回空对象
            return new JSONObject();
        }
    }

    // 读取单个key的指定值
    public static String getSingleValue(Context context, String key, String field) {
        try {
            JSONObject allData = loadAllData(context);
            if (allData.has(key)) {
                JSONObject keyData = allData.getJSONObject(key);
                return keyData.optString(field, "默认值");
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
        return "默认值";
    }

    // 修改单个key的指定值
    public static void updateSingleValue(Context context, String key, String field, String newValue) {
        try {
            JSONObject allData = loadAllData(context);
            if (allData.has(key)) {
                JSONObject keyData = allData.getJSONObject(key);
                keyData.put(field, newValue);
                allData.put(key, keyData);
                
                FileOutputStream fos = context.openFileOutput(STORAGE_FILE, Context.MODE_PRIVATE);
                fos.write(allData.toString().getBytes());
                fos.close();
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

使用示例 #

// 存储key1的4个值
FileStorageHelper.saveKeyData(this, "key1", "v1", "v2", "v3", "v4");

// 读取key1的v1到变量
String var1 = FileStorageHelper.getSingleValue(this, "key1", "v1");

// 修改key1的v1为新值
FileStorageHelper.updateSingleValue(this, "key1", "v1", "new value");

方案对比 #

• SharedPreferences：操作最简单，无需额外文件读写逻辑，适合少量key的场景。
• 内部JSON文件：适合结构化管理大量数据，扩展性更强，但需要处理文件读写异常。
• 硬编码数组：无法持久化修改，重启后会恢复初始值，完全不满足需求，建议放弃。

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