用数据库存储方式代替SharedPreferences

时间 2019-11-16

标签数据库存储方式代替 sharedpreferences 栏目 SQL 繁體版

原文原文链接

第一次写博客，不足之处，请多多指点。主要是练手。 html

来自个人CSDN：http://blog.csdn.net/kareci/article/details/8979909 java

--------------------------------------------- 我是分割线 (华丽的 @ - @)--------------------------------------------- android

在应用开发中SharedPreferences确实很好用，可是最近应用崩溃时候，遇到SharedPreferences数据丢失问题。因此只有转用数据库存储，但愿能解决问题。 sql

模拟一个简单的SharedPreferences工具，嘿嘿。主要就是简单实现几个主要数据类型的存储。我支持的类型是：String,boolean,int,long,float，还有一个SharedPreferences不支持的Date类型。数据库

废话很少说，上代码，由于都有注释，因此LZ不做多余解释。 0 - 0 app

1.对象编辑器

package com.example.TimerTest.share;

import java.io.Serializable;
import java.util.Date;

/**
 * <b>数据存储对象</b></br>
 *
 * @author Jony
 * @13-5-24
 * @下午4:28
 */
public class SharedData implements Serializable, Cloneable
{
    private static final long serialVersionUID = 1L;

    /**
     * id
     */
    private long id;

    /**
     * <br>数据对应惟一Key值<br/>
     * <br>若是数据库已存在Key,则会覆盖以前的数据<br/>
     */
    private String key;

    /**
     * 默认String类型值
     */
    private String mStr;

    /**
     * 默认boolean类型值 code值: 0(true) ,1(false)
     */
    private boolean mBoolean;

    /**
     * 默认int类型值
     */
    private int mInt;

    /**
     * 默认Date类型值
     */
    private Date mDate;

    /**
     * 默认long类型数据
     */
    private long mLong;

    /**
     * 默认float类型数据
     */
    private float mFloat;

    /**
     * 当前数据类型
     */
    private DataType dataType;

    /**
     * *****************************
     * 预留字段 end
     * *****************************
     */

    /**
     * 数据库对应字段名称
     */
    public static final String ID = "id";

    /**
     * 惟一key对应数据库字段名称
     */
    public static final String KEY = "key";

    /**
     * 默认String类型数据对应数据库字段名称
     */
    public static final String M_STR = "m_str";

    /**
     * 默认boolean对应数据库字段名称
     */
    public static final String M_BOOLEAN = "m_boolean";

    /**
     * 默认int对应数据库字段名称
     */
    public static final String M_INT = "m_int";

    /**
     * 默认Date对应数据库字段名称
     */
    public static final String M_DATE = "m_date";

    /**
     * 默认long对应数据库字段名称
     */
    public static final String M_LONG = "m_long";

    /**
     * 默认float对应数据库字段名称
     */
    public static final String M_FLOAT = "m_float";

    /**
     * 数据类型数据库字段名称
     */
    public static final String DATA_TYPE = "data_type";

    /**
     * 表名
     */
    public static final String TABLE_NAME = "t_shared_data";

    public long getId()
    {
        return id;
    }

    public void setId(long id)
    {
        this.id = id;
    }

    public String getKey()
    {
        return key;
    }

    public void setKey(String key)
    {
        this.key = key;
    }

    public String getmStr()
    {
        return mStr;
    }

    public void setmStr(String mStr)
    {
        this.mStr = mStr;
    }

    public boolean ismBoolean()
    {
        return mBoolean;
    }

    public void setmBoolean(boolean mBoolean)
    {
        this.mBoolean = mBoolean;
    }

    public int getmInt()
    {
        return mInt;
    }

    public void setmInt(int mInt)
    {
        this.mInt = mInt;
    }

    public Date getmDate()
    {
        return mDate;
    }

    public void setmDate(Date mDate)
    {
        this.mDate = mDate;
    }

    public long getmLong()
    {
        return mLong;
    }

    public void setmLong(long mLong)
    {
        this.mLong = mLong;
    }

    public float getmFloat()
    {
        return mFloat;
    }

    public void setmFloat(float mFloat)
    {
        this.mFloat = mFloat;
    }

    public DataType getDataType()
    {
        return dataType;
    }

    public void setDataType(DataType dataType)
    {
        this.dataType = dataType;
    }


