Module 1: Unidimensional Arrays

There is another conceptual view that's useful:

• First, let's step back and look at all of memory as one block:

  

• Within this, parts are allocated to the operating system and to a user's applications.

• The user's Java program is one such application.

• The space allocated to the Java program itself has parts: place for the code, and for three types of program memory:
  • The stack: where local variables and parameters are stored.
  • The heap: where arrays and objects are stored.
  • The global area: where everything else (like static variables) is stored.

  

Now consider a simple program:

public class Simple {

    static int a;
    static int b;
    static int c;

    public static void main (String[] argv)
    {
        // At this point: a==0, b==0, c==0;
        a = 5;
        // At this point: a==5, b==0, c==0;
        b = 1;
        // At this point: a==5, b==1, c==0;
        c = a + b;
        // At this point: a==5, b==1, c==6;
    }

}

• Initially, space is allocated (in the "global area") for the variables:

  

• Then, after the first assignment:

  

• After the last assignment:

  

Next, let's consider arrays:

public class Simple2 {

    static int a;
    static int b;
    static int c;
    static int[] A;

    public static void main (String[] argv)
    {
        // At this point: a==0, b==0, c==0, A==null;
        a = 5;
        // At this point: a==5, b==0, c==0, A==null;
        b = 1;
        // At this point: a==5, b==1, c==0, A==null;
        c = a + b;
        // At this point: a==5, b==1, c==6, A==null;

        A = new int [4];
        // At this point: A will have an address (a pointer).
    }

}

• In some languages, space for arrays is allocated in the global area:

  

• In Java:

  

  • The variable A is itself in the global area (at address 112).
  • The variable A contains the address ("810") of the actual array.
  • The actual array with its contents is allocated on the heap at address "810".

• What happens with assignment? Consider this modification:

  public class Simple3 {
  
      static int a;
      static int b;
      static int c;
      static int[] A;
  
      public static void main (String[] argv)
      {
          // At this point: a==0, b==0, c==0, A==null;
          a = 5;
          // At this point: a==5, b==0, c==0, A==null;
          b = 1;
          // At this point: a==5, b==1, c==0, A==null;
          c = a + b;
          // At this point: a==5, b==1, c==6, A==null;
  
          A = new int [4];
          // At this point: A will have an address (a pointer).
  
          A[2] = 12;
          // At this point: A[0]==0, A[1]==0, A[2]==12, A[3]==0.
      }
  
  }
     

  • Initially, when allocated, the array contents will be all zero.
  • After the assignment A[2] = 12:

    

Let's summarize what we've learned:

• Main memory is a sequence of locations, each of which has a numeric address (like "812" above).

• At the highest level, various parts of memory are allocated to programs like the operating system and applications.

• Your Java program runs as one application.

• The memory allocated to your program itself has four parts: code, stack, heap, global.

• static variables are allocated in the global area.

• An array is a contiguous sequence of memory locations.

• Array variables are really pointers: an array variable points to an area of heap memory where the actual contents are.

• The term "pointer" is used in the sense that an envelope with your address on it "points" to you: it has information on how to reach you (your address).

The idea of a memory pointer is a really important one that we will encounter many times in this course.

In-Class Exercise 3: Why are the addresses above numbered 100, 104, 108, ... , instead of 100, 101, 102, ... ?

To answer this question, Consider the following...

• Computers use binary representation meaning that computers can only represent values as either a 0 or 1. The smallest indivisible binary data unit is called a "bit".
• To represent more than just two values, we group together a number of bits into larger data units. We typically call 8 contiguous bits a "byte". 1 byte (8 bits) can represent a maximum number of 256 discrete values.
• Computer architects group together several bytes to form data units that can represent more than 256 values. When a computer architecture is described as 32-bit or 64-bit, this generally describes the number of bits grouped together to form an address.
• If there are 8 bits to a byte, then a 32-bit value is also a 4-byte value. In a 32-bit architecture, an int is a 4-byte data unit, so whenever an int is declared, it requires 4 bytes of to address the entire int.
• If the array in the example above was declared instead as a byte array instead, each data unit would only require 1 byte.
• This is primarily provided for context as this topic is one of the central topics of your future Computer Architecture class.

In case you were wondering what kinds of variables are allocated on the heap or stack, here's a preview:

class MySpecialObject {
    // Space for this variable is allocated on the heap.
    int a;
}
// In fact, space for the whole object instance is allocated on the heap.


public class VariableExamples {

    // Static variable allocated in global area.
    static int b = 1;


    //                       NOTE: parameter variable argv

    public static void main (String[] argv)
    {
        // Local variable 'c' allocated on the stack.
        int c = 2;

        // The value in 'c' gets copied into the parameter variable (see below).
        print (c);

        // Space for the whole object is allocated on the heap.
        MySpecialObject obj = new MySpecialObject ();

        // Access variables inside the object via variable name and '.' operator.
        obj.a = 3;
        print (obj.a);

        // When the method exits, 'c' and 'obj' both disappear.
    }
    

    //                 Parameter variable x is on the stack.
    static void print (int x)
    {
        System.out.println ("x=" + x);

        // You can treat the parameter like any variable.
        x = 4;

        // Static variable 'b' is accessible here.
        System.out.println ("b=" + b);

        // When the method exits, 'x' disappears.
    }
    
}

import java.util.*;

public class ArraySize {

