Java Collection Framework

Transcription

1 Java Collection Framework Readings Purpose To provide a working knowledge of the Java Collections framework and iterators. Learning Objectives Understand the structure of the Java Collections framework 1 Where are we? We have examined the use of one collection class: ArrayList, and observed that we sometimes need other classes that support very similar operations (with some differences). We will now raise the level of abstraction and use a hierarchy of interfaces to abstract the common behaviours that are shared by these classes. This hierarchy is declared in the Java collections framework. The framework also contains concrete (non-abstract) classes, like ArrayList, that implement these interfaces. We will discuss them in the following section. 2

2 Java Collection Framework Java provides the Collection Framework in the java.util package. The interfaces and classes in this package provide efficient, highly-optimized implementations of common data structures (e.g. ArrayList) standardized interfaces with multiple implementations of most data structures (e.g. List) interoperability between programs by making it easier to exchange collections 3 Aside on Data Structures A data type is a collection of values and operations on these values Simple (or primitive) data type: values are atomic cannot decomposed further at the language level e.g., int, double, etc. Composite data type or data structure: a collection of elements e.g., an array, a list, etc. 4

3 Java Collection Framework Consists of 3 components: Interfaces provide specifications for the behaviour of the collections form inheritance hierarchies Implementations provide specific structures that store the elements and relevant operations on those structures each interface may have multiple implementations that differ only by which optional operations they implement and by the efficiency of the operations Algorithms polymorphic algorithms that manipulate data stored in collections are not members of any collection 5 Extracting interfaces Let us reflect on the behaviours of the ArrayList class we discussed. Some of the methods perform tasks that can be used on any collection of objects: adding elements (accts.add(myaccount)) determining if an element belongs to the collection (accts.contains(heraccount)) removing an element (accts.remove(yraccount)) finding out the size of the collection (accts.size()) going through the elements of the collection using an iterator 6

4 Extracting interfaces However, since the elements in an ArrayList are associated with a corresponding position, some behaviours are unique to the ArrayList class: adding an element in the middle (accts.add(i, acct)) finding the position of an element (accts.indexof(x)) removing elements by position (accts.remove(i)) Observations such as these allow us to define hierarchies of interfaces that specify the behaviours that will ultimately be supported by implementing classes. 7 Collection Interfaces 8

5 Iterable Objects The Iterable interface is defined in java.lang as: public interface Iterable<T> { /** * Returns an iterator over a set of * elements of type T. */ Iterator<T> iterator(); } Each iterable object can return an Iterator: order depends on the type of the collection This is another example of a generic type. The type T is a placeholder for a type that will be specified when we declare a reference of type Iterable. 9 The Iterator Interface Is defined in java.util public interface Iterator<E> { } boolean hasnext(); E next(); void remove(); // Optional next()returns the next object in the collection and advances the iterator to the next object remove() removes the object that was returned by the last next() operation can be called only once per call to next() otherwise IllegalStateException thrown. 10

6 The Iterator Interface (cont'd) Some notes on the optional remove() method: Methods in an interface that are documented to be optional: provide flexibility allow for a reduction in the number of interfaces needed must be implemented by classes that implement the interface although those implementations may do nothing more than throw an UnsupportedOperationException. 11 The Collection Interface public interface Collection<E> extends Iterable<E> { int size(); boolean isempty(); boolean contains(object o); boolean add(e o); // Optional boolean remove(object o); // Optional Iterator<E> iterator(); // Bulk Operations boolean containsall(collection<?> c);... more... // Array Operations Object[] toarray(); <T> T[] toarray(t[] a); // Object operations; allow collections to customize boolean equals(object o); int hashcode(); } 12

7 The Collection Interface (cont d) Provides a general set of methods applicable to all collections Used as a base for more specific sub-interfaces (e.g. List and Set) Note: the contains() method uses equals() for comparison. For each application we must decide whether we want strong equality or weak equality. 13 Common Algorithms: the Collections Class The Collections class contains static, polymorphic methods that operate on collections: void shuffle(<list<?> list, Random rnd) shuffles the elements of list in random order void Collections.reverse(List<?> list) reverses the elements in list int Collections.frequency(Collection<?> c,object o) returns the number of times the element o occurs in the collection c 14

8 The sort() method <T extends Comparable<? super T>> void Collections.sort(List<T> list) sorts the element of list in increasing order This method declaration requires a little explanation. The method takes o a List of elements of type T where o T implements the Comparable interface, where o the compareto() method may have been defined either in T, or in one of its superclasses). 15 Java 1.5: For loop Syntax Java 1.5 provides a special type of for loop we can use with ArrayLists and other collections Example: public void sendadd( { } Collection<? extends Account> targets) for(account a: targetaccounts) { } System.out.println(a.getOwnersName()); Warning: do NOT call remove() from within this loop! 16

9 Exercises 1. Write a public static function that accepts a argument a collection of type Collection<String> and removes all objects in collection c that satisfy the test: boolean test(string) 2. Write a generic public static function that removes duplicates from a collection. 17