Android中SharedPreferencesUtil工具类，注意事项

我会带着你远行 2022-08-22 03:49 277阅读 0赞

SharedPreferences只能保存简单类型的数据，例如四种基本类型（int，float，long，boolean）+String。如果需要存取比较复杂的数据类型比如类或者图像，则需要对这些数据进行编码，通常将其转换成Base64编码，然后将转换后的数据以字符串的形式保存在XML文件中。

--------------------

**正确使用的建议**  
1、不要存放大的key和value在SharedPreferences中，否则会一直存储在内存中得不到释放，内存使用过高会频发引发GC，导致界面丢帧甚至ANR。

2、不相关的配置选项最好不要放在一起，单个文件越大读取速度则越慢。

3、读取频繁的key和不频繁的key尽量不要放在一起（如果整个文件本身就较小则忽略，为了这点性能添加维护得不偿失）。

4、不要每次都edit，因为每次都会创建一个新的EditorImpl对象，最好是批量处理统一提交。

否则edit().commit每次创建一个EditorImpl对象并且进行一次IO操作，严重影响性能。

5、commit发生在UI线程中，apply发生在工作线程中，对于数据的提交最好是批量操作统一提交。虽然apply发生在工作线程（不会因为IO阻塞UI线程）但是如果添加任务较多也有可能带来其他严重后果（参照ActivityThread源码中handleStopActivity方法实现）。

6、尽量不要存放json和html，这种可以直接文件缓存。

7、不要指望这货能够跨进程通信 Context.PROCESS 。

8、最好提前初始化SharedPreferences，避免SharedPreferences第一次创建时读取文件线程未结束而出现等待情况。

--------------------

public class SharedPreferencesUtil { 
        /** * 保存在手机里面的文件名 */  
        private static final String FILE_NAME = "share_date";  
        /** * 保存数据的方法，我们需要拿到保存数据的具体类型，然后根据类型调用不同的保存方法 * @param context * @param key * @param object */  
        public static void setParam(Context context , String key, Object object){  
    
            String type = object.getClass().getSimpleName();  
            SharedPreferences sp = context.getSharedPreferences(FILE_NAME, Context.MODE_PRIVATE);  
            SharedPreferences.Editor editor = sp.edit();  
    
            if("String".equals(type)){  
                editor.putString(key, (String)object);  
            }  
            else if("Integer".equals(type)){  
                editor.putInt(key, (Integer)object);  
            }  
            else if("Boolean".equals(type)){  
                editor.putBoolean(key, (Boolean)object);  
            }  
            else if("Float".equals(type)){  
                editor.putFloat(key, (Float)object);  
            }  
            else if("Long".equals(type)){  
                editor.putLong(key, (Long)object);  
            }  
    
            editor.commit();  
        }  
    
    
        /** * 得到保存数据的方法，我们根据默认值得到保存的数据的具体类型，然后调用相对于的方法获取值 * @param context * @param key * @param defaultObject * @return */  
        public static Object getParam(Context context , String key, Object defaultObject){  
            String type = defaultObject.getClass().getSimpleName();  
            SharedPreferences sp = context.getSharedPreferences(FILE_NAME, Context.MODE_PRIVATE);  
    
            if("String".equals(type)){  
                return sp.getString(key, (String)defaultObject);  
            }  
            else if("Integer".equals(type)){  
                return sp.getInt(key, (Integer)defaultObject);  
            }  
            else if("Boolean".equals(type)){  
                return sp.getBoolean(key, (Boolean)defaultObject);  
            }  
            else if("Float".equals(type)){  
                return sp.getFloat(key, (Float)defaultObject);  
            }  
            else if("Long".equals(type)){  
                return sp.getLong(key, (Long)defaultObject);  
            }  
    
            return null;  
        }  
    }

另外，再列举一个方法更全的SharedPreference工具类，如下：

public class SPUtils { 
        /** * 保存在手机里面的文件名 */
        public static final String FILE_NAME = "FILE_NAME";
    
        /** * 保存数据的方法，我们需要拿到保存数据的具体类型，然后根据类型调用不同的保存方法 * * @param context * @param key * @param object */
        public static void put(Context context, String key, Object object) {
            if (object == null) {
                return;
            }
            SharedPreferences sp = context.getSharedPreferences(FILE_NAME,
                    Context.MODE_PRIVATE);
            SharedPreferences.Editor editor = sp.edit();
    
            if (object instanceof String) {
                editor.putString(key, (String) object);
            } else if (object instanceof Integer) {
                editor.putInt(key, (Integer) object);
            } else if (object instanceof Boolean) {
                editor.putBoolean(key, (Boolean) object);
            } else if (object instanceof Float) {
                editor.putFloat(key, (Float) object);
            } else if (object instanceof Long) {
                editor.putLong(key, (Long) object);
            } else {
                editor.putString(key, object.toString());
            }
    
            SharedPreferencesCompat.apply(editor);
        }
    