    public static void main (String[] argv)
    {
        // Hard-coded size.
        int[] A = new int [5];
        System.out.println ("Array A has size " + A.length);
        
        // Use a variable, and assign the variable a value.
        int size = 6;
        int[] B = new int [size];
        System.out.println ("Array B has size " + B.length);
        
        // Have the size determined elsewhere.
        size = getSize ();
        int[] C = new int [size];
        System.out.println ("Array C has size " + C.length);

        // Unknown size until run-time.
        size = getSizeFromScreen ();
        int[] D = new int [size];
        System.out.println ("Array D has size " + D.length);
    }


    static int getSize ()
    {
        return 7;
    }
    
    
    static int getSizeFromScreen ()
    {
        System.out.print ("Enter size: ");
        Scanner scanner = new Scanner (System.in);
        return scanner.nextInt ();
    }

}

public class ReferenceExample {

    public static void main (String[] argv)
    {
        int x = 16;
        // Note: x is a primitive type.
        int[] A = {1, 2, 3, 4, 5};
        // Note: A is really a reference type that refers to an array.

    }

}

public class StringExample {

    public static void main (String[] argv)
    {
        // Pangram: a sentence with at least one occurence of each letter 'a' to 'z'.

        // Direct creation of String array with constants.
        String[] pangramWords = {"two", "driven", "jocks", "help", "fax", "my", "big", "quiz"};
        // Note: pangramWords is a pointer.

        // Count total length of all words.
        int totalChars = 0;
        for (int i=0; i < pangramWords.length; i++) {
            // Here we are using String's length() method.
            totalChars += pangramWords[i].length();
        }
        System.out.println ("Total #letters in pangram: " + totalChars);
    }

}

public class StringExample2 {

    public static void main (String[] argv)
    {
        // Get the list of words.
        String[] words = WordTool.getDictionary ();

        int num = 0;
        for (int i=0; i < words.length; i++) {
            // Extract first and last char's and check equality.
            char firstChar = words[i].charAt (0);
            char lastChar = words[i].charAt (words[i].length()-1);
            if (firstChar == lastChar) {
                num ++;
            }
        }
        System.out.println ("Number of words with same first and last char: " + num);
    }

}

import java.util.*;

public class RandomArray {

    public static void main (String[] argv)
    {
        // Generate 10 random integers, each between 1 and 100
        int[] randomInts = new int [10];
        for (int i=0; i < randomInts.length; i++) {
            randomInts[i] = UniformRandom.uniform (1, 100);
        }
    
        // Print.
        System.out.println ( "Array elements: " + Arrays.toString(randomInts) );

        // Generate 10 random doubles between 1 and 100
        double[] randomReals = new double [10];
        for (int i=0; i < randomReals.length; i++) {
            randomReals[i] = UniformRandom.uniform (1.0, 100.0);
        }
        
        // Print.
        System.out.println ( "Array elements: " + Arrays.toString(randomReals) );
    }

}

public class RandomArray2 {

    public static void main (String[] argv)
    {
        double p = estimateSortedProb (5, 100000);
        System.out.println ("Probability an array of length 5 is sorted: " + p);
    }
    

    static double estimateSortedProb (int arraySize, int numTrials) 
    {
        // Count the number of sorted arrays generated.
        int numSorted = 0;

        // Repeat for given number of experiments.
        for (int n=0; n < numTrials; n++) {

            // Generate a random array.
            int[] randomInts = new int [arraySize];
            for (int i=0; i < randomInts.length; i++) {
                randomInts[i] = UniformRandom.uniform (1, 100);
            }
            
            // See if sorted.
            boolean isSorted = true;
            for (int i=1; i < randomInts.length; i++) {
                if (randomInts[i] < randomInts[i-1]) {
                    isSorted = false;
                }
            }
            if (isSorted) {
                numSorted ++;
            }

        } //end-for-numTrials
        
        // The fraction of trials that resulted in a sorted array:
        double prob = (double) numSorted / (double) numTrials;

        return prob;
    }

}

   int numSuccessfulTrials = 0;
   for (int n=0; n < numTrials; n++) {
       doTrial ();
       if (trialSuccessful) {
           numSuccessfulTrials ++;
       }
   }
   double probSuccess = (double) numSuccessfulTrials / (double) numTrials;

public class Birthday {

    public static void main (String[] argv)
    {
        double p = birthdayProblem (10);
        System.out.println ("Prob[shared birthday with 10 people] = " + p);
    }


    static double birthdayProblem (int numPeople)
    {
        // Number of times to repeatedly create a random group of people:
        int numTrials = 10000;

        // We'll need to count how often we get a shared b'day.
        int numTrialSuccesses = 0;

        // Repeat and count.
        for (int n=0; n < numTrials; n++) {

            // Generate birthdays (random array)
            int[] birthdays = new int [numPeople];
            for (int i=0; i < birthdays.length; i++) {
                birthdays[i] = UniformRandom.uniform (1, 365);
            }

            // Check if any two match.
            boolean matchExists = false;
            for (int i=0; i < birthdays.length; i++) {
                for (int j=0; j < birthdays.length; j++) {
                    if ( (i != j) && (birthdays[i] == birthdays[j]) ) {
                        // Note: musn't forget the i!=j test above!
                        matchExists = true;
                    }
                }
            }
            
            if (matchExists) {
                numTrialSuccesses ++;
            }
            
        } //end-for-trials
        
        double prob = (double) numTrialSuccesses / (double) numTrials;
        return prob;
    }
    
}