核心原理：

对象序列化

步骤

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

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

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

下面是完整代码

步骤1.要保存的对象实现序列化Serializablepublic class Sertest implements Serializable{

private String name;

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进制的数据转为数组

*

创建人：聂旭阳 , 2014-5-25 上午11:08:33

* @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

{

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;

}

原文：http://blog.csdn.net/z8711042/article/details/26942811