What Happens in Memory

1static int[] makeArray(int n) {2    int[] arr = new int[n];                  // the array object lives on the heap3    for (int i = 0; i < n; i++) {4        arr[i] = (i + 1) * 10;5    }6    return arr;                              // hands back the reference, not a copy7}8 9static int sum(int[] a) {10    int total = 0;                           // a primitive: stored inside sum's frame11    for (int x : a) {12        total += x;13    }14    return total;                            // sum's frame is thrown away after this15}16 17static int run(int n) {18    int[] data = makeArray(n);19    int[] alias = data;                      // copies the arrow, not the array20    alias[0] = 99;                           // so data[0] is 99 now too21    return sum(data);22}

1static void countBuggy(int n, int count) {   // every frame gets its own copy of count2    if (n == 0) return;3    count++;                                 // lost as soon as this frame returns4    countBuggy(n - 1, count);5}6 7static void countInto(int n, int[] count) {  // every frame shares ONE array on the heap8    if (n == 0) return;9    count[0]++;10    countInto(n - 1, count);11}12 13static int countReturned(int n) {            // cleanest: return the answer up the stack14    return n == 0 ? 0 : 1 + countReturned(n - 1);15}

1static boolean[] stringChecks() {2    String a = "rahul";                      // a literal: stored once in the String pool3    String b = "rahul";                      // the same literal: the same pooled object4    String c = new StringBuilder("ra").append("hul").toString();  // built at run time: a new object5    return new boolean[] {6        a == b,                              // true:  same object (thanks to the pool)7        a == c,                              // false: two objects, same text8        a.equals(c),                         // true:  compares the characters9    };10}11 12static boolean[] arrayChecks() {13    int[] x = {1, 2, 3};14    int[] y = {1, 2, 3};15    return new boolean[] {16        x == y,                              // false: two array objects17        x.equals(y),                         // false: arrays keep Object.equals, which is ==18        Arrays.equals(x, y),                 // true:  element by element19    };20}

1static int[][] aliasVsCopy() {2    int[] original = {1, 2, 3};3    int[] alias = original;                  // same array, two names4    int[] copy = original.clone();           // a new array with the same values (Arrays.copyOf works too)5    alias[0] = 100;                          // visible through original6    copy[1] = 200;                           // original is not affected7    return new int[][] {original, copy};     // [[100, 2, 3], [1, 200, 3]]8}

1static int[][] sharedRowsBug(int rows, int cols) {2    int[][] grid = new int[rows][];          // an array of row REFERENCES, all null for now3    int[] row = new int[cols];4    Arrays.fill(grid, row);                  // BUG: every grid[r] points at the SAME row5    grid[0][0] = 7;                          // so this "changes" every row6    return grid;7}8 9static int[][] separateRows(int rows, int cols) {10    int[][] grid = new int[rows][cols];      // rows separate row arrays, all zeros11    grid[0][0] = 7;12    return grid;13}14 15static int[][] deepCopy(int[][] grid) {16    int[][] copy = new int[grid.length][];17    for (int r = 0; r < grid.length; r++) {18        copy[r] = grid[r].clone();           // grid.clone() alone would copy only the row references19    }20    return copy;21}

1static long[] limits() {2    return new long[] {3        Byte.MAX_VALUE,                      // 127                  (8 bits)4        Short.MAX_VALUE,                     // 32767                (16 bits)5        Character.MAX_VALUE,                 // 65535                (16 bits, unsigned: a char is a number)6        Integer.MAX_VALUE,                   // 2147483647, ~2.1e9   (32 bits)7        Long.MAX_VALUE,                      // 9223372036854775807, ~9.2e18 (64 bits)8    };9}10 11static long sumAll(int[] nums) {12    long total = 0;                          // 10^5 values of 10^9 each = 10^14: needs long13    for (int x : nums) total += x;14    return total;15}16 17static long areaWrong(int w, int h) {18    return (long) (w * h);                   // BUG: the int multiply overflowed before the cast19}20 21static long area(int w, int h) {22    return (long) w * h;                     // cast first, then multiply in 64 bits23}24 25static int checkedAdd(int a, int b) {26    return Math.addExact(a, b);              // throws ArithmeticException instead of wrapping27}

1static int wrapDemo() {2    return Integer.MAX_VALUE + 1;            // wraps around to Integer.MIN_VALUE, silently3}4 5static int midBroken(int lo, int hi) {6    return (lo + hi) / 2;                    // lo + hi can pass 2^31 - 1 and turn negative7}8 9static int midSafe(int lo, int hi) {10    return lo + (hi - lo) / 2;               // hi - lo never overflows when 0 <= lo <= hi11}12 13static int midShift(int lo, int hi) {14    return (lo + hi) >>> 1;                  // unsigned shift reads the wrapped bits correctly15}16 17static long sumAsLong(int lo, int hi) {18    return (long) lo + hi;                   // widen BEFORE adding: 64 bits hold any int sum19}

1static long sumPrimitive(int n) {2    long total = 0;                          // 8 bytes inside the frame, no objects at all3    for (int i = 0; i < n; i++) total += i;4    return total;5}6 7static Long sumBoxed(int n) {8    Long total = 0L;                         // a Long OBJECT: each += unboxes, adds, then boxes a new Long9    for (int i = 0; i < n; i++) total += i;10    return total;11}12 13static int[] countsArray(int[] values, int maxValue) {14    int[] counts = new int[maxValue + 1];    // 4 bytes per counter, one object in total15    for (int v : values) counts[v]++;16    return counts;17}18 19static Map<Integer, Integer> countsMap(int[] values) {20    Map<Integer, Integer> counts = new HashMap<>();  // boxed keys, boxed values, one entry object each21    for (int v : values) counts.merge(v, 1, Integer::sum);22    return counts;23}

1static long sumTo(int n) {2    if (n == 0) return 0;                    // base case3    return n + sumTo(n - 1);                 // every call waits on the stack: depth n4}5 6static long sumToLoop(int n) {7    long total = 0;                          // one frame, reused n times8    for (int i = 1; i <= n; i++) {9        total += i;10    }11    return total;12}

1class ObjectStack<T> {2    private Object[] items = new Object[4];3    private int size = 0;4 5    void push(T item) {6        if (size == items.length) items = Arrays.copyOf(items, size * 2);  // old array becomes garbage7        items[size++] = item;8    }9 10    @SuppressWarnings("unchecked")11    T pop() {12        T top = (T) items[--size];13        items[size] = null;                  // forget it, so the GC can reclaim the object14        return top;15    }16 17    int size() {18        return size;19    }20}