    @Override
    public String toString()
    {
        return "SharedData{" +
                "id=" + id +
                ", key='" + key + '\'' +
                ", mStr='" + mStr + '\'' +
                ", mBoolean=" + mBoolean +
                ", mInt=" + mInt +
                ", mDate=" + mDate +
                ", mLong=" + mLong +
                ", mFloat=" + mFloat +
                ", dataType=" + dataType +
                '}';
    }
}

2. 数据类型

package com.example.TimerTest.share;

/**
 * <b>SharedData对应的数据类型</b></br>
 *
 * @author Jony
 * @13-5-27
 * @上午10:29
 */
public enum DataType
{
    STRING(0), BOOLEAN(1), INT(2), DATA(3), LONG(4), FLOAT(5);

    private int value;

    private DataType(int value)
    {
        this.value = value;
    }

    public int getValue()
    {
        return value;
    }

    public void setValue(int value)
    {
        this.value = value;
    }

    /**
     * 根据值获取当前数据类型对象
     *
     * @param value
     * @return
     */
    public static DataType getDataTypeByValue(int value)
    {
        for (DataType type : DataType.values())
        {
            if (type.value == value)
            {
                return type;
            }
        }
        return null;
    }
}

3.数据库 ide

package com.example.TimerTest.share;

import android.content.Context;
import android.database.sqlite.SQLiteDatabase;
import android.database.sqlite.SQLiteOpenHelper;

/**
 * <b>数据库操做助手</b></br>
 *
 * @author Jony
 * @12-7-12
 * @上午10:53
 */
public class LocalSqLiteHelper extends SQLiteOpenHelper
{
    public LocalSqLiteHelper(Context context, String name,
                             SQLiteDatabase.CursorFactory factory, int version)
    {
        super(context, name, factory, version);
    }

    @Override
    public void onCreate(SQLiteDatabase sqLiteDatabase)
    {
        //建立表
        sqLiteDatabase.execSQL("CREATE TABLE IF NOT EXISTS "
                + SharedData.TABLE_NAME + "(" + SharedData.ID
                + " integer primary key autoincrement,"
                + SharedData.KEY + " varchar,"
                + SharedData.M_STR + " varchar,"
                + SharedData.M_BOOLEAN + " integer(1),"
                + SharedData.M_DATE + " datetime,"
                + SharedData.M_INT + " integer,"
                + SharedData.M_LONG + " int8, "
                + SharedData.M_FLOAT + " float,"
                + SharedData.DATA_TYPE + " integer" + ")");
    }

    @Override
    public void onUpgrade(SQLiteDatabase sqLiteDatabase, int oldVersion,
                          int newVersion)
    {
        onCreate(sqLiteDatabase);
    }
}

数据库助手：

package com.example.TimerTest.share;

import android.content.ContentValues;
import android.content.Context;
import android.database.Cursor;
import android.database.sqlite.SQLiteDatabase;
import android.text.TextUtils;

import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.Date;

/**
 * <b>SharedData对象数据库操做助手</b></br>
 *
 * @author Jony
 * @13-5-24
 * @下午5:13
 * @since xCloud4.1
 */
public class SharedDataSqLiteHelper
{

    /**
     * 数据库存放code值 1 - 表示 boolean 中的 true
     */
    public static final int TRUE_CODE = 1;

    public static final int VERSION = 1;

    public static final String DB_NAME = "myTest.db";

    /**
     * 时间格式
     */
    public static final String DATE_FORMAT = "yyyy-MM-dd HH:mm:ss";

    /**
     * 本地数据库助手
     */
    private LocalSqLiteHelper localSqLiteHelper;

    private SQLiteDatabase sqLiteDatabase;

    private boolean isClosed;

    /**
     * 时间格式化对象
     */
    private SimpleDateFormat sDateFormat;

    /**
     * 默认建立可写数据库
     *
     * @param context
     */
    public SharedDataSqLiteHelper(Context context)
    {
        localSqLiteHelper = new LocalSqLiteHelper(context,
                DB_NAME, null, VERSION);
        sDateFormat = new SimpleDateFormat(DATE_FORMAT);

        try
        {
            sqLiteDatabase = localSqLiteHelper.getWritableDatabase();
        }
        catch (Exception e)
        {
            e.printStackTrace();
        }
    }

