一个方便的SharedPreferencesUtils工具

SharedPreferencesUtils存储对象

SharedPreferences可以存储基本类型，在这里不多阐述。在这里主要介绍怎么存储对象。

在我学习优化Utils工具包的一些常见的工具类。

在百度上的一些关于SharedPreferences存储对象的方式的使用Base64转，或者转成json类型，存入SharedPreferences中，这样写显得很笨拙。并不符合我的需求。在此给一种新的方法（我也不确定，应该很早就有这样写的吧）。

  • 读写基本数据类型
  • 读写Javabean类型
  • 读写List<Javabean>类型
  • 读写图片资源

1， 读写基本数据类型

 /**
     * 存储基本数据类型
     * @param context
     * @param key key
     * @param data value
     */
public static void saveData(Context context, String key, Object data) {
        String type = data.getClass().getSimpleName();
        SharedPreferences sharedPreferences = context.getSharedPreferences(FILE_NAME, Context
                .MODE_PRIVATE);//读写基本数据类型都是在一个特定的文件，以软件的包名为文件名
        Editor editor = sharedPreferences.edit();
        if ("Integer".equals(type)) {//注意这里是integer对象，同下
            editor.putInt(key, (Integer) data);
        } else if ("Boolean".equals(type)) {
            editor.putBoolean(key, (Boolean) data);
        } else if ("String".equals(type)) {
            editor.putString(key, (String) data);
        } else if ("Float".equals(type)) {
            editor.putFloat(key, (Float) data);
        } else if ("Long".equals(type)) {
            editor.putLong(key, (Long) data);
        }
        editor.commit();
    }

/**
     * 读取基本数据类型
     * @param context
     * @param key key
     * @param defValue 当取不到值时返回默认值
     * @return
     */
    public static Object getData(Context context, String key, Object defValue) {
        String type = defValue.getClass().getSimpleName();
        SharedPreferences sharedPreferences = context.getSharedPreferences(FILE_NAME, Context
                .MODE_PRIVATE);  //defValue为为默认值，如果当前获取不到数据就返回它
        if ("Integer".equals(type)) {
            return sharedPreferences.getInt(key, (Integer) defValue);
        } else if ("Boolean".equals(type)) {
            return sharedPreferences.getBoolean(key, (Boolean) defValue);
        } else if ("String".equals(type)) {
            return sharedPreferences.getString(key, (String) defValue);
        } else if ("Float".equals(type)) {
            return sharedPreferences.getFloat(key, (Float) defValue);
        } else if ("Long".equals(type)) {
            return sharedPreferences.getLong(key, (Long) defValue);
        }
        return null;
    }

将常用到的基本数据类型存入特定的文件中，获取的时候也十分方便快捷。（PS，string不是基本数据类型）

读写Javabean类型

先期准备

Javabean是序列化的，需要继承Serializable接口，实现serialVersionUID。

1.判断处理是否是各个数据类型

 private static boolean isObject(Class<?> clazz) {
        return clazz != null && !isSingle(clazz) && !isArray(clazz) && !isCollection(clazz) && !isMap(clazz);
    }

    private static boolean isSingle(Class<?> clazz) {
        return isBoolean(clazz) || isNumber(clazz) || isString(clazz);
    }

    public static boolean isBoolean(Class<?> clazz) {
        return clazz != null && (Boolean.TYPE.isAssignableFrom(clazz) || Boolean.class.isAssignableFrom(clazz));
    }

    public static boolean isNumber(Class<?> clazz) {
        return clazz != null && (Byte.TYPE.isAssignableFrom(clazz) || Short.TYPE.isAssignableFrom(clazz) || Integer.TYPE.isAssignableFrom(clazz) || Long.TYPE.isAssignableFrom(clazz) || Float.TYPE.isAssignableFrom(clazz) || Double.TYPE.isAssignableFrom(clazz) || Number.class.isAssignableFrom(clazz));
    }

    public static boolean isString(Class<?> clazz) {
        return clazz != null && (String.class.isAssignableFrom(clazz) || Character.TYPE.isAssignableFrom(clazz) || Character.class.isAssignableFrom(clazz));
    }

    public static boolean isArray(Class<?> clazz) {
        return clazz != null && clazz.isArray();
    }

    public static boolean isCollection(Class<?> clazz) {
        return clazz != null && Collection.class.isAssignableFrom(clazz);
    }

    public static boolean isMap(Class<?> clazz) {
        return clazz != null && Map.class.isAssignableFrom(clazz);
    }
    private static boolean isParcelableCreator(Field field) {
        return Modifier.toString(field.getModifiers()).equals("public static final") && "CREATOR"
                .equals(field.getName());
    }

