Array initialization and how references work

1. Array Declaration and Initialization

In Java, arrays are objects stored on the heap, and variables hold references to them.

Basic Syntax

// Declaration

int[] numbers;        // Preferred style
int numbersAlt[];     // Also valid

// Initialization with size
numbers = new int[5]; // Creates array of length 5, all elements = 0

// Declaration + initialization
int[] nums = new int[5];

// Initialization with values
int[] primes = {2, 3, 5, 7, 11};

2. Default Values

When you create an array with new, all elements are automatically initialized to default values:

Example:

String[] names = new String[3];
System.out.println(names[0]); // null

3. Array References

​Arrays are reference types:

• Assigning one array variable to another copies the reference, not the contents.
• Modifying one affects the other.

int[] a = {1, 2, 3};
int[] b = a; 
// b references the same array as a
b[0] = 99;
System.out.println(a[0]); // 99 (changed via b)

4. Creating Independent Copies

To avoid shared references, you must clone or copy the array:​​

int[] original = {1, 2, 3};
int[] copy1 = original.clone(); // Shallow copy

int[] copy2 = java.util.Arrays.copyOf(original, original.length);
copy1[0] = 99;
System.out.println(original[0]); // Still 1

5. Multi-Dimensional Arrays

Java supports arrays of arrays (jagged arrays):

int[][] matrix = new int[2][3]; // 2 rows, 3 columns each
matrix[0][0] = 10;
// Jagged array

int[][] jagged = new int[2][];
jagged[0] = new int[3];
jagged[1] = new int[5];

6. Complete Runnable Example

import java.util.Arrays;

public class ArrayDemo {    
    public static void main(String[] args) {        
        // 1. Declaration + initialization 
        int[] nums = {1, 2, 3};        
        System.out.println("Original: " + Arrays.toString(nums));     
 
        // 2. Reference assignment
        int[] ref = nums;        
        ref[0] = 99;        
        System.out.println("After ref change: " + Arrays.toString(nums));     
 
        // 3. Independent copy 
        int[] copy = nums.clone();        
        copy[0] = 42;        
        System.out.println("Copy changed: " + Arrays.toString(copy));        
        System.out.println("Original unaffected: " + Arrays.toString(nums));       
 
        // 4. Default values 
        String[] names = new String[3];        
        System.out.println("Default String array: " + Arrays.toString(names)); 
 
        // 5. Multi-dimensional 
        int[][] matrix = new int[2][3];        
        matrix[1][2] = 7;        
        System.out.println("Matrix: " + Arrays.deepToString(matrix));    
    }
}

Output

Original: [1, 2, 3]
After ref change: [99, 2, 3]
Copy changed: [42, 2, 3]
Original unaffected: [99, 2, 3]
Default String array: [null, null, null]
Matrix: [[0, 0, 0], [0, 0, 7]]

✅ Key Takeaways

• Arrays in Java are objects; variables store references.
• Assigning one array to another does not copy elements.
• Use .clone() or Arrays.copyOf() for independent copies.
• Default values depend on the element type.
• Multi-dimensional arrays are arrays of arrays.