| << Chapter < Page | Chapter >> Page > |
The method named fillIt receives an incoming reference to a collection object as type Collection . The method calls the add method on the incoming reference five times in succession to add five elementsto the collection. These elements are added without regard for the actual type or underlying implementation of the collection. (As written, the fillIt method has no way of knowing the underlying implementation.)
| Listing 2 . The Populator class. |
|---|
class Populator{
public static void fillIt(Collection ref){ref.add(new Integer(4));
ref.add(new Integer(4));ref.add(new Integer(3));
ref.add(new Integer(2));ref.add(new Integer(1));
}//end fillIt()}//end class populator |
The fillIt method will be used to populate two collections of different types with the same data values in the same order.
Consider the code fragment shown in Listing 3 .
| Listing 3 . Create and populate a TreeSet object. |
|---|
Collection ref = new TreeSet();
Populator.fillIt(ref);Iterator iter = ref.iterator();
while(iter.hasNext()){System.out.print(iter.next());
}//end while loop |
The code in Listing 3 instantiates an object of type TreeSet , and passes that object's reference to the fillIt method as type Collection . As described above, the fillIt method adds five elements to the collection, in random order with two of the elements beingduplicates.
"Note that this program does not use the syntax for Generics. Therefore, if you copy and compile this program, you will probably see a warningregarding unchecked or unsafe operations"
Then the code in Listing 3 gets an Iterator object on the collection and uses the iterator to display the contents of the collection.
The TreeSet class implements one of the core collection interfaces named SortedSet . SortedSet extends (is a child of) Set . One of the characteristics of a Set object is that it doesn't allow duplicate elements. One of the characteristics of a SortedSet object is that, by default, it maintains its elements in ascending natural order. Since the TreeSet class implements both of these interfaces, it is both a Set and a SortedSet , and exhibits the characteristics of both interfaces.
Because the underlying structure of the TreeSet class doesn't allow duplicates, and the underlying structure maintains its elements in ascendingorder, the code in Listing 3 produces the following text on the screen:
1234
Now consider the code fragment shown in Listing 4 .
| Listing 4 . Create and populate an ArrayList object. |
|---|
ref = new ArrayList();
Populator.fillIt(ref);iter = ref.iterator();while(iter.hasNext()){
System.out.print(iter.next());}//end while loop |
The code in Listing 4 instantiates a new collection of type ArrayList , and passes that object's reference to the same fillIt method, once again as type Collection .
The code in the fillIt method adds five elements having the same values as before to the collection and adds them in the same order as before. The added elements are references to Integer objects encapsulating the same values as were earlier added to the TreeSet collection. Although they are physically different objects, the result is that essentially the same data is added to bothcollections.
Notification Switch
Would you like to follow the 'Object-oriented programming (oop) with java' conversation and receive update notifications?
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|