Collections in Java

1. Collections in Java

2. Kinds of Collections • Collection--a group of objects, called elements • Set--An unordered collection with no duplicates • SortedSet--An ordered collection with no duplicates • List--an ordered collection, duplicates are allowed • Map--a collection that maps keys to values • SortedMap--a collection ordered by the keys • Note that there are two distinct hierarchies

3. Using Collections • import java.util.*or import java.util.Collection; • There is a sister class, java.util.Collections; that provides a number of algorithms for use with collections: sort, binarySearch, copy, shuffle, reverse, max, min, etc.

4. Collections are interfaces • Collection is actually an interface • Each kind of Collection has one or more implementations • You can create new kinds of Collections • When you implement an interface, you promise to supply the required methods • Some Collection methods are optional

5. Creating a Collection • All Collection implementations should have two constructors: • A no-argument constructor to create an empty collection • A constructor with another Collection as argument • Cannot be enforced, because an Interface cannot specify constructors

6. Collection: Basic operations • int size( ); • boolean isEmpty( ); • boolean contains(Object element); • boolean add(Object element); // Optional • boolean remove(Object element); // Optional • Iterator iterator( );

7. Collection: Iterator public interface Iterator { • boolean hasNext( ); • // true if there is another element • Object next( ); • // returns the next element (advances the iterator) void remove( ); // Optional// removes the element returned by next}

8. Using an Iterator • static void printAll (Collection c) { Iterator i = c.iterator( ); while (i.hasNext( )) { System.out.println ( i.next( ) ); } } • Note that this code is polymorphic--it will work for any collection

9. Iterator vs. Enumeration • Iterators are better than the old Enumerations • It is safe to remove objects with an Iterator • The names have been improved: • Enumeration IteratorhasMoreElements( ) hasNext( )nextElement( ) next( )can’t remove remove( )

10. Collection: Bulk operations • boolean containsAll(Collection c); • boolean addAll(Collection c); // Optional • boolean removeAll(Collection c); // Optional • boolean retainAll(Collection c); // Optional • void clear( ); // Optional • addAll, removeAll, retainAll return true if the object receiving the message was modified

11. Mixing Collection types • Note that most methods, such as boolean containsAll(Collection c); are defined for any type of Collection, and take any type of Collection as an argument. • This makes it very easy to work with different types of Collections.

12. singleton • Collections.singleton(e) returns an immutable set containing only the element e • c.removeAll(Collections.singleton(e)); will remove all occurrences of e from the Collection c

13. Collection: Array operations • Object[ ] toArray( ); • creates a new array of Object • Object[ ] toArray(Object a[ ]); • Allows the caller to provide the array • Examples: • Object[ ] a = c.toArray( ); • String[ ] a;a = (String[ ]) c.toArray(new String[0]);

14. The Set interface • A Set is unordered and has no duplicates • Operations are exactly those for Collections int size( ); boolean isEmpty( ); boolean contains(Object e); boolean add(Object e); boolean remove(Object e); Iterator iterator( ); boolean containsAll(Collection c); boolean addAll(Collection c); boolean removeAll(Collection c); boolean retainAll(Collection c); void clear( ); Object[ ] toArray( ); Object[ ] toArray(Object a[ ]);

15. Set implementations • Set is an interface; you can’t say new Set ( ) • There are two implementations: • HashSet is best for most purposes • TreeSet guarantees the order of iteration • It’s poor style to expose the implementation, so: • Good: Set s = new HashSet( );Bad: HashSet s = new HashSet( );

16. Typical set operations • Testing if s2 is a subset of s1 s1.containsAll(s2) • Setting s1 to the union of s1 and s2 s1.addAll(s2) • Setting s1 to the intersection of s1 and s2 s1.retainAll(s2) • Setting s1 to the set difference of s1 and s2 s1.removeAll(s2)

17. Set equality • Object.equals(Object), inherited by all objects, really is an identity comparison • Implementations of Set override equals so that sets are equal if they contain the same elements • equals even works if two sets have different implementations • hashCode has been extended similarly

18. Set tips • add and remove return true if they modify the set • Here's a trick to remove duplicates from a Collection c: • Collection noDups = new HashSet(c); • A Set may not contain itself an an element • Danger: undefined behavior if you change an element to be equal to another element

19. The SortedSet interface • A SortedSet is just like a Set, except that an Iterator will go through it in a guaranteed order • Implemented by TreeSet

20. The List interface • A List is ordered and may have duplicates • Operations are exactly those for Collections int size( ); boolean isEmpty( ); boolean contains(Object e); boolean add(Object e); boolean remove(Object e); Iterator iterator( ); boolean containsAll(Collection c); boolean addAll(Collection c); boolean removeAll(Collection c); boolean retainAll(Collection c); void clear( ); Object[ ] toArray( ); Object[ ] toArray(Object a[ ]);

21. List implementations • List is an interface; you can’t say new List ( ) • There are two implementations: • LinkedList gives faster insertions and deletions • ArrayList gives faster random access • It’s poor style to expose the implementation, so: • Good: List list = new LinkedList ( );Bad: LinkedList list = new LinkedList ( );

22. Inherited List methods • list.remove(e) removes the first e • add and addAll add to the end of the list • To append one list to another: • list1.addAll(list2); • To append two lists into a new list: • List list3 = new ArrayList(list1);list3.addAll(list2); • Again, it's good style to hide the implementation

23. List: Positional access • Object get(int index); // Required -- // the rest are optional • Object set(int index, Object element); • void add(int index, Object element); • Object remove(int index); • abstract boolean addAll(int index, Collection c); • These operations are more efficient with the ArrayList implementation

24. List: Searching • int indexOf(Object o); • int lastIndexOf(Object o); • equals and hashCode work even if implementations are different

25. List: Iteration • ListIterator listIterator( ); • ListIterator listIterator(int index); • starts at the position indicated (0 is first element) • Inherited methods: • boolean hasNext( ); • Object next( ); • void remove( );

26. List: Iterating backwards • boolean hasPrevious( ); • Object previous( ); • int nextIndex( ); • int previousIndex( ); • Think of the iterator as “between” elements • Hence, next followed by previous gives you the same element each time

27. List: More operations • void add(Object o); • Inserts an object at the cursor position • Object set(Object o); // Optional • Replace the current element; return the old one • Object remove(int index); // Optional • Remove and return the element at that position

28. List: Range-view • List subList(int from, int to); allows you to manipulate part of a list • A sublist may be used just like any other list

29. The Map interface • A Map is an object that maps keys to values • A map cannot contain duplicate keys • Each key can map to at most one value • Examples: dictionary, phone book, etc.

30. Map implementations • Map is an interface; you can’t say new Map ( ) • Here are two implementations: • HashMap is the faster • TreeMap guarantees the order of iteration • It’s poor style to expose the implementation, so: • Good: Map map = new HashMap ( );Bad: HashMap map = new HashMap ( );

31. Map: Basic operations • Object put(Object key, Object value); • Object get(Object key); • Object remove(Object key); • boolean containsKey(Object key); • boolean containsValue(Object value); • int size( ); • boolean isEmpty( );

32. Map: Bulk operations • void putAll(Map t); • copies one Map into another • void clear();

33. Map: Collection views • public Set keySet( ); • public Collection values( ); • public Set entrySet( ); • returns a set of Map.Entry (key-value) pairs • The above views provide the only way to iterate over a Map

34. Map.Entry: Interface for entrySet elements • public interface Entry { Object getKey( ); Object getValue( ); Object setValue(Object value);} • This is a small interface for working with the Collection returned by entrySet( ) • Can get elements only from the Iterator, and they are only valid during the iteration

35. The End http://java.sun.com/docs/books/tutorial/collections/interfaces/list.html