6.170 Recitation 2

Using Collections and Module Dependency Diagrams

The goal for this recitation is to introduce the collection classes in java.util, especially HashMap, and to explore Module Depency Diagrams.

The activities this week concern the code provided. This is a little information system that keeps track of the user's appointments, and allows the user to find out what has been planned for a given "slot" (regarded as a one-hour period, which is the unit for making appointments in this system). Diary.java uses a Vector, to store the collection of appointments.

The methods of Diary use a private method findIndex, which traverses the vector of appointments looking for one that deals with a particular slot (given as an argument). Each appointment is tested using the check method of Appointment, which itself calls the equals method of TimeDate, which is redefined to provide value equality. Suppose the programmer changed check so it tests for reference equality of TimeDate objects. That is check would be
```
    public boolean check(TimeDate when) {
        return (slot==when);
    }
```
What would this do to the behavior of the whole system?
Notice that in TimeDate, the hashCode method has been redefined, even though it is never called in the system. This is because the semantics of the superclass Object require two important properties of the equals method in every class.
- whenever x==y, x.equals(y) returns true
- whenever x.equals(y), x.hashCode()==y.hashCode()
Show that the TimeDate class satisfies these properties.
The Diary class uses a Vector to store the collection of appointments, and all methods of Diary except the constructor call findIndex which traverses the vector. Thus the runtime cost for methods of Diary will grow linearly as the system holds more appointments. This cost can be avoided by using a different collection class to hold the set of appointments. Rewrite the Diary class to keep appointments in a java.util.HashMap object, which keeps a collection of "keys" each associated with a "value". For the diary, use the TimeDate slot as the key, and the Appointment as the associated value. In all methods of HashMap, when we talk about a particular key, the collection uses the equals method of the key objects to determine the key involved. The most important methods are given next. These almost always run in constant time, no matter how large the collection is.
- To associate a key to a value, replacing any previous association for this key (and returning the previously associated value, or returning null if there was no previously associatiated value).
```
Object put(Object key, Object value)
```
- To remove the key and its associated value from the collection (returning the previously associated value, or null if no value was previously associated to this key)
```
Object remove(Object key)
```
- To return the value associated to a key, or null if no value is associated to the key
```
Object get(Object key)
```
- To determine whether there is a value associated to a key
```
boolean containsKey(Object key)
```
- To return the number of keys with which values are associated
```
int size()
```
By the way, there is also a similar class called Hashtable that carried over from Java1.0
Draw the MDD for the diary system.
Discuss how one could modify the design of the diary system, to reduce the MDD to a single line, such as
```
DiaryUI --> Diary --> Appointment --> TimeDate
```
Compare your new design with the original design for simplicity, ease of extension, etc.
The Diary class is designed to maintain an "invariant": the appointments should all be for different slots. Suppose we allow Appointment to be mutable (rather than immutable as in the code given) and we extend Appointment with a method to change the slot of an Appointment object. Would this allow outside code to violate the invariant in Diary?
Discuss how to modify the whole system so that it can work for multiple users, and keep track of the appointments for each user separately.
In the Java1.2 collection library, HashMap is one implementation of the Map interface. What would be needed to change the code you wrote so it uses some other implementation of Map to store the association between keys and values.