Question

I have an Object X which contains a list of Objects X.
I do a loop on the list and pass an Object X from the list to another activity through an Intent.

In the other activity, I modify this Object X and then return this modified Object X.

When I get back the Object X in my first activity, I can see it’s been modified, this point is ok.

But the root Object X (the one containing the list of Objects X and from which comes from the modified Object X), shouldn’t it be modified as well as I passed a reference to the intent ?

If not, how can I manage to have it modified as the root depth of Objects X inside other Objects X can be deep ?

(tell me in I’m not clear enough).

Thanks for your help.
I have an activity with send and Object X through another activity

My object to be more precise (don’t pay attention of the fact that it is Serializable and not Parcelable, I’ll fix this later):

public class CategoryBean implements Externalizable, Cloneable {
    public static final boolean ACTIVE = true;
    public static final boolean INACTIVE = false;

    public static final int VALIDATED = 1;
    public static final int NON_OBSERVED = 2;
    public static final int IN_PROGRESS = 3;
    public static final int PARTIEL = 4;

    private String perimetre;
    private CategoryBean parentCategory;
    private List<CategoryBean> categoryList = new ArrayList<CategoryBean>();
    protected String title;
    /**
     * Category validée ou non
     */
    protected int state;
    /**
     * Category active ou inactive
     */
    protected boolean activated = ACTIVE;

    // public CategoryBean(Parcel in) {
    // this.parentCategory = in.readParcelable(CategoryBean.class.getClassLoader());
    // this.categoryList = Arrays.asList(in.readParcelableArray(CategoryBean.class.getClassLoader()));
    // this.title = in.readString();
    // }

    /**
     * @return the parentCategory
     */
    public CategoryBean getParentCategory() {
        return parentCategory;
    }

    /**
     * @return the perimetre
     */
    public String getPerimetre() {
        return perimetre;
    }

    /**
     * @param perimetre
     *            the perimetre to set
     */
    public void setPerimetre(String perimetre) {
        this.perimetre = perimetre;
    }

    /**
     * @param parentCategory
     *            the parentCategory to set
     */
    public void setParentCategory(CategoryBean parentCategory) {
        this.parentCategory = parentCategory;
    }

    /**
     * @return the category
     */
    public List<CategoryBean> getCategoryList() {
        return categoryList;
    }

    /**
     * @param category
     *            the category to set
     */
    public void setCategoryList(List<CategoryBean> categoryList) {
        this.categoryList = categoryList;
    }

    /**
     * @return the title
     */
    public String getTitle() {
        return title;
    }

    /**
     * @param title
     *            the title to set
     */
    public void setTitle(String title) {
        this.title = title;
    }

    /**
     * @return the state
     */
    public int getState() {
        return state;
    }

    /**
     * @param state
     *            the state to set
     */
    public void setState(int state) {
        this.state = state;
    }

    /**
     * @return the activated
     */
    public boolean isActivated() {
        return activated;
    }

    /**
     * @param activated
     *            the activated to set
     */
    public void setActivated(boolean activated) {
        this.activated = activated;
    }

    @Override
    public int hashCode() {
        return parentCategory.hashCode() + categoryList.hashCode() + title.hashCode();
    }

    @SuppressWarnings("unchecked")
    @Override
    public void readExternal(ObjectInput input) throws IOException, ClassNotFoundException {
        setPerimetre((String) input.readObject());
        setParentCategory((CategoryBean) input.readObject());
        setCategoryList((List<CategoryBean>) input.readObject());
        setTitle((String) input.readObject());
        setState((Integer) input.readObject());
        setActivated((Boolean) input.readObject());
    }

    @Override
    public void writeExternal(ObjectOutput output) throws IOException {
        output.writeObject(getPerimetre());
        output.writeObject(getParentCategory());
        output.writeObject(getCategoryList());
        output.writeObject(getTitle());
        output.writeObject(getState());
        output.writeObject(isActivated());
    }

    @Override
    public CategoryBean clone() throws CloneNotSupportedException {
        try {
            CategoryBean clone = (CategoryBean) super.clone();
            clone.setPerimetre(clone.getPerimetre());
            clone.setParentCategory(clone.getParentCategory());
            clone.setCategoryList(clone.getCategoryList());
            clone.setTitle(clone.getTitle());
            clone.setState(clone.getState());
            clone.setActivated(clone.isActivated());
            return clone;
        } catch (CloneNotSupportedException e) {
            throw new InternalError();
        }
    }

    @Override
    public String toString() {
        StringBuilder sb = new StringBuilder("( CategoryBean -> ");
        sb.append(" perimetre : ");
        sb.append(getPerimetre());
        sb.append(" parentCategory : ");
        sb.append(getParentCategory() != null ? getParentCategory().getTitle() : null);
        sb.append(" categoryList : ");
        sb.append(getCategoryList());
        sb.append(" title : ");
        sb.append(getTitle());
        sb.append(" state : ");
        sb.append(getState());
        sb.append(" activated : ");
        sb.append(isActivated());
        sb.append(" )");
        return sb.toString();
    }
}

Answer 1

In general i wouldn’t recommend to do modifications by reference even if its possible in Java. It has several drawbacks that will become clear later in development stage when you have thousand of lines of code and a few other developers working on the same project and everyone is wondering why the heck the list items get modified magically and WHERE 🙂

I would suggest you simply store the modified object back into the list replacing it. All you have to do is keep track of the index.

Use the set method of the List interface:

set(int index, Object element) 
      Replaces the element at the specified position in this list with the specified element.

EDIT:
That would also be a cleaner approach in terms of low coupling and modularity. So one activity doesn’t rely on another and can be reused for a specific task.

To answer your exact question: I guess Android does clone the item or due to serialization of the item it is copied/newly created and not passed by reference, because of the reasons mentioned above.