1. Chapter 6- Arrays

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

3. Arrays, what are they?

4. What are arrays? n An array is a large collection of variables that are all of the same data type. n It allows us to have a large number of similar variables without having to declare each one individually.

5. What are arrays used for? n 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.

6. More on arrays n 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 0123 Value Index Value43105

7. Arrays n 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. n We’ve already seen them, we just haven’t used them.

8. Declaring and initializing arrays

9. Declaring arrays. n 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;

10. Initializing arrays. n 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’s muglets[0]=2.3; muglets[1]=1.2; String [] args = {“Hello”, “How”, “are”, “you”};

11. Array indices n 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-19 muglets = new double[4]; //indexed 0-3 args = {“Howdy”, “there”}; //indexed 0-1 int [] lonely = {1}; //indexed 0-0

12. Declaring and initializing n 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};

13. What is happening int [] blar = {1,7,4,6}; blar 0123 1746

14. 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 Valid

15. 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-4 0-3

16. Using Arrays

17. Accessing arrays n To get at the information inside of an array, we again use the [ ] operators. n To access the i th element of an array called arrayName, we say arrayName[i]. n Remember, we start at index 0, with the 0 th element.

18. Using arrays double []someArray = {1.4, 2.6,2.1, 3.4,8.4}; double I = someArray[0];//I=1.4 double j = someArray[1];//j = 2.6 double k = someArray[2];//k = 2.1 double m = someArray[3];//m = 3.4 double n = someArray[4];//n=8.4 double o = someArray[5];//o = ArrayIndexOutOfBounds Exception

19. More info on arrays. n The length of an array is also stored in the array object, and we can access it through the public length variable. arrayName.length n We can only read this variable. We cannot set it.

20. Common uses of length. //assume arr is an array. … for(int I=0; I<arr.length;I++) { System.out.println(arr[I]); }

21. 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 Valid

22. Array Details

23. Some more rules about arrays. n 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. n 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.

24. More rules. n Don’t go out of bounds! Stay within your array. You WILL make this mistake. Often. It WILL crash your program. n 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!).

25. Array details review n What is output to the screen? int []someArray = new int[5]; someArray[5] = 3; System.out.println(someArray[5]); n What does the name of the array store? What two common operations can’t you do with arrays? Nothing

26. Array Details Review n What is output to the screen? int [] someArray = new int[20]; System.out.println(someArray[5]); n Is the following valid? int [] someArray = new int[20]; someArray[5] = “1”; 0 No

27. Using arrays with classes / in classes.

28. Using arrays in classes n 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. n We can also pass arrays to methods, return arrays from methods, or pass single elements from arrays to a method.

29. 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; …

30. Passing single elements to a method n 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);

31. Passing arrays to methods n 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 use the [ ] symbols, you will pass a single element, not the whole array. Indicates it requires an array

32. Returning arrays from methods n 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.

33. Review - Arrays in classes and methods. n Can we use arrays in classes? Is there anything special that we have to do to use them in classes? n How do we pass or return a single element of an array? n Make a method declaration that is public, returns nothing, is called “muglet”, and accepts an integer array as a parameter.

34. Review- Arrays in Classes. n Make a method declaration for a method that is public, returns an array of doubles, is called “blar”, and accepts an array of integers. n Why do we have to be careful when returning an array from a method? What can we do to be safe?

35. Searching/Sorting

36. How to find information in arrays n Now that we are able to store information in arrays, we also need to be able to find the information again and retrieve it. n To find information we will perform a searching algorithm on the array(we’ll look for the value in the array).

37. Sequential search n 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.

38. Sequential search in code int 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.”);

39. Other searches n There are other searches we can perform that are sometimes faster. n 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.

40. Other searches continued... n Many of these faster searches, such as a binary search, require that our list of information (or array) be sorted. n We must find some way of sorting an array.

41. Why sorting n 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. n The first sorting algorithm we will look at is the Selection Sort.

42. Selection Sort algorithm(smallest to largest). n For each element i in the list. –Find the i th smallest value. –Place this value in the i th position. n This is probably the most intuitive sort algorithm. We need to refine this algorithm more before we can use it in Java code, though.

43. Selection Sort algorithm refined. n For each i th element in the list –For each of the elements from I on compare against the smallest seen so far. –Swap the i th value in the list with the i th smallest value.

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

45. Swapping-Exchanging values in arrays. n Swapping is an important step that occurs in every sorting algorithm. n The idea is to exchange the value from one index with the value located at another index. n For this, we will always need a temporary variable to store the value from one of the elements while it is being overwritten.

46. Other sorting algorithms. n There are other sorting algorithms out there, and some even run much faster than the selection sort. n If you would like to do some research, look at the Bubble Sort, the Insertion Sort, the Merge Sort, and the Quick Sort.

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

48. Searching/Sorting review. n Explain the Sequential Search algorithm in your own words. n Why do we want to do sorting? n Explain the Selection Sort algorithm in your own words. n Are there faster sorting algorithms than the Selection Sort algorithm?

49. Sorting Review n Go through the steps to do the Selection Sort on the following list of numbers: 1,5,17,6,3,12,18

50. Multidimensional Arrays

51. Multidimensional arrays n We can have arrays with more than a single dimension. n These are used for things like tables of data, game boards, keeping 3/4 dimensional data, weather forecasting, etc. n Can have as many dimensions as you would like, but we usually keep it under 5 dimensions. n Most often we will deal with 2-dimensional arrays.

52. Declaring multidimensional arrays n 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.

53. 2 dimensional tables. n Our most common multi-dimensional array. n 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;

54. What that code created 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;

55. Rules about arrays. n 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. n 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.

56. Implementation of arrays. n 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

57. Multidimensional array review. n Write a declaration and initialization of a 3- dimensional array of integers that is sized 3 by 5 by 7. n Are the following declarations legal? int table = new int [15][23][5][24][13]; double [ ] [ ] anotherTable = new double[2][3];

58. Multidimensional array review. 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]= 14 23 234 3 8 54 4 32 73 23 98 89

59. Review

60. Arrays Review n What is an array? n What data types can you use in arrays? n Declare an array of integers called “prices” and initialize it to have size 10. n What are the indices for the prices array?

61. Arrays Review n What is output to the screen? int [] someArray = new int[20]; System.out.println(someArray[5]); n What is output to the screen? int []someArray = new int[5]; someArray[5] = 3; System.out.println(someArray[5]);

62. Arrays Review n What is actually stored in an array name? n What are the following values? Prices[3]= Prices[0]= Prices[2]= Prices[6]= Prices.length=

63. Arrays Review n Run the selection sort on the following numbers: 5,23,1,3,2,15,8

64. Arrays Review Table[1][1]= Table[0][0]= Table[6][0]= Table[2][1]= Table[3][0]= Table[3][5]=