Textbook Data Structures and the Java Collections Framework

Textbook: Data Structures and the Java Collections Framework 3 rd Edition by William Collins Instructor: 中央資 系 陳振炎

Chapter 0 Introduction to Java

Basically, a class consists of: 1) variables called fields together with 2) functions called methods that act on those fields.

The following class, Hello. World, has no fields and defines only one method, a special method called main, whose execution entails the calling of another method, println: public class Hello. World { public static void main (String [ ] args) {System. out. println ("Hello, world!"); } } // end of class Hello. World

The output from the execution of this program is Hello, world!

A primitive type is a collection of values, together with operations that can be performed on those values. For example, the int type consists of all integer values in the range from − 2, 147, 483, 648 to 2, 147, 483, 647, inclusive. The operations that can be performed on those values include addition, subtraction , multiplication, division, and remainder. The division operator, /, returns the result of truncated integer division, so 14 / 3 returns 4. The remain-der operator, %, returns the integer remainder from integer division. 14%3 returns 2.

We can declare variables of type int, and assign values to those variables: int first, last; first = 14 / 3; last = 14 % 3 + 7;

In addition to variables whose type is primitive, Java also has objects. An object – sometimes called an instance of a class – is a variable whose type is a class. An object has the fields and can call the methods of its class.

Let’s look at the String class

A String object is a variable that contains a string (a sequence of characters) and can call methods in the String class. Objects cannot be explicitly declared in Java; instead, programmers declare object reference variables.

String s; s is not a String object, but rather a String reference, a variable that can hold the address of a String object.

To store the address of a String object in s, we will: 1. Allocate space for a new String object. 2. Initialize the fields in that object. 3. Assign to s the address of that object. All three of these tasks can be accomplished in a single assignment next:

s = new String();

A method with the same name as the class is called a constructor. The purpose of a constructor is to initialize the object’s fields. A class’s default constructor has no parameters.

The String class’s default constructor initializes the fields so that the String object represents an empty string.

Another constructor in the String class has a String reference parameter. Here’s the heading parameter public String (String original) And here is a statement that calls that constructor: String t = new String (“Aloha”); argument Actually, the argument is a reference to “Aloha”.

Now, the String objects referenced by s and t can invoke String methods: s. length()// returns 0 t. to. Lower. Case() // returns (a reference to) “aloha”. // t is still a reference to “Aloha”

/** index. Of() * returns the index within this String object * of the first occurrence of the specified * substring. * @param str – the specified substring * @return * * the index of the first occurrence of str in this String object, or – 1 if str is not a substring of this String object

* @throws Null. Pointer. Exception – if this or str is null */ public int index. Of (String str) The JAVADOC comments plus the method heading constitute the method specification – the user’s view of the method.

Determine the output: System. out. println (t. index. Of (“ha”)); System. out. println (t. index. Of (“a”)); System. out. println (s. index. Of (“ha”)); Hint: Indexes start at 0. ANS: 3 4 null pointer exception

String w = null; w does not contain the address of any String object, so w cannot be used to call any String methods.

The equals method tests for equality of objects The == operator tests for equality of references. String z = new String (“Aloha”);

Given String s=new String(“”); String t = new String(“Aloha”); String w = null; Find what is returned below: s. equals (“”) s == “” t. equals (“Aloha”) t == “Aloha” t. equals (null) t. equals (z) t == z w. equals (null) w == null String z = new String(“Aloha”);

s. equals (“”) ANS: true s == “” false t. equals (“Aloha”) true t == “Aloha” false t. equals (null) false t. equals (z) true t == z false w. equals (null) run time error w == null true

String y 1 = “Aloha”; String y 2 = “Aloha”; These statements create two references, y 1 and y 2, to the same string object, so y 1 == y 2 // returns true y 1 == t // returns false but y 1. equals (t) // returns true

LOCAL VARIABLES

A local variable is one that is declared within a method, including the method’s parameters. For example, the following method, with 3 local variables (n, sum, i), returns the sum of the first n positive integers:

