Android SharedPreferences工具类，实现List/Map的保存读取

最近因为需要将List集合和Map集合的数据保存到SharedPreferences中，所以对以前自己封装的SharedPreferencesUtil进行了修改，在原有的保存读Integer，String，Float，Long，Boolean，Object的基础上增加了保存读取List<Object>以及Map<String,Object>的功能。话不多说，下面直接贴代码和简单的Demo，仅供参考：

SharedPreferencesUtil
代码
/**
* Created by ZhangHao on 2016/6/21.
* SharedPreferences 工具类
*/

public class SharedPreferencesUtil {

private static SharedPreferencesUtil util;
private static SharedPreferences sp;

private SharedPreferencesUtil(Context context, String name) {
sp = context.getSharedPreferences(name, Context.MODE_PRIVATE);
}

/**
* 初始化SharedPreferencesUtil,只需要初始化一次，建议在Application中初始化
*
* @param context 上下文对象
* @param name SharedPreferences Name
*/
public static void getInstance(Context context, String name) {
if (util == null) {
util = new SharedPreferencesUtil(context, name);
}
}

/**
* 保存数据到SharedPreferences
*
* @param key 键
* @param value 需要保存的数据
* @return 保存结果
*/
public static boolean putData(String key, Object value) {
boolean result;
SharedPreferences.Editor editor = sp.edit();
String type = value.getClass().getSimpleName();
try {
switch (type) {
case "Boolean":
editor.putBoolean(key, (Boolean) value);
break;
case "Long":
editor.putLong(key, (Long) value);
break;
case "Float":
editor.putFloat(key, (Float) value);
break;
case "String":
editor.putString(key, (String) value);
break;
case "Integer":
editor.putInt(key, (Integer) value);
break;
default:
Gson gson = new Gson();
String json = gson.toJson(value);
editor.putString(key, json);
break;
}
result = true;
} catch (Exception e) {
result = false;
e.printStackTrace();
}
editor.apply();
return result;
}

/**
* 获取SharedPreferences中保存的数据
*
* @param key 键
* @param defaultValue 获取失败默认值
* @return 从SharedPreferences读取的数据
*/
public static Object getData(String key, Object defaultValue) {
Object result;
String type = defaultValue.getClass().getSimpleName();
try {
switch (type) {
case "Boolean":
result = sp.getBoolean(key, (Boolean) defaultValue);
break;
case "Long":
result = sp.getLong(key, (Long) defaultValue);
break;
case "Float":
result = sp.getFloat(key, (Float) defaultValue);
break;
case "String":
result = sp.getString(key, (String) defaultValue);
break;
case "Integer":
result = sp.getInt(key, (Integer) defaultValue);
break;
default:
Gson gson = new Gson();
String json = sp.getString(key, "");
if (!json.equals("") && json.length() > 0) {
result = gson.fromJson(json, defaultValue.getClass());
} else {
result = defaultValue;
}
break;
}
} catch (Exception e) {
result = null;
e.printStackTrace();
}
return result;
}

/**
* 用于保存集合
*
* @param key key
* @param list 集合数据
* @return 保存结果
*/
public static <T> boolean putListData(String key, List<T> list) {
boolean result;
String type = list.get(0).getClass().getSimpleName();
SharedPreferences.Editor editor = sp.edit();
JsonArray array = new JsonArray();
try {
switch (type) {
case "Boolean":
for (int i = 0; i < list.size(); i++) {
array.add((Boolean) list.get(i));
}
break;
case "Long":
for (int i = 0; i < list.size(); i++) {
array.add((Long) list.get(i));
}
break;
case "Float":
for (int i = 0; i < list.size(); i++) {
array.add((Float) list.get(i));
}
break;
case "String":
for (int i = 0; i < list.size(); i++) {
array.add((String) list.get(i));
}
break;
case "Integer":
for (int i = 0; i < list.size(); i++) {
array.add((Integer) list.get(i));
}
break;
default:
Gson gson = new Gson();
for (int i = 0; i < list.size(); i++) {
JsonElement obj = gson.toJsonTree(list.get(i));
array.add(obj);
}
break;
}
editor.putString(key, array.toString());
result = true;
} catch (Exception e) {
result = false;
e.printStackTrace();
}
editor.apply();
return result;
}

/**
* 获取保存的List
*
* @param key key
* @return 对应的Lis集合
*/
public static <T> List<T> getListData(String key, Class<T> cls) {
List<T> list = new ArrayList<>();
String json = sp.getString(key, "");
if (!json.equals("") && json.length() > 0) {
Gson gson = new Gson();
JsonArray array = new JsonParser().parse(json).getAsJsonArray();
for (JsonElement elem : array) {
list.add(gson.fromJson(elem, cls));
}
}
return list;
}

/**
* 用于保存集合
*
* @param key key
* @param map map数据
* @return 保存结果
*/
public static <K, V> boolean putHashMapData(String key, Map<K, V> map) {
boolean result;
SharedPreferences.Editor editor = sp.edit();
try {
Gson gson = new Gson();
String json = gson.toJson(map);
editor.putString(key, json);
result = true;
} catch (Exception e) {
result = false;
e.printStackTrace();
}
editor.apply();
return result;
}

/**
* 用于保存集合
*
* @param key key
* @return HashMap
*/
public static <V> HashMap<String, V> getHashMapData(String key, Class<V> clsV) {
String json = sp.getString(key, "");
HashMap<String, V> map = new HashMap<>();
Gson gson = new Gson();
JsonObject obj = new JsonParser().parse(json).getAsJsonObject();
Set<Map.Entry<String, JsonElement>> entrySet = obj.entrySet();
for (Map.Entry<String, JsonElement> entry : entrySet) {
String entryKey = entry.getKey();
JsonObject value = (JsonObject) entry.getValue();
map.put(entryKey, gson.fromJson(value, clsV));
}
Log.e("SharedPreferencesUtil", obj.toString());
return map;
}
}

