Copying Arrays in Java: Shallow vs Deep Copy Explained

public class ReferenceVsCopy {
    public static void main(String[] args) {

        // Original array of top-3 game scores
        int[] originalScores = {1500, 2300, 900};

        // THIS IS NOT A COPY — both variables point to the same array in memory
        int[] aliasScores = originalScores;

        // We think we're only changing aliasScores...
        aliasScores[0] = 9999;

        // ...but originalScores is also changed, because they share the same memory
        System.out.println("originalScores[0] = " + originalScores[0]); // Surprise!
        System.out.println("aliasScores[0]    = " + aliasScores[0]);

        // Proof they point to the same object
        System.out.println("\nSame object? " + (originalScores == aliasScores));
    }
}

import java.util.Arrays;

public class SystemArrayCopyDemo {
    public static void main(String[] args) {

        // Weekly temperature readings in Celsius
        int[] weeklyTemps = {18, 21, 19, 23, 25, 22, 20};

        // --- Full copy ---
        // Step 1: Create a new array of the same length
        int[] fullCopy = new int[weeklyTemps.length];

        // Step 2: Copy all elements from weeklyTemps into fullCopy
        // Args: (source, sourceStartIndex, destination, destStartIndex, numberOfElements)
        System.arraycopy(weeklyTemps, 0, fullCopy, 0, weeklyTemps.length);

        // Modifying fullCopy does NOT affect weeklyTemps
        fullCopy[0] = 999;

        System.out.println("Original temps : " + Arrays.toString(weeklyTemps));
        System.out.println("Full copy      : " + Arrays.toString(fullCopy));

        // --- Partial copy (just the weekday readings, indices 0-4) ---
        int[] weekdayTemps = new int[5];

        // Copy 5 elements starting at index 0 of weeklyTemps into weekdayTemps at index 0
        System.arraycopy(weeklyTemps, 0, weekdayTemps, 0, 5);

        System.out.println("\nWeekday temps  : " + Arrays.toString(weekdayTemps));

        // --- Inserting a slice into the middle of another array ---
        int[] dashboard = new int[10]; // pre-filled with zeroes
        // Place the weekend temps (indices 5 and 6) into positions 3 and 4 of dashboard
        System.arraycopy(weeklyTemps, 5, dashboard, 3, 2);

        System.out.println("Dashboard      : " + Arrays.toString(dashboard));
    }
}

import java.util.Arrays;

public class ArraysCopyOfDemo {
    public static void main(String[] args) {

        String[] studentNames = {"Alice", "Bob", "Carol", "David", "Eve"};

        // --- Arrays.copyOf: full copy ---
        // Creates a new array with all 5 names
        String[] fullRoster = Arrays.copyOf(studentNames, studentNames.length);
        System.out.println("Full roster    : " + Arrays.toString(fullRoster));

        // --- Arrays.copyOf: truncated copy (first 3 only) ---
        String[] topThree = Arrays.copyOf(studentNames, 3);
        System.out.println("Top three      : " + Arrays.toString(topThree));

        // --- Arrays.copyOf: extended copy (extra slots become null) ---
        // Useful pattern for manually growing an array
        String[] expandedRoster = Arrays.copyOf(studentNames, 8);
        System.out.println("Expanded roster: " + Arrays.toString(expandedRoster));

        // --- Arrays.copyOfRange: extract a specific slice ---
        // Copies from index 1 (inclusive) to index 4 (exclusive) → Bob, Carol, David
        String[] middleStudents = Arrays.copyOfRange(studentNames, 1, 4);
        System.out.println("Middle students: " + Arrays.toString(middleStudents));

        // Verify independence: changing fullRoster does NOT affect studentNames
        fullRoster[0] = "Zara";
        System.out.println("\nAfter change:");
        System.out.println("studentNames[0]: " + studentNames[0]); // Still Alice
        System.out.println("fullRoster[0]  : " + fullRoster[0]);   // Now Zara
    }
}

import java.util.Arrays;

public class ShallowVsDeepCopy {

    // A simple mutable class representing a student
    static class Student {
        String name;
        int grade;

        Student(String name, int grade) {
            this.name = name;
            this.grade = grade;
        }

        @Override
        public String toString() {
            return name + "(" + grade + ")";
        }
    }

    public static void main(String[] args) {

        // --- PRIMITIVE ARRAY: shallow copy is fine ---
        int[] originalScores = {85, 90, 78};
        int[] scoreCopy = Arrays.copyOf(originalScores, originalScores.length);

        scoreCopy[0] = 999; // Does NOT affect originalScores
        System.out.println("Primitive original : " + Arrays.toString(originalScores));
        System.out.println("Primitive copy     : " + Arrays.toString(scoreCopy));

        // --- OBJECT ARRAY: shallow copy shares references ---
        Student[] classA = {
            new Student("Alice", 90),
            new Student("Bob",   85)
        };

        // Shallow copy — new array, but SAME Student objects inside
        Student[] classB = Arrays.copyOf(classA, classA.length);

        // Changing a FIELD on classB[0]'s Student also changes classA[0]'s Student!
        classB[0].grade = 55;

        System.out.println("\n--- Shallow Copy (Object Array) ---");
        System.out.println("classA after classB change: " + Arrays.toString(classA));
        System.out.println("classB                    : " + Arrays.toString(classB));
        System.out.println("Same Student object? " + (classA[0] == classB[0])); // true!

        // --- DEEP COPY: create new Student objects in a loop ---
        Student[] classC = {
            new Student("Carol", 92),
            new Student("David", 88)
        };

        Student[] classD = new Student[classC.length];
        for (int i = 0; i < classC.length; i++) {
            // Create a brand-new Student object with the same values
            classD[i] = new Student(classC[i].name, classC[i].grade);
        }

        // Now changing classD[0] does NOT affect classC[0]
        classD[0].grade = 10;

        System.out.println("\n--- Deep Copy (Object Array) ---");
        System.out.println("classC after classD change: " + Arrays.toString(classC));
        System.out.println("classD                    : " + Arrays.toString(classD));
        System.out.println("Same Student object? " + (classC[0] == classD[0])); // false!
    }
}