If your answer was E. 1234 , then you are correct.
Eligibility for inclusion in a TreeSet
The TreeSet class implements the SortedSet interface.
In an earlier module, I told you that in order to be eligible for inclusion in a TreeSet collection, an object must be instantiated from a class that implements the Comparable interface.
At that time, I also told you that it is possible to instantiate a new TreeSet object using a constructor that receives an incoming reference to a Comparator object, in which case it is not necessary for the objects in the collection to implement the Comparable interface.
Using a Comparator object
The program in Listing 1 takes this latter approach. The main purpose of this program is to illustrate the use of a Comparator object as an alternative to implementation of the Comparable interface.
Passing Comparator to TreeSet constructor
The code fragment in Listing 2 shows the instantiation of a new TreeSet object, passing an anonymous object of type TheComparator as a parameter to the constructor for TreeSet . Shortly, we will see that the class named TheComparator implements the Comparator interface. Therefore, an object instantiated from that class is a Comparator object.
| Listing 2 . Passing Comparator to TreeSet constructor. |
|---|
Collection ref;
ref = new TreeSet(new TheComparator());Populator.fillIt(ref); |
Passing the TreeSet to a Populator method
The code fragment in Listing 2 also shows the reference to the TreeSet object being stored in a reference variable of the interface type Collection . The reference to the TreeSet object is passed as type Collection to a method named fillIt .
The purpose of the fillIt method is to instantiate some objects of type MyClass , and to store those object references in the TreeSet collection.
The fillIt method
The code fragment in Listing 3 shows the entire method named fillIt . This method instantiates five objects from the class named MyClass and adds those object's references to the TreeSet collection.
| Listing 3 . The fillIt method. |
|---|
class Populator{
public static void fillIt(Collection ref){ref.add(new MyClass(4));
ref.add(new MyClass(4));ref.add(new MyClass(3));
ref.add(new MyClass(2));ref.add(new MyClass(1));
}//end fillIt()}//end class Populator |
Similar to previous program
This is essentially the same code that we saw in a sample program in a previous module. In that module, we saw that it was necessary for theclass named MyClass to implement the Comparable interface. Otherwise, the add method would throw a runtime exception.
MyClass does not implement Comparable
In that program, however, the TreeSet object was instantiated without benefit of a Comparator object.
As you can see in the code fragment in Listing 4 , the class named MyClass in this programdoes not implement the Comparable interface.
Comparator eliminates requirement for Comparable
Furthermore, the add method in Listing 3 does not throw a runtime exception. That is because the TreeSet object was instantiated with the benefit of a Comparator object.
The use of a Comparator object in the instantiation of the TreeSet object eliminates the requirement for objects stored in the TreeSet collection to implement the Comparable interface.