content: package cn.com.superLei.aoparms.common.utils;
  
  import android.content.Context;
  import android.content.SharedPreferences;
  import android.text.TextUtils;
  import android.util.Base64;
  
  import java.io.ByteArrayInputStream;
  import java.io.ByteArrayOutputStream;
  import java.io.IOException;
  import java.io.ObjectInputStream;
  import java.io.ObjectOutputStream;
  import java.lang.reflect.Method;
  import java.util.Map;
  
  /**
   * Created by LiuLei on 2016/7/15.
   *
   */
  public class ArmsPreference {
  
      /**
       * 保存在手机里面的文件名
       */
      public static final String FILE_NAME = "share_data";
  
      /**
       * 保存数据的方法，我们需要拿到保存数据的具体类型，然后根据类型调用不同的保存方法
       *
       * @param context
       * @param key
       * @param object
       */
      public static void put(Context context, String key, Object object) {
          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 {
              putObject(editor, key, object);
          }
          SharedPreferencesCompat.apply(editor);
      }
  
      /**
       * 得到保存数据的方法，我们根据默认值得到保存的数据的具体类型，然后调用相对于的方法获取值
       *
       * @param context
       * @param key
       * @param defaultObject
       * @return
       */
      public static <T> T get(Context context, String key, T defaultObject) {
  	    SharedPreferences sp = context.getSharedPreferences(FILE_NAME, Context.MODE_PRIVATE);
  	    if (defaultObject instanceof String) {
  		    return (T) sp.getString(key, (String) defaultObject);
  	    } else if (defaultObject instanceof Integer) {
  		    return (T) Integer.valueOf(sp.getInt(key, (Integer) defaultObject));
  	    } else if (defaultObject instanceof Boolean) {
  		    return (T) Boolean.valueOf(sp.getBoolean(key, (Boolean) defaultObject));
  	    } else if (defaultObject instanceof Float) {
  		    return (T) Float.valueOf(sp.getFloat(key, (Float) defaultObject));
  	    } else if (defaultObject instanceof Long) {
  		    return (T) Long.valueOf(sp.getLong(key, (Long) defaultObject));
  	    } else {
  		    return (T) getObject(sp, key);
  	    }
      }
  
      private static Object getObject(SharedPreferences sp, String key) {
          try {
              String stringBase64 = sp.getString(key, "");
              if (TextUtils.isEmpty(stringBase64))
                  return null;
              byte[] base64Bytes = Base64.decode(stringBase64.getBytes(), Base64.DEFAULT);
              ByteArrayInputStream bais = new ByteArrayInputStream(base64Bytes);
              ObjectInputStream ois = new ObjectInputStream(bais);
              return ois.readObject();
          } catch (Exception e) {
              e.printStackTrace();
          }
          return null;
      }
  
  
      private static void putObject(SharedPreferences.Editor editor, String key, Object obj) {
          try {
              ByteArrayOutputStream baos = new ByteArrayOutputStream();
              ObjectOutputStream oos = new ObjectOutputStream(baos);
              oos.writeObject(obj);
  
              String stringBase64 = new String(Base64.encode(baos.toByteArray(), Base64.DEFAULT));
              editor.putString(key, stringBase64);
          } catch (IOException e) {
              e.printStackTrace();
          }
      }
  
  
  
      /**
       * 移除某个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) {
                  e.printStackTrace();
              }
              return null;
          }
  
          /**
           * 如果找到则使用apply执行，否则使用commit
           *
           * @param editor
           */
          public static void apply(SharedPreferences.Editor editor) {
              try {
                  if (sApplyMethod != null) {
                      sApplyMethod.invoke(editor);
                      return;
                  }
              } catch (Exception e) {
                  e.printStackTrace();
              }
              editor.commit();
          }
      }
  
  }
  