一个方便的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 getObject(Context context, Class 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中几个主要的存储数据的方式，熟练掌握还是 非常有必要的。