Android SharedPreferences存储基本用法

作者: 但但但丶 | 来源:发表于2017-08-21 14:43 被阅读111次

这里面有基本数据类型、List集合、Map集合、对象都在这了 工具类里面 可以直接拿来用

简书图片
    public class SpUtil {  
      
        private static SharedPreferences sp;  
      
        private static SharedPreferences getSp(Context context) {  
            if (sp == null) {  
                sp = context.getSharedPreferences("SpUtil", Context.MODE_PRIVATE);  
            }  
            return sp;  
        }  
      
      
        /** 
         * 存入字符串 
         * 
         * @param context 上下文 
         * @param key     字符串的键 
         * @param value   字符串的值 
         */  
        public static void putString(Context context, String key, String value) {  
            SharedPreferences preferences = getSp(context);  
            //存入数据  
            Editor editor = preferences.edit();  
            editor.putString(key, value);  
            editor.commit();  
        }  
      
        /** 
         * 获取字符串 
         * 
         * @param context 上下文 
         * @param key     字符串的键 
         * @return 得到的字符串 
         */  
        public static String getString(Context context, String key) {  
            SharedPreferences preferences = getSp(context);  
            return preferences.getString(key, "");  
        }  
      
        /** 
         * 获取字符串 
         * 
         * @param context 上下文 
         * @param key     字符串的键 
         * @param value   字符串的默认值 
         * @return 得到的字符串 
         */  
        public static String getString(Context context, String key, String value) {  
            SharedPreferences preferences = getSp(context);  
            return preferences.getString(key, value);  
        }  
      
        /** 
         * 保存布尔值 
         * 
         * @param context 上下文 
         * @param key     键 
         * @param value   值 
         */  
        public static void putBoolean(Context context, String key, boolean value) {  
            SharedPreferences sp     = getSp(context);  
            Editor            editor = sp.edit();  
            editor.putBoolean(key, value);  
            editor.commit();  
        }  
      
        /** 
         * 获取布尔值 
         * 
         * @param context  上下文 
         * @param key      键 
         * @param defValue 默认值 
         * @return 返回保存的值 
         */  
        public static boolean getBoolean(Context context, String key, boolean defValue) {  
            SharedPreferences sp = getSp(context);  
            return sp.getBoolean(key, defValue);  
        }  
      
        /** 
         * 保存long值 
         * 
         * @param context 上下文 
         * @param key     键 
         * @param value   值 
         */  
        public static void putLong(Context context, String key, long value) {  
            SharedPreferences sp     = getSp(context);  
            Editor            editor = sp.edit();  
            editor.putLong(key, value);  
            editor.commit();  
        }  
      
        /** 
         * 获取long值 
         * 
         * @param context  上下文 
         * @param key      键 
         * @param defValue 默认值 
         * @return 保存的值 
         */  
        public static long getLong(Context context, String key, long defValue) {  
            SharedPreferences sp = getSp(context);  
            return sp.getLong(key, defValue);  
        }  
      
        /** 
         * 保存int值 
         * 
         * @param context 上下文 
         * @param key     键 
         * @param value   值 
         */  
        public static void putInt(Context context, String key, int value) {  
            SharedPreferences sp     = getSp(context);  
            Editor            editor = sp.edit();  
            editor.putInt(key, value);  
            editor.commit();  
        }  
      
        /** 
         * 获取long值 
         * 
         * @param context  上下文 
         * @param key      键 
         * @param defValue 默认值 
         * @return 保存的值 
         */  
        public static int getInt(Context context, String key, int defValue) {  
            SharedPreferences sp = getSp(context);  
            return sp.getInt(key, defValue);  
        }  
      
        /** 
         * 保存对象 
         * 
         * @param context 上下文 
         * @param key     键 
         * @param obj     要保存的对象(Serializable的子类) 
         * @param <T>     泛型定义 
         */  
        public static <T extends Serializable> void putObject(Context context, String key, T obj) {  
            try {  
                put(context, key, obj);  
            } catch (Exception e) {  
                e.printStackTrace();  
            }  
        }  
      
        /** 
         * 获取对象 
         * 
         * @param context 上下文 
         * @param key     键 
         * @param <T>     指定泛型 
         * @return 泛型对象 
         */  
        public static <T extends Serializable> T getObject(Context context, String key) {  
            try {  
                return (T) get(context, key);  
            } catch (Exception e) {  
                e.printStackTrace();  
            }  
            return null;  
        }  
      
        /** 
         * 存储List集合 
         * @param context 上下文 
         * @param key 存储的键 
         * @param list 存储的集合 
         */  
        public static void putList(Context context, String key, List<? extends Serializable> list) {  
            try {  
                put(context, key, list);  
            } catch (Exception e) {  
                e.printStackTrace();  
            }  
        }  
      
        /** 
         * 获取List集合 
         * @param context 上下文 
         * @param key 键 
         * @param <E> 指定泛型 
         * @return List集合 
         */  
        public static <E extends Serializable> List<E> getList(Context context, String key) {  
            try {  
                return (List<E>) get(context, key);  
            } catch (Exception e) {  
                e.printStackTrace();  
            }  
            return null;  
        }  
      
        /** 
         * 存储Map集合 
         * @param context 上下文 
         * @param key 键 
         * @param map 存储的集合 
         * @param <K> 指定Map的键 
         * @param <V> 指定Map的值 
         */  
        public static <K extends Serializable, V extends Serializable> void putMap(Context context,  
                String key, Map<K, V> map)  
        {  
            try {  
                put(context, key, map);  
            } catch (Exception e) {  
                e.printStackTrace();  
            }  
        }  
      
        public static <K extends Serializable, V extends Serializable> Map<K, V> getMap(Context context,  
                String key)  
        {  
            try {  
                return (Map<K, V>) get(context, key);  
            } catch (Exception e) {  
                e.printStackTrace();  
            }  
            return null;  
        }  
      
        /**存储对象*/  
        private static void put(Context context, String key, Object obj)  
                throws IOException  
        {  
            if (obj == null) {//判断对象是否为空  
                return;  
            }  
            ByteArrayOutputStream baos = new ByteArrayOutputStream();  
            ObjectOutputStream    oos  = null;  
            oos = new ObjectOutputStream(baos);  
            oos.writeObject(obj);  
            // 将对象放到OutputStream中  
            // 将对象转换成byte数组,并将其进行base64编码  
            String objectStr = new String(Base64.encode(baos.toByteArray(), Base64.DEFAULT));  
            baos.close();  
            oos.close();  
      
            putString(context, key, objectStr);  
        }  
      
        /**获取对象*/  
        private static Object get(Context context, String key)  
                throws IOException, ClassNotFoundException  
        {  
            String wordBase64 = getString(context, key);  
            // 将base64格式字符串还原成byte数组  
            if (TextUtils.isEmpty(wordBase64)) { //不可少,否则在下面会报java.io.StreamCorruptedException  
                return null;  
            }  
            byte[]               objBytes = Base64.decode(wordBase64.getBytes(), Base64.DEFAULT);  
            ByteArrayInputStream bais     = new ByteArrayInputStream(objBytes);  
            ObjectInputStream    ois      = new ObjectInputStream(bais);  
            // 将byte数组转换成product对象  
            Object obj = ois.readObject();  
            bais.close();  
            ois.close();  
            return obj;  
        }  
    }  



相关文章

网友评论

    本文标题:Android SharedPreferences存储基本用法

    本文链接:https://www.haomeiwen.com/subject/gjgcdxtx.html