Android 如何在SharedReferences中存储整数数组？

我想使用SharedReference保存/调用整数数组，这可能吗？

您只能在

SharedReference

中保存原语值。改用Sqlite。

您不能将数组放入SharedReference中，但可以解决以下问题：

private static final String LEN_PREFIX = "Count_";
private static final String VAL_PREFIX = "IntValue_";
public void storeIntArray(String name, int[] array){
    SharedPreferences.Editor edit= mContext.getSharedPreferences("NAME", Context.MODE_PRIVATE).edit();
    edit.putInt(LEN_PREFIX + name, array.length);
    int count = 0;
    for (int i: array){
        edit.putInt(VAL_PREFIX + name + count++, i);
    }
    edit.commit();
}
public int[] getFromPrefs(String name){
    int[] ret;
    SharedPreferences prefs = mContext.getSharedPreferences("NAME", Context.MODE_PRIVATE);
    int count = prefs.getInt(LEN_PREFIX + name, 0);
    ret = new int[count];
    for (int i = 0; i < count; i++){
        ret[i] = prefs.getInt(VAL_PREFIX+ name + i, i);
    }
    return ret;
}

private static final String LEN\u PREFIX=“Count\u”；
私有静态最终字符串VAL_PREFIX=“IntValue”；
公共void存储阵列（字符串名称，int[]数组）{
SharedReferences.Editor edit=mContext.getSharedReferences（“NAME”，Context.MODE_PRIVATE）.edit（）；
edit.putInt（LEN_前缀+名称，array.length）；
整数计数=0；
for（int i:array）{
edit.putInt（VAL_前缀+名称+计数++，i）；
}
edit.commit（）；
}
public int[]getFromPrefs（字符串名称）{
int[]ret；
SharedReferences prefs=mContext.getSharedReferences（“名称”，Context.MODE\u PRIVATE）；
int count=prefs.getInt（LEN_前缀+名称，0）；
ret=新整数[计数]；
for（int i=0；i

您可以尝试这样做：

• 将整数放入字符串中，用字符（例如逗号）分隔每个整数，然后将其另存为字符串：

  SharedPreferences prefs = getPreferences(MODE_PRIVATE);
  int[] list = new int[10];
  StringBuilder str = new StringBuilder();
  for (int i = 0; i < list.length; i++) {
      str.append(list[i]).append(",");
  }
  prefs.edit().putString("string", str.toString());
  

  SharedPreferences-prefs=getPreferences（MODE\u PRIVATE）；
  int[]列表=新int[10]；
  StringBuilder str=新的StringBuilder（）；
  for（int i=0；i

• 获取字符串并使用StringTokenizer对其进行分析：

  String savedString = prefs.getString("string", "");
  StringTokenizer st = new StringTokenizer(savedString, ",");
  int[] savedList = new int[10];
  for (int i = 0; i < 10; i++) {
      savedList[i] = Integer.parseInt(st.nextToken());
  }
  

  String savedString=prefs.getString（“String”，“字符串”）；
  StringTokenizer st=新的StringTokenizer（savedString，“，”）；
  int[]savedList=新int[10]；
  对于（int i=0；i<10；i++）{
  savedList[i]=Integer.parseInt（st.nextToken（））；
  }
  

---

这是我的版本，基于埃戈尔的回答。我不喜欢使用StringBuilder，除非我正在构建一个Enoumous字符串，但感谢Egor使用StringTokenizer——在过去没有太多使用它，但它非常方便！仅供参考，这是我的实用课程：

public static void saveIntListPrefs(
    String name, Activity activity, List<Integer> list)
{
  String s = "";
  for (Integer i : list) {
    s += i + ",";
  }

  Editor editor = activity.getPreferences(Context.MODE_PRIVATE).edit();
  editor.putString(name, s);
  editor.commit();
}

public static ArrayList<Integer> readIntArrayPrefs(String name, Activity activity)
{
  SharedPreferences prefs = activity.getPreferences(Context.MODE_PRIVATE);
  String s = prefs.getString(name, "");
  StringTokenizer st = new StringTokenizer(s, ",");
  ArrayList<Integer> result = new ArrayList<Integer>();
  while (st.hasMoreTokens()) {
    result.add(Integer.parseInt(st.nextToken()));
  }
  return result;
}

公共静态void saveIntListPrefs(
字符串名称、活动、列表）
{
字符串s=“”；
for（整数i：列表）{
s+=i+“，”；
}
Editor Editor=activity.getPreferences（Context.MODE_PRIVATE.edit（）；
编辑器.putString（名称，s）；
commit（）；
}
公共静态ArrayList readIntArrayPrefs（字符串名称、活动）
{
SharedReferences prefs=activity.getPreferences（Context.MODE\u PRIVATE）；
字符串s=prefs.getString（名称“”）；
StringTokenizer st=新的StringTokenizer，“，”；
ArrayList结果=新建ArrayList（）；
而（st.hasMoreTokens（））{
add（Integer.parseInt（st.nextToken（））；
}
返回结果；
}

两种解决方案：
（1） 使用
它具有split/join函数，允许您在一行中连接和拆分整数：

StringUtils.join([1, 2, 3], ';')  = "1;2;3"
StringUtils.split("1;2;3", ';')   = ["1", "2", "3"]

不过，您仍然需要将字符串转换回整数
实际上，对于拆分

java.lang.String.split（）

也同样有效：
（2） 使用SharedReferences.putStringSet（）（API 11）：

SharedReferences.Editor=preferences.edit（）；
int count=this.intSet.size（）；
如果（计数>0）{
Set theSet=newhashset（）；
for（长l:this.intSet）{
集合add（字符串valueOf（l））；
}
编辑器.putStringSet（PREFS_键，theSet）；
}否则{
编辑器。删除（PREFS_键）；
}
commit（）；

为了找回它：

    Set<String> theSet = this.preferences.getStringSet(PREFS_KEY, null);
    if (theSet != null && !theSet.isEmpty()) {
        this.intSet.clear();
        for (String s : theSet) {
            this.intSet.add(Integer.valueOf(s));
        }
    }

Set theSet=this.preferences.getStringSet（PREFS_键，null）；
if（theSet！=null&&！theSet.isEmpty（））{
this.intSet.clear（）；
用于（字符串s:theSet）{
this.intSet.add（Integer.valueOf（s））；
}
}

---

这段代码不捕获NPE或NumberFormatException，因为intSet不包含任何空值。当然，如果您不能保证在代码中使用try/catch，那么我喜欢使用JSON来表示SharedReference中的任何复杂数据，JSON可以作为字符串存储和检索。 因此，对于int数组：

public void setPrefIntArray(String tag, int[] value)
{
    SharedPreferences.Editor prefEditor = PreferenceManager.getDefaultSharedPreferences(context)
            .edit();

    String s;
    try
    {
        JSONArray jsonArr = new JSONArray();
        for (int i : value)
            jsonArr.put(i);

        JSONObject json = new JSONObject();
        json.put(tag, jsonArr);

        s = json.toString();
    }
    catch(JSONException excp)
    {
        s = "";
    }

    prefEditor.putString(tag, s);
    prefEditor.commit();
}

public int[] getPrefIntArray(String tag, int[] defaultValue)
{
    SharedPreferences pref = PreferenceManager.getDefaultSharedPreferences(context);

    String s = pref.getString(tag, "");

    try
    {
        JSONObject json = new JSONObject(new JSONTokener(s));
        JSONArray jsonArr = json.getJSONArray(tag);

        int[] result = new int[jsonArr.length()];

        for (int i = 0; i < jsonArr.length(); i++)
            result[i] = jsonArr.getInt(i);

        return result;
    }
    catch(JSONException excp)
    {
        return defaultValue;
    }
}

public void setPrefIntArray（字符串标记，int[]值）
{
SharedReferences.Editor prefEditor=PreferenceManager.GetDefaultSharedReferences（上下文）
.edit（）；
字符串s；
尝试
{
JSONArray jsonArr=新的JSONArray（）；
for（int i:value）
jsonArr.put（一）；
JSONObject json=新的JSONObject（）；
put（tag，jsonArr）；
s=json.toString（）；
}
捕获（JSONException excp）
{
s=“”；
}
prefEditor.putString（标记，s）；
提交（）；
}
公共int[]getPrefIntArray（字符串标记，int[]defaultValue）
{
SharedReferences pref=PreferenceManager.GetDefaultSharedReferences（上下文）；
字符串s=pref.getString（标记“”）；
尝试
{
JSONObject json=新的JSONObject（新的JSONTokener）；
JSONArray jsonArr=json.getJSONArray（标记）；
int[]result=newint[jsonArr.length（）]；
for（int i=0；i

美妙之处在于，同样的想法也可以应用于任何其他可表示为JSON的复杂数据。
以下是Kotlin中“转换为逗号分隔字符串”解决方案的外观，它作为扩展函数实现：

fun SharedPreferences.Editor.putIntArray(key: String, value: IntArray): SharedPreferences.Editor {
    return putString(key, value.joinToString(
            separator = ",", 
            transform = { it.toString() }))
}

fun SharedPreferences.getIntArray(key: String): IntArray {
    with(getString(key, "")) {
        with(if(isNotEmpty()) split(',') else return intArrayOf()) {
            return IntArray(count(), { this[it].toInt() })
        }
    }
}

这样，您就可以像其他put和set方法一样使用

putIntArray（String，IntArray）

和

getIntArray（String）

：

val prefs = getSharedPreferences(PREFS_NAME, Context.MODE_PRIVATE)
prefs.edit().putIntArray(INT_ARRAY_TEST_KEY, intArrayOf(1, 2, 3)).apply()
val intArray = prefs.getIntArray(INT_ARRAY_TEST_KEY)

---

请注意，此方法只能在数据量很少的情况下使用，因为字符串操作效率不高。（读取时需要解析每个字符）。根据javadoc，不鼓励使用StringTokenizer:，而是使用String.split（）。请看这里的解决方案

val prefs = getSharedPreferences(PREFS_NAME, Context.MODE_PRIVATE)
prefs.edit().putIntArray(INT_ARRAY_TEST_KEY, intArrayOf(1, 2, 3)).apply()
val intArray = prefs.getIntArray(INT_ARRAY_TEST_KEY)