SharedPreferences是无法直接保存Object,List集合和Map集合的，需要先将它们转换为字符串，在保存到SharedPreferences中，取得时候再把对应的字符串转为Object,List集合或者Map集合。
我这里的做法是利用Gson将Object,List或者Map转成Json保存到SharedPreferences中，取数据的时候再通过Gson将json数据转成Object,List集合或者Map集合。

使用步骤
1、初始化：

2、保存常规数据：

3、读取常规数据 :

4、保存List集合：

5、读取List集合：

6.保存Map集合：

7、读取Map集合：

Demo
SharedPreferencesUtil的使用方法十分简单，基本上不需要Demo就能直接使用。但这里还是把demo代码贴一下，觉得没必要的可以直接略过：

Activity
/**
* Created by ZhangHao on 2017/6/23.
* 用来测试SharedPreferencesUtil工具类
*/
public class SpActivity extends AppCompatActivity {

@BindView(R.id.boolean_check)
CheckBox booleanCheck;
@BindView(R.id.int_input)
EditText intInput;
@BindView(R.id.text_input)
EditText textInput;
@BindView(R.id.float_input)
EditText floatInput;
@BindView(R.id.long_input)
EditText longInput;
@BindView(R.id.showResult)
TextView showResult;
private String intKey = "intKey";
private String stringKey = "stringKey";
private String floatKey = "floatKey";
private String longKey = "longKey";
private String booleanKey = "booleanKey";
private String beanKey = "beanKey";
private String hunmansKey = "hunmansKey";
private String intsKey = "intsKey";
private String strsKey = "strsKey";
private String mapKey = "mapKey";

private HumanBean bean;
//List
private List<Integer> integers = new ArrayList<>();
private List<HumanBean> humanBeens = new ArrayList<>();
private List<String> strings = new ArrayList<>();
//Map
private Map<String, HumanBean> map = new HashMap<>();

@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_sp);
ButterKnife.bind(this);
//初始化HumanBean
bean = new HumanBean(true, 20, "Black_Hao", 24f, "男", System.currentTimeMillis()
, new SchoolBean("AnHui", 20, System.currentTimeMillis(), false));
}

