CONTENTS: Arrays Strings. COMP-202 Unit 5: Loops in Practice

Transcription

1 CONTENTS: Arrays Strings COMP-202 Unit 5: Loops in Practice

2 Computing the mean of several numbers Suppose we want to write a program which asks the user to enter several numbers and then computes the average of them. COMP Programming Basics 2

3 First, think of what we need to do at a high level 1)We need to ask the user to enter numbers and store the result into a variable. 2)We need to repeat this several times 3)As we go, we should store the sum of the numbers they have entered 4)At the end, divide by the total number of numbers they entered. COMP Programming Basics 3

4 First, think of what we need to do at a high level 1)We need to ask the user to enter numbers and store the result into a variable. -->Scanner 2)We need to repeat this several times -->For loop 3)As we go, we should store the sum of the numbers they have entered -->Variable that we keep adding to 4)At the end, divide by the total number of numbers they entered. -->Store how many numbers they enter (additional variable) COMP Programming Basics 4

5 First, think of what we need to do at a high level import java.util.scanner; public class MeanProgram { public static void main(string[] args) { final int TOTAL_NUM = 100; double total = 0; Scanner reader = new Scanner(System.in); for (int i = 0; i < TOTAL_NUM; i++) { double nextnumber = reader.nextdouble(); total += nextnumber; } System.out.println(total / TOTAL_NUM); } COMP Programming Basics 5

6 What if, we needed to store all these numbers? For example, if you were computing the standard deviation of the numbers, you need to store the numbers in order to do the computation. Denote by X the mean of all the values. Then the standard deviation of x1, x2...,x100 is: std(x1,...x100) = sqrt( sum(x_i X)^2 / n-1 ) There is no way to compute this without storing all 100 numbers. How can we do this? COMP Programming Basics 6

7 Option 1 (bad option) Store the 100 numbers into 100 different, unrelated variables. int fml1, fml2, fml3, fml4, fml5, fml6, fml7, fml8, fml9, fml10, fml11, fml12, fml13, fml14, fml15, fml16, fml17, fml18, fml19, fml20, fml21, fml22, fml23, fml24, fml25, fml26, fml27, /*okay I'm tired of typing all these fml's. I need a drink now...*/ fml99, fml100; COMP Programming Basics 7

8 Option 1 (bad option) COMP Programming Basics 8

9 Problems with this? The problems with this are kind of obvious: -Really annoying to write -The only way to understand this is to have several drinks. This means the user will be drunk if he has to do this more than a couple times (well, I guess it's debatable if this is bad :) ) -The user will be hungover the next morning if he has to do this more than a couple times (okay this one's definitely bad) -Easy to make an error (sound familiar?) COMP Programming Basics 9

10 Problems with this? Most importantly, this technique does not take advantage of ANY of the looping techniques we have just used! If we want to store these numbers, we can't use a while loop or a for loop. So we spent time learning this cool thing called loops and now we can't even use it. :( COMP Programming Basics 10

11 COMP Programming Basics 11

12 Part 1: Arrays

13 Array Definition An array is a container object that holds a fixed number of values of a single type. The length of an array is established when the array is created. After creation, its length is fixed. (From tsandbolts/arrays.html) COMP Programming Basics 13

14 Array Definition What this means, is we can store many values of the same type into a single array. This allows us to group related values into a single object Because it is all in one object, we can access the values in the array using the same variable. COMP Programming Basics 14

15 Array type For any type, you can create an array variable of that type, by writing type[] instead of type COMP Programming Basics 15

16 Example public static void main(string[] args) args, is a variable of type String array COMP Programming Basics 16

17 Purpose of array When you create an array, you create an object which contains many values of a specific type. The point is to group together similar pieces of data into one piece of data. COMP Programming Basics 17

18 Examples of array variables String[] classlist; //used to store a list of names int[] grades; /*used to store all the grades of 1 person or 1 grade per student boolean[] wins; //used to store results of a game String[] friendslist; /*used to store a list of friends but only if you are popular! */ COMP Programming Basics 18

19 Creating an array When you create an array, you have to specify how big to make the array. In other words, how many values should the array store. There are 2 ways to do this: COMP Programming Basics 19

20 Initializer List: At the same time as you declare an array variable, you provide a list of the elements to fill in: type[] variablename = {exp1, exp2, exp3}; exp1, exp2, exp3, etc all have to be of type type COMP Programming Basics 20

21 Example: Array of days of the week String[] days = { Monday, Tuesday, Wednesday, Thursday, Friday, Saturday, Sunday }; COMP Programming Basics 21

22 Example: Arrays storing hockey results (a small array) int[] rangerswin = {1928, 1933, 1940, 1994, 2012}; int[] habswin = {1916,1924,1930,1931,1944,1946,1953,1956, 1957,1958,1959,1960,1965,1966,1968,1969,1971,19 72, 1973, 1976, 1977, 1978, 1979,1986,1993}; COMP Programming Basics 22

23 More general way... This way only works when you know ahead of time (i.e. as you are typing the code) how many values you want to store in your array. Very often, this is a reasonable assumption: -games in a hockey season -number of countries in North America -the number of wheels on a Hummer COMP Programming Basics 23

24 Sometimes, you don't know Sometimes, you will not know how many values you want to store: Example: -storing a list of books bought in an order from Amazon.com -storing a list of games won by the Montreal Canadiens -... COMP Programming Basics 24

25 new operator (1) In this case, you will use the new operator to create an array and specify how big it is: type[] variablename = new type[size]; This will create an array, referred to by the name variablename. The array will contain size values of type type. COMP Programming Basics 25

26 new operator (2) When you use this approach, you will have to set the values in a different step. It is not necessary to specify the size when you create the variable, but it is necessary when you create the array itself (using new) Scanner scanner = new Scanner(System.in); int numberquestions = scanner.nextint(); String[] jeopardy = new String[numberQuestions]; COMP Programming Basics 26

27 Using an array When you create an array of size n, you are creating n places in memory that can store values of that type. These places in memory are all contiguous. That is, they are all in a row. In addition to storing a value, each place is assigned an index. The index is what you use to access various values. COMP Programming Basics 27

28 boolean[] beatscasino False True False False False False False False False Here is an array with 9 values in it. The casino almost always wins, and indeed 8 values are false. One is true. COMP Programming Basics 28

29 boolean[] beatscasino False True False False False False False False False Each spot of the array has a value and an index. COMP Programming Basics 29

30 boolean[] beatscasino False True False False False False False False False The value is any legitimate value of the type of the array, in this case boolean. COMP Programming Basics 30

31 boolean[] beatscasino False True False False False False False False False The index is an integer. Interestingly the counting starts from 0 instead of 1. COMP Programming Basics 31

32 Accessing values of beatscasino False True False False False False False False False To get or set values of an array, we will use a similar syntax to a normal variable, except we have to specify which value of the array we wish to get or set. We do this by using the index. COMP Programming Basics 32

33 Accessing values of beatscasino False True False False False False False False False System.out.println(beatsCasino[0]); // prints False beatscasino[1] = false; // sets the value at index 1 to be false if (!beatscasino[0] &&!beatscasino[1] ) { System.out.println( LOSER!!! ); } COMP Programming Basics 33

34 Checking if you lost all your games Let's say we want to test if we won any games at the casino. The naïve way to do this, would be to test every single value. (Remember that in a boolean expression it is not necessary to compare the boolean to true) if (beatscasino[0] beatscasino[1] beatscasino[2] beatscasino[3] beatscasino[4] beatscasino[5] beatscasino[6] beatscasino[7] beatscasino[8] ) { System.out.println( You won! ); } else { System.out.println( You're broke! ); } COMP Programming Basics 34

