> ### Sample Quiz Answers
> For Chapter 12

> THIS PAGE CONTAINS SAMPLE ANSWERS to the Quiz on Chapter 12 of this on-line Java textbook. Note that in many cases, there are lots of correct answers to a given question.

> Question 1: What is meant by generic programming and what is the alternative?

> Answer: Generic programming means writing data structures and subroutines that can be used for many different types of data. The alternative would be to write a new data structure or subroutine for each different type of data, even when they would all be essentially identical except for the type name. For example, a single generic sort routine could be used for sorting arrays that contain data of any type. The alternative is one routine for sorting arrays of integers, one for sorting arrays of strings, one for storing arrays of real numbers, and so on.

> Question 2: Java does not support generic programming with the primitive types. Why not? What is it about generic programming in Java that prevents it from working with primitive types such as `int` and `double`.

> Answer: In Java, generic programming means working with values of type `Object`. Since every class is a subclass of `Object`, a data structure that holds `Objects` can hold objects belonging to any class, and a subroutine that has a parameter of type `Object` can be applied to an object belonging to any class. Such data structures and subroutines are generic -- but only for objects. However, in Java, values belonging to the primitive types are not objects. So, you can't use `ints` or `doubles` in places where objects are required. This means you can't use them with generic data structures and subroutines.

> Question 3: What is an iterator and why are iterators necessary for generic programming?

> Answer: One of the principle features of Java's generic programming framework is Collections. There are several types of collection (including LinkedLists, ArrayList, TreeSet, and HashSet). In order to deal with all the different types of collection in a generic way, we need a generic way to access all the elements in a collection. An iterator makes this possible. An iterator is an object associated with a collection that makes it possible to traverse the collection (that is, to visit each of the items in the collection in turn). Code written using iterators will work for any type of Collection.

> Question 4: Suppose that `integers` is a variable of type `Collection` and that every object in the collection belongs to the wrapper class `Integer`. Write a code segment that will compute the sum of all the integer values in the collection.

> Answer: We need to use an Iterator to access all the items in the Collection. To get the integer value from an object of type `Integer`, we can call its `intValue()` method.

>              int sum = 0;  // This will be the sum of all the integers.

>              Iterator iter = integers.getIterator();

>              while ( iter.hasNext() ) {
>                 Object item = iter.next();   // Next item as an Object.
>                 Integer num = (Integer)item; // Type-cast item to an Integer.
>                 sum = sum + num.intValue();  // Add the number to the sum
>              }

> Question 5: Interfaces such as `List`, `Set`, and `Map` define abstract data types. Explain what this means.

> Answer: An abstract data type is defined by the operations that can be performed on it, not by the way the data is actually stored or by the way the operations are implemented. An interface such as `List` defines operations that can be performed, but says nothing about how they are to be implemented. In fact, there can be many different implementations. For example, both `LinkedList` and `ArrayList` implement the `List` interface. They are different "concrete" data types that represent the same abstract data type.

> Question 6: What is the fundamental property that distinguishes `Sets` from other types of `Collections`?

> Answer: A `Set` cannot contain repeated elements. (The `equals()` method is used to test whether two objects should be considered the same.)

> Question 7: What is the essential difference in functionality between a `TreeMap` and a `HashMap`?

> Answer: The key/value pairs in a `TreeMap` are sorted so that the keys are in ascending order. (For this reason, it must be possible to compare the keys in a `TreeMap`, either by using the `compareTo()` method or a `Comparator`.)

> Question 8: Explain what is meant by a hash code.

> Answer: The hash code of an object is an integer that tells where that object should be stored in a hash table. A hash table is an array of linked lists. When an object is stored in a hash table, it is added to one of these linked lists. The object's hash code is the index of the position in the array where the object is stored. All objects with the same hash code go into the same linked list.

> Question 9: Modify the following `Date` class so that it implements the `Comparable` interface. The ordering on objects of type `Date` should be the natural, chronological ordering.

>           class Date {
>              int month;  // Month number in range 1 to 12.
>              int day;    // Day number in range 1 to 31.
>              int year;   // Year number.
>              Date(int m, int d, int y) { // Convenience constructor.
>                 month = m;
>                 day = d;
>                 year = y;
>              }
>           }

> Answer: A `compareTo()` method must be added to the class, and the class must be declared to implement the `Comparable` interface. To compare two dates, first try comparing the years. If the years are equal, try comparing the months. If the months are also equal, compare the days.

>           class Date implements Comparable {
>              int month;  // Month number in range 1 to 12.
>              int day;    // Day number in range 1 to 31.
>              int year;   // Year number.
>              Date(int m, int d, int y) { // Convenience constructor.
>                 month = m;
>                 day = d;
>                 year = y;
>              }
>              public int compareTo( Object obj ) {
>                     // The parameter must be of type Date.  Otherwise,
>                     // a ClassCastException will be thrown.  The return
>                     // value is negative if this Date comes before otherDate,
>                     // it's zero if the two dates are the same, and
>                     // it's positive if this Date comes after otherDate.
>                 Date otherDate = (Date)obj;  // Try to type-cast the object
>                                              // into a Date.
>                 if (year < otherDate.year)
>                    return -1;
>                 else if (year > otherDate.year)
>                    return 1;
>                 else { // Years are equal; compare months.
>                    if (month < otherDate.month)
>                       return -1;
>                    else if (month > otherDate.month)
>                       return 1;
>                    else { // Years and months are equal; compare days.
>                       if (day < otherDate.day)
>                          return -1;
>                       else if (day > otherDate.day)
>                          return 1;
>                       else
>                          return 0;
>                    }
>                 }
>              }
>           }

> Question 10: Suppose that `syllabus` is a variable of type `TreeMap`, the keys in the map are objects belonging to the `Date` class from the previous problem, and the values are of type `String`. Write a code segment that will write out the value string for every key that is in the month of September, 2002.

> Answer: I will give two solutions. One of them simply looks up each date in September, 2002 in the map and prints the corresponding value, if there is one. The other iterates though a submap that contains all the entries for dates in that month.

>     A solution using the map's get() method:

>           for (int day = 1; day <=30; day++) {
>                // Get the info for one day in September, 2002;
>              Date date = new Date(9,day,2002); // The key.
>              Object info = syllabus.get(date); // Get the value for that key.
>                                                // (Can be null.)
>              if (info != null)
>                 System.out.println("September " + day + ": " + info);
>           }

>     A solution using a submap (harder, but more efficient):

>           Date startDate = new Date(9,1,2002);  // Starting date for submap.
>           Date endDate = new Date(10,1,2002);   // Ending date for submap.
>                                                 // (Remember that the end date
>                                                 // is not included.)
>           Map september = syllabus.subMap(startDate, endDate);
>           Iterator iter = september.entrySet().iterator();
>           while (iter.hasNext()) {
>              Map.Entry entry = (Map.Entry)iter.next();
>              Date date = (Date)entry.getKey(); // Get the date so I can print it.
>              String info = (String)entry.getValue();  // The value for that date.
>              System.out.println("September " + date.day ": " + info);
>           }

[ Chapter Index | Main Index ]