Android使用SharedPreferences保存数组

核心原理：

对象序列化

步骤

1.要保存的对象实现序列化Serializable

2.将序列化的对象保存String（本文的做法是保存为byte数组在转为16进制的String类型保存起来）

3.将保存的String反序列化为对象

下面是完整代码

步骤1.要保存的对象实现序列化Serializable

public class Sertest implements Serializable{
    private String name;

    private String strs[];

    private int age;
}

步骤2。将序列化的对象保存String（本文的做法是保存为byte数组在转为16进制的String类型保存起来）

步骤3.将保存的String反序列化为对象

    /**
     * desc:保存对象
   
     * @param context
     * @param key 
     * @param obj 要保存的对象，只能保存实现了serializable的对象
     * modified:	
     */
    public static void saveObject(Context context,String key ,Object obj){
        try {
            // 保存对象
            SharedPreferences.Editor sharedata = context.getSharedPreferences(FILENAME, 0).edit();
            //先将序列化结果写到byte缓存中，其实就分配一个内存空间
            ByteArrayOutputStream bos=new ByteArrayOutputStream();
            ObjectOutputStream os=new ObjectOutputStream(bos);
            //将对象序列化写入byte缓存
            os.writeObject(obj);
            //将序列化的数据转为16进制保存
            String bytesToHexString = bytesToHexString(bos.toByteArray());
            //保存该16进制数组
            sharedata.putString(key, bytesToHexString);
            sharedata.commit();
        } catch (IOException e) {
            e.printStackTrace();
            Log.e("", "保存obj失败");
        }
    }
    /**
     * desc:将数组转为16进制
     * @param bArray
     * @return
     * modified:	
     */
    public static String bytesToHexString(byte[] bArray) {
        if(bArray == null){
            return null;
        }
        if(bArray.length == 0){
            return "";
        }
        StringBuffer sb = new StringBuffer(bArray.length);
        String sTemp;
        for (int i = 0; i < bArray.length; i++) {
            sTemp = Integer.toHexString(0xFF & bArray[i]);
            if (sTemp.length() < 2)
                sb.append(0);
            sb.append(sTemp.toUpperCase());
        }
        return sb.toString();
    }
    /**
     * desc:获取保存的Object对象
     * @param context
     * @param key
     * @return
     * modified:	
     */
    public Object readObject(Context context,String key ){
        try {
            SharedPreferences sharedata = context.getSharedPreferences(FILENAME, 0);
            if (sharedata.contains(key)) {
                 String string = sharedata.getString(key, "");
                 if(TextUtils.isEmpty(string)){
                     return null;
                 }else{
                     //将16进制的数据转为数组，准备反序列化
                     byte[] stringToBytes = StringToBytes(string);
                       ByteArrayInputStream bis=new ByteArrayInputStream(stringToBytes);
                       ObjectInputStream is=new ObjectInputStream(bis);
                       //返回反序列化得到的对象
                       Object readObject = is.readObject();
                       return readObject;
                 }
            }
        } catch (StreamCorruptedException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        } catch (IOException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        } catch (ClassNotFoundException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
        //所有异常返回null
        return null;
        
    }
    /**
     * desc:将16进制的数据转为数组
 
     * @param data
     * @return
     * modified:	
     */
    public static byte[] StringToBytes(String data){
        String hexString=data.toUpperCase().trim();
        if (hexString.length()%2!=0) {
            return null;
        }
        byte[] retData=new byte[hexString.length()/2];
        for(int i=0;i<hexString.length();i++)
        {
            int int_ch;  // 两位16进制数转化后的10进制数
            char hex_char1 = hexString.charAt(i); ////两位16进制数中的第一位(高位*16)
            int int_ch1;
            if(hex_char1 >= '0' && hex_char1 <='9')
                int_ch1 = (hex_char1-48)*16;   //// 0 的Ascll - 48
            else if(hex_char1 >= 'A' && hex_char1 <='F')
                int_ch1 = (hex_char1-55)*16; //// A 的Ascll - 65
            else
                return null;
            i++;
            char hex_char2 = hexString.charAt(i); ///两位16进制数中的第二位(低位)
            int int_ch2;
            if(hex_char2 >= '0' && hex_char2 <='9')
                int_ch2 = (hex_char2-48); //// 0 的Ascll - 48
            else if(hex_char2 >= 'A' && hex_char2 <='F')
                int_ch2 = hex_char2-55; //// A 的Ascll - 65
            else
                return null;
            int_ch = int_ch1+int_ch2;
            retData[i/2]=(byte) int_ch;//将转化后的数放入Byte里
        }
        return retData;
  }