When you declare an array in Java, like int[] numbers;, you're not creating the array itself. You're creating a reference, a variable that will hold the memory address of the array. Think of it as a signpost that points to where the actual data is stored. This signpost lives in a region of memory called the stack, which is fast, small, and used for managing method calls and local variables.

The actual array data, the block that holds all the elements, is allocated in a different, much larger memory area called the heap when you use the new keyword, for example: numbers = new int[5];. This command tells the Java Virtual Machine (JVM) to find a chunk of available space on the heap, reserve it for five integers, and then store the starting address of that chunk in your numbers variable on the stack. This separation is key to understanding Java's memory model.

The memory block allocated on the heap for an array is contiguous. This means all the elements of the array are stored one after another in an unbroken sequence. If you have an array of integers, the first integer is right next to the second, which is right next to the third, and so on. This layout is extremely efficient for the CPU. To access numbers[3], the system doesn't need to search for the element. It takes the starting address of the array, calculates an offset ($start\_address + 3 * size\_of\_integer$), and jumps directly to the correct memory location. This is why array lookups by index are lightning fast.

This is why you can't just 'add' an element to a full Java array. To 'grow' an array, you must create a completely new, larger array and copy every element from the old one to the new one. This is the underlying process used by data structures like ArrayList.

The contiguous nature of arrays has different implications for primitive types versus object types.

• An array of primitives, like int[], stores the actual primitive values directly within its contiguous block on the heap. An array of five integers will have a block of memory that holds five integer values back-to-back.

• An array of objects, like String[], works differently. It does not store the objects themselves inside the array's memory block. Instead, it stores a series of references. Each element of the array is a memory address pointing to where the actual String object is located elsewhere on the heap.

This difference explains why an array of primitives can be more memory-efficient. There's less memory overhead because you're only storing the data itself, not an extra layer of pointers. However, storing references provides flexibility, allowing arrays to hold complex objects of varying sizes without needing to know their exact size when the array is created, just the size of a reference.

Because Java passes the reference by value, any changes made to the array's elements inside the method will persist after the method returns. The method receives a copy of the signpost, but that new signpost still points to the same block of data on the heap. If you use it to change an element at numbers[0], you are changing the original data. However, if you try to reassign the array variable itself inside the method (e.g., numbers = new int[10];), you are only changing the method's local copy of the reference. The original reference outside the method remains untouched.

Understanding this stack-and-heap dance is fundamental. It clarifies why arrays are fixed-size, how they handle different data types, and what happens when you pass them around in your code. This knowledge forms a solid base for analyzing the performance and memory usage of more complex algorithms.