public void onClick(View view) {
switch (view.getId()) {
case R.id.save_input:
//保存从EditText输入的常规数据到sp
boolean bool = booleanCheck.isChecked();
String str = textInput.getText().toString().trim();
int in = Integer.parseInt(intInput.getText().toString());
float f = Float.parseFloat(floatInput.getText().toString().trim());
long lo = Long.parseLong(longInput.getText().toString().trim());

boolean resultBol = SharedPreferencesUtil.putData(booleanKey, bool);
boolean resultInt = SharedPreferencesUtil.putData(intKey, in);
boolean resultStr = SharedPreferencesUtil.putData(stringKey, str);
boolean resultFlo = SharedPreferencesUtil.putData(floatKey, f);
boolean resultLon = SharedPreferencesUtil.putData(longKey, lo);
boolean resultBea = SharedPreferencesUtil.putData(beanKey, bean);
showResult.setText("resultBol:---" + resultBol + " \nresultInt:--- " + resultInt
+ " \nresultStr:--- " + resultStr + " \nresultFlo:--- " +
resultFlo + " \nresultLon:--- " + resultLon
+ " \nresultBea --- " + resultBea);
break;
case R.id.get_input:
//读取常规数据并显示到showResult
boolean Bol = (boolean) SharedPreferencesUtil.getData(booleanKey, false);
int Int = (int) SharedPreferencesUtil.getData(intKey, -1);
String Str = (String) SharedPreferencesUtil.getData(stringKey, "");
float Flo = (float) SharedPreferencesUtil.getData(floatKey, 0f);
long Lon = (long) SharedPreferencesUtil.getData(longKey, 1L);
HumanBean Bea = (HumanBean) SharedPreferencesUtil.getData(beanKey, bean);

showResult.setText(Bol + " \n " + Int + " \n " + Str
+ " \n " + Flo + " \n " + Lon + " \n " + Bea.toString());
break;

case R.id.save_list:
//保存List数据到SharedPreferences
getDefaultList();
boolean resultInts = SharedPreferencesUtil.putListData(intsKey, integers);
boolean resultBeans = SharedPreferencesUtil.putListData(hunmansKey, humanBeens);
boolean resultStrs = SharedPreferencesUtil.putListData(strsKey, strings);
showResult.setText("resultInts:---" + resultInts
+ "\nresultBeans:---" + resultBeans + "\nresultStrs:---" + resultStrs);
break;
case R.id.get_list:
////读取Map数据并显示到showResult
integers.clear();
humanBeens.clear();
strings.clear();
integers.addAll(SharedPreferencesUtil.getListData(intsKey, Integer.class));
humanBeens.addAll(SharedPreferencesUtil.getListData(hunmansKey, HumanBean.class));
strings.addAll(SharedPreferencesUtil.getListData(strsKey, String.class));
//遍历integers并将结果打印
String intsStr = "{";
for (int i = 0; i < integers.size(); i++) {
intsStr += integers.get(i) + " --- ";
}
intsStr += "}";
//遍历humanBeens并将结果打印
String humsStr = "";
for (int i = 0; i < humanBeens.size(); i++) {
humsStr += humanBeens.get(i).toString() + "\n";
}
//遍历strings并将结果打印
String strs = "{";
for (int i = 0; i < strings.size(); i++) {
strs += strings.get(i) + " ---- ";
}
strs += "}";
showResult.setText(intsStr + "\n" + humsStr + "\n" + strs);
break;
case R.id.save_map:
//保存Map数据到SharedPreferences
getDefaultList();
boolean resultMap = SharedPreferencesUtil.putHashMapData(mapKey, map);
showResult.setText("resultMap:---" + resultMap);
break;
case R.id.get_map:
//读取Map数据并显示到showResult
map.clear();
map.putAll(SharedPreferencesUtil.getHashMapData(mapKey, HumanBean.class));
//遍历map并将结果打印
String mapStr = "";
for (String key : map.keySet()) {
mapStr += key + " : " + map.get(key).toString() + "\n";
}
showResult.setText(mapStr);
break;
}
}

/**
* 生成默认数据以保存到SharedPreferences
*/
private void getDefaultList() {
integers.clear();
humanBeens.clear();
strings.clear();
String[] names = new String[]{"Black_Hao", "White_Hao", "Gray_Hao", "Blue_Hao"};
Random random = new Random();
for (int i = 0; i < 20; i++) {
int s = random.nextInt(100);
integers.add(s);
humanBeens.add(new HumanBean(s % 2 == 0, s, names[s % 4], 24f, "男", System.currentTimeMillis()
, new SchoolBean("AnHui", 20, System.currentTimeMillis(), s % 3 == 0)));
strings.add(names[s % 4]);
map.put(strings.get(i) + i, humanBeens.get(i));
}
}
}

