chapter 6- arrays

Chapter 6- Arrays

Overview What are arrays? Declaring/initializing arrays. Using arrays. Arrays details. Using arrays with classes/ in classes. Sorting/searching arrays. Multidimensional arrays. Review

Arrays, what are they?

What are arrays?

An array is a large collection of variables that are all of the same data type.

It allows us to have a large number of similar variables without having to declare each one individually.

What are arrays used for?

Think back to the grocery purchase program that we did. Imagine instead of having only five items (and declaring five Purchase objects) we had 100 items the user could choose. Since much of the code for each Purchase object is similar, we could just have an array and one piece of code to repeatedly do stuff to that array.

More on arrays Arrays are like mailboxes. They have a

collective name (say the zip code for the University), an index (your box number), and a value (any mail in your box).

Name

0 1 2 3

Value

Index

Value 43 105

Arrays

Arrays are actually objects (though they don’t look like it). They are initialized with the new operator. They store a memory address in their variable.

We’ve already seen them, we just haven’t used them.

Declaring and initializing arrays

Declaring arrays.

We declare an array in a very similar way to how we declare variables. The only difference is the [ ] symbols.

int [] blar;double [3] muglets;String [] args;

Initializing arrays.

There are lots of ways to initialize arrays.

blar=new int[20]; //blar now has 20 0’s.

muglets = new int[2]; //muglets now has 2 0’smuglets[0]=2.3; muglets[1]=1.2;

String [] args = {“Hello”, “How”, “are”, “you”};

Array indices

Arrays are indexed from 0 to (the length of the array –1). Remember this. It will cause you immeasurable grief in programming. The index always starts a 0.

blar = new int[20]; //indexed 0-19muglets = new double[4]; //indexed 0-3args = {“Howdy”, “there”}; //indexed 0-1int [] lonely = {1}; //indexed 0-0

Declaring and initializing

Can declare and initialize arrays in just one statement(this is the usual way).

double [] muglet = new double[4];String [] words = {“Hello”, “Howdy”};int [] lonely = {1};

What is happeningint [] blar = {1,7,4,6};

blar

0 1 2 3

1 7 4 6

Which of the following are valid declarations/initializations of arrays?

int arg = new int(5);

int arg = new int[10];

double [] blar;blar = new double[15];

String [] muglet = “Hello”;

char [] yadda = “Howdy”;

int [] someNum = {1,5,7};

Not valid

Not valid

Not valid

Not valid

Valid

Valid

What are the indices of the following arrays?

int [] arr = new int[10];

double [] yadda = new double[1];

String [] hello = {“Hello, Hello, Hello”};

int [] number = {1,5,10,15,20};

int I = 4;double sum = new double[I];

0-9

0-0

0-0

0-4

0-3

Using Arrays

Accessing arrays

To get at the information inside of an array, we again use the [ ] operators.

To access the ith element of an array called arrayName, we say arrayName[i].

Remember, we start at index 0, with the 0th element.

Using arrays

double []someArray = {1.4, 2.6,2.1, 3.4,8.4};

double I = someArray[0];//I=1.4double j = someArray[1];//j = 2.6double k = someArray[2];//k = 2.1double m = someArray[3];//m = 3.4double n = someArray[4];//n=8.4double o = someArray[5];//o =

ArrayIndexOutOfBounds Exception

More info on arrays.

The length of an array is also stored in the array object, and we can access it through the public length variable.

arrayName.length We can only read this variable. We

cannot set it.

Common uses of length.

//assume arr is an array.…for(int I=0; I<arr.length;I++){

System.out.println(arr[I]);}

Which are valid uses of arrays?int []muglets = new int[5];double []blar = new double[3];…muglets(0) = 3;

muglets[3] = 24;

muglets[5] = 3;

blar.length = muglets.length;

if(muglets.length == blar.length){…}

Not valid

Valid

Not valid

Not valid

Valid

Array Details

Some more rules about arrays.

All of a single array should be of the same type. You can’t have a mixed array, part String and part integer. You can only store one type of data in a single array.

Array names are just memory addresses. Thus they act more like objects than primitives. You can’t just use = and == to copy an array or compare arrays. Have to do it element by element.

More rules.

Don’t go out of bounds! Stay within your array. You WILL make this mistake. Often. It WILL crash your program.

If you don’t give an initialization list to an array, the computer just initializes all of the data in the array to some default value for the data type. If your data type is a class, it just stores null in the array position(you need to construct a new object when before you use this!).

Array details review

What is output to the screen?int []someArray = new int[5];

