Why does this method of copying and modifying an array result differently for a one dimensional vs two dimensional array?

The result of running the code below is:

Scenario 1: 
Array c: [[2, 2, 3], [4, 5, 6]]
Array d: [[2, 2, 3], [4, 5, 6]]
Scenario 2: 
Array e: [ 1 2 3 ]
Array f: [ 2 2 3 ]

I don't understand why you can modify the one dimensional array afterwards without it affecting the other but you cannot do the same for the two dimensional arrays.

import java.util.Arrays;
public class Tester {
public static void main(String args[]) {
//Scenario 1:
int[][] c = {{1, 2, 3}, {4, 5, 6}};
int[][] d = new int[c.length][c.length];
for (int i = 0; i < d.length; i++) {
d[i] = c[i];
}
//test side effect
d[0][0]++;
//c[0] = d[];
System.out.println("Scenario 1: ");
System.out.println("Array c: " + Arrays.deepToString(c));
System.out.println("Array d: " + Arrays.deepToString(d));
//Scenario 2:
int[] e = {1, 2, 3};       int[] f = new int[e.length];
for (int i = 0; i < f.length; i++) {
f[i] = e[i];
}
//test side effect
f[0]++;
System.out.println("Scenario 2: ");
System.out.print("Array e: ");
printArray(e);
System.out.print("Array f: ");
printArray(f);
}
public static void printArray(int[] a) {
System.out.print("[ ");
for (int i = 0; i < a.length; i++) {
System.out.print(a[i] + " ");
}
System.out.println("]");
}
}

2D arrays? Java does not have them.

What java does have, is arrays of arrays. It's not the same thing.

Also, arrays are objects. Which means any given expression that resolves to an array is a reference. A pointer. It's like a treasure map to treasure, not the treasure itself. So:

int[] x = new {5, 6, 7};

I take a treasure chest, I open it, I toss a 5 cent, 6 cent, and 7 cent coin in it. I close it, bury it in the sand. Then, I take a piece of paper and draw a map to the treasure. I shall label this map x, and I put it in my pocket.

int[][] y = {{1, 2, 3}, {4, 5, 6}};
// NOTE:
// the above is syntax sugar for:
int[][] y = new int[][] { new int[] {1, 2, 3}, new int[] {4, 5, 6}};

I take 2 treasure chests. I put a 1c, 2c, and 3c coin in one, and a 4c, 5c, and 6c coin in the other. I bury both, and make treasure maps for both.

Then I get a third treasure chest, open it, put these maps inside (not the other chests!!), and bury my treasure-chest-full-of-maps. Then I make yet another map to this chest, label it y, and put that in my pocket too.

y[0] = x;

I take my y map out of my pocket, follow it, get out my shovel, and dig. I open the chest and find that it is a treasure-map-containing-chest. I take the first map out, take an eraser, and wipe it out. Then I take the x map out of my pocket and copy the map over. I put the y[0] map back in the treasure chest, bury the treasure chest. I stick my y and x maps back in my pocket (now the first map in the chest you find if you follow the y map is a copy of my x map!), and go home.

x[0] = 100;

I get the x map out of my pocket, follow it, dig down, take the first (5c) coin out and toss it away, then I take a shiny 100 piece-o-eight and put it back.

System.out.println(y[0][0]);

I take my y map, follow it, dig, open the chest, take the first map out (remember, it was a copy of the x map), follow that map, dig again, and lo! The first coin is... a 100 piece-o-eight! Wow! Score!

y[0] = new int[] {};

I make a new treasure chest, put nothing inside, and bury it. I then take my y map, follow it, dig, open the chest, which contains more treasure maps. I take out the first map and erase it, and I scribble down a map to this new (empty) chest I buried.

System.out.println(x[0]);

... that is still going to print 100.

TL;DR:

• x.y and x[] is java-ese for: Follow the map and dig.
• = is java-ese for: Take an eraser and wipe, then take a pen and draw a map.
• ... unless it's primitives (int, double, boolean, byte, etc) - then nevermind all that. No treasure chests involved for those.