1. Grouping Related Items
We often need to group together related items of data.
Cards in a pack.
Ships in a port.
Java provides two distinct facilities:
Fixed-size arrays.
Flexible-size collection classes (java.util).
OOP with Java, David J. Barnes
Arrays and Further Control Structures

2. Problems That Arrays Solve
class YearlyRainfall {
public int meanMonthlyRainfall(){
return (getJan()+getFeb()+getMar()+getApr()+
getMay()+getJun()+getJul()+getAug()+
getSep()+getOct()+getNov()+getDec()) /
numMonths; }
public int getJan(){
return Jan;
...
private static final int numMonths = 12;
private int Jan, Feb, Mar, Apr, May, Jun,
Jul, Aug, Sep, Oct, Nov, Dec;
OOP with Java, David J. Barnes
Arrays and Further Control Structures

3. Arrays for Primitive-Types
class YearlyRainfall {
...
// Fixed size of the rainfall array.
private static final int numMonths = 12;
// Declare an attribute to hold the monthly
// rainfall figures.
private int[] rainfall = new int [numMonths]; }
Square bracket notation is distinctive of arrays:
Type: int[]
Construction: new int[...]
OOP with Java, David J. Barnes
Arrays and Further Control Structures

4. Initial value for Primitive-Types
Each individual array element is initialized with the default value of the base type:
int, long, short, char 0
double, float
Boolean false
OOP with Java, Eric Jul
Arrays and Further Control Structures

5. Arrays and Further Control Structures
Arrays for Objects
class CardGame {
...
// There are four distinct suits in this game.
final int numSuits = 4;
// An array for the names of the distinct suits.
private String[] suitNames = new String[numSuits]; }
NB: No String objects are created. Only a container for Strings.
Each location is initialized to null (!).
OOP with Java, David J. Barnes
Arrays and Further Control Structures

6. Arrays and Further Control Structures
Array Lengths
The length of an array is fixed on construction.
Each array object has a public final length attribute.
The individual elements of an array are always indexed from zero to (length-1).
Individual elements initialized to default value of base type (e.g., 0, false, null, etc.)
OOP with Java, David J. Barnes
Arrays and Further Control Structures

7. Arrays and Further Control Structures
Indexing an Array
// Store the rainfall figure for January.
rainfall[0] = 30;
...
// Compare the December and November figures.
if(rainfall[11] > rainfall[10]){
System.out.println(
"December was wetter than November."); }
// Correct an error of 1 millimeter in March's
// rainfall total.
rainfall[2]++;
OOP with Java, David J. Barnes
Arrays and Further Control Structures

8. Accessors for Array Attributes
class YearlyRainfall {
...
// Return a reference to the array.
public int[] getRainfall(){
// Independent copy not returned!
return rainfall; }
// Fixed size of the rainfall array.
private static final int numMonths = 12;
// Declare an attribute to hold the monthly
// rainfall figures.
private int[] rainfall = new int [numMonths];
OOP with Java, David J. Barnes
Arrays and Further Control Structures

9. Mutators for Array Attributes
class Polyline {
public Polyline(Point[] p){
setPoints(p); }
...
public void setPoints(Point[] p){
if(p != null){
// Independent copy not taken!
points = p;
private Point[] points = null;
OOP with Java, David J. Barnes
Arrays and Further Control Structures

10. Arrays and Further Control Structures
Initializing Arrays
class AssignmentMonitor {
...
// Differentially weight the assignments.
private int[] assignmentWeights = {
1, 2, 1, 5, 1, };
private final int numAssignments =
assignmentWeights.length; }
No new required.
Terminating semicolon.
Optional final comma.
OOP with Java, David J. Barnes
Arrays and Further Control Structures

11. Further Initializer Examples
String[] suitNames = {
"Spades", "Hearts", "Diamonds", "Clubs" };
Point[] vertices = {
new Point(0,0),
new Point(0,1),
new Point(1,1),
new Point(1,0),
YearlyRainfall y2k = new YearlyRainfall(
new int[]{10,10,8,8,6,4,4,0,4,4,7,10,});
OOP with Java, David J. Barnes
Arrays and Further Control Structures

12. Using For Loops with Arrays
public int totalRainFall(){
// Obtain the data values.
final int[] monthlyValues = getRainfall();
int totalRain = 0;
final int numMonths = monthlyValues.length;
for(int month = 0; month < numMonths; month++){
totalRain += monthlyValues[month]; }
return totalRain;
OOP with Java, David J. Barnes
Arrays and Further Control Structures

13. Iterating over an Array in Reverse
public void printInReverse(){
final double[] numbers = getMarks();
for(int index = numbers.length-1; index >= 0;
index--){
System.out.print(numbers[index]+" "); }
System.out.println();
OOP with Java, David J. Barnes
Arrays and Further Control Structures

14. Arrays and Further Control Structures
Initializer Blocks
private final int numSeats = 150;
// The status of seats in a theater.
// true means the seat is free, false means occupied.
private boolean[] seatStatus = new boolean[numSeats]; {
// All seats are free to start with.
for(int i = 0; i < numSeats; i++){
seatStatus[i] = true; }
Static initializers are available to initialize static fields.
OOP with Java, David J. Barnes
Arrays and Further Control Structures

15. The Main Method Array Argument
Used to access command line argument values:
java PrintArguments x y z
The strings "x", "y" and "z" are placed in the main method's args argument.
If there are no arguments, the length of args is zero.
OOP with Java, David J. Barnes
Arrays and Further Control Structures

16. Using Command Line Arguments
class LookupWords {
public static void main(String[] args) {
GlossaryManager glossary =
new GlossaryManager();
for(int n = 0; n < args.length; n++){
System.out.println("Looking up "+args[n]);
System.out.println(
glossary.definition(args[n])); }
OOP with Java, David J. Barnes
Arrays and Further Control Structures

17. Arrays and Further Control Structures
Copying Arrays
// Make a copy of the Point data.
public void setPoints(Point[] p){
if(p != null){
final int numPoints = p.length;
points = new Point[numPoints];
// Copy from p to points.
System.arraycopy(p,0,points,0,numPoints); }
OOP with Java, David J. Barnes
Arrays and Further Control Structures

18. Searching an Unsorted Array
We often need to search an array for a particular item of data.
The data is often unsorted.
The item might or might not be present.
Care must be taken not to search beyond the end of the array.
We need to decide how to return a found item.
OOP with Java, David J. Barnes
Arrays and Further Control Structures

19. Search with Multiple Returns
public int indexOf(int[] numbers,int value){
final int notPresent = -1;
for(int index = 0; index < numbers.length;
index++){
if(numbers[index] == value){
return index; }
// We did not find it.
return notPresent;
OOP with Java, David J. Barnes
Arrays and Further Control Structures

20. Search with a Single Return
public int indexOf(int[] numbers,int value){
final int notPresent = -1;
int index = 0;
boolean found = false;
while((index < numbers.length) && !found){
if(numbers[index] == value){
found = true; }
else{
index++;
return found ? index : notPresent;
OOP with Java, David J. Barnes
Arrays and Further Control Structures

21. Arrays and Further Control Structures
The Arrays Class
Defined in the java.util package.
Contains static methods for manipulating arrays:
binarySearch: search for a value.
equals: compare the contents of two arrays.
fill: fill an array with a particular value.
sort: sort the contents of an array.
OOP with Java, David J. Barnes
Arrays and Further Control Structures

22. Multi-Dimensional Arrays
Arrays of multiple dimensions are possible.
2D grid, for a board game such as chess.
3D cube structure, etc.
Multi-dimensional arrays are regarded as being arrays of arrays.
Non-rectangular structures are possible.
OOP with Java, David J. Barnes
Arrays and Further Control Structures

23. Arrays and Further Control Structures
2D Array Construction
final int numRows = 10, numCols = 5;
double[][] matrix = new double[numRows][numCols];
double[][] grid = new double[numRows][];
for(int row = 0; row < grid.length; row++){
grid[row] = new double[numCols]; }
char[][] hiddenWord = {
{ 'd', 'g', 'i', 'b' },
{ 'e', 'i', 'u', 'm' },
{ 't', 'a', 's', 'a' }, };
OOP with Java, David J. Barnes
Arrays and Further Control Structures

24. Non-Rectangular Arrays
final int numRows = 5;
int[][] triangle = new int[numRows][];
for(int row = 0; row < numRows; row++){
triangle[row] = new int[row+1]; }
int[][] pascalsTriangle = {
{1},
{1,1},
{1,2,1},
{1,3,3,1}, };
OOP with Java, David J. Barnes
Arrays and Further Control Structures

25. Further Control Statements
Java defines several further statements that affect a program's flow of control.
The Switch Statement
The Break Statement
The Continue Statement
Statements may also be labelled.
We rarely use this feature.
OOP with Java, David J. Barnes
Arrays and Further Control Structures

26. Arrays and Further Control Structures
The Switch Statement
An integer expression is used to select a case label.
Case labels are integer constant expressions.
A default label provides a no-match option.
Labels mark statements to be executed on selection.
A break statement is used to end a case.
OOP with Java, David J. Barnes
Arrays and Further Control Structures

27. The Switch Statement (cont.)
public void menuAction(char choice){
switch(choice){
case 'd':
delete();
break;
case 'i':
insert();
case 'h':
help();
default:
System.out.println("Unknown command: "+choice); }
OOP with Java, David J. Barnes
Arrays and Further Control Structures

28. Arrays and Further Control Structures
The Break Statement
public int indexOf(int[] numbers,int value){
final int notPresent = -1;
int index;
boolean found = false;
for(index = 0; index < numbers.length; index++){
if(numbers[index] == value){
found = true;
// Leave now - before index is incremented.
break; }
return found ? index : notPresent;
OOP with Java, David J. Barnes
Arrays and Further Control Structures

29. The Continue Statement
public void skipPrinting(int x, int y, int z){
for(int num = 1; num <= 100; num++){
if((num % x) == 0){
continue; }
if((num % y) == 0){
if((num % z) == 0){
// This one isn't divisible by them.
System.out.println(num);
OOP with Java, David J. Barnes
Arrays and Further Control Structures

30. Arrays and Further Control Structures
Labeled Statements
Any statement may be preceded by a label:
identifier:
Labels may be the target of break and continue statements.
There is no goto statement in Java.
This simplifies breaking out of deeply nested loops.
This feature should be used with caution.
OOP with Java, David J. Barnes
Arrays and Further Control Structures

31. Arrays and Further Control Structures
Review
Arrays make it possible to group related items in a single object.
An array's length is fixed on construction.
Arrays may have multiple dimensions.
The Switch, Break and Continue statements provide further flow control capabilities.
Labeled statements should be used sparingly.
OOP with Java, David J. Barnes
Arrays and Further Control Structures