1. Chapter VII: Arrays

2. Chapter overview This chapter focuses on Array declaration and use
Bounds checking and capacity
Arrays storing object references
Variable length parameter lists
Multidimensional arrays
The ArrayList class

3. Chapter overview This chapter focuses on Array declaration and use
Bounds checking and capacity
Arrays storing object references
Variable length parameter lists
Multidimensional arrays
The ArrayList class

4. Arrays: definition Array
is a powerful construct used to group and organize data
manages a large amount of information
such as a list of 100 names
it is not logical to declare separate variables in this case
declares one variable
Holding multiple, individually accessible values

5. Each value has a numeric index
Arrays
An array is an ordered list of values
height
The entire array
has a single name
Each value has a numeric index
Array indices always begin at zero
An array of size N is indexed from zero to N-1
This array holds 10 values that are indexed from 0 to 9

6. Accessing array elements
A particular value in an array
is referenced using the array name
followed by the index in brackets
Example: height[2] refers to the value 94
height[2] referred to as array element
represents a single integer stored at a memory location
Can be used wherever an integer variable can be used

7. Manipulating array elements
An array element
Can be assigned a value, printed, or used in calculation
height[2] = 89;
height[first] = height[first] + 2;
mean = (height[0] + height[1])/2;
System.out.println ("Top = " + height[5]);

8. Array elements Values stored in an array are called array elements
An array stores multiple values of the same type
Called the element type
The element type can be
Primitive type or
Object reference
Therefore, we can create
An array of integers, characters, or String objects

9. Declaring arrays In Java, the array is an object
height
In Java, the array is an object
It must be declared and instantiated as follows
int[] height = new int[10];
The type of variable height is an array of integers (int [ ])
And reference variable height is set to a new array object
that holds 10 integers
Refer to BasicArray.java

10. int[] scores = new int[10];
Declaring Arrays
The scores array could be declared as follows:
int[] scores = new int[10];
The type of the variable scores
is int[] (an array of integers)
Note that the array type
does not specify its size,
but each object of that type has a specific size
The reference variable scores
is set to a new array object that can hold 10 integers

11. Declaring Arrays Some other examples of array declarations:
float[] prices = new float[500];
boolean[] flags;
flags = new boolean[20];
char[] codes = new char[1750];

12. Using Arrays The iterator version of the for
loop can be used when processing array elements
for (int score : scores)
System.out.println (score);
This is only appropriate when
processing all array elements
from top (lowest index) to bottom (highest index)

13. Chapter overview This chapter focuses on Array declaration and use
Bounds checking and capacity
Arrays storing object references
Variable length parameter lists
Multidimensional arrays
The ArrayList class

14. Bounds checking Once an array is created, it has a fixed size N
int[ ] height = new int[10];
=> size of height = 10
An index used must specify a valid element
That is, index value must be in the range of 0 to N-1
The valid indexes for height are from 0 to 9
In other words, height[10], height[11], … are not allowed

15. Automatic bounds checking
Whenever you reference an element in the array
=> the value of index used is checked
Example: height[index] => index is checked
if 0<= index <= 9 => valid
if index > 9 => index not valid (out of bound)
If an array index is out of bound
An out-of -bound exception is issued by the execution
This is called automatic bounds checking
Refer to Invalidindex.java

16. Off-by-one errors For example, System.out.println (codes[count]);
if the array codes can hold 100 values
it can be indexed using only the numbers 0 to 99
If the value of count is 100,
then the following reference will cause an exception to be thrown:
System.out.println (codes[count]);
It’s common to introduce off-by-one errors
when using arrays
problem
for (int index=0; index <= 100; index++)
codes[index] = index*50 + epsilon;

17. Length constant One way to check for the bounds of an array
use the length constant
Each array has a public constant called length
That stores the size of the array
It is referenced using the array name
The array Prices created with 25 elements
Prices.length contains the value 25
maximum index of Prices is Prices.length - 1

18. The length constant Note Refer to ReverseOrder.java That length
holds the number elements
NOT the largest index
Useful in situations where you don’t know the size of the array
Refer to ReverseOrder.java
Read a list of numbers from the user
Store them in an array
Then print them in the opposite order

19. Alternate array syntax
When declaring an array, the brackets can either
be associated with the type of values stored in the array
float[] prices;
or with the name of array
float prices[];
These 2 declarations are equivalent
However, the first format
Associating brackets with the type
is more readable and should be used

20. Initializer lists Initializer lists are used to instantiate an array
And provide initial values for the elements of the array
=> The idea is to instantiate and fill the array in one step
Values delimited by braces and separated by commas
When used, the new operator will no more be needed
Size of array determined by the number of items in initializer