35 Smarter way... If we do this though, we are not taking advantage of the array at all. We are simply treating the 9 values completely separately. What we'd like to do is create a loop that checked all of these values. Each step of the loop will look at one value of the array. What is it that should change at each step? COMP Programming Basics 35

36 For loop : array int size = 9; boolean foundwinner = false; for (int i = 0; i < size; i++) { if (beatscasino[i]) { foundwinner = true; } } if (foundwinner) { System.out.println( You win ); } else { System.out.println( Sucker! ); } COMP Programming Basics 36

37 While loop : array int size = 9; int i = 0; boolean foundwinner = false; while (i < size) { if (beatscasino[i]) { foundwinner = true; } i++; } if (foundwinner) { System.out.println( You win ); } else { System.out.println( Sucker! ); } COMP Programming Basics 37

38 Arrays as Objects An array is a type of Object. An object is a collection of data along with methods/functions to work with the data. We have seen Objects before: String and Scanner In fact, except for the 8 primitive types, all types in Java are Objects. COMP Programming Basics 38

39 String as an Object Recall some of the things we can do with Strings. String university = McGill ; int size = university.length(); String breathingdevices = university.substring(2).tolowercase() + s This is because a String is an Object. In addition to data, a String also has associated methods/functions. You call these methods by writing the name of a variable referring to the Object you are interested in, followed by a dot, followed by the name of the method (and any arguments the method requires) The significance is that the substring method will differ depending on which String the method is called upon! COMP Programming Basics 39

