# Array Review

# Subscripts, Declaration, Allocation

- Array subscripts start at 0.
- Array subscription checks bounds. May throw `ArrayIndexOutOfBoundsException`.
- Array declaration doesn't create an array.

      int[] a;          // Declares an array reference.
      a = new int[200]; // Allocates an array.

- Arrays are allocated on the heap, not on the stack.
- Copying an array reference doesn't copy the array.

         int[] a = int[100];
         int[] b;

- The declared size of an array is accessed with the `length` field.

         for (int i=0; i<a.length; i++) { ...

# Array Initialization

- Array elements are initialized to 0 / null / false by default.
- Arrays may be allocated and initialized on declaration.

        int a[] = {31, 28, 31, 30, 31};

# Array Algorithms

- The `java.util.Arrays` class has many algorithms for working with arrays.
  - `equals(...)`
  - `fill(...)`
  - `sort(...)`
  - `binarySearch(...)`
  - `asList(...)`
  - Do not confuse this with the `java.lang.reflect.Array` class or `java.sql.Array` interface.
- `System.arrayCopy(...)` is another useful utility.
- More algorithms are available for the Collections data structures, but not arrays directly (see `asList` to convert

# Multidimensional Arrays

- This discussion is about two-dimensional arrays, but there's no limit on the number of dimensions.
- There are two kinds of two-dimensional array implementations
  - Compiler maps two subscripts into one linear space. (C, C++)
  - Array of arrays (C, C++, Java).
- The Array-of-array approach allows ragged arrays.
- Initilization is supported with nested braces.
- Example

      int[][] a2 = { {1,2,4}, {5,5,7,8}, {9}};
      . . .
      for (int row=0; row<a2.length; row++) {
          for (int col=0; col<a2[row].length; col++) {
             if (a2[row][col] == specialValue) { . . .

# Beyond Arrays

- Arrays are very good for fixed-length data.
- They are bad for variable length data, leading to buffer overflow vulnerabilities in C and C++, or ArrayIndexOutOfBoundsException in Java.
- Insertions and deletions may give poor O() performance. LinkedList might be a good choice in this case.
- A better choice is often one of the Collections data structures: eg, ArrayList (or the older Vector), etc.

# End