/** * Returns the sum of the integers from 1 up to a given integer. * @param n – the given positive integer. * @return the sum of the first n positive integers. */ public static int sum. Up (int n) { int sum = 0; for (int i = 1; i < n; i++) sum += i; // same as sum = sum + i; return sum; } // end sum. Up()

Local variables must be initialized before they can be used. For example, method sum. Up initialized its local variable sum to 0. The following method initializes its local variable last to 20. When sum. Up is called, its local variable n is initialized to 20: public void run( ) { int last = 20; System. out. println (sum. Up (last)); } // end run()

But the following version would generate a compile-time error: variable last may not have been initialized public void run( ) { int last; System. out. println (sum. Up (last)); } // end run()

The Scanner Class

The Scanner class allows users easy access to text data. A text is a sequence of lines, separated by end-of-line markers. A Scanner object skips over irrelevant characters called delimiters (for example, spaces) to access tokens (for example, integers). The text can 1) be entered from the keyboard, 2) be entered from a file, or 3) consist of a string of characters. The Scanner class has constructors to initialize each of the three kinds of Scanner object.

Scanner keyboard. Scanner = new Scanner (System. in); int n = keyboard. Scanner. next. Int(); Suppose the input from the keyboard is 74 Then the token 74 will be stored in the variable n.

Scanner keyboard. Scanner = new Scanner (System. in); int j, k, m, n; j = keyboard. Scanner. next. Int(); k = keyboard. Scanner. next. Int(); m = keyboard. Scanner. next. Int(); Suppose the input from the keyboard is 74 58 0 The delimiters are whitespace characters: spaces, tabs, end-of-line markers, and so on. They are skipped over, and the tokens 74, 58 and 0 will be assigned to the variables j, k and m, respectively.

The has. Next. Int method tests to see if the next token is an int value: Scanner keyboard. Scanner = new Scanner (System. in); int bonus; if (keyboard. Scanner. has. Next. Int()) bonus = keyboard. Scanner. next. Int(); else bonus = 0; The Scanner class also has methods to scan in and check for other primitive values, such as: next. Double(), next. Long(), has. Next. Double(), …

The next() method scans in the next token as a string of characters: Scanner keyboard. Scanner = new Scanner (System. in); String s = keyboard. Scanner. next(); Suppose the input from the keyboard is gentle Then the variable s will contain a reference to the string “gentle”.