Layout
<?xml version="1.0" encoding="utf-8"?>
<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
android:layout_width="match_parent"
android:layout_height="match_parent"
android:orientation="vertical">

<TextView
android:id="@+id/showResult"
android:layout_width="wrap_content"
android:layout_height="wrap_content"
android:layout_margin="5dp" />
</LinearLayout>

Application
这里Application只做了初始化SharedPreferencesUtil的操作

/**
* Created by ZhangHao on 2017/6/23.
*/

public class HaoApp extends Application {

@Override
public void onCreate() {
super.onCreate();
SharedPreferencesUtil.getInstance(this, "Test");
}
}

自定义实体类
为了测试Object保存读取，自定义两个简单的实体类

HumanBean
/**
* Created by ZhangHao on 2017/6/23.
* 用来测试SharedPreferencesUtil
*/

public class HumanBean {

private boolean isTest;
private int num;
private String name;
private String sex;
private float age;
private long time;
private SchoolBean bean;
private List<String> family;

public HumanBean(boolean isTest, int num, String name, float age,
String sex, long time, SchoolBean bean) {
this.isTest = isTest;
this.num = num;
this.name = name;
this.age = age;
this.sex = sex;
this.time = time;
this.bean = bean;
family = new ArrayList<>();
family.add("Father");
family.add("Mother");
family.add("Sister");
family.add("Brother");
family.add("Self");
}

public boolean isTest() {
return isTest;
}

public void setTest(boolean test) {
isTest = test;
}

public int getNum() {
return num;
}

public void setNum(int num) {
this.num = num;
}

public String getName() {
return name;
}

public void setName(String name) {
this.name = name;
}

public String getSex() {
return sex;
}

public void setSex(String sex) {
this.sex = sex;
}

public float getAge() {
return age;
}

public void setAge(float age) {
this.age = age;
}

public long getTime() {
return time;
}

public void setTime(long time) {
this.time = time;
}

public SchoolBean getBean() {
return bean;
}

public void setBean(SchoolBean bean) {
this.bean = bean;
}

@Override
public String toString() {
return "HumanBean{" +
"isTest=" + isTest +
", num=" + num +
", name='" + name + '\'' +
", sex='" + sex + '\'' +
", age=" + age +
", time=" + time +
", bean=" + bean +
", family=" + family +
'}';
}
}

SchoolBean
/**
* Created by ZhangHao on 2017/6/23.
* 用来测试SharedPreferencesUtil
*/

public class SchoolBean {

private String homeAddr;
private int grade;
private long schoolTime;
private boolean isBoarding;
private List<Integer> students;

public SchoolBean(String homeAddr, int grade, long schoolTime, boolean isBoarding) {
this.homeAddr = homeAddr;
this.grade = grade;
this.schoolTime = schoolTime;
this.isBoarding = isBoarding;
students = new ArrayList<>();
students.add(15);
students.add(105);
students.add(150);
}

public String getHomeAddr() {
return homeAddr;
}

public void setHomeAddr(String homeAddr) {
this.homeAddr = homeAddr;
}

public int getGrade() {
return grade;
}

public void setGrade(int grade) {
this.grade = grade;
}

public long getSchoolTime() {
return schoolTime;
}

public void setSchoolTime(long schoolTime) {
this.schoolTime = schoolTime;
}

public boolean isBoarding() {
return isBoarding;
}

public void setBoarding(boolean boarding) {
isBoarding = boarding;
}

@Override
public String toString() {
return "SchoolBean{" +
"homeAddr='" + homeAddr + '\'' +
", grade=" + grade +
", schoolTime=" + schoolTime +
", isBoarding=" + isBoarding +
", students=" + students +
'}';
}
}
---------------------
作者：Black_Hao
来源：CSDN
原文：https://blog.csdn.net/a512337862/article/details/73633420
版权声明：本文为博主原创文章，转载请附上博文链接！

Android SharedPreferences工具类 ，实现List/Map的保存读取

猜你喜欢

Android SharedPreferences工具类，实现List/Map的保存读取