如何在SharedPreferences中存储整数数组？

Question

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

Answer 1

你可以尝试这样来做：

• 把你的整数转换成字符串，每划定一个字符诠释，例如一个逗号，然后将其保存为一个字符串：

  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()); 
  

• 获得信特林和使用的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()); 
  } 
  

Answer 2

您只能保存原始值sharedPreference。改为使用Sqlite。

Answer 3

你不能把数组中sharedPrefs，但可以解决方法：

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

Answer 4

这里是我的版本的基础上，叶戈尔的回答。我更喜欢不使用StringBuilder，除非我构建了一个丰富的字符串，但是感谢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; 
} 

Answer 5

两个解决方案：

（1）使用http://commons.apache.org/proper/commons-lang/apidocs/org/apache/commons/lang3/StringUtils.html

它已经分裂/加入，让你加入的功能，并在一个衬垫分割整数：

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

尽管如此，仍然必须将字符串转换回整数。

事实上，分裂java.lang.String.split()将工作一样精细： http://docs.oracle.com/javase/7/docs/api/java/lang/String.html#split(java.lang.String)

（2）使用SharedPreferences.putStringSet（）（API 11）：

SharedPreferences.Editor editor = preferences.edit(); 
    int count = this.intSet.size(); 
    if (count > 0) { 
     Set<String> theSet = new HashSet<String>(); 
     for (Long l : this.intSet) { 
      theSet.add(String.valueOf(l)); 
     } 
     editor.putStringSet(PREFS_KEY, theSet); 
    } else { 
     editor.remove(PREFS_KEY); 
    } 
    editor.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)); 
     } 
    } 

此代码无法捕获NPE或NumberFormatExceptions，因为intSet会以其他方式保证为否不包含任何空值。但是，当然，如果你不能保证在你的代码中你应该用try/catch来包围它。

Answer 6

我喜欢使用JSON，它可以作为字符串存储和检索，以表示SharedPreferences中的任何复杂数据。 因此，在一个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; 
    } 
} 

的妙处在于，同样的想法可以应用于任何其它复杂的数据表示为一个JSON。

Answer 7

这里是如何的“转换为逗号分隔字符串”解决方案可以看看在科特林，作为扩展函数来实现：

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() }) 
     } 
    } 
} 

这样，你可以使用putIntArray(String, IntArray)和getIntArray(String)就像其他PUT和设置方法：

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)