    /**
     * 保存数据
     *
     * @param sharedData
     * @return
     */
    public long putData(SharedData sharedData)
    {
        long id = -1;
        if (sharedData == null || TextUtils.isEmpty(sharedData.getKey()) || sharedData.getDataType() == null)
        {
            return id;
        }

        long dataId = hasData(sharedData);

        if (dataId > 0)
        {
            sharedData.setId(dataId);
            int row = updateDataById(sharedData);

            if (row > 0)
            {
                return dataId;
            }
        }
        else
        {
            id = saveData(sharedData);
        }

        return id;
    }

    /**
     * 根据Key 删除数据
     *
     * @param key
     * @return
     */
    public boolean remove(String key)
    {
        if (TextUtils.isEmpty(key))
        {
            return false;
        }

        long rows = -1;

        try
        {
            rows = sqLiteDatabase.delete(SharedData.TABLE_NAME,
                    SharedData.KEY + " = ?", new String[]
                    {
                            key
                    });
        }
        catch (Exception e)
        {
            e.printStackTrace();
        }

        return rows > 0;
    }

    /**
     * 根据Key获取相应的数据
     *
     * @param key
     * @return
     */
    public SharedData getGlobalDataByKey(String key)
    {
        if (TextUtils.isEmpty(key))
        {
            return null;
        }

        SharedData sharedData = null;
        String sql = "select * from " + SharedData.TABLE_NAME + " where "
                + SharedData.KEY + "=\"" + key + "\" order by "
                + SharedData.ID + " desc";
        Cursor cursor = null;
        try
        {
            cursor = sqLiteDatabase.rawQuery(sql, null);
            if (cursor.moveToFirst())
            {
                long id = cursor.getLong(cursor.getColumnIndex(SharedData.ID));

                String mKey = cursor.getString(cursor
                        .getColumnIndex(SharedData.KEY));

                String mStr = cursor.getString(cursor
                        .getColumnIndex(SharedData.M_STR));

                int boolCode = cursor.getInt(cursor
                        .getColumnIndex(SharedData.M_BOOLEAN));

                int mInt = cursor.getInt(cursor
                        .getColumnIndex(SharedData.M_INT));

                String dataStr = cursor.getString(cursor
                        .getColumnIndex(SharedData.M_DATE));
                Date mData = null;
                int trueCode = TRUE_CODE;

                boolean mBoolean = boolCode == trueCode;

                long mLong = cursor.getLong(cursor.getColumnIndex(SharedData.M_LONG));

                float mFloat = cursor.getFloat(cursor.getColumnIndex(SharedData.M_FLOAT));

                int mTypeCode = cursor.getInt(cursor.getColumnIndex(SharedData.DATA_TYPE));

                DataType dataType = DataType.getDataTypeByValue(mTypeCode);

                try
                {
                    if (!TextUtils.isEmpty(dataStr))
                        mData = sDateFormat.parse(dataStr);
                }
                catch (ParseException e)
                {
                    e.printStackTrace();
                }

                sharedData = new SharedData();
                sharedData.setId(id);
                sharedData.setKey(mKey);
                sharedData.setmStr(mStr);
                sharedData.setmBoolean(mBoolean);
                sharedData.setmInt(mInt);
                sharedData.setmDate(mData);
                sharedData.setmLong(mLong);
                sharedData.setmFloat(mFloat);
                sharedData.setDataType(dataType);
            }
        }
        catch (Exception e)
        {
            e.printStackTrace();
        }
        finally
        {
            if (null != cursor && !cursor.isClosed())
            {
                cursor.close();
            }
        }

        return sharedData;
    }

    /**
     * 保存数据
     *
     * @param sharedData
     * @return
     */
    private long saveData(SharedData sharedData)
    {
        long id = -1;

        if (sharedData == null || TextUtils.isEmpty(sharedData.getKey()) || sharedData.getDataType() == null)
        {
            return id;
        }

        ContentValues contentValues = new ContentValues();
        contentValues.put(SharedData.KEY, sharedData.getKey());
        contentValues.put(SharedData.M_STR, sharedData.getmStr());
        contentValues.put(SharedData.M_BOOLEAN, sharedData.ismBoolean());
        contentValues.put(SharedData.M_INT, sharedData.getmInt());
        contentValues.put(SharedData.M_LONG, sharedData.getmLong());
        contentValues.put(SharedData.M_FLOAT, sharedData.getmFloat());
        contentValues.put(SharedData.DATA_TYPE, sharedData.getDataType().getValue());

        String mTime = null;

        if (sharedData.getmDate() != null)
        {
            mTime = sDateFormat.format(sharedData.getmDate());
        }

        contentValues.put(SharedData.M_DATE, mTime);

        try
        {
            id = sqLiteDatabase.insert(SharedData.TABLE_NAME, null, contentValues);
        }
        catch (Exception e)
        {
            e.printStackTrace();
        }

        return id;
    }