40 Properties of Objects In addition to calling methods on Objects, you can also access properties of Objects. To access a property, you can do it the same way as a method, except there are no ( ) and no arguments inside. In the case of an array, there is just 1 property, and there are no methods. COMP Programming Basics 40

41 Array property : length When you have an array stored into a variable, you can access the length of the array by writing: variablename.length For example: int[] numbers = {1, 5, 9, 11, 3, 4}; int arraysize = numbers.length; This accesses the property called length of the array referred to by the variable arraysize. COMP Programming Basics 41

42 Preview:Reference vs Primitive Types(1) When we write int x = 10; what we are technically doing is the following: 1)Creating a space in memory that will store an int 2)Specifying that whenever we use the identifier x later in our program, we want to access that memory location. 3)Storing the value of 10 into that memory location. COMP Programming Basics 42

43 Preview : References One tricky concept that we will see is that a variable of any Object type, does NOT actually store the DATA inside the variable! It actually stores the address in memory that the data is located. We will see the consequences of this in the next unit, but it can lead to some very weird results! An array is an Object, so that means the variable itself, does not actually store the data! It merely stores the address in memory of the data. COMP Programming Basics 43

44 Preview:Reference vs Primitive Types(2) When we write int x[] = {10, 3, 5}; what we are technically doing is the following: 1)Creating a space in memory that will store the address of an int array. 2)Specifying that whenever we use the identifier x later in our program, we want to access that space in memory (which stores an address). 3)Creating an array somewhere else in memory. That array will store the values 10, 3, and 5 and have length of 3. That array must be located somewhere in memory. Call that address a 4)Setting the value of x to be a. (In other words, store into the space of memory reserved for the variable x, the value of a) COMP Programming Basics 44

45 Consequence of Reference Types There are some interesting consequences of storing addresses into variables instead of the values. int[] x = {1, 2, 3}; int[] y = x; y[0] = 2; System.out.println(x[0]); What do you think the above prints? COMP Programming Basics 45

46 Consequence of Reference Types There are some interesting consequences of storing addresses into variables instead of the values. int[] x = {1, 2, 3}; int[] y = x; y[0] = 2; System.out.println(x[0]); What do you think the above prints? It actually prints 2! Because changing y[0] also changes x[0] COMP Programming Basics 46

47 Step by step: Memory Addresses Values int[] x = {1, 2, 3}; COMP Programming Basics 47

48 Step by step: Memory Addresses Values int[] x = {1, 2, 3}; The {1, 2, 3} creates an array in memory. The address of the start of this spot in memory is COMP Programming Basics 48

49 Step by step: Memory Addresses Values int[] x = {1, 2, 3}; int[] x creates a variable of type int array. This means we create space in memory to store the address of an int array. In this case, we use the storage space in memory of 2000, to store the space 1000 x COMP Programming Basics 49

50 Step by step: Memory Addresses Values int[] x = {1, 2, 3}; int[] y = x; x This means: 1)Create space in memory to store an int[] variable 2)Store into that int[] variable the value of the expression x COMP Programming Basics 50

