CSCI 161 - Lecture 12 - Reference Semantics, Advanced Array Techniques, Multidimensional Arrays

Instructor's Class Notes

1. Reference Semantics
• Value Semantics (Value Types) - A system in which values are stored directly and copying is achieved by creating independent copies of values. Types that use value semantics are called value types.
• Primitive data types, like int, double are stored as value types.
  
  Question: What does int x look like in memory?
• Reference Semantics (Reference Types) - A system in which references to values are stored and copying is achieved by copying these references. Types that use reference semanticsare are called reference types.
• Objects, such as those variables declared from classes (String, Scanner, File, ...) and arrays are stored as reference types.
  
  Question: What does int list[5] look like in memory?
• Why Reference Types? - Objects can be complex and they can hold a lot of data. For this reason, the ability to pass them around and sharing them in your program as a reference increases efficiency (uses less memory, and less resources such as heap and the stack, etc.).
• Then Why Primitive (aka Value) Types? - Again, for efficiency. For certain types of data (integers, booleans, etc. that are small and without complexity the overhead of references just adds bloat and decreases efficiency.
• Multiple Objects - Consider the following:

                  
  int[] list1 = new int[5];
  int[] list2 = new int[5];
  for (int i = 0; i < list1.length; i++) {
      list1[i] = 2 * i + 1;
      list2[i] = 2 * i + 1;
  }
  int[] list3 = list2;
                  
                  

  Question: What do list1, list2 and list3 look like in memory?
• Critical Point: - When you pass an array to a method it is passed by reference and you are able to change the contents of the array.
• .equals() method - Just like the same named method of the String object this method can tell whether two array objects are the same (two different objects, but each object is an array with the same number of elements and each respective element identical.)
• null - Java keyword signifying no object. Arrays of objects (like String[] are auto-initialized to null when the array is declared with no initial values.
2. Advanced Array Techniques
• Shifting Values in an Array - A complex subject, but boils down to rotateLeft() and rotateRight methods.
• rotateLeft - method for integer arrays:

                  
  public static void rotateLeft(int[] list) {
      int first = list[0];
      for (int i = 0; i < list.length -1; i++) {
          list[i] = list[ i + 1];
      }
      list[list.length - 1] = first;
  }                
                  
                  

• rotateRight - method for integer arrays

                  
   public static void rotateRight(int[] list) {
      int last = list[list.length - 1];
      for (int i = list.length-1; i >= 1; i--) {
          list[i] = list[ i - 1];
      }
      list[0] = last;
  }
                  
                  

• Arrays of Objects - Already dealt with this as arrays of Strings
• As we learn other objects, in particular our own objects it will be important to remember that declaring and filling arrays of objects is often a two step process.
1. Declare the array given its size.
2. Loop through the array creating and assigning new objects of the type of interest.
3. Multidimensional Arrays
• Multidimensional Array - An array of arrays, the elements of which are accessed with multiple integer indexes (one per dimension).
• All dimensions must be arrays of the same data type.
• All dimensions have arrays that are zero-based.
• Easy to think of in two dimensions (think of a sheet with rows and columns), especially Rectangular Two-Dimensional Arrays.
  

                  
  double[][] temps = new double[3][4];   // 3 rows by 4 columns                
                  
                  

• Harder to visualize in three or more dimensions, but a bit easier if you think of multiple sheets, with each sheet a different "plane", with general recommendation to think of first dimension as the plane #, followed by row, followed by column.
  

                  
  int[][][] numbers = new int[numPlanes][numRows][numColumns];
                  
                  

• Jagged Arrays - Arrays need not be rectangular, they can be jagged as so:
  

                  
  int[][] jagged = new int[3][];
  jagged[0] = new int[2];
  jagged[1] = new int[4];
  jagged[2] = new int[3];