一个方便的SharedPreferencesUtils工具

SharedPreferencesUtils存储对象

SharedPreferences可以存储基本类型，在这里不多阐述。在这里主要介绍怎么存储对象。

在我学习优化Utils工具包的一些常见的工具类。

在百度上的一些关于SharedPreferences存储对象的方式的使用Base64转，或者转成json类型，存入SharedPreferences中，这样写显得很笨拙。并不符合我的需求。在此给一种新的方法（我也不确定，应该很早就有这样写的吧）。

读写基本数据类型

读写Javabean类型

读写List<Javabean>类型

读写图片资源

1， 读写基本数据类型

/**
* 存储基本数据类型
* @param context
* @param key key
* @param data value
*/
public static void saveData(Context context, String key, Object data) {
String type = data.getClass().getSimpleName();
SharedPreferences sharedPreferences = context.getSharedPreferences(FILE_NAME, Context
.MODE_PRIVATE);//读写基本数据类型都是在一个特定的文件，以软件的包名为文件名
Editor editor = sharedPreferences.edit();
if ("Integer".equals(type)) {//注意这里是integer对象，同下
editor.putInt(key, (Integer) data);
} else if ("Boolean".equals(type)) {
editor.putBoolean(key, (Boolean) data);
} else if ("String".equals(type)) {
editor.putString(key, (String) data);
} else if ("Float".equals(type)) {
editor.putFloat(key, (Float) data);
} else if ("Long".equals(type)) {
editor.putLong(key, (Long) data);
}
editor.commit();
}

/**
* 读取基本数据类型
* @param context
* @param key key
* @param defValue 当取不到值时返回默认值
* @return
*/
public static Object getData(Context context, String key, Object defValue) {
String type = defValue.getClass().getSimpleName();
SharedPreferences sharedPreferences = context.getSharedPreferences(FILE_NAME, Context
.MODE_PRIVATE);  //defValue为为默认值，如果当前获取不到数据就返回它
if ("Integer".equals(type)) {
return sharedPreferences.getInt(key, (Integer) defValue);
} else if ("Boolean".equals(type)) {
return sharedPreferences.getBoolean(key, (Boolean) defValue);
} else if ("String".equals(type)) {
return sharedPreferences.getString(key, (String) defValue);
} else if ("Float".equals(type)) {
return sharedPreferences.getFloat(key, (Float) defValue);
} else if ("Long".equals(type)) {
return sharedPreferences.getLong(key, (Long) defValue);
}
return null;
}

将常用到的基本数据类型存入特定的文件中，获取的时候也十分方便快捷。（PS，string不是基本数据类型）

读写Javabean类型

先期准备

Javabean是序列化的，需要继承Serializable接口，实现serialVersionUID。

1.判断处理是否是各个数据类型

private static boolean isObject(Class<?> clazz) {
return clazz != null && !isSingle(clazz) && !isArray(clazz) && !isCollection(clazz) && !isMap(clazz);
}

private static boolean isSingle(Class<?> clazz) {
return isBoolean(clazz) || isNumber(clazz) || isString(clazz);
}

public static boolean isBoolean(Class<?> clazz) {
return clazz != null && (Boolean.TYPE.isAssignableFrom(clazz) || Boolean.class.isAssignableFrom(clazz));
}

public static boolean isNumber(Class<?> clazz) {
return clazz != null && (Byte.TYPE.isAssignableFrom(clazz) || Short.TYPE.isAssignableFrom(clazz) || Integer.TYPE.isAssignableFrom(clazz) || Long.TYPE.isAssignableFrom(clazz) || Float.TYPE.isAssignableFrom(clazz) || Double.TYPE.isAssignableFrom(clazz) || Number.class.isAssignableFrom(clazz));
}

public static boolean isString(Class<?> clazz) {
return clazz != null && (String.class.isAssignableFrom(clazz) || Character.TYPE.isAssignableFrom(clazz) || Character.class.isAssignableFrom(clazz));
}

public static boolean isArray(Class<?> clazz) {
return clazz != null && clazz.isArray();
}

public static boolean isCollection(Class<?> clazz) {
return clazz != null && Collection.class.isAssignableFrom(clazz);
}

public static boolean isMap(Class<?> clazz) {
return clazz != null && Map.class.isAssignableFrom(clazz);
}
private static boolean isParcelableCreator(Field field) {
return Modifier.toString(field.getModifiers()).equals("public static final") && "CREATOR"
.equals(field.getName());
}

2,插入数据

