Android_数据存储-SharedPreferences

一、SharedPreferences简介

1.了解SharedPreferences
        为了保存软件的设置参数，Android 平台为我们提供了一个SharedPreferences 类，它是一个轻量级的存储类，特别适合用于保存软件配置参数。使用SharedPreferences 保存数据，其背后是用xml文件存放数据，文件存放在/data/data/<package name>/shared_prefs 目录下。

2.获取SharedPreferences对象方法：
        SharedPreferences pre = Context.getSharedPreferences(String name,int mode);
        name为本组件的配置文件名（如果想要与本应用程序的其他组件共享此配置文件，可以用这个名字来检索到这个配置文件，在这里要特别注意，因为在Android 中已经确定了SharedPreferences 是以xml形式保存，所以，在填写文件名参数时，不要给定“.xml”后缀，android会自动添加。只要直接写上文件名即可。它会直接被保存在/data/data/<package name>/shared_prefs路径下，它是采用键值对的形式保存参数。当你需要获得某个参数值时，按照参数的键索引即可）。
        SharedPreferences pre = Activity.getPreferences(int mode);
        配置文件仅可以被调用的Activity使用。mode为操作模式，默认的模式为0或MODE_PRIVATE，还可以使用MODE_APPEND、MODE_WORLD_READABLE和MODE_WORLD_WRITEABLE。
        SharedPreferences pre = PreferenceManager.getDefaultSharedPreferences(Context);
        每个应用都有一个默认的配置文件preferences.xml，使用getDefaultSharedPreferences获取。

3.SharedPreferences使用步骤：
        SharedPreferences使用非常简单，能够轻松地存放数据和读取数据。SharedPreferences只能保存简单类型的数据，例如：String、int等。一般会将复杂类型的数据转换成Base64编码，然后将转换后的数据以字符串的形式保存在XML文件中，再用SharedPreferences保存。
        使用SharedPreferences保存key-value对的步骤如下：
      （1）获得SharedPreferences对象
      （2）获得SharedPreferences.Editor对象。
      （3）通过SharedPreferences.Editor接口的putXxx（）方法存放key-value对（其中Xxx表示不同的数据类型。如：字符串类型的value需要用putString（）方法）。
      （4）通过SharedPreferences.Editor接口的commit（）方法保存key-value对（commit方法相当于数据库事务中的提交（commit）操作）。

4.apply和commit的区别
       apply和commit方法都可以提交操作，那他们之间的区别是什么呢？
      （1）apply没有返回值，commit返回boolean表明修改是否提交成功 
      （2）apply是将数据提交到内存, 然后异步提交到硬件磁盘；commit是同步的提交到硬件磁盘。因此，在多个并发的提交的时候，commit提交方式会等待正在处理的commit保存到磁盘后在操作，从而降低了效率。apply是先提交到内存，然后异步提交到硬件磁盘，这样从一定程度上提高了很多效率。 
      （3）apply方法不会提示任何失败的提示。 在一个进程中，sharedPreference是单实例，一般不会出现并发冲突，如果对提交的结果不关心的话，建议使用apply，当然需要确保提交成功且有后续操作的话，还是需要用commit的。

       个人的扯蛋总结：我个人总喜欢把程序的相关类都想象成一个帝国建筑（像Google总部，苹果总部）里面相关的东西进行记忆和理解！每做一个程序就相当于建造一个大楼，而SharedPreferences就是相当于一间存放相关配置信息的房间，里面有很多柜子，每个柜子放着对应的信息，我们可以根据柜子的名称去获取到相关的资料信息，这个房间就好像是SharedPreferences，只是一个存放信息的空间，我们可以获取和存放信息，可是我们存放信息需要整理成键值对的形式进行存放，这时候就需要一个editor工人，把相关的信息进行整理，然后就放到这个房间中！        

二、SharedPreferences工具类的Demo
        先看效果图：

       SharedPreferencesUtils的代码：

package com.liangdianshui.sharedpreferencesutildemo;

import android.content.Context;
import android.content.SharedPreferences;

import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
import java.util.Map;

/**
 * Created by liangdianshui on 2016/6/6.
 */
public class SharedPreferencesUtils {
    //文件名称
    private static final String NAME = "SharedPreferences_Date";