21. Initializer lists: Examples
int[] units = {147, 323, 89, 933, 540,
269, 97, 114, 298, 476};
char[] letterGrades = {'A', 'B', 'C', 'D', ’F'};
Note that when an initializer list is used
The new operator is not used
no size value is specified
As size is determined by the number of items in the list
See Primes.java

22. Chapter overview This chapter focuses on Array declaration and use
Bounds checking and capacity
Arrays storing object references
Variable length parameter lists
Multidimensional arrays
The ArrayList class

23. Arrays of objects The elements of an array can be object references
The following declaration
reserves space to store 5 references to String objects
String[] words = new String[5];
Initially, an array of objects holds null references
Each object stored in an array
must be instantiated separately

24. Initial array of object declaration
The words array when initially declared
String[] words = new String[5];
words -

25. After a few object creation
After some String objects
are created
and stored in the array
“friendship”
words -
“loyalty”
“honor”

26. String literals Keep in mind The following declaration
String objects can be created using string literals
The following declaration
Creates an array object called verbs
and fills it with four String objects
Created using string literals
String[] verbs = {"play", "work", "eat", "sleep"};

27. Array of objects: application
The following example
Creates an array of Grade objects
Each with
a string representation and
a numeric lower bound
Refer to GradeRange.java, and Grade.java

28. Command line arguments
The signature of the main method
it takes an array of String objects as a parameter
Ignored so far, let us discuss how it might be useful
The String[] parameter called args
represents command line arguments
provided when the interpreter is invoked
Extra information on CLI is stored in the args

29. Command line arguments (cont’d)
For example
The following invocation of the interpreter
passes 3 String objects into main
java StateEval pennsylvania texas arizona
These strings are stored
At indexes 0-2 of the array parameter of the main method
See CLI_reading.java and NameTag.java

30. Arrays as parameters An entire array An individual array element
Can be passed as a parameter to a method
In which case
The method may permanently change an element of the array
An individual array element
Can be passed to a method as well
The type of the parameter is the same as element type

31. Example Design and implement a method
That accepts an array of integer values
and then calculates the numerical average
of the group of numbers that are stored in the array

32. Example: solution public double average (int[] list) {
double result = 0.0;
if (list.length != 0)
int sum = 0;
for (int num : list)
sum += num;
result = (double)num / list.length; }
return result;

33. Method Overloading Method overloading is the process
of giving a single method name multiple definitions
If a method is overloaded,
the method name is not sufficient to determine
which method is being called
The signature of each overloaded method must be unique
The signature includes
the number, type, and order of the parameters

34. Method Overloading
The compiler determines which method is being invoked by analyzing the parameters
float tryMe(int x) {
return x ; }
result = tryMe(25, 4.32)
Invocation
float tryMe(int x, float y) {
return x*y; }

35. Method Overloading The println method is overloaded: and so on...
println (String s)
println (int i)
println (double d)
and so on...
The following lines invoke different versions of the println method:
System.out.println ("The total is:");
System.out.println (total);

36. Variable length parameter lists
Suppose
We want to create a method
That processes a different amount of data
From one invocation to the next
For example, let us design a method called average
That returns the average of a set of integer parameters
// one call to average three values
mean1 = average (42, 69, 37);
// another call to average seven values
mean2 = average (35, 43, 93, 23, 40, 21, 75);

37. Possible solutions define overloaded versions of the average method
Downside:
This requires that we know the max number of parameters
And create a separate version of the method
for each parameter count
define the method to accept an array of integers
Downside
Need to create the array and store integers prior to method call
Instead, Java provides a more convenient way
to create variable length parameter lists

38. Syntax of variable length parameter list
Using a special syntax
You can define a method
To accept any number of parameter of the same type
For each method call
The parameters are automatically
Put into an array for easy processing in the method
Indicates a variable length parameter list
public double average (int ... list) {
// whatever }
element
type
array
name

39. Variable length parameter list average method
public double average (int ... list) {
double result = 0.0;
if (list.length != 0)
int sum = 0;
for (int num : list)
sum += num;
result = (double)num / list.length; }
return result;

40. Type of the multiple parameters
The type of the parameters
can be any primitive or object type
public void printGrades (Grade ... grades) {
for (Grade letterGrade : grades)
System.out.println (letterGrade); }

41. methods accepting a variable number of parameters
A method
that accepts a variable number of parameters
Can also accept other parameters
The following method
Accepts an
int, a String object, and a variable number of double
public void test (int count, String name,
double ... nums) {
// whatever }

42. Variable length parameter lists: example
The varying number of parameters
must come last in the formal arguments
A single method cannot accept
Two sets of varying parameters
Constructors
Can also be setup
to accept a variable number of parameters
Refer to VariableParameters.java & Family.java