    /**
     * 根据ID更新数据
     *
     * @param sharedData
     * @return
     */
    private int updateDataById(SharedData sharedData)
    {
        int rows = 0;

        if (sharedData == null || TextUtils.isEmpty(sharedData.getKey())
                || sharedData.getId() <= 0 || sharedData.getDataType() == null)
        {
            return -1;
        }

        // 更新保存
        ContentValues contentValues = new ContentValues();
        contentValues.put(SharedData.KEY, sharedData.getKey());
        contentValues.put(SharedData.M_STR, sharedData.getmStr());
        contentValues.put(SharedData.M_BOOLEAN, sharedData.ismBoolean());
        contentValues.put(SharedData.M_INT, sharedData.getmInt());
        contentValues.put(SharedData.M_LONG, sharedData.getmLong());
        contentValues.put(SharedData.M_FLOAT, sharedData.getmFloat());
        contentValues.put(SharedData.DATA_TYPE, sharedData.getDataType().getValue());

        String mTime = null;

        if (sharedData.getmDate() != null)
        {
            mTime = sDateFormat.format(sharedData.getmDate());
        }

        contentValues.put(SharedData.M_DATE, mTime);

        try
        {
            rows = sqLiteDatabase.update(SharedData.TABLE_NAME,
                    contentValues, SharedData.ID + "= ? ", new String[]
                    {
                            String.valueOf(sharedData.getId())
                    });
        }
        catch (Exception e)
        {
            e.printStackTrace();
        }

        return rows;
    }

    /**
     * 是否存在key值
     *
     * @param key
     * @return
     */
    public boolean contains(String key)
    {
        if (TextUtils.isEmpty(key))
        {
            return false;
        }

        String sql = "select count(*) from " + SharedData.TABLE_NAME
                + " where " + SharedData.KEY + "=\""
                + key + "\"";

        Cursor cursor = null;
        try
        {
            cursor = sqLiteDatabase.rawQuery(sql, null);
            cursor.moveToFirst();
            long count = cursor.getLong(0);
            if (count > 0)
            {
                return true;
            }
        }
        catch (Exception e)
        {
            e.printStackTrace();
        }
        finally
        {
            if (null != cursor && !cursor.isClosed())
            {
                cursor.close();
            }
        }

        return false;
    }


    /**
     * 是否存在数据，存在则返回相应ID
     *
     * @param sharedData
     * @return
     */
    private long hasData(SharedData sharedData)
    {
        if (sharedData == null || TextUtils.isEmpty(sharedData.getKey()))
        {
            return -1;
        }

        String sql = "select * from " + SharedData.TABLE_NAME
                + " where " + SharedData.KEY + "=\""
                + sharedData.getKey() + "\"";

        Cursor cursor = null;
        try
        {
            cursor = sqLiteDatabase.rawQuery(sql, null);

            if (cursor.moveToFirst())
            {
                long id = cursor.getLong(cursor.getColumnIndex(SharedData.ID));

                if (id > 0)
                {
                    return id;
                }

            }
        }
        catch (Exception e)
        {
            e.printStackTrace();
        }
        finally
        {
            if (null != cursor && !cursor.isClosed())
            {
                cursor.close();
            }
        }

        return -1;
    }


    public boolean isClosed()
    {
        return isClosed;
    }

    public void close()
    {
        if (!isClosed)
        {
            try
            {
                if (null != localSqLiteHelper)
                {
                    localSqLiteHelper.close();
                }

                if (null != sqLiteDatabase)
                {
                    sqLiteDatabase.close();
                }
                isClosed = true;
            }
            catch (Exception e)
            {
                e.printStackTrace();
            }
        }
    }

