Android如何从Activity向ViewPager中的Fragment传递嵌套对象？

完全不用担心，Parcelable完全支持传递包含内部对象的复杂数据，只要你的嵌套类（Answers、Dependencies）也实现Parcelable接口就可以了。下面是具体的实现步骤：

1. 让内部类实现Parcelable #

首先需要给Answers和Dependencies这两个类添加Parcelable实现。假设你的Answers类结构如下：

public class Answers implements Parcelable {
    // 示例成员变量，根据你实际的类结构调整
    private int id;
    private String optionText;

    // 空构造函数（Room数据库查询需要保留）
    public Answers() {}

    // 从Parcel读取数据的构造函数
    protected Answers(Parcel in) {
        id = in.readInt();
        optionText = in.readString();
    }

    // 必须的CREATOR静态对象
    public static final Creator<Answers> CREATOR = new Creator<Answers>() {
        @Override
        public Answers createFromParcel(Parcel in) {
            return new Answers(in);
        }

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

    @Override
    public int describeContents() {
        return 0; // 普通对象返回0即可
    }

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

    // 你的getter、setter方法
}

同样给Dependencies类实现Parcelable：

public class Dependencies implements Parcelable {
    // 示例成员变量，根据你实际的类结构调整
    private int targetQuestionId;
    private String condition;

    public Dependencies() {}

    protected Dependencies(Parcel in) {
        targetQuestionId = in.readInt();
        condition = in.readString();
    }

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

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

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

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

    // 你的getter、setter方法
}

2. 修改Questions类实现Parcelable #

现在更新你的Questions类，让它实现Parcelable，并正确处理内部的集合和对象：

public class Questions implements Parcelable {
    private int questionId;
    @PrimaryKey
    @SerializedName("Id")
    @Expose
    private int id;
    @SerializedName("DisplayText")
    @Expose
    private String displayText;
    @SerializedName("IsRequired")
    @Expose
    private boolean isRequired;
    @SerializedName("AnswerType")
    @Expose
    private String answerType;
    @SerializedName("Answers")
    @Expose
    @TypeConverters(AnswersTypeConverter.class)
    private List<Answers> answers;
    @SerializedName("Dependencies")
    @Expose
    @TypeConverters(DependenciesTypeConverter.class)
    private Dependencies dependencies;

    // 空构造函数（Room数据库查询需要保留）
    public Questions() {}

    // 从Parcel读取数据的构造函数
    protected Questions(Parcel in) {
        questionId = in.readInt();
        id = in.readInt();
        displayText = in.readString();
        isRequired = in.readByte() != 0; // boolean用byte存储
        answerType = in.readString();
        // 读取List<Answers>，使用createTypedArrayList配合CREATOR
        answers = in.createTypedArrayList(Answers.CREATOR);
        // 读取单个Dependencies对象
        dependencies = in.readParcelable(Dependencies.class.getClassLoader());
    }

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

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

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

    @Override
    public void writeToParcel(Parcel dest, int flags) {
        dest.writeInt(questionId);
        dest.writeInt(id);
        dest.writeString(displayText);
        dest.writeByte((byte) (isRequired ? 1 : 0));
        dest.writeString(answerType);
        // 写入List<Answers>，使用writeTypedList
        dest.writeTypedList(answers);
        // 写入单个Dependencies对象
        dest.writeParcelable(dependencies, flags);
    }

    // 你的getter、setter方法
}

3. 在Activity和Fragment之间传递数据 #

从Activity传递到Fragment： #

给ViewPager创建Fragment实例时，把Questions对象放入Bundle：

// 创建Fragment实例
YourPagerFragment fragment = new YourPagerFragment();
Bundle bundle = new Bundle();
bundle.putParcelable("KEY_QUESTION_DATA", yourQuestionsObject);
fragment.setArguments(bundle);

// 把fragment添加到ViewPager的适配器中即可

在Fragment中接收数据： #

在Fragment的onCreate或onViewCreated方法中取出数据：

@Override
public void onCreate(Bundle savedInstanceState) {
    super.onCreate(savedInstanceState);
    if (getArguments() != null) {
        Questions questions = getArguments().getParcelable("KEY_QUESTION_DATA");
        // 拿到数据后就可以用于页面展示了
    }
}

补充说明 #

• 你用到的@TypeConverters是Room数据库的注解，和Parcelable的实现完全不冲突，不会影响内存间的数据传递。
• 如果觉得Parcelable写起来繁琐，也可以用Serializable接口（只需要让所有类实现Serializable即可），但Parcelable是Android官方推荐的方案，效率比Serializable高很多，更适合页面间的内存数据传递。

内容的提问来源于stack exchange，提问作者Hemal Adani