someArray[5] = 3;

System.out.println(someArray[5]);

What does the name of the array store? What two common operations can’t you do with arrays?

Nothing

Array Details Review

What is output to the screen?int [] someArray = new int[20];

System.out.println(someArray[5]);

Is the following valid?int [] someArray = new int[20];

someArray[5] = “1”;

0

No

Using arrays with classes / in classes.

Using arrays in classes

We can use an array in any class that we want. They can be private instance variables. They can be public static variables. They can be variables that are local to a method.

We can also pass arrays to methods, return arrays from methods, or pass single elements from arrays to a method.

Using arrays in classes

…private int [] blar; //want to initialize

//in a constructor or //in some method.

public static double [] mug = new double[15];

private Purchase []itemsOffered;…

Passing single elements to a method If a method requires a variable of the same

data type as your array base type, then you can pass a single element to the method.

double []blar = {3.0,4.0};

Triangle a = new Triangle();

a.setBase(blar[0]); //a.setBase(3.0);

b.setHeight(blar[1]); //a.setHeight(4.0);

Passing arrays to methods

We can also pass whole arrays to methods(notice, every main method accepts a String array).…

public void doSomething(int [] someArray)

{…}

…

int [] blar = new int[20];

…

doSomething(blar);

Don’t use array index things[ ]. Just the name. If you usethe [ ] symbols, you will passa single element, not the whole array.

Indicates it requires an array

Returning arrays from methods

We can also return arrays from methods, if we like. Be careful, this is just like returning a non-String object. If you want the array to be private, it is better to make a copy and return it.public int[] doSomething()

{ int [] someArray = new int[20];

…

return someArray;

}

Again, want to return the whole array, so we use the whole name, no [ ] symbols.

Indicates going to return an array.

Review - Arrays in classes and methods. Can we use arrays in classes? Is there

anything special that we have to do to use them in classes?

How do we pass or return a single element of an array?

Make a method declaration that is public, returns nothing, is called “muglet”, and accepts an integer array as a parameter.

Review- Arrays in Classes.

Make a method declaration for a method that is public, returns an array of doubles, is called “blar”, and accepts an array of integers.

Why do we have to be careful when returning an array from a method? What can we do to be safe?

Searching/Sorting

How to find information in arrays

Now that we are able to store information in arrays, we also need to be able to find the information again and retrieve it.

To find information we will perform a searching algorithm on the array(we’ll look for the value in the array).

Sequential search

The sequential search is very simple: We start at the first element in the array, and compare it against what we want to find. We continue this till the last element in the array. If we ever find the value, we’re done. If we get to the end of the array, and we haven’t found it, then the value isn’t in the array.

Sequential search in codeint toSearchFor = 5, i;int [] anArray = new int[20];

//anArray gets some values from the user.

for(I=0; I<anArray.length; I++){

if(toSearchFor == anArray[I]){ System.out.println(“Found it.”); System.out.println(“At location: “+I); break;}

}if(I==anArray.length)

System.out.println(“Didn’t find it.”);

Other searches There are other searches we can perform

that are sometimes faster. A binary search can be performed if all of

the data is in order(like a phone book)– Look at the halfway point. If you are at too

small of a value, disregard the left half and proceed searching the right half. If you are at too large a value, disregard the right half, and look at the left half.

Other searches continued...

Many of these faster searches, such as a binary search, require that our list of information (or array) be sorted.

We must find some way of sorting an array.

Why sorting

Organization in general can make things quicker. We spend less time looking for things, and more time using them. This is why we do sorting. It makes our information easier to find and use.

The first sorting algorithm we will look at is the Selection Sort.

Selection Sort algorithm(smallest to largest). For each element i in the list.

– Find the ith smallest value.– Place this value in the ith position.

This is probably the most intuitive sort algorithm. We need to refine this algorithm more before we can use it in Java code, though.

Selection Sort algorithm refined.

For each ith element in the list– For each of the elements from I on

• compare against the smallest seen so far.

– Swap the ith value in the list with the ith smallest value.

Selection sort code

See the code on page 426 and 427 for the full code of an implementation of the Selection Sort algorithm.

Swapping-Exchanging values in arrays. Swapping is an important step that

occurs in every sorting algorithm. The idea is to exchange the value from

one index with the value located at another index.

For this, we will always need a temporary variable to store the value from one of the elements while it is being overwritten.

Other sorting algorithms.

There are other sorting algorithms out there, and some even run much faster than the selection sort.

If you would like to do some research, look at the Bubble Sort, the Insertion Sort, the Merge Sort, and the Quick Sort.

