| << Chapter < Page | Chapter >> Page > |
The String class implements the Comparable interface. Therefore, objects instantiated from the String class have a natural ordering when placed in a collection.
Because the compareTo method of the String class, (which implements the Comparable interface) considers upper-case and lower-case characters to be different, there were no duplicate elements added to thecollection when only the compareTo method was used to compare elements. The six String objects were simply arranged so that the iterator would return references to those objects in sorted order. This produced the output shownbelow:
BILL Bill JOE Joe TOM Tom
The code shown in Listing 4 was used to instantiate a new TreeSet object. A Comparator object's reference was passed to the TreeSet constructor. The Comparator object (instead of the compareTo method) was subsequently used for comparing and controlling the sorting order of the elements in the TreeSet collection.
| Listing 4 . A TreeSet with a Comparator. |
|---|
ref = new TreeSet(new TheComparator());Populator.fillIt(ref);iter = ref.iterator();
while(iter.hasNext()){System.out.print(iter.next() + " ");
}//end while loop |
The code in Listing 4 was also used to populate the collection, and to display the contents of the collection after it was populated.
As before, the fillIt method shown in Listing 5 was used to populate the collection. The same six names as before were added to the TreeSet collection. However, the result of adding those six names was determined by the behavior of the compare method in the Comparator object used by the TreeSet object for managing the collection. (Three of the names were rejected as duplicates.)
| Listing 5 . Populating the TreeSet collection. |
|---|
public static void fillIt(Collection ref){
ref.add("Joe");ref.add("Bill");
ref.add("Tom");ref.add("JOE");
ref.add("BILL");ref.add("TOM");
}//end fillIt() |
The code in Listing 6 shows the beginning of the class from which the Comparator object was instantiated. Note that this class implements the Comparator interface, and therefore defines a concrete version of the method named compare .
| Listing 6 . Beginning of the Comparator class. |
|---|
class TheComparator
implements Comparator,Serializable{public int compare(Object o1,Object o2){
if(!(o1 instanceof String))throw new ClassCastException();
if(!(o2 instanceof String))throw new ClassCastException(); |
Listing 6 doesn't contain the interesting part of this class. The code in Listing 6 simply throws an exception if the compare method receives any incoming parameters of types other than String .
The interesting code in the method named compare is shown in Listing 7 .
| Listing 7 . The interesting code in the compare method. |
|---|
int result =
((String)o1).toUpperCase().compareTo(((String)o2).
toUpperCase());return result;
}//end compare() |
The code in Listing 7 makes use of two methods of the String class to compare the two incoming objects.
Notification Switch
Would you like to follow the 'Object-oriented programming (oop) with java' conversation and receive update notifications?
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|