    /**
     * 根据数据类型的不同调用不同的方法保存数据到SharedPreferences中
     *
     * @param context 上下文
     * @param key     key名
     * @param object  数据值
     */
    public static void setParam(Context context, String key, Object object) {

        String type = object.getClass().getSimpleName();
        SharedPreferences sp = context.getSharedPreferences(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();
    }


    /**
     * 根据默认值获取对应的数据类型，从SharedPreferences中获取对应的值
     *
     * @param context       上下文
     * @param key           key值
     * @param defaultObject 默认值
     * @return
     */
    public static Object getParam(Context context, String key, Object defaultObject) {
        String type = defaultObject.getClass().getSimpleName();
        SharedPreferences sp = context.getSharedPreferences(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;
    }

    /**
     * 移除某个key值已经对应的值
     *
     * @param context
     * @param key
     */
    public static void remove(Context context, String key) {
        SharedPreferences sp = context.getSharedPreferences(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(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(NAME, Context.MODE_PRIVATE);
        return sp.contains(key);
    }

    /**
     * 返回所有的键值对
     *
     * @param context
     * @return
     */
    public static Map<String, ?> getAll(Context context) {
        SharedPreferences sp = context.getSharedPreferences(NAME, Context.MODE_PRIVATE);
        return sp.getAll();
    }


    /**
     * 创建一个解决SharedPreferencesCompat.apply方法的一个兼容类
     */
    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 (IllegalArgumentException e) {
                e.printStackTrace();
            } catch (IllegalAccessException e) {
                e.printStackTrace();
            } catch (InvocationTargetException e) {
                e.printStackTrace();
            }
            editor.commit();
        }
    }

}

       MainActivity的代码：

package com.liangdianshui.sharedpreferencesutildemo;

import android.support.v7.app.AppCompatActivity;
import android.os.Bundle;
import android.text.Editable;
import android.util.Log;
import android.view.View;
import android.widget.Button;
import android.widget.EditText;
import android.widget.TextView;
import android.widget.Toast;

import java.io.BufferedReader;
import java.io.FileInputStream;
import java.io.InputStreamReader;
import java.util.Map;

public class MainActivity extends AppCompatActivity implements View.OnClickListener {

    public static final String PATH = "/data/data/com.liangdianshui.sharedpreferencesutildemo" +
            "/shared_prefs/SharedPreferences_Date.xml";
    private EditText mEtKey;
    private EditText mEtValue;
    private Button mBtSetParam;
    private Button mBtGetParam;
    private Button mBtRemove;
    private Button mBtClear;
    private Button mBtContains;
    private Button mBtGetAll;
    private Toast mToast;
    private TextView mTvText;

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);
        initView();
    }

    private void initView() {
        mEtKey = (EditText) findViewById(R.id.et_key);
        mEtValue = (EditText) findViewById(R.id.et_value);
        mBtSetParam = (Button) findViewById(R.id.bt_setParam);
        mBtGetParam = (Button) findViewById(R.id.bt_getParam);
        mBtRemove = (Button) findViewById(R.id.bt_remove);
        mBtClear = (Button) findViewById(R.id.bt_clear);
        mBtContains = (Button) findViewById(R.id.bt_contains);
        mBtGetAll = (Button) findViewById(R.id.bt_getAll);
        mTvText = (TextView) findViewById(R.id.tv_text);
        mBtSetParam.setOnClickListener(this);
        mBtGetParam.setOnClickListener(this);
        mBtRemove.setOnClickListener(this);
        mBtClear.setOnClickListener(this);
        mBtContains.setOnClickListener(this);
        mBtGetAll.setOnClickListener(this);
    }

    /**
     * 获取存储文件的数据
     */
    private String printSharedPreferences() {
        StringBuffer buff = new StringBuffer();
        try {
            BufferedReader reader = new BufferedReader(new InputStreamReader(
                    new FileInputStream(PATH)));
            String str;
            while ((str = reader.readLine()) != null) {
                buff.append(str + "\n");
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
        return buff.toString();
    }


    @Override
    public void onClick(View v) {
        String key;
        String value;
        switch (v.getId()) {
            case R.id.bt_setParam:
                key = mEtKey.getText().toString();
                value = mEtValue.getText().toString();
                if ((!"".equals(key)) && (!"".equals(value))) {
                    SharedPreferencesUtils.setParam(this, key, value);
                    mTvText.setText(printSharedPreferences());
                } else {
                    showToast("key和value不能为空!");
                }
                break;
            case R.id.bt_getParam:
                key = mEtKey.getText().toString();
                value = mEtValue.getText().toString();
                if ((!"".equals(key)) && (!"".equals(value))) {
                    mTvText.setText(printSharedPreferences());
                    showToast("获取的值为：" + SharedPreferencesUtils.getParam(this, key, value).toString());
                } else {
                    showToast("key和value不能为空!");
                }
                break;
            case R.id.bt_remove:
                key = mEtKey.getText().toString();
                if (!"".equals(key)) {
                    SharedPreferencesUtils.remove(this, key);
                    showToast("移除成功");
                    mTvText.setText(printSharedPreferences());
                } else {
                    showToast("key不能为空!");
                }
                break;
            case R.id.bt_clear:
                SharedPreferencesUtils.clear(this);
                showToast("清除成功");
                mTvText.setText(printSharedPreferences());
                break;
            case R.id.bt_contains:
                key = mEtKey.getText().toString();
                if (!"".equals(key)) {
                    SharedPreferencesUtils.contains(this, key);
                    showToast("key值存在");
                } else {
                    showToast("key不能为空!");
                }
                break;
            case R.id.bt_getAll:
                Map<String, String> all = (Map<String, String>) SharedPreferencesUtils.getAll(this);
                showToast(all.toString());
                break;
        }
    }


    private void showToast(String text) {
        if (mToast == null) {
            mToast = Toast.makeText(this, text, Toast.LENGTH_SHORT);
        } else {
            mToast.setText(text);
        }
        mToast.show();
    }
}

       Demo下载地址： http://download.csdn.net/detail/two_water/9543283