Android应用偶现内部存储数据丢失问题求助

核心问题分析 #

你的问题大概率是以下几个原因导致的：

1. onDestroy() 不保证执行：Android系统在内存紧张时，会直接终止应用进程，不会触发Activity的onDestroy()方法，导致数据没机会写入。
2. 文件写入未确保落地：流操作未正确刷新或关闭，导致数据停留在内存缓冲区，未写入磁盘。
3. 序列化/反序列化逻辑有漏洞：空集合处理、异常捕获范围错误等，导致写入失败或解析失败。
4. 异常处理不严谨：仅用printStackTrace()无法定位问题，且未处理关键异常。

针对性解决步骤 #

1. 替换数据保存的生命周期方法 #

不要依赖onDestroy()保存关键数据，改用onStop()或onPause()——这两个方法在Activity不可见时一定会被调用，可靠性远高于onDestroy()。同时保留onDestroy()作为兜底：

@Override
protected void onStop() {
    super.onStop();
    saveUserData();
}

@Override
protected void onDestroy() {
    super.onDestroy();
    saveUserData();
}

private void saveUserData() {
    user.setSfondo(bgs.getActiveIndex());
    String dataToSave = user.store();
    FileHelper.writeToFile(getApplicationContext(), getResources().getString(R.string.fileName), dataToSave);
    // 调试用：确认写入内容
    Log.d("MainActivity", "已保存数据: " + dataToSave);
}

2. 修复文件写入的可靠性 #

修改FileHelper的写入逻辑，使用try-with-resources确保流自动关闭，同时主动调用flush()保证数据写入磁盘，并用日志记录异常：

public class FileHelper {
    public static void writeToFile(Context context, String fileName, String data) {
        try (FileOutputStream fos = context.openFileOutput(fileName, Context.MODE_PRIVATE);
             BufferedWriter writer = new BufferedWriter(new OutputStreamWriter(fos))) {
            writer.write(data);
            writer.flush(); // 强制将缓冲区数据写入磁盘
        } catch (IOException e) {
            Log.e("FileHelper", "写入文件失败", e); // 用Logcat替代printStackTrace，方便定位问题
        }
    }

    public static String readFromFile(Context context, String fileName) {
        StringBuilder stringBuilder = new StringBuilder();
        try (FileInputStream fis = context.openFileInput(fileName);
             BufferedReader reader = new BufferedReader(new InputStreamReader(fis))) {
            String line;
            while ((line = reader.readLine()) != null) {
                stringBuilder.append(line);
                // 原代码添加的"\n"会导致解析时多一个换行符，建议去掉
            }
        } catch (IOException e) {
            Log.e("FileHelper", "读取文件失败", e);
        }
        return stringBuilder.toString();
    }
}

3. 修复序列化/反序列化的漏洞 #

User类的store/load方法

• 处理rules为空的情况，避免数组越界异常
• 增加数据格式校验，跳过空字符串
• 捕获正确的异常类型（Exception而非Error）

public String store(){
    StringBuilder s = new StringBuilder();
    s.append(anno).append("#").append(sfondo).append("#").append(notifiche);
    if (!rules.isEmpty()) {
        for (Rule rule : rules) {
            s.append("#").append(rule.store());
        }
    }
    return s.toString();
}

public void load(String s){
    try {
        String[] data = s.split("#");
        if (data.length < 3) {
            Log.w("User", "存储数据格式错误：字段不足");
            return;
        }
        this.anno = Integer.parseInt(data[0]);
        this.sfondo = Integer.parseInt(data[1]);
        this.notifiche = Integer.parseInt(data[2]);
        rules.clear();
        for (int i = 3; i < data.length; i++) {
            String ruleStr = data[i].trim();
            if (ruleStr.isEmpty()) continue;
            Rule r = new Rule();
            if (r.load(ruleStr)) {
                rules.add(r);
            } else {
                Log.w("User", "加载Rule失败：" + ruleStr);
            }
        }
        generateMonths();
    } catch (Exception e) {
        Log.e("User", "加载用户数据失败", e);
    }
}

Rule类的load方法

• 校验参数数量，避免数组越界
• 捕获具体的解析异常（NumberFormatException）
• 增加日志记录

public boolean load(String rule){
    String[] params = rule.split(";");
    if (params.length != 7) {
        Log.w("Rule", "Rule格式错误：参数数量不符，当前：" + params.length);
        return false;
    }
    try {
        setNome(params[0].trim());
        setImporto(Double.parseDouble(params[1].trim()));
        setMeseInizio(Integer.parseInt(params[2].trim()));
        setAnnoInizio(Integer.parseInt(params[3].trim()));
        setFrequenza(Integer.parseInt(params[4].trim()));
        setNumRipetiz(Integer.parseInt(params[5].trim()));
        setCategoria(params[6].trim());
        return true;
    } catch(NumberFormatException e) {
        Log.e("Rule", "数字解析失败：" + rule, e);
        return false;
    } catch (Exception e) {
        Log.e("Rule", "加载Rule失败", e);
        return false;
    }
}

4. 可选优化：改用SharedPreferences #

对于这种结构化的键值对数据，SharedPreferences比自定义文件存储更可靠，Android系统会保证写入的原子性，无需自己处理流和序列化：

// 保存数据
SharedPreferences sp = getSharedPreferences("user_data", Context.MODE_PRIVATE);
SharedPreferences.Editor editor = sp.edit();
editor.putInt("anno", user.anno);
editor.putInt("sfondo", user.sfondo);
editor.putInt("notifiche", user.notifiche);
// 存储rules可以用Gson转成Json字符串
Gson gson = new Gson();
editor.putString("rules", gson.toJson(user.rules));
editor.apply(); // apply()异步写入，commit()同步写入，根据需求选择

// 加载数据
SharedPreferences sp = getSharedPreferences("user_data", Context.MODE_PRIVATE);
user.anno = sp.getInt("anno", 默认值);
user.sfondo = sp.getInt("sfondo", 默认值);
user.notifiche = sp.getInt("notifiche", 默认值);
String rulesJson = sp.getString("rules", "[]");
user.rules = gson.fromJson(rulesJson, new TypeToken<List<Rule>>(){}.getType());

调试建议 #

• 在saveUserData()方法中，写入后立即读取一次数据，确认是否写入成功
• 查看Logcat中的错误日志，定位具体的异常位置
• 模拟内存紧张场景（比如打开多个应用），测试数据是否会丢失

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