    /**
     * 查询记录的总数
     */
    public long getCount()
    {
        String sql = "select count(*) from " + SharedData.TABLE_NAME;
        Cursor cursor = null;
        long length = 0;
        try
        {
            cursor = sqLiteDatabase.rawQuery(sql, null);
            cursor.moveToFirst();
            length = cursor.getLong(0);
        }
        catch (Exception e)
        {
            e.printStackTrace();
        }
        finally
        {
            if (null != cursor && !cursor.isClosed())
            {
                cursor.close();
            }
        }
        return length;
    }

    /**
     * 删除表中全部数据
     */
    public boolean clearAll()
    {
        String sql = "delete from " + SharedData.TABLE_NAME;

        Cursor cursor = null;
        Boolean hasData = false;

        try
        {
            sqLiteDatabase.execSQL(sql);
            cursor = sqLiteDatabase.query(SharedData.TABLE_NAME, null, null, null,
                    null, null, null);
            hasData = cursor.moveToFirst();

        }
        catch (Exception e)
        {
            e.printStackTrace();
        }
        finally
        {
            if (null != cursor && !cursor.isClosed())
            {
                cursor.close();
            }
        }

        return !hasData;
    }
}

4.工具类

package com.example.TimerTest.share;

import android.content.Context;
import android.text.TextUtils;

import java.util.Date;
import java.util.HashMap;

/**
 * <b>数据操做工具类</b></br>
 *
 * @author Jony
 * @13-5-24
 * @下午5:59
 */
public class SharedDataUtil
{
    /**
     * 数据库操做助手
     */
    private SharedDataSqLiteHelper sharedDataSqLiteHelper;

    private static SharedDataUtil sharedDataUtil;

    private SharedDataEditor sharedDataEditor;

    private SharedDataUtil(Context context)
    {
        if (sharedDataSqLiteHelper == null || sharedDataSqLiteHelper.isClosed())
        {
            this.sharedDataSqLiteHelper = new SharedDataSqLiteHelper(context);
        }
    }

    public static synchronized SharedDataUtil getInstance(Context context)
    {
        if (context == null)
        {
            return null;
        }

        if (sharedDataUtil == null)
        {
            sharedDataUtil = new SharedDataUtil(context);
        }

        return sharedDataUtil;
    }

    /**
     * 根据key获取String类型数据
     *
     * @param key
     * @param defaultValue 默认值，无值时返回传入的默认值
     * @return
     */
    public String getString(String key, String defaultValue)
    {
        if (TextUtils.isEmpty(key))
            return defaultValue;

        SharedData sharedData = this.sharedDataSqLiteHelper.getGlobalDataByKey(key);

        if (sharedData == null || sharedData.getDataType() != DataType.STRING)
        {
            return defaultValue;
        }

        return sharedData.getmStr();
    }

    /**
     * 根据key获取boolean类型数据
     *
     * @param key
     * @param defaultValue 默认值，无值时返回传入的默认值
     * @return
     */
    public boolean getBoolean(String key, boolean defaultValue)
    {
        if (TextUtils.isEmpty(key))
            return defaultValue;

        SharedData sharedData = this.sharedDataSqLiteHelper.getGlobalDataByKey(key);

        if (sharedData == null || sharedData.getDataType() != DataType.BOOLEAN)
        {
            return defaultValue;
        }

        return sharedData.ismBoolean();
    }

    /**
     * 根据key获取int类型数据
     *
     * @param key
     * @param defaultValue 默认值，无值时返回传入的默认值
     * @return
     */
    public int getInt(String key, int defaultValue)
    {
        if (TextUtils.isEmpty(key))
            return defaultValue;

        SharedData sharedData = this.sharedDataSqLiteHelper.getGlobalDataByKey(key);

        if (sharedData == null || sharedData.getDataType() != DataType.INT)
        {
            return defaultValue;
        }

        return sharedData.getmInt();
    }

    /**
     * 根据key获取Date类型数据
     *
     * @param key
     * @param defaultValue 默认值，无值时返回传入的默认值
     * @return
     */
    public Date getDate(String key, Date defaultValue)
    {
        if (TextUtils.isEmpty(key))
            return defaultValue;

        SharedData sharedData = this.sharedDataSqLiteHelper.getGlobalDataByKey(key);

        if (sharedData == null || sharedData.getDataType() != DataType.DATA)
        {
            return defaultValue;
        }

        return sharedData.getmDate();
    }

