Android保存多个对象

• 在做Android开发的时候，有时候可能需要保存不同类中多个对象里封装好的数据，比如一个项目里面，既有书的类，书这个可以有很多不同的对象，还有学生的类，学生的类也可以创建出不同的对象，那么当有很多Activity都要用到这些数据的时候，最好可以把这些类的对象都保存起来。

• 下面的代码就是如何保存一个类的对象

1.首先创建一个叫SaveObject的类。主要用它来序列化对象和方序列话对象。

• 这个类也可以用来保存对象，我已经在写好了saveObject()和getObject(),但用起来很不方便，因为只能保存一个对象的数据。我希望的是像SharedPreferences这个类一样，通过键值对来进行对数据的保存和访问，这样就可以保存多个对象数据，只要你的key不一样就可以了。那么接下来再对数据进行进一步的封装。

import java.io.ByteArrayInputStream;
import java.io.ByteArrayOutputStream;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
import java.io.StreamCorruptedException;
import android.content.Context;
import android.util.Base64;

public class SaveObject {

    private Context context;
    private final String name = "OBJECT_DATA";

    public SaveObject(Context context){
        this.context = context;
    }

    /**
     * 保存单个对象
     * @param object
     */
    public void saveObject(Object object){
        FileOutputStream stream;
        ObjectOutputStream oos;
        try {

            stream = context.openFileOutput(name, Context.MODE_PRIVATE);
            oos = new ObjectOutputStream(stream);  
            oos.writeObject(object);
            oos.close();

        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        }  



    }

    /**
     * 取得单个对象
     * @return
     */
    public Object getObject(){

        FileInputStream stream;
        Object obj = null;

        try {

            stream = context.openFileInput(name);
            ObjectInputStream ois = new ObjectInputStream(stream);  
            obj = ois.readObject();  
            ois.close();

        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } catch (StreamCorruptedException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        } catch (ClassNotFoundException e) {
            e.printStackTrace();
        }
        return obj;  

    }

    /**
     * 序列化对象
     */
    public String serialize(Object object) throws IOException {

        ByteArrayOutputStream byteArrayOutputStream = new ByteArrayOutputStream();
        ObjectOutputStream objectOutputStream = new ObjectOutputStream(byteArrayOutputStream);
        objectOutputStream.writeObject(object);
        String serializeString = new String(Base64.encode(
        byteArrayOutputStream.toByteArray(), Base64.DEFAULT));

        objectOutputStream.close();
        byteArrayOutputStream.close();

        return serializeString;
    }

    /**
     * 反序列化对象
     */
    public Object UnSerialize(String str) throws IOException,ClassNotFoundException {

        byte[] mobileBytes = Base64.decode(str.getBytes(),
                Base64.DEFAULT);

        ByteArrayInputStream byteArrayInputStream = new ByteArrayInputStream(mobileBytes);
        ObjectInputStream objectInputStream = new ObjectInputStream(byteArrayInputStream);
        Object object = objectInputStream.readObject();
        objectInputStream.close();
        byteArrayInputStream.close();

        return object;
    }
}

2.首先创建一个叫SharedPreferencesDatat的类，保存多个数据对象。

• 因为有了前面的SaveObject类中的序列化对象和反序列化对象，我们就可以用SharedPreferences 来保存对象数据了。在这个类里面我也写了一些基本数据的保存方法。

import java.io.IOException;
import android.content.Context;
import android.content.SharedPreferences;
import android.content.SharedPreferences.Editor;

/**
 * 保存轻量级数据的类
 * @author Lenovo
 *
 */
public class SharedPreferencesData {

    private String saveName = "MY_DATA";
    private Editor editor;
    private SharedPreferences sharedPreferences;
    private SaveObject saveObject;

    public SharedPreferencesData(Context context){

        editor = context.getSharedPreferences(saveName, Context.MODE_PRIVATE).edit();
        sharedPreferences = context.getSharedPreferences(saveName, Context.MODE_PRIVATE);

        saveObject = new SaveObject(context);

    }

    public Editor putString(String key, String value) {

        editor.putString(key, value);

        return editor;
    }

    public Editor putInt(String key, int value) {

        editor.putInt(key, value);

        return editor;
    }

    public Editor putBoolean(String key, boolean value) {

        editor.putBoolean(key, value);

        return editor;
    }

    public Editor remove(String key) {

        editor.remove(key);

        return editor;
    }

    public Editor clear() {

        editor.clear();

        return editor;
    }

    public Editor commit() {

        editor.commit();

        return editor;
    }

    public String getString(String key, String defValue) {

        return sharedPreferences.getString(key, defValue);
    }


    public int getInt(String key, int defValue) {

        return sharedPreferences.getInt(key, defValue);
    }

    public boolean getBoolean(String key, boolean defValue) {

        return sharedPreferences.getBoolean(key, defValue);
    }

    /**
     * 自定义保存对象
     * @param key
     * @param object
     */
    public void putObject(String key,Object object){
        try {
            this.putString(key, saveObject.serialize(object));
        } catch (IOException e) {
            e.printStackTrace();
        }
    }

    /**
     * 自定义取得对象
     * @param key
     * @param defValeObject
     * @return
     */
    public Object getObject(String key,Object defValeObject){

        Object object = null;

        try {
                object =   saveObject.UnSerialize(this.getString(key,(String)defValeObject));
        } catch (IOException e) {
            e.printStackTrace();
        } catch (ClassNotFoundException e) {
            e.printStackTrace();
        }

        return object;

    }
}

注意：你要保存的对象一定要是继承了Serializable接口，告诉系统这是一个被序列化的类，不然会报错（例如：public class Human implements Serializable）

到这里，就可以用SharedPreferencesData类中的putObject()和getObject()方法来保存多个对象和获取多个对象的数据了。