核心原理：

对象序列化

步骤

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;

  }