Access the pointer to an ArrayList?

You can't because the line someOtherList = new ArrayList(); is assigning a whole new "section of memory" to someOtherList, meaning it will point to a different place in memory than listContainingObject.getList().

Now it is true that the listContainingObject has only a reference to your created list, but this reference is not semantically linked to someOtherList. So if someOtherList changes, your object won't know about it.

If you want to clear the lists without destroying the link, use someOtherList.clear() instead.

EDIT: You may be able to get away with resetting the list another way:

public class ListContainingObject {
    public void resetList(List toReset) {
        this.list = new ArrayList();
        toReset = this.list;
    }
}
listContainingObject.resetList(someOtherList);

This is, however, a pretty dirty hack. But without somehow manually changing both variables to reference the new structure in memory, I know of no way to get one to automatically update the other.

Probably, you are trying to update the contents of the "list" field. Please find an solution here:

import java.util.ArrayList;
import java.util.List;

public class ListContainingObject {

        private List list;

        public List getList() {
                return list;
        }

        public void setList(List list) {
                this.list = list;
        }

        public static void main(String args[]){
                ListContainingObject listContainingObject= new ListContainingObject();

                System.out.println(listContainingObject.getList());

                List someOtherList = new ArrayList();
                listContainingObject.setList(someOtherList);
                System.out.println(listContainingObject.getList());
                System.out.println(someOtherList);
                someOtherList = listContainingObject.getList();
                someOtherList.add("1");
                System.out.println(listContainingObject.getList());
                System.out.println(someOtherList);

                //I want the two below to have the same value
                //someOtherList = new ArrayList();
                someOtherList.clear();
                System.out.println(listContainingObject.getList());
                System.out.println(someOtherList);
        }
}

Thus, someOtherList is referring to the "list" field which is the same.

You have to again setList to the new address as once someOtherList is referring to different. So, as required "list" should be updated also and must be followed elsewhere.

Suppose you have a method, which modifies this list you can achieve this by below.

public void someMethod(){
 List someOtherList = getList();
 someOtherList =  new ArrayList();
 //some code
 setList(someOtherList);
}

For similar post check: Confused, whether java uses call by value or call by reference when an object reference is passed?

first the someotherlist is pointing to an object in heap

someotherlist ----> Object

then you are making two references to point to the same object in the heap

someotherlist ----

               |
             Object
               |

list -------------

now when you assign the reference someotherlist to a new object in the heap

someotherlist ------> new Object

the object refered by list will not be changed

list -----------> oldobject

you have to call the setters again to make list point to the new object refered by someotherlist

           Object (now eligible for garbage collection as referred by none)

someotherobject ------

                  |
             new Object
                  |

list ------

Note: you can only refer objects not object references.. what you can do is set up a method for setting the object to someotherlist and assign the same reference to the list also... like

class Test {
  List<E> list;
  List<E> someOtherList;

  setterMethod(ArrayList<E> a) {
    someOtherList = a;
    list = someOtherList;
  }

Edit:

class One {
    List<E> list;

    public void setList(List<E> newList) {
        this.list = newList;
    }
//getters and setters and other methods
}

class Two {
    One one;
    List<E> someOtherList;

    public void setSomeOtherList(List<E> newList) {
      this.someOtherList = newList;
      this.one.setList(newList);
    }
    //getters and setters and other methods
}