Does Java's reference system help save memory when storing data in multiple containers?

Question

Basic question

Consider this object:

Person alice = new Person("Alice", 0);

It's added to two ArrayLists:

ArrayList<Person> foo = new ArrayList<Person>();
ArrayList<Person> bar = new ArrayList<Person>();

foo.add(alice);
bar.add(alice);

At this point, are there three Person objects in heap memory (alice plus one in each ArrayList)? Or is there one Person object in memory along with three references (pointers) to it?

Motivation for/more involved question

A Person object has two fields, a String and an int. Say I have many Person objects, and I want to have them all sorted in two different ways at different times (sometimes by their Strings alphabetically, sometimes by their ints numerically).

It seems this can be done in two ways:

• Have one container, like an ArrayList, of the objects and sort it on demand whenever I want to change the sorting scheme

• Have two containers, one which sorts Persons by their Strings alphabetically and one which sorts by their ints numerically

The first way is time inefficient but space efficient.

The second way is time efficient but space inefficient (say Person objects are very large).

In languages like C++, doing this efficiently in time and space would entail the second way but with multiple containers of pointers to a single collection of Person objects. Because this is difficult, people often recommend things like Boost's multi_index_container, which does exactly this. In Java, I've seen people elide this complexity, something that seems possible because all Java objects are behind pointer-like references at all times.

Are they correct in doing so? In Java, is doing things the second way in a space-efficient manner as simple as having multiple containers with redundant references to the same objects?

Bonus question

Is this true or untrue in other languages, like JavaScript, Python, Ruby, C#, Go, Rust, etc.?

Answer 1

At this point, are there three Person objects in heap memory (alice plus one in each ArrayList)?

One Person object in memory, with three object references (pointers). The Person alice variable you declared holds one reference, while each List you created holds a single element for an object reference (pointer). So a total of 3 references.

Technically speaking, a ArrayList is a list of object references (pointers), not objects. When we say ArrayList<Person>, we mean a list of pointers that are only allowed to point to objects of class Person but not School or Invoice. So the size of the Person object, School or Invoice object is irrelevant in terms of size in the List. Every List has elements containing only an object reference in each element, so they are always the same size.

The tricky part to understand is that Java syntax was purposely designed to hide the reference/pointer from us as Java programmers. This gives us the convenience in our day-to-day programming work of thinking of the List as containing Person objects. We know the underlying structure as actually references/pointers, but we need not think about that.

When we retrieve a Person from the List:

Person p = foo.get( 0 ) ;  // Annoying zero-based index counting. So zero is the first element.

…Java does the work of accessing the element in the list, obtaining its stored reference/pointer, then following that reference/pointer to look up that object’s place in memory, and return that memory location (basically, a number) to be stored in the reference-to-a-Person-object variable named p here in this example.

When we get the name member from that Person object:

String name = p.name ; 

…the JVM follows that reference/pointer stored in p to locate the actual object floating around elsewhere in memory, then moving through that chunk of memory to find the name member variable within the object.

In contrast, the C language makes these pointers quite obvious and available. This makes programming much more confusing and complicated, and much more error-prone.

You need not understand all this when starting out programming. Occassionally revisit the topic, mull it over, and eventually it will click to make sense. Diagrams can help. For more info and drawings, see a couple of my Answers to related Questions, here and here. Search Stack Overflow, as this topic has been covered many times such as here and here.

Sorting

Using the Java Collections Framework, you have two options to access a group of objects in sorted order: Either re-sort when switching order, or maintain two collections. The size of the content within the objects is irrelevant as only pointers are involved in the collections.

Of course third-parties are free to develop their own collections to exhibit other behavior.