51 Step by step: Memory Addresses Values int[] x = {1, 2, 3}; int[] y = x; x y This means: 1)Create space in memory to store an int[] variable 2)Store into that int[] variable the value of the expression x COMP Programming Basics 51

52 Step by step: Memory Addresses Values int[] x = {1, 2, 3}; int[] y = x; y[0] = 2; x y This means: 1)Assign to the first value of the array referred to by y, the value of the expression 2 COMP Programming Basics 52

53 Step by step: Memory Addresses Values int[] x = {1, 2, 3}; int[] y = x; y[0] = 2; x y This means: 1)Assign to the first value of the array referred to by y, the value of the expression 1 COMP Programming Basics 53

54 Step by step: Memory Addresses Values int[] x = {1, 2, 3}; int[] y = x; y[0] = 2; System.out.println(x[0]); x y So printing the first value stored in the array referred to by x now will print 2! COMP Programming Basics 54

55 Equality with arrays int[] x = {1,2,3}; int[] y = new int[3]; y[0] = 1; y[1] = 2; y[2] = 3; System.out.println(x == y); Do you think this prints true or false? COMP Programming Basics 55

56 Equality It actually prints false It does this because it is comparing the values of the variables. The value of each variable is just an address though! x and y refer to 2 different arrays which each happen to have the same values, but they are not the same array! This is why when you compare 2 Strings to each other, you should use.equals() instead of == COMP Programming Basics 56

57 Why? Why would they EVER make things so complicated? It turns out there are some very good reasons that will be crucial to the idea of object oriented programming. One useful feature is the ability to pass addresses of data means it's easier to share (and modify!) data between methods! COMP Programming Basics 57

58 Exceptions and Runtime Errors Sometimes, you will try to execute a command that is impossible to do for various reasons. In this case, you will generate an exception or runtime error. Normally, these will cause your program to crash, but we'll see ways that you can avoid your program crashing. COMP Programming Basics 58

59 Ex: Scanning for the wrong kind of value An example of a Runtime Error happens if you try to scan for an int and get a String: dan:~/comp202$ java ScannerTest Enter a number: foo Exception in thread "main" java.util.inputmismatchexception at java.util.scanner.throwfor(scanner.java:819) at java.util.scanner.next(scanner.java:1431) at java.util.scanner.nextint(scanner.java:2040) at java.util.scanner.nextint(scanner.java:2000) at ScannerTest.main(ScannerTest.java:4) COMP Programming Basics 59

60 Information from an Exception Exception in thread "main" java.util.inputmismatchexception at java.util.scanner.throwfor(scanner.java:819) at java.util.scanner.next(scanner.java:1431) at java.util.scanner.nextint(scanner.java:2040) at java.util.scanner.nextint(scanner.java:2000) at ScannerTest.main(ScannerTest.java:4) An Exception contains a lot of information to help you fix the problem: -The type of Exception -The line number and file that the exception occurred in -The stack trace which helps you see which methods called the method that crashed your program COMP Programming Basics 60

61 Divide by Zero Exception Another kind of exception is a divide by zero exception: dan:~/examples daniel$ java DivideByZero I'm going to divide 1 by 0 Exception in thread "main" java.lang.arithmeticexception: / by zero at DivideByZero.main(DivideByZero.java:4) This message contains the same sorts of information. COMP Programming Basics 61

62 Exceptions with arrays When we use arrays, there are 2 kinds of Exceptions that we must be careful to avoid: 1)ArrayIndexOutOfBoundsException 2)NullPointerException COMP Programming Basics 62

63 ArrayIndexOutOfBounds An ArrayIndexOutOfBounds exception occurs when you try to access an invalid index. This happens when you use an index < 0 or >= the length of the array: Ex: int[] x = {1, 2, 3}; System.out.println( x[-1] ); COMP Programming Basics 63

64 ArrayIndexOutOfBounds dan:~/examples daniel$ java ArrayOOB Exception in thread "main" java.lang.arrayindexoutofboundsexception: -1 at ArrayOOB.main(DivideByZero.java:4) The information in an ArrayIndexOutOfBoundsException is very similar to the other Exceptions. One useful thing is in addition to the stacktrace and line number, it provides the index that caused the ArrayIndexOutOfBoundsException (in this case -1) This is really useful when you have a complicated statement such as x[y/2*z]; COMP Programming Basics 64