    /**
     * 根据key获取long类型数据
     *
     * @param key
     * @param defaultValue 默认值，无值时返回传入的默认值
     * @return
     */
    public long getLong(String key, long defaultValue)
    {
        if (TextUtils.isEmpty(key))
            return defaultValue;

        SharedData sharedData = this.sharedDataSqLiteHelper.getGlobalDataByKey(key);

        if (sharedData == null || sharedData.getDataType() != DataType.LONG)
        {
            return defaultValue;
        }

        return sharedData.getmLong();
    }

    /**
     * 根据key获取float类型数据
     *
     * @param key
     * @param defaultValue 默认值，无值时返回传入的默认值
     * @return
     */
    public float getFloat(String key, float defaultValue)
    {
        if (TextUtils.isEmpty(key))
            return defaultValue;

        SharedData sharedData = this.sharedDataSqLiteHelper.getGlobalDataByKey(key);

        if (sharedData == null || sharedData.getDataType() != DataType.FLOAT)
        {
            return defaultValue;
        }

        return sharedData.getmFloat();
    }


    /**
     * 是否存在该key
     *
     * @param key
     * @return
     */
    public boolean contains(String key)
    {
        if (TextUtils.isEmpty(key))
            return false;

        return this.sharedDataSqLiteHelper.contains(key);
    }

    /**
     * 删除该key对应的数据
     *
     * @param key
     * @return
     */
    public boolean remove(String key)
    {
        if (TextUtils.isEmpty(key))
            return false;

        return this.sharedDataSqLiteHelper.remove(key);
    }

    /**
     * 清除全部数据
     *
     * @return
     */
    public boolean clear()
    {
        return this.sharedDataSqLiteHelper.clearAll();
    }


    /**
     * 获取编辑器
     *
     * @return
     */
    public SharedDataEditor getSharedDataEditor()
    {
        if (sharedDataEditor == null)
        {
            sharedDataEditor = new SharedDataEditor();
        }

        sharedDataEditor.clearDatas();

        return sharedDataEditor;
    }

    /**
     * <br>数据编辑器<br/>
     * <br>最后使用commit()提交数据保存<br/>
     */
    public class SharedDataEditor
    {
        private HashMap<String, SharedData> sharedDataHashMap;

        public SharedDataEditor()
        {
            if (sharedDataHashMap == null)
            {
                sharedDataHashMap = new HashMap<String, SharedData>();
            }
            else
            {
                sharedDataHashMap.clear();
            }
        }

        /**
         * 放入String类型数据
         *
         * @param key
         * @param value
         * @return
         */
        public SharedDataEditor putString(String key, String value)
        {
            if (TextUtils.isEmpty(key) || TextUtils.isEmpty(value))
            {
                return this;
            }

            SharedData sharedData = getDefaultData();
            sharedData.setKey(key);
            sharedData.setmStr(value);
            sharedData.setDataType(DataType.STRING);

            sharedDataHashMap.put(key, sharedData);

            return this;
        }

        /**
         * 放入boolean类型数据
         *
         * @param key
         * @param value
         * @return
         */
        public SharedDataEditor putBoolean(String key, boolean value)
        {
            if (TextUtils.isEmpty(key))
                return this;

            SharedData sharedData = getDefaultData();
            sharedData.setKey(key);
            sharedData.setmBoolean(value);
            sharedData.setDataType(DataType.BOOLEAN);
            sharedDataHashMap.put(key, sharedData);

            return this;
        }

        /**
         * 放入int类型数据
         *
         * @param key
         * @param value
         * @return
         */
        public SharedDataEditor putInt(String key, int value)
        {
            if (TextUtils.isEmpty(key))
                return this;

            SharedData sharedData = getDefaultData();
            sharedData.setKey(key);
            sharedData.setmInt(value);
            sharedData.setDataType(DataType.INT);

            sharedDataHashMap.put(key, sharedData);

            return this;
        }

        /**
         * 放入Date类型数据
         *
         * @param key
         * @param date
         * @return
         */
        public SharedDataEditor putDate(String key, Date date)
        {
            if (TextUtils.isEmpty(key) || date == null)
                return this;

            SharedData sharedData = getDefaultData();
            sharedData.setKey(key);
            sharedData.setmDate(date);
            sharedData.setDataType(DataType.DATA);

            sharedDataHashMap.put(key, sharedData);

            return this;
        }