        /** * 得到保存数据的方法，我们根据默认值得到保存的数据的具体类型，然后调用相对于的方法获取值 * * @param context * @param key * @param defaultObject * @return */
        public static Object get(Context context, String key, Object defaultObject) {
            SharedPreferences sp = context.getSharedPreferences(FILE_NAME,
                    Context.MODE_PRIVATE);
    
            if (defaultObject instanceof String) {
                return sp.getString(key, (String) defaultObject);
            } else if (defaultObject instanceof Integer) {
                return sp.getInt(key, (Integer) defaultObject);
            } else if (defaultObject instanceof Boolean) {
                return sp.getBoolean(key, (Boolean) defaultObject);
            } else if (defaultObject instanceof Float) {
                return sp.getFloat(key, (Float) defaultObject);
            } else if (defaultObject instanceof Long) {
                return sp.getLong(key, (Long) defaultObject);
            }
    
            return null;
        }
    
        /** * 移除某个key值已经对应的值 * * @param context * @param key */
        public static void remove(Context context, String key) {
            SharedPreferences sp = context.getSharedPreferences(FILE_NAME,
                    Context.MODE_PRIVATE);
            SharedPreferences.Editor editor = sp.edit();
            editor.remove(key);
            SharedPreferencesCompat.apply(editor);
        }
    
        /** * 清除所有数据 * * @param context */
        public static void clear(Context context) {
            SharedPreferences sp = context.getSharedPreferences(FILE_NAME,
                    Context.MODE_PRIVATE);
            SharedPreferences.Editor editor = sp.edit();
            editor.clear();
            SharedPreferencesCompat.apply(editor);
        }
    
        /** * 查询某个key是否已经存在 * * @param context * @param key * @return */
        public static boolean contains(Context context, String key) {
            SharedPreferences sp = context.getSharedPreferences(FILE_NAME,
                    Context.MODE_PRIVATE);
            return sp.contains(key);
        }
    
        /** * 返回所有的键值对 * * @param context * @return */
        public static Map<String, ?> getAll(Context context) {
            SharedPreferences sp = context.getSharedPreferences(FILE_NAME,
                    Context.MODE_PRIVATE);
            return sp.getAll();
        }
    
        /** * 创建一个解决SharedPreferencesCompat.apply方法的一个兼容类 * * @author zhy */
        private static class SharedPreferencesCompat { 
            private static final Method sApplyMethod = findApplyMethod();
    
            /** * 反射查找apply的方法 * * @return */
            @SuppressWarnings({
       "unchecked", "rawtypes"})
            private static Method findApplyMethod() {
                try {
                    Class clz = SharedPreferences.Editor.class;
                    return clz.getMethod("apply");
                } catch (NoSuchMethodException e) {
                }
    
                return null;
            }
    
            /** * 如果找到则使用apply执行，否则使用commit * * @param editor */
            public static void apply(SharedPreferences.Editor editor) {
                try {
                    if (sApplyMethod != null) {
                        sApplyMethod.invoke(editor);
                        return;
                    }
                } catch (IllegalArgumentException e) {
                } catch (IllegalAccessException e) {
                } catch (InvocationTargetException e) {
                }
                editor.commit();
            }
        }
    
    }

**对象存储：**

*  方法一：fastJson/Gson/Jackson将对象转换成字符串，然后再保存。
 *  方法二：ObjectOutputStream将对象转化成流，base64将流转成字符串，然后再保存。

/** * 存放实体类以及任意类型 * * @param context 上下文对象 * @param key * @param obj */
        public static void putBean(Context context, String key, Object obj) {
            if (obj instanceof Serializable) {
       // obj必须实现Serializable接口，否则会出问题
                try {
                    ByteArrayOutputStream baos = new ByteArrayOutputStream();
                    ObjectOutputStream oos = new ObjectOutputStream(baos);
                    oos.writeObject(obj);
                    String string64 = new String(Base64.encode(baos.toByteArray(), 0));
                    SharedPreferences sp = context.getSharedPreferences(FILE_NAME,
                            Context.MODE_PRIVATE);
                    SharedPreferences.Editor editor = sp.edit();
                    editor.putString(key, string64);
                    editor.commit();
                } catch (IOException e) {
                    e.printStackTrace();
                }
    
            } else {
                throw new IllegalArgumentException("the obj must implement Serializble");
            }
    
        }
    
        public static Object getBean(Context context, String key) {
            Object obj = null;
            try {
                String base64 = context.getSharedPreferences(FILE_NAME,
                        Context.MODE_PRIVATE).getString(key, "");
                if (base64.equals("")) {
                    return null;
                }
                byte[] base64Bytes = Base64.decode(base64.getBytes(), 1);
                ByteArrayInputStream bais = new ByteArrayInputStream(base64Bytes);
                ObjectInputStream ois = new ObjectInputStream(bais);
                obj = ois.readObject();
            } catch (Exception e) {
                e.printStackTrace();
            }
            return obj;
        }

另外两篇文章供参考[《请不要滥用SharedPreference》][SharedPreference]  
[《一个null引发的SharedPreference惨案》][null_SharedPreference]

[SharedPreference]: https://www.jianshu.com/p/8eb2147c328b
[null_SharedPreference]: https://blog.csdn.net/tracyxia716/article/details/52967110