Module 0: Arrays: A first look

Let's focus on three aspects of arrays that seem to beg explanation:

1. Why do array indices start from 0?
          ⇒ That is, why start with A[0] and not A[1]?

2. How come when one array variable is assigned to another, both seem to affect the same contents?

   	// An array A:
           int[] A = {25, 36, 49, 64};
   	// An array B:
           int[] B;
   	// What appears to be a copy:
           B = A;
   	// Prints 25 as expected:
           System.out.println (B[0]);
   
           B[3] = 16;
           System.out.println (A[3]);
   	// Prints 16 (unexpectedly), implying that A[3] has been changed to 16
       

   Why exactly, when we set the first entry of B to 0 did the first entry of A also get set to 0?

3. What are those strange things printed out when we have

   	// Something strange:
   	System.out.println (A);
       

To understand why, we're going dig a little deeper:

• Remember the "boxes" idea?
  • Variables like

        int i = 5;
        

    have a box in memory. Here, the value 5 gets into the box.

• We'll now understand these "boxes" in a little more detail.

• Think of a computer's memory as a long list of boxes, where each box has a number:
  • A box's number is like the number of a apartment mailbox.
  • The numbering starts from 0 and goes up to the size of the memory (which can be quite large).

• Every variable lives somewhere in memory.

• Let's use this example to further explain:

      // A simple 4-element array of integers:
      int[] A = {25, 36, 49, 64};
  
      // Declare B, assign it A
      int[] B = A;
  
      // Use a for-loop to print B
      for (int i=0; i<4; i++) {
          System.out.println (B[i]);
      }
  
      // Modify the 4-th element of B:
      B[3] = 81;
  
      // Print the 4-th element of A:
      System.out.println (A[3]);          // Prints 81
      

• First, let's examine this conceptual picture of memory:

  

• Examine the box for i:
  • It so happens that this particular time (the Java system determines this) that the box for i: is at location 8673.
  • This location can change with every new execution of the program but stays fixed during an execution.
  • When the for-loop executes, this is where the values 0,1,2,3 will live, as the iterations proceed.

• Now, the box for A is a little different:
  • Inside the box is an address of another box: 1032.
  • If we look at box #1032, we see that that is where the first element of the array 25 happens to reside.
  • This is no coincidence. It is by design.

• Next, notice that all the array elements of A are contiguous, one after another. This too is by design.

• To access array elements, what really happens under the hood is this:
  • The first element, A[0], is at 1032 + 0.
  • The second element, A[1], is at 1032 + 1.
  • The third element, A[2], is at 1032 + 2.
  • And so on.
  • We don't do this in our program, but underneath, that is what Java is doing when the program runs.

• In fact, in a for-loop, the i-th element, A[i], would be found at 1032 + i.

• So, the computer "goes" to location 1032 + i to fetch its contents as A[i].

Next, let's consider what happens when

        int[] A = {25, 36, 49, 64};
        int[] B;
        B = A;
        System.out.println (B[0]);
    

• The state of memory is now:

  

• Here, we say "B points to the same place A is pointing to".

• That place is the start of the actual array contents (1032 in this case).

• Thus, when we execute the println

  
          int[] A = {25, 36, 49, 64};
          int[] B;
          B = A;
          System.out.println (B[0]);
      

  B has the value 1032 and so B[0] refers to the first element, which means 25 gets printed out.

Next, consider what happens next:

        int[] A = {25, 36, 49, 64};
        int[] B;
        B = A;
        System.out.println (B[0]);
        B[3] = 16;
        System.out.println (A[3]);
    

• The assignment B[3] = 16 changes the 4-element of the array "pointed to" by B.

• So, the picture of memory now becomes:

  

• Thus, the value in A[3] is now 16.

Lastly, what was that strange output we saw when we executed

	// Something strange:
	System.out.println (A);
    

• What we see is the address in A being printed out.

• If the address were actually 1032 (as in our picture) that is what would get printed out.

• However, Java's address list is quite large and most addresses have many digits (not four as in 1032).

• In fact, it's so large that the decimal system proves inconvenient, which is why hexadecimal numbers (base 16) are used. These have the letters a,b,c,d,e,f in them.

• We don't need to understand how "hexadecimal". Just think of those as addresses, like a mailbox address.