Java Arrays: References, Non-Primitive Variables, and Shared Object Semantics

Determine the output of a small Java program that demonstrates how non-primitive variables (like arrays) store references to objects, not the objects themselves.
Emphasize the mental model of drawing variables as boxes and objects as circles/ovals to understand memory references behind the scenes.

Primitive vs non-primitive variables
- Primitives store actual values (e.g., int, boolean).
- Non-primitives store references (addresses) to objects on the heap, not the objects themselves.
- In Java, arrays are objects; an int[] is an object on the heap with 10 integer elements.
Allocation and references
- The expression like $\text{new int[10]}$ creates an array object with space for 10 integers on the heap and returns a reference to that object.
- A reference is stored in the variable (e.g., x). The variable holds the address, not the entire object.
Copying references (not copying objects)
- If we do $\text{int[] y = x;}$ , we copy the reference from x into y. Both x and y refer to the same array object.
- Modifying the array through either reference affects the same underlying object.
#### Default values of arrays
- For an int[] of length 10, each element is initially $0$ unless you assign a different value.
### #Accessing array elements through a reference
- After you have a reference to an array object, you can access elements via index: $A[i]$ , where i \in {0, 1, \ldots, A.length-1}.
#### Important distinction
- The array variable (e.g., x, y) is a reference to the array object, not the array object itself.
- The array object is the data structure on the heap containing its elements; the variables point to it.

#### Step 1: Declare int[] x
- x is a non-primitive variable that will hold a reference to an array object, not the array data itself.
#### Step 2: Allocate the array and assign its reference to x
- Conceptually: $x = \text{address of A}$ where A is the array object with length 10.
- A is the array object on the heap with elements A[0] through A[9].

Step 3: Declare int[] y and assign it the value of x

Conceptually: $y = x$ , so - $\text{ref}(x) = A$ and $\text{ref}(y) = A$ after the assignment.
Both x and y store the same address pointing to the same A object.

#### Step 4: Print x[5] and y[5] before writing to the array
- Since the array elements are initially 0, we expect $x[5] = 0$ and $y[5] = 0$ .
#### Step 5: Write to x[5]
- Execute: $x[5] = 99.$
- This updates the array object A at index 5 to 99.

Step 6: Print x[5] and y[5] after the write

Because both x and y refer to the same array object A, accessing index 5 through either reference yields the same updated value:- $x[5] = 99$ and $y[5] = 99$ .
#### Expected program output (conceptual)
First prints: 0
Second prints: 0
Then prints: 99
Then prints: 99

Before assignment to index 5, each element of the new int[10] array has the default value 0, so both x[5] and y[5] read 0.
When we assign $x[5] = 99$ , we're modifying the single shared array object A at index 5.
Since y points to the same A object (ref(y) = ref(x) = A), reading A[5] via either x or y yields the updated value 99.
The two variables do not hold copies of the array; they hold references to the same array object on the heap.

Draw x as a small box (variable) that holds a reference (address) to an array object on the heap.
Draw the array object as a larger circle/oval with 10 cells inside it (indices 0–9).
Draw an arrow from x’s box to the array object to represent the stored reference.
For the line $int[] y = x;$ draw another box for y and copy the same address so y also points to the same array object (another arrow from y to the same circle).
Show that both x and y share the same underlying array object; changes through one reference affect what you see via the other reference.

#### Distinguish between
- Array variable: a reference that points to an array object (e.g., x, y).
- Array object: the data structure on the heap containing the actual elements.
Non-primitive variables store references; primitive variables store actual values.
A deep copy would require creating a new array object and copying each element; simple assignment copies only the reference.
A powerful debugging habit is to sketch memory layout on paper to reason about code that uses arrays and references.

When you pass an array to a method or assign it to another variable, you’re typically passing or copying the reference, not creating a new independent array.
If you want independent copies, you must manually copy elements (e.g., loop through and assign each element to a new array).
This understanding helps with debugging and reasoning about side effects in code that uses arrays and objects.

What happens if an array is of a non-primitive type (e.g., an array of objects like Student instances) rather than primitive types like int.
Expectation: similar reference semantics apply, but with the caveat that each element is itself a reference to an object.

Arrays are objects in Java; an array variable holds a reference to that object.
Primitive variable holds a value; non-primitive variable holds a reference.
Assigning one array variable to another copies the reference, not the array contents.
All elements of a newly created int[] are initialized to the default value for int, which is $0$ .
Modifying the array through any reference that points to the same array object reflects in all references to that same object.

Let A be the array object of length 10: $A.length = 10,\text{ and } A[i] \,\in\, \mathbb{Z}, \; i \in {0,1,\,\ldots,\,9}.$
#### References
- $x = \text{ref}(A)$ (x references A)
- $y = x \implies \text{ref}(y) = A$ (both refer to the same object)
#### Access and modification
- $A[5] = 99$
- $x[5] = A[5] = 99$
- $y[5] = A[5] = 99$

The program demonstrates the core concept that array variables are references to a single array object. Changes made through one reference are visible through any other reference to the same object.
This understanding is foundational for debugging memory-related behavior in Java and for comprehending more advanced topics like shallow vs deep copies and references to non-primitive array elements.