        /**
         * 放入Long类型数据
         *
         * @param key
         * @param value
         * @return
         */
        public SharedDataEditor putLong(String key, long value)
        {
            if (TextUtils.isEmpty(key))
                return this;

            SharedData sharedData = getDefaultData();
            sharedData.setKey(key);
            sharedData.setmLong(value);
            sharedData.setDataType(DataType.LONG);
            sharedDataHashMap.put(key, sharedData);

            return this;
        }

        /**
         * 放入float类型数据
         *
         * @param key
         * @param value
         * @return
         */
        public SharedDataEditor putFloat(String key, float value)
        {
            if (TextUtils.isEmpty(key))
                return this;

            SharedData sharedData = getDefaultData();
            sharedData.setKey(key);
            sharedData.setmFloat(value);
            sharedData.setDataType(DataType.FLOAT);
            sharedDataHashMap.put(key, sharedData);

            return this;
        }

        /**
         * 保存数据
         *
         * @return
         */
        public boolean commit()
        {
            boolean isSuccess = false;

            SharedDataSqLiteHelper sharedDataSqLiteHelper1 = sharedDataSqLiteHelper;

            for (SharedData sharedData : sharedDataHashMap.values())
            {
                if (sharedData != null)
                {
                    long id = sharedDataSqLiteHelper1.putData(sharedData);

                    isSuccess = id > 0;
                }
            }

            sharedDataHashMap.clear();

            return isSuccess;
        }

        /**
         * 清除数据
         */
        public void clearDatas()
        {
            if (sharedDataHashMap != null)
                sharedDataHashMap.clear();
        }
    }


    /**
     * 获取一个默认数据对象
     *
     * @return
     */
    private SharedData getDefaultData()
    {
        SharedData sharedData = new SharedData();
        sharedData.setmStr(null);
        sharedData.setmBoolean(false);
        sharedData.setmDate(null);
        sharedData.setmInt(-1);
        sharedData.setmLong(-1);
        sharedData.setmFloat(-1f);
        sharedData.setDataType(null);
        return sharedData;
    }
}

以上就是主要代码,下面是我本身的测试类，展现了使用方法，嘿嘿：

package com.example.TimerTest.share;

import android.app.Activity;
import android.os.Bundle;

import java.util.Date;

/**
 * <b></b></br>
 *
 * @author Jony
 * @13-5-27
 * @上午11:20
 */
public class SharedDataTestActivity extends Activity
{

    @Override
    protected void onCreate(Bundle savedInstanceState)
    {
        super.onCreate(savedInstanceState);

        final SharedDataUtil sharedDataUtil = SharedDataUtil.getInstance(this);

        new Thread(new Runnable()
        {
            @Override
            public void run()
            {

                SharedDataUtil.SharedDataEditor globalDataEditor = sharedDataUtil.getSharedDataEditor();

                globalDataEditor.putString("str1", "test..put str");
                globalDataEditor.putBoolean("bol1", true);
                globalDataEditor.putDate("date1", new Date());
                globalDataEditor.putInt("int1", 999);
                globalDataEditor.putLong("long1", 123456654);
                globalDataEditor.putFloat("float1", 9.99f);

                globalDataEditor.commit();


                String str = sharedDataUtil.getString("str1", "deafult...");
                boolean bol = sharedDataUtil.getBoolean("bol1", false);
                Date date = sharedDataUtil.getDate("date1", null);
                int myint = sharedDataUtil.getInt("int1", -100);
                long mylong = sharedDataUtil.getLong("long1", 0);
                float myFloat = sharedDataUtil.getFloat("float1", 0.0f);

                System.out.println(str);
                System.out.println(bol);
                System.out.println(date);
                System.out.println(myint);
                System.out.println(mylong);
                System.out.println(myFloat);


            }
        }).start();


    }
}

测试结果：

05-27 14:53:27.509: INFO/System.out(3572): test..put str  
05-27 14:53:27.509: INFO/System.out(3572): true  
05-27 14:53:27.509: INFO/System.out(3572): Mon May 27 14:53:26 格林尼治标准时间+0800 2013  
05-27 14:53:27.509: INFO/System.out(3572): 999  
05-27 14:53:27.509: INFO/System.out(3572): 123456654  
05-27 14:53:27.519: INFO/System.out(3572): 9.99

好了，完成。 0 - 0