4.4 Arrays and array processing

There are many ways to store data. So far, we have covered linear recursive structures, lists, and binary recursive structures, trees. Let's consider another way of storing data, as a contiguous, numbered (indexed) set of data storage elements:

anArray =

This " array " of elements allows us to access any individual element using a numbered index value.

array

At its most basic form, a random access data structure where any element can be accessed by specifying a single index value corresponding to that element.

Arrays in java

• Arrays...
  • are contiguous (in memory) sets of object references (or values, for primitives),
  • are objects,
  • are dynamically created (via new ), and
  • may be assigned to variables of type Object or primitives
• An array object contains zero or more unnamed variables of the same type. These variables are commonly called the elements of the array.
• A non-negative integer is used to name each element. For example, arrayOfInts[i] refers to the i+1 st element in the arrayOfInts array. In computer-ese, an array is said to be a "random access" container, because you can directly (and I suppose, randomly) access any element in the array.
• An array has a limited amount of intelligence, for instance, it does know its maximum length at all times, e.g. arrayOfInts.length .
• Arrays have the advantage that they
  • provide random access to any element
  • are fast.
  • require minimum amounts of memory

More information on arrays can be found in the Java Resources web site page on arrays

Array types

• An array type is written as the name of an element type followed by one or more empty pairs of square brackets.
  • For example, int[] is the type corresponding to a one-dimensional array of integers.
• An array's length is not part of its type.
• The element type of an array may be any type, whether primitive or reference, including interface types and abstract class types.

Array variables

• Array variables are declared like other variables: a declaration consists of the array's type followed by the array's name. For example, double[][]matrixOfDoubles; declares a variable whose type is a two-dimensional array of double-precision floating-point numbers.
• Declaring a variable of array type does not create an array object. It only creates the variable, which can contain a reference to an array.
• Because an array's length is not part of its type, a single variable of array type may contain references to arrays of different lengths.
• To complicate declarations, C/C++-like syntax is also supported, for example, double rowvector[], colvector[], matrix[][]; This declaration is equivalent to double[] rowvector, colvector, matrix[]; or double[] rowvector, colvector;double[][]matrix; Please use the latter!

Array creation

• Array objects, like other objects, are created with new . For example, String[] arrayOfStrings = new String[10]; declares a variable whose type is an array of strings, and initializes it to hold a reference to an array object with room for ten references to strings.
• Another way to initialize array variables is int[] arrayOf1To5 = { 1, 2, 3, 4, 5 };String[] arrayOfStrings = { "array","of", "String" };Widget[] arrayOfWidgets = { new Widget(), new Widget() };
• Once an array object is created, it never changes length! int[][]arrayOfArrayOfInt = {{ 1, 2 }, { 3, 4 }};
• The array's length is available as a final instance variable length. For example, int[] arrayOf1To5 = { 1, 2, 3, 4, 5 };System.out.println(arrayOf1To5.length); would print ``5''.