Arrays

Apr 30, 2008

A problem with simple variables

One variable holds one value

The value may change over time, but at any given time, a variable holds a single value

If you want to keep track of many values, you need many variables All of these variables need to have names What if you need to keep track of hundreds or thousands of values?

Multiple values

An array lets you associate one name with a fixed (but possibly large) number of values All values must have the same type The values are distinguished by a numerical index between 0 and array size minus 1

myArray 12 43

83 14 -57 109 12

Indexing into arrays

To reference a single array element, use array-name [ index ] Indexed elements can be used just like simple variables

You can access their values You can modify their values

An array index is sometimes called a subscript

0 1 2 3 4 5 6 7 8 9

myArray 12 43 myArray[0]

83 14 -57 109 12
myArray[5]

myArray[9]
4

Using array elements

0 1 2 3 4 5 6 7 8 9

myArray 12 43

83 14 -57 109 12

Examples:

x = myArray[1]; myArray[4] = 99; m = 5; y = myArray[m]; z = myArray[myArray[9]];

// sets x to 43 // replaces 14 with 99 // sets y to -57 // sets z to 109

Array values

An array may hold any type of value All values in an array must be the same type

For example, you can have: an array of integers an array of Strings an array of Person an array of arrays of String an array of Object

In this case, all the elements are Objects; but they may belong to different subclasses of Object You probably want to cast the value to something more specific after you get it from the array
6

Strings and arrays

Strings and arrays both have special syntax Strings are objects, and can be used as objects Arrays are objects, but

Arrays are created using special syntax: new type[size] instead of new Person() If an array holds elements of type T, then the arrays type is array of T

Declaration versus definition

Arrays are objects Creating arrays is like creating other objects:

the declaration provides type information and allocates space for a reference to the array (when it is created) the new definition actually allocates space for the array declaration and definition may be separate or combined Person p; p = new Person("John"); Person p = new Person("John"); // declaration // definition // combined

Example for ordinary objects:

Declaring and defining arrays

Example for array objects:

int[ ] myArray; // declaration This declares myArray to be an array of integers It does not create an arrayit only provides a place to put an array Notice that the size is not part of the type myArray = new int[10]; // definition new int[10] creates the array The rest is an ordinary assignment statement int[ ] myArray = new int[10]; // both
9

Two ways to declare arrays

You can declare more than one variable in the same declaration:
int a[ ], b, c[ ], d; // notice position of brackets

a and c are int arrays b and d are just ints

Another syntax:
int [ ] a, b, c, d;

// notice position of brackets

a, b, c and d are int arrays

When the brackets come before the first variable, they apply to all variables in the list In Java, we typically declare each variable separately
10

But...

Array assignment

Array assignment is object assignment Object assignment does not copy values
Person p1; Person p2; p1 = new Person("John"); p2 = p1; // p1 and p2 refer to the same person

Array assignment does not copy values

int[ ] a1; int[ ] a2; a1 = new int[10]; a2 = a1; // a1 and a2 refer to the same array
11

An arrays size is not part of its type

When you declare an array, you declare its type; you must not specify its size

Example: String names[ ];

When you define the array, you allocate space; you must specify its size

Example: names = new String[50]; Example: String names[ ] = new String[50];

This is true even when the two are combined

12

Array assignment

When you assign an array value to an array variable, the types must be compatible The following is not legal:
double[ ] dub = new int[10]; // illegal

The following is legal:

int[ ] myArray = new int[10]; ...and later in the program, myArray = new int[500]; // legal! Legal because array size is not part of its type

13

Example of array use I

Suppose you want to find the largest value in an array scores of 10 integers:
int largestScore = 0; for (int i = 0; i < 10; i++) if (scores[i] > largestScore) largestScore = scores[i];

By the way, do you see an error in the above program?

What if all values in the array are negative?

14

Example of array use II

To find the largest value in an array scores of 10 (possibly negative) integers:

int largestScore = scores[0]; for (int i = 1; i < 10; i++) if (scores[i] > largestScore) largestScore = scores[i];

15

Example of array use III

Suppose you want to find the largest value in an array scores and the location in which you found it:
int largestScore = scores[0]; int index = 0; for (int i = 1; i < 10; i++) { if (scores[i] > largestScore) { largestScore = scores[i]; index = i; } }