public static void setObject(Context context, Object o) {
Field[] fields = o.getClass().getDeclaredFields();//获取所有声明的属性
SharedPreferences sp = context.getSharedPreferences(o.getClass().getName(), 0);//将存储的文件名改为Javabean的包名+類名
SharedPreferences.Editor editor = sp.edit();

for (int i = 0; i < fields.length; ++i) {
if (!isParcelableCreator(fields[i])) {
Class type = fields[i].getType();//类型 class java.lang.class
String name = fields[i].getName();//名称 id
Object e;
if (isSingle(type)) {
try {
if (type != Character.TYPE && !type.equals(String.class)) {
if (!type.equals(Integer.TYPE) && !type.equals(Short.class)) {
if (type.equals(Double.TYPE)) {
editor.putLong(name, Double.doubleToLongBits(fields[i]
.getDouble(o)));//将double类型的数值存入
} else if (type.equals(Float.TYPE)) {
editor.putFloat(name, fields[i].getFloat(o));//将float类型的数值存入
} else if (type.equals(Long.TYPE) && !name.equals("serialVersionUID")) {
editor.putLong(name, fields[i].getLong(o));//将long类型的数值存入
} else if (type.equals(Boolean.TYPE)) {
editor.putBoolean(name, fields[i].getBoolean(o));//将boolean类型的数值存入
}
} else {
editor.putInt(name, fields[i].getInt(o));//将int类型的数值存入
}
} else {
e = fields[i].get(o);//将string类型的数值存入
editor.putString(name, null == e ? null : e.toString());
}
} catch (Exception var14) {
}
}else if (isObject(type)) {
try {
e = fields[i].get(o);
if (null != e) {
setObject(context, e);
} else {
try {
setObject(context, fields[i].getClass().newInstance());//重新跑一遍
} catch (InstantiationException var11) {
}
}
} catch (Exception var12) {

}
} else {
try {
e = fields[i].get(o);
//转成json插入
} catch (IllegalAccessException e1) {
e1.printStackTrace();
}

}
}
}
editor.apply();
}

public static <T> T getObject(Context context, Class<T> clazz) {
Object o = null;

try {
o = clazz.newInstance();
} catch (InstantiationException e) {
e.printStackTrace();
return (T) o;
} catch (IllegalAccessException e) {
e.printStackTrace();
return (T) o;
}

Field[] fields = clazz.getDeclaredFields();
SharedPreferences sp = context.getSharedPreferences(clazz.getName(), 0);

for(int i = 0; i < fields.length; ++i) {
if(!isParcelableCreator(fields[i])) {
Class type = fields[i].getType();
String name = fields[i].getName();
String o_1;
if(isSingle(type)) {
try {
fields[i].setAccessible(true);
if(type != Character.TYPE && !type.equals(String.class)) {
if(!type.equals(Integer.TYPE) && !type.equals(Short.class)){
if(type.equals(Double.TYPE)) {
fields[i].setDouble(o, Double.longBitsToDouble(sp.getLong(name, 0L)));
} else if(type.equals(Float.TYPE)) {
fields[i].setFloat(o, sp.getFloat(name, 0.0F));
} else if(type.equals(Long.TYPE)) {
fields[i].setLong(o, sp.getLong(name, 0L));
} else if(type.equals(Boolean.TYPE)) {
fields[i].setBoolean(o, sp.getBoolean(name, false));
}
} else {
fields[i].setInt(o, sp.getInt(name, 0));
}
} else {
o_1 = sp.getString(name, (String)null);
if(null != o_1) {
fields[i].set(o, o_1);
}
}
} catch (Exception e) {

}
} else if(isObject(type)) {
Object tempValue = getObject(context, fields[i].getType());
if(null != tempValue) {
fields[i].setAccessible(true);

try {
fields[i].set(o, tempValue);
} catch (Exception e) {

}
}
} else {
//json数据解析
}
}
}

return (T) o;
}

主要的思想就是遍历javabean所有的属性对象，取出，按照类型一个个的存入XML文件中。

取出时也是同时转成了存入的形式，很方便利

读写List<Javabean>

对于list<javabean>，不太适合用上面的方法，一般来说不太会存这种数据，数据量比较大。如果有这个需求，可以把list<javabean>转成json形式，然后存入xml文件中。关于Javabean数据转成json会在另一篇叙述。

读写图片资源

所谓的读写图片，个人感觉用处不大，先说一下思路。其实也很简单，就是通过base64将输出流转成string。

代码奉上：

private void saveBitmapToSharedPreferences(Context context,String key,Bitmap bitmap){
//第一步:将Bitmap压缩至字节数组输出流ByteArrayOutputStream
ByteArrayOutputStream byteArrayOutputStream=new ByteArrayOutputStream();
bitmap.compress(CompressFormat.PNG, 80, byteArrayOutputStream);
//第二步:利用Base64将字节数组输出流中的数据转换成字符串String
byte[] byteArray=byteArrayOutputStream.toByteArray();
String imageString=new String(Base64.encodeToString(byteArray, Base64.DEFAULT));
//第三步:将String保持至SharedPreferences
SharedPreferences sharedPreferences=context.getSharedPreferences(FILE_NAME, Context.MODE_PRIVATE);
Editor editor=sharedPreferences.edit();
editor.putString(key, imageString);
editor.commit();
}

private Bitmap getBitmapFromSharedPreferences(Context context, String key, Object defValue){
SharedPreferences sharedPreferences=getSharedPreferences(FILE_NAME, Context.MODE_PRIVATE);
//第一步:取出字符串形式的Bitmap
String imageString=context.sharedPreferences.getString(key,defValue);
//第二步:利用Base64将字符串转换为ByteArrayInputStream
byte[] byteArray=Base64.decode(imageString, Base64.DEFAULT);
ByteArrayInputStream byteArrayInputStream=new ByteArrayInputStream(byteArray);
//第三步:利用ByteArrayInputStream生成Bitmap
Bitmap bitmap=BitmapFactory.decodeStream(byteArrayInputStream);
return bitmap;
}

结束

简单叙述了下SharedPreferences的使用，毕竟作为Android中几个主要的存储数据的方式，熟练掌握还是 非常有必要的。