2,插入数据

 public static void setObject(Context context, Object o) {
        Field[] fields = o.getClass().getDeclaredFields();//获取所有声明的属性
        SharedPreferences sp = context.getSharedPreferences(o.getClass().getName(), 0);//将存储的文件名改为Javabean的包名+類名
        SharedPreferences.Editor editor = sp.edit();

        for (int i = 0; i < fields.length; ++i) {
            if (!isParcelableCreator(fields[i])) {
                Class type = fields[i].getType();//类型 class java.lang.class
                String name = fields[i].getName();//名称 id
                Object e;
                if (isSingle(type)) {
                    try {
                        if (type != Character.TYPE && !type.equals(String.class)) {
                            if (!type.equals(Integer.TYPE) && !type.equals(Short.class)) {
                                if (type.equals(Double.TYPE)) {
                                    editor.putLong(name, Double.doubleToLongBits(fields[i]
                                            .getDouble(o)));//将double类型的数值存入
                                } else if (type.equals(Float.TYPE)) {
                                    editor.putFloat(name, fields[i].getFloat(o));//将float类型的数值存入
                                } else if (type.equals(Long.TYPE) && !name.equals("serialVersionUID")) {
                                    editor.putLong(name, fields[i].getLong(o));//将long类型的数值存入
                                } else if (type.equals(Boolean.TYPE)) {
                                    editor.putBoolean(name, fields[i].getBoolean(o));//将boolean类型的数值存入
                                }
                            } else {
                                editor.putInt(name, fields[i].getInt(o));//将int类型的数值存入
                            }
                        } else {
                            e = fields[i].get(o);//将string类型的数值存入
                            editor.putString(name, null == e ? null : e.toString());
                        }
                    } catch (Exception var14) {
                    }
                    }else if (isObject(type)) {
                        try {
                            e = fields[i].get(o);
                            if (null != e) {
                                setObject(context, e);
                            } else {
                                try {
                                    setObject(context, fields[i].getClass().newInstance());//重新跑一遍
                                } catch (InstantiationException var11) {
                                }
                            }
                        } catch (Exception var12) {

                        }
                    } else {
                    try {
                        e = fields[i].get(o);
                        //转成json插入
                    } catch (IllegalAccessException e1) {
                        e1.printStackTrace();
                    }

                }
                }
            }
        editor.apply();
    }

public static <T> T getObject(Context context, Class<T> clazz) {
        Object o = null;

        try {
            o = clazz.newInstance();
        } catch (InstantiationException e) {
            e.printStackTrace();
            return (T) o;
        } catch (IllegalAccessException e) {
            e.printStackTrace();
            return (T) o;
        }

        Field[] fields = clazz.getDeclaredFields();
        SharedPreferences sp = context.getSharedPreferences(clazz.getName(), 0);

        for(int i = 0; i < fields.length; ++i) {
            if(!isParcelableCreator(fields[i])) {
                Class type = fields[i].getType();
                String name = fields[i].getName();
                String o_1;
                if(isSingle(type)) {
                    try {
                        fields[i].setAccessible(true);
                        if(type != Character.TYPE && !type.equals(String.class)) {
                            if(!type.equals(Integer.TYPE) && !type.equals(Short.class)){
                                if(type.equals(Double.TYPE)) {
                                    fields[i].setDouble(o, Double.longBitsToDouble(sp.getLong(name, 0L)));
                                } else if(type.equals(Float.TYPE)) {
                                    fields[i].setFloat(o, sp.getFloat(name, 0.0F));
                                } else if(type.equals(Long.TYPE)) {
                                    fields[i].setLong(o, sp.getLong(name, 0L));
                                } else if(type.equals(Boolean.TYPE)) {
                                    fields[i].setBoolean(o, sp.getBoolean(name, false));
                                }
                            } else {
                                fields[i].setInt(o, sp.getInt(name, 0));
                            }
                        } else {
                            o_1 = sp.getString(name, (String)null);
                            if(null != o_1) {
                                fields[i].set(o, o_1);
                            }
                        }
                    } catch (Exception e) {

                    }
                } else if(isObject(type)) {
                    Object tempValue = getObject(context, fields[i].getType());
                    if(null != tempValue) {
                        fields[i].setAccessible(true);

                        try {
                            fields[i].set(o, tempValue);
                        } catch (Exception e) {

                        }
                    }
                } else {
                    //json数据解析
                }
            }
        }

        return (T) o;
    }

主要的思想就是遍历javabean所有的属性对象，取出，按照类型一个个的存入XML文件中。

取出时也是同时转成了存入的形式，很方便利

读写List<Javabean>

对于list<javabean>，不太适合用上面的方法，一般来说不太会存这种数据，数据量比较大。如果有这个需求，可以把list<javabean>转成json形式，然后存入xml文件中。关于Javabean数据转成json会在另一篇叙述。

读写图片资源

所谓的读写图片，个人感觉用处不大，先说一下思路。其实也很简单，就是通过base64将输出流转成string。

