如何不使用Serializable在Android Activity间传递数组对象？

嘿，针对你说的在Activity之间传递AsyncTask获取的对象数组且不想用Serializable的需求，我给你整理了几个实用的方案，都是Android开发中常用的：

这是替代Serializable的首选方案，性能比Serializable高出不少，也是Android原生支持的序列化方式。具体步骤如下：

• 给你的实体类实现Parcelable接口，重写必要的方法并定义CREATOR常量。举个简单的示例：

public class User implements Parcelable {
    private String userName;
    private int userAge;

    // 常规构造函数、getter/setter 省略

    // Parcelable 构造方法
    protected User(Parcel in) {
        userName = in.readString();
        userAge = in.readInt();
    }

    public static final Creator<User> CREATOR = new Creator<User>() {
        @Override
        public User createFromParcel(Parcel in) {
            return new User(in);
        }

        @Override
        public User[] newArray(int size) {
            return new User[size];
        }
    };

    @Override
    public int describeContents() {
        return 0;
    }

    @Override
    public void writeToParcel(Parcel dest, int flags) {
        dest.writeString(userName);
        dest.writeInt(userAge);
    }
}

• 传递数组时直接放入Intent：

Intent intent = new Intent(CurrentActivity.this, TargetActivity.class);
intent.putParcelableArrayExtra("USER_ARRAY", userArray);
startActivity(intent);

• 目标Activity接收数据：

User[] receivedUsers = (User[]) getIntent().getParcelableArrayExtra("USER_ARRAY");

如果是ArrayList的话，用putParcelableArrayListExtra()和getParcelableArrayListExtra()会更方便哦。

如果只是临时在Activity间传递，不需要持久化，单例类是个简单直接的选择：

• 先写一个单例数据持有者类：

public class DataHolder {
    private static DataHolder instance;
    private Object[] targetArray;

    private DataHolder() {}

    public static DataHolder getInstance() {
        if (instance == null) {
            instance = new DataHolder();
        }
        return instance;
    }

    public void setTargetArray(Object[] array) {
        this.targetArray = array;
    }

    public Object[] getTargetArray() {
        return targetArray;
    }
}

• 在AsyncTask的onPostExecute()里存入数据并跳转：

@Override
protected void onPostExecute(Object[] result) {
    super.onPostExecute(result);
    DataHolder.getInstance().setTargetArray(result);
    startActivity(new Intent(CurrentActivity.this, TargetActivity.class));
}

• 目标Activity中取出数据：

Object[] receivedArray = DataHolder.getInstance().getTargetArray();
// 用完记得清空，避免内存泄漏
DataHolder.getInstance().setTargetArray(null);

注意：这种方式要警惕内存泄漏，数据用完一定要及时清理；而且如果App被系统回收，数据会丢失，只适合临时传递场景。

如果不想写Parcelable的繁琐代码，可以把对象数组转成JSON字符串，通过Intent传递后再反序列化回来：

• 以Gson为例，先添加Gson依赖，然后进行转换：

// 当前Activity传递时
Gson gson = new Gson();
String jsonStr = gson.toJson(userArray);
Intent intent = new Intent(CurrentActivity.this, TargetActivity.class);
intent.putExtra("USER_JSON", jsonStr);
startActivity(intent);

• 目标Activity接收并反序列化：

String jsonStr = getIntent().getStringExtra("USER_JSON");
User[] receivedUsers = new Gson().fromJson(jsonStr, User[].class);

这种方式优点是代码简洁，不用写Parcelable的一堆方法；缺点是序列化/反序列化有一定性能开销，适合数据量不大的场景。

如果你的两个Activity属于同一个导航组件（比如用Navigation Component），共享ViewModel是更优雅的方式，还能避免配置变化导致的数据丢失：

• 创建一个共享的ViewModel类：

public class SharedDataViewModel extends ViewModel {
    private MutableLiveData<Object[]> dataArrayLiveData = new MutableLiveData<>();

    public void setDataArray(Object[] array) {
        dataArrayLiveData.setValue(array);
    }

    public LiveData<Object[]> getDataArray() {
        return dataArrayLiveData;
    }
}

• 当前Activity设置数据：

SharedDataViewModel viewModel = new ViewModelProvider(this).get(SharedDataViewModel.class);
viewModel.setDataArray(result);

• 目标Activity观察数据：

SharedDataViewModel viewModel = new ViewModelProvider(this).get(SharedDataViewModel.class);
viewModel.getDataArray().observe(this, array -> {
    // 在这里处理传递过来的数组数据
});

这种方式能很好地管理组件间的数据共享，还能自动处理生命周期，避免内存泄漏。

内容的提问来源于stack exchange，提问作者raguM.tech.