The next() method can help with the scanning of dirty data. Assume the keyboard input is supposed to consist of positive int values, ending with a value of -1 (called a sentinel); final int SENTINEL = -1; Scanner keyboard. Scanner = new Scanner (System. in); int sum = 0, score; while (true) if (keyboard. Scanner. has. Next. Int()) { score = keyboard. Scanner. next. Int(); if (score == SENTINEL) break; // terminate execution of loop sum += score; } // if has. Next. Int else keyboard. Scanner. next(); System. out. println (sum);

Suppose the input entered from the keyboard is 90 100 50 7 z 80 5 o -1

The preceding loop would be executed seven times, but the erroneous values 7 z and 5 o would be skipped over. The output would be 320 If the else part of the preceding if statement were omitted, an infinite loop would occur because 7 z would fail the has. Next. Int() condition. If the entire body of the loop were replaced with score = keyboard. Scanner. next. Int(); if (score == SENTINEL) break; // terminate execution of loop sum += score; Then an error (technically, an exception, as defined in Chapter 2) would occur at run time because 7 z is not an int value.

Sometimes the remainder of an input line should be skipped over if an incorrect value is discovered during scanning. For example, it might be that each input line is supposed to contain a name, grade point average (gpa), class year and age, with “***” as the sentinel. If the grade point average is not a double value (or the class year or age is not an int value), the rest of the line should be skipped. final String SENTINEL = “***”; Scanner keyboard. Scanner = new Scanner (System. in); String name; double gpa; int class. Year, age;

while (true) { name = keyboard. Scanner. next(); if (name. equals (SENTINEL)) break; if (!keyboard. Scanner. has. Next. Double()) { keyboard. Scanner. next. Line(); continue; // start another iteration of the loop } // if next token is not a double gpa = keyboard. Scanner. next. Double();

if (!keyboard. Scanner. has. Next. Int()) { keyboard. Scanner. next. Line(); continue; // start another iteration of loop } // if next token is not an int class. Year = keyboard. Scanner. next. Int(); if (!keyboard. Scanner. has. Next. Int()) { keyboard. Scanner. next. Line(); continue; // start another iteration of loop } // if next token is not an int age = keyboard. Scanner. next. Int(); // process name, gpa, class. Year and age … } // end while

For scanning over a file, the constructor is different from keyboard scanning, but the “has. Next(), has. Next. Int(), next. Double(), …” methods are still available. For example, Scanner file. Scanner = new Scanner (new File (“data”)); if (file. Scanner. has. Next. Double()) double gpa = file. Scanner. next. Double(); else file. Scanner. next();

Sentinels are not used in file scanning because it is too easy to forget to append the sentinel to the end of the file. (With keyboard input, a scan loop will continue until the sentinel is entered. ) So a typical scanning loop with file. Scanner will start with while (file. Scanner. has. Next()) or while (file. Scanner. has. Next. Line()) or while (file. Scanner. has. Next. Int()) or …

Scanning over a line is fairly straightforward. For example, suppose we want to add up the int values in a line, and skip over the non-int values. Scanner line. Scanner = new Scanner (“ 70 o 2 50”); int sum = 0; while (line. Scanner. has. Next()) if (line. Scanner. has. Next. Int()) sum += line. Scanner. next. Int(); else line. Scanner. next(); // skip non-int System. out. println (sum); ANS: 120

Often a program needs all three kinds of Scanner object: a 1) keyboard scanner to get the name of a file, a 2) file scanner to access each line in that file, and a 3) line scanner to access the tokens in a line. You can specify the delimiters for your scanner with the use. Delimiter method. For example, if you want the tokens in a string line to be upper- or lower-case letters, any other character will be a delimiter: Scanner sc = new Scanner (line). use. Delimiter ("[^a-z. A-Z]+"); In the argument of the above call to the use. Delimiter method, the ‘+’ can be read as “one or more occurrences” and ‘^’ means “except”. So a delimiter is one or more occurrences of any character except a letter.

Exercise: Create a keyboard scanner in which the tokens are unsigned integers, and write the code to determine the sum of the integers. Note: -5 will be scanned as the unsigned integer 5, and the minus sign will be skipped over as a delimiter.

Arrays

An array is a collection of elements, of the same type, that can be stored one after the other in memory. For example, we can create an array object of 10 double values as follows: double[ ] weights = new double[10]; This array of double values is automatically initialized to 0. 0 by the Java Virtual Machine. The values are stored at indexed locations, starting at index 0, and weights is a reference to the element at index 0.

We can fill up the array: for (int j = 0; j < 10; j++) weights[j] = j; The int values of j are converted to double values, so we have weights[0] = 0. 0, weights[1] = 1. 0, weights[2] = 2. 0, …, weights[9] = 9. 0. The length field in an array object holds the capacity of the array, that is, the number of indexes. So System. out. println (weights. length) would print out 10, but because array indexes start at 0, weights[10] is illegal.

The capacity of an array object can be set explicitly at run time: Scanner sc = new Scanner (System. in); int n = sc. next. Int(); double[ ] weights = new double[n]; Or implicitly: double [ ] weights = {107. 3, 112. 1, 114. 4, 119. 0, 117. 4}; The value stored in the length field is 5.

Arguments and Parameters

When a method is called, the arguments are the expressions (separated by commas) inside the parentheses following the method identifier. In the declaration of a method, the parameters are the variables (each preceded by its type, and separated by commas) inside the parentheses following the method identifier.

The relationship between an argument and its corresponding parameter is, at least apparently, simple: A copy of the value of the argument is stored in the parameter. For example, suppose we have: public void run( ) { int last = 20; System. out. println (sum. Up (last)); } // end of run()

public static int sum. Up (int n) { int sum = 0; for (int i = 1; i < n; i++) sum += i; // same as sum = sum + i; return sum; } // end sum. Up() When the call to sum. Up is made in the run method, a copy of the argument’s value, 20, is stored in the parameter n, the sum. Up method is executed, and 190 is returned and printed in the run method.

Because a copy of the argument is stored in the parameter, the argument itself is unaffected by the call. For example, here is a method that swaps the values of its two parameters: public static void swap (int a, int b) { int temp = a; a = b; b = temp; } // end of swap()

Here is a call to the swap method: int a = 15, b = 6; swap (a, b); System. out. println (a + “ “ + b); What will the output be?

The output will be 15 6 Because the value of the arguments a and b are unchanged by the call to the method swap. The values of the parameters a and b are swapped, but that has no effect on the arguments. On the other hand, If the argument is a reference, the argument will be unchanged by a method call, but the object referenced may be changed. For example,

public void swap (double[ ] a, int i, int j) { double temp = a[i]; a[i] = a[j]; a[j] = temp; } // end of swap() What will the output be from the following call: double [ ] x = {5. 0, 8. 0, 12. 2, 20. 0}; swap (x, 1, 2); System. out. println (x [1] + “ " + x [2]);

The argument x is unchanged (and, certainly, the constants 1 and 2 are unchanged), but the array object referenced by x is changed, and the output is 12. 2 8. 0