代码奉上：

 private void saveBitmapToSharedPreferences(Context context,String key,Bitmap bitmap){
        //第一步:将Bitmap压缩至字节数组输出流ByteArrayOutputStream
        ByteArrayOutputStream byteArrayOutputStream=new ByteArrayOutputStream();
        bitmap.compress(CompressFormat.PNG, 80, byteArrayOutputStream);
        //第二步:利用Base64将字节数组输出流中的数据转换成字符串String
        byte[] byteArray=byteArrayOutputStream.toByteArray();
        String imageString=new String(Base64.encodeToString(byteArray, Base64.DEFAULT));
        //第三步:将String保持至SharedPreferences
        SharedPreferences sharedPreferences=context.getSharedPreferences(FILE_NAME, Context.MODE_PRIVATE);
        Editor editor=sharedPreferences.edit();
        editor.putString(key, imageString);
        editor.commit();
    }  

    private Bitmap getBitmapFromSharedPreferences(Context context, String key, Object defValue){
        SharedPreferences sharedPreferences=getSharedPreferences(FILE_NAME, Context.MODE_PRIVATE);
        //第一步:取出字符串形式的Bitmap
        String imageString=context.sharedPreferences.getString(key,defValue);
        //第二步:利用Base64将字符串转换为ByteArrayInputStream
        byte[] byteArray=Base64.decode(imageString, Base64.DEFAULT);
        ByteArrayInputStream byteArrayInputStream=new ByteArrayInputStream(byteArray);
        //第三步:利用ByteArrayInputStream生成Bitmap
        Bitmap bitmap=BitmapFactory.decodeStream(byteArrayInputStream);
        return bitmap;
    }

结束

简单叙述了下SharedPreferences的使用，毕竟作为Android中几个主要的存储数据的方式，熟练掌握还是 非常有必要的。

时间： 2024-10-27 13:21:00

一个方便的SharedPreferencesUtils工具的相关文章

[email&#160;protected]一个高效的配置管理工具--Ansible configure management--翻译（六）

无书面许可请勿转载 高级playbook Finding files with variables All modules can take variables as part of their arguments by dereferencing them with {{ and }} . You can use this to load a particular file based on a variable. For example, you might want to select a

[email&#160;protected]一个高效的配置管理工具--Ansible configure management--翻译（七）

如无书面授权,请勿转载 Larger Projects Until now, we have been looking at single plays in one playbook file. This approach will work for simple infrastructures, or when using Ansible as a simple deployment mechanism. However, if you have a large and complicated

[email&#160;protected]一个高效的配置管理工具--Ansible configure management--翻译（一）

未经书面许可,请勿转载 ---      Ansible is the simplest way to automate apps and IT infrastructure 这是Ansible官方站点的介绍,本着学习的态度我决定一边学习一边翻译Ansible configure management这本书.原文下载稍后放出 #一些自解释的文字,我会忽略.或者依照自己的理解简单翻译一下,并不是每行每句都是一一相应. Preface Since CFEngine was first created

自己实现的一个分布式锁的工具以及后面的一些计划

https://github.com/ruanjianlxm/distributedLock 顶上的链接是我自己简单实现的一个分布式锁的工具,目前只支持基于zookeeper.功能也不太完善,准备后期优化下. 借着各个工具的代码梳理下一些简单的架构应该如何去设计,在哪些位置应该捕获异常,哪些异常应该抛出.以及如何去封装与继承. 同时: 1.1个版本将会优化各个地方的异常处理情况,以及加上一些抽象与继承. 1.2版本加上基于redis的分布式锁的实现. 1.3版本打包成工具类.并且完善各种异常情况

自己写的一个自动化测试任务执行工具（模板）

@echo off REM 设置自动执行的最大次数 SET nMaxJobTimes=100 REM 启用变量延迟 setlocal enabledelayedexpansion FOR /L %%i IN (0,1,%nMaxJobTimes%) DO ( cls echo. echo. echo ******************************************** echo. echo 测试任务自动化执行工程 echo 版本:v1.0.0.1 echo. echo ***

一个方便的数据库管理工具 Database.NET

今天找到一个较方便,的数据库管理工具,这个工具很全面,且是绿色的. Database.NET是一个免费多重数据库管理工具,提供更简单方便的可视化界面浏览数据库内容,无须另外安装整个数据库系统, 即可直接本地或远程进行数据库的在线存取,方便数据库调试,修改,查询,打印,输出,备份等多方面处理. http://fishcodelib.com/index.htm

[email&#160;protected]一个高效的配置管理工具--Ansible configure management--翻译（十二）

如无书面授权,请勿转载 第五章 自定义模块 External inventories In the first chapter we saw how Ansible needs an inventory file, so that it knows where its hosts are and how to access them. Ansible also allows you to specify a script that allows you to fetch the inventor

Ansi[email&#160;protected]一个高效的配置管理工具--Ansible configure management--翻译（五）

无书面许可请勿转载 高级Playbook Extra variables You may have seen in our template example in the previous chapter that we used a variable called group_names . This is one of the magic variables that are provided by Ansible itself. At the time of writing there a

给大家介绍一个java取色器工具

Java取色器中调用了robot方法的getPixelColor方法下面我们来看robot类中方法的具体实现如下 getPixelColor public Color getPixelColor(int x, int y) 返回给定屏幕坐标处的像素颜色. 参数: x - 像素的 X 位置 y - 像素的 Y 位置 返回: 像素的颜色 取色器通过x,y坐标返回颜色值 我通可以通过定义鼠标监听来获得鼠标的x,y坐标然后来获得要取的位置的颜色值 具体例子如下 public void mouseClic