Keeping the address space the same in java

I'm trying to keep my address the same, since I have a JList pointing towards listAccts. How do I make ListAccts have the same address space? Basically, how do I copy this object?

public class BankEngine extends AbstractListModel {

/** holds the accounts inside the bank engine */
private ArrayList<Account> listAccts;
/** holds all the actions the user has done. */
private ArrayList<Action> actions;
/** holds old versions of the bank. */
private ArrayList<ArrayList<Account>> oldEngines;

/*****************************************************************
 * Constructor that creates a new BankEngine, the core of the pro开发者_StackOverflow中文版ject
 ******************************************************************/
public BankEngine() {
    listAccts = new ArrayList<Account>();
    // actions = new ArrayList<Action>();
    oldEngines = new ArrayList<ArrayList<Account>>();
    oldEngines.add(listAccts);
}
public void undo() {
    if (oldEngines.size() == 0) {

    } else {
        listAccts = oldEngines.get(oldEngines.size()-1); <--- I want this to have the same listAccts pointer.

}

All the objects in a java process share the same address space i.e. the address space of the running JVM

If I understand correctly, you want to ensure that listAccts refers to the same physical object throughout the lifetime of your code. Unless you assign listAccts to refer to a different object (in code you haven't shown us), this is a given.

After oldEngines.add(listAccts) is executed, oldEngines will contain a reference to the same object listAccts is referring to. However, listAccts is not changed in any way - it still refers to the exact same object!

So - again: unless you reassign listAccts in code you haven't shown us - the line

listAccts = oldEngines.get(oldEngines.size()-1);

looks totally unnecessary to me. In fact, it may be confusing you, if you have added other elements to oldEngines in the meantime, as then its last element won't anymore refer to the same object listAccts does.

Note also that Java doesn't have pointers, only references. All non-primitive (object) variables are actually references, not by-value copies of an object. And the JVM can actually change the physical memory location of objects under the hood, updating all references to these objects. We have no way to notice this, because there is no way to get the actual physical memory address from a reference (at least within Java - I guess you could do it using e.g. JNI). A reference is a higher level of abstraction than a pointer - it is not a memory address. This is why terms like address space are meaningless in Java.

Update

what I'm trying to do is make it so that the last oldEngine is now replacing what is the current listAccts.

If you mean to change the listAccts reference to point to the last element in oldEngine, you are already doing that. If you mean to copy the contents of the last element in oldEngine into the current listAccts object (overwriting its current contents), try

listAccts.clear();
listAccts.addAll(oldEngines.get(oldEngines.size()-1));

If you mean you want listAccts to essentially be the same object as it was before, i.e. you don't want to create a new list, then what you need to do is:

listAccts.addAll(oldEngines.get(oldEngines.size() - 1));

i.e., manipulate your existing list rather than creating a new object.

My problem was I was passing along the same old listAccts to the array list, without saying "new". Even when I did say "new" i was passing along the accounts inside of listAccts, so the arraylist would be new, but the accounts inside of the new array list would be the ones I wanted to have backups of. What I had to do was create a new object from a deep copy using this method.

http://www.javaworld.com/javaworld/javatips/jw-javatip76.html?page=2

Thanks everyone who offered help.