16

Array names I

The rules for variables apply to arrays

Use lowercase for the first word and capitalize only the first letter of each subsequent word that appears in a variable name Use nouns to name variables Pluralize the names of collection references

17

Array names II

Heres what the naming rules mean:

Array variables should be capitalized just like any other variable Array names should be plural nouns scores phoneNumbers preferredCustomers

Example array names:

18

Length of an array

Arrays are objects Every array has an instance constant, length, that tells how large the array is Example:
for (int i = 0; i < scores.length; i++) System.out.println(scores[i]);

Use of length is always preferred over using a constant such as 10 Strings have a length() method!

19

Magic numbers

Use names instead of numbers in your code

Names help document the code; numbers dont It may be hard to tell why a particular number is used--we call it a magic number

This is a pejorative term

You might change your name about the value of a constant (say, more than ten scores)

You can change the value of a name in one place

An arrays length is always correct!

20

NullPointerException

Suppose you declare a Person p but you dont define it

Until you define p, it has the special value null null is a legal value for any kind of object null can be assigned, tested, and printed But if you try to use a field or method of null, such as p.name or p.birthday(), the error you get is a nullPointerException

21

Arrays of objects

Suppose you declare and define an array of objects:

Person[ ] people = new Person[20]; it has 20 references to Persons in it all of these references are initially null you have not yet defined 20 Persons For example, people[12].name will give you a nullPointerException

There is nothing wrong with this array, but

22

Initializing arrays I

Heres one way to initialize an array of objects

Person[ ] people = new Person[20]; for (int i = 0; i < people.length; i++) { people[i] = new Person("Dave"); }

This approach has a slight drawback: all the array elements have similar values

23

Initializing arrays II

There is a special syntax for giving initial values to the elements of arrays

This syntax can be used in place of new type[size] It can only be used in an array declaration The syntax is: { value, value, ..., value }

Examples:
int[ ] primes = {2, 3, 5, 7, 11, 13, 19}; String[ ] languages = { "Java", "C", "C++" };

24

Array literals

You can create an array literal with the following syntax:

type[ ] { value1, value2, ..., valueN }

Examples:
myPrintArray(new int[] {2, 3, 5, 7, 11});

int[ ] foo; foo = new int[]{42, 83};

25

Initializing arrays III

To initialize an array of Person:

Person[ ] people = { new Person("Alice"), new Person("Bob"), new Person("Carla"), new Person("Don") };

Notice that you do not say the size of the array

The computer is better at counting than you are!

26

Arrays of arrays

The elements of an array can be arrays Once again, there is a special syntax Declaration: int[ ][ ] table; (or int table[ ][ ];) Definition: table = new int[10][15]; Combined: int[ ][ ] table = new int[10][15]; The first index (10) is usually called the row index; the second index (15) is the column index An array like this is called a two-dimensional array

27

Example array of arrays

int[ ][ ] table = new int[3][2]; or, int[ ][ ] table = { {1, 2}, {3, 6}, {7, 8} };
0 0 1 1

2 1 3 6 2 7 8

For example, table[1][1] contains 6 table[2][1] contains 8, and table[1][2] is array out of bounds To zero out this table:
for (int i = 0; i < 3; i++) for (int j = 0; j < 2; j++) table[i][j] = 0;

How could this code be improved?

28

Size of 2D arrays

0 0 1

2 1 3 6 2 7 8

int[ ][ ] table = new int[3][2]; The length of this array is the number of rows: table.length is 3 Each row contains an array To get the number of columns, pick a row and ask for its length: table[0].length is 2 But remember, rows may not all be the same length

29

Arrays of Object

Arrays are useful for holding many values of the same type If the array type is Object, then it is convenient to cast the value to the correct type after you get it from the array If the type is Object, then the array can hold anything except primitives If you want to put primitives into an array of objects, you need to wrap them in objects There are wrapper classes defined for each of the primitive objects Example:

Integer wrappedInt = new Integer(5); int number = wrappedInt.intValue();

30

Wrappers

Constructors:

Extraction methods:

Boolean(value) Byte(value) Character(value) (not Char) Double(value) Float(value) Integer(value) (not Int) Long(value) Short(value)

booleanValue() byteValue() charValue() doubleValue() floatValue() intValue() longValue() shortValue()

31

The End

32