65 NullPointerException The other kind of exception you get is a NullPointerException. This happens when you have an array variable but it is not actually assigned to an array! For example: int[] x; //creates a variable which can store the address of an int[] System.out.println(x.length) Because x does not actually contains the address of an array yet, it has no length. This causes a NullPointerException! Sometimes, the compiler will catch the error, but not always. COMP Programming Basics 65

66 Preview: Variables vs Objects Because variables of types that are not primitive store addresses, this means that we can create a variable but not actually an Object. There are thus three different steps: 1)Create a variable which could store the address of an Object 2)Create an Object 3)Link the variable to the Object COMP Programming Basics 66

67 Multidimensional Arrays So far, the elements of all the arrays we have seen have been simple values: primitive types or Strings Such arrays are one-dimensional However, we can create arrays whose elements are themselves one-dimensional arrays Such an array is really an array of arrays These arrays are two-dimensional arrays (or 2D arrays) COMP Arrays 67

68 Two-Dimensional Arrays Elements in a two dimensional array are accessed using two indices The first index specifies the one-dimensional array containing the element we want to access The second index specifies the element we want to access within the one-dimensional array specified by the first index COMP Arrays 68

69 Creating a 2d array Like 1d arrays, there are 2 ways to create a 2d array: 1)Initializer list 2)Using the new operator. COMP Arrays 69

70 Initializer List We said to create an array using an initializer list, you could write: type[] variablename = {exp1, exp2, exp3,...} where exp1, exp2, exp3, etc all evaluated to type Well, in this case type is just an array: COMP Arrays 70

71 Initializer List int[][] board = { {1,2,3}, {1,4}, {6,2} } This is creating an array of int[]. The first array in the array is {1,2,3} the second is {1,4} and the third is {6,2} COMP Arrays 71

72 Using the new keyword There are two ways to create a 2d array using the new keyword: 1)type[][] variablename= new type[size_1][size_2]; This creates a rectangular array. You can then fill in values or access values using 2 indices. COMP Arrays 72

73 Accessing values of a 2d array int[][] x = new int[3][4]; //creates an array which contains 3 arrays of size 4. x[0][1] = 3; //assigns to the 2 nd spot of the 1 st array, the value 3; x[2][3] = 10; //assigns to the 4 th spot of the 3 rd array, the value of 10; x[10][2] = 5; //causes an array out of bounds exception int[] y = x[2]; //stores into y the address of the 3 rd array COMP Arrays 73

74 Using the new keyword The second way to use the new keyword with 2d arrays is less commonly used but also possible. Since it is an array of arrays, you can create each array separately: COMP Arrays 74

75 Using the new keyword int[][] x = new int[4][]; //creates an array which will store 4 arrays x[0] = new int[5]; /*creates an array of size 5 and puts it into the first spot of the array x */ x[2] = new int[3]; /*creats an array of size 3 and puts it into the 3 rd spot of the array x */ COMP Arrays 75

76 Higher dimensional arrays You can actually create arrays of even more dimensions: int[][][][][][][][][][] x = new int[2][2][2][2][2][2][2][2][2][2]; creates a 10 dimensional array! COMP Arrays 76

77 Arrays and Strings in loops Both arrays and Strings translate very well to loop operations. We will see some examples in class of this. COMP Arrays 77

78 Useful String methods The following are some useful methods you can use to operate on a String. For all of the following, you have to provide an example of a String to call the method on. (e.g. foo.length() where foo is a variable of the type String). All of these return values without modifying the original String.length() - gets the length of a String.charAt(int i) gets the ith symbol of the String (count from 0).substring(a,b) gets String consisting of from a of the original up to but not including a+b.equals(string other) compare two Strings values to each other (since == compares addresses).compareto(string other) tells you which String is larger.indexof(char c) returns the index of the first instance of c.tolowercase() - returns a lowercase version of String COMP Arrays 78