Sorting examples in action.

View the Sorting demo in the applet demos in the directory you installed Java to (C:\jdk1.3\demo\applets\SortDemo)

Searching/Sorting review.

Explain the Sequential Search algorithm in your own words.

Why do we want to do sorting? Explain the Selection Sort algorithm in

your own words. Are there faster sorting algorithms than

the Selection Sort algorithm?

Sorting Review

Go through the steps to do the Selection Sort on the following list of numbers:

1,5,17,6,3,12,18

Multidimensional Arrays

Multidimensional arrays

We can have arrays with more than a single dimension.

These are used for things like tables of data, game boards, keeping 3/4 dimensional data, weather forecasting, etc.

Can have as many dimensions as you would like, but we usually keep it under 5 dimensions.

Most often we will deal with 2-dimensional arrays.

Declaring multidimensional arrays Just add an extra set of square brackets

[ ] for every dimension.

double [][] excelSheet = new double[10][8];

double [][][] temps3D = new double[20][20][20];

char [][] ticTacToeBoard = new char[3][3];

Creates a tic tac toe board with 3 rows, 3 columns

Creates a table with 10 rows, 8 columns.

Creates a 3-Dimensional cube for storing temperatures in a three dimensional space.

2 dimensional tables.

Our most common multi-dimensional array.

By convention, listed in row-column order.

int numRows = 3, numCols = 2;int [][]table = new int[numRows][numCols];for(int rows = 0; rows <numRows; rows++) for(int cols = 0; cols < numCols; cols++)

table[rows][cols] = rows+cols;

What that code created

Indices 0 1

0 0+0=0 0+1=11 1+0=1 1+1=22 2+0=2 2+1=3

int numRows = 3, numCols = 2;int [][]table = new int[numRows][numCols];for(int rows = 0; rows <numRows; rows++) for(int cols = 0; cols < numCols; cols++)

table[rows][cols] = rows+cols;

Rules about arrays.

Make sure you don’t reverse the row-column ordering. Row-Column. Row-Column. Row-Column. RC, RC, RC, Row-Column, Row-Column, Row-Column. RC. RC. Row-Column. RC. Row-Column. Row-Column. Row Column. Row-Column. Row-Column.

You can pass and return multidimensional arrays to and from methods like any other array. Just make sure you get enough brackets in the method declaration.

Implementation of arrays.

A multi-dimensional array is actually just an array of arrays.int [][][]table = new int[4][10][3];

table[2][5].length; //3

table[2].length; //10

table.length; //4

Multidimensional array review.

Write a declaration and initialization of a 3-dimensional array of integers that is sized 3 by 5 by 7.

Are the following declarations legal?

int table = new int [15][23][5][24][13];

double [ ] [ ] anotherTable = new double[2][3];

Multidimensional array review.Table 0 1 2 3 4 5

0 8 19 12 14 12 451 108 3 43 4 234 55552 15 23 678 5 4232 423 98 3458 21122 34562 32 894 112 145 10 56 73 885 41 49 75 34 23 5546 54 1 2141 34 234 6

Table[0][3]=Table[5][4]=Table[1][4]=Table[1][1]=Table[0][0]=Table[6][0]=

Table[1][3]=Table[3][4]=Table[4][4]=Table[2][1]=Table[3][0]=Table[3][5]=

14232343854

43273239889

Review

Arrays Review

What is an array? What data types can you use in arrays? Declare an array of integers called

“prices” and initialize it to have size 10. What are the indices for the prices

array?

Arrays Review

What is output to the screen?int [] someArray = new int[20];

System.out.println(someArray[5]);

What is output to the screen?int []someArray = new int[5];

someArray[5] = 3;

System.out.println(someArray[5]);

Arrays Review

What is actually stored in an array name?

What are the following values?

indices 0 1 2 3 4 5

Prices 1.45 1.24 2.99 2.39 0.25 0.85

Prices[3]=Prices[0]=

Prices[2]=Prices[6]=

Prices.length=

Arrays Review

Run the selection sort on the following numbers:

5,23,1,3,2,15,8

Arrays ReviewTable 0 1 2 3 4 5

0 8 19 12 14 12 451 108 3 43 4 234 55552 15 23 678 5 4232 423 98 3458 21122 34562 32 894 112 145 10 56 73 885 41 49 75 34 23 5546 54 1 2141 34 234 6

Table[1][1]=Table[0][0]=Table[6][0]=

Table[2][1]=Table[3][0]=Table[3][5]=