Collection, Iterable, and Iterator Interfaces
•
•
•
•
The Collection Interface and its Hierarchy
The Iterable and Iterator Interfaces
For-each Loops with Iterable Collections
Reading: L&C 3rd: 15.1-15.2 2nd:3.2
1
Collections
• A collection is a typical example of Abstract
Data Type.
• A collection is a data type that contains and
allows access to a group of objects.
• The Collection ADT is the most general form of
ADTs designed for containing/accessing a
group of objects.
• We have more specific forms of Collection
ADTs which describe the access “strategy” that
2
models that collection:
The Java Collections API
• The classes and interfaces in the Java
Collections Library are named to indicate
the underlying data structure and the
abstract Data type.
• For example, the ArrayList we studied in
CS110 uses an underlying array as the data
structure for storing its objects and
implements its access model as a list
• However, from the user’s code point of view,
3
the data structure is hidden by the
API.
The Collection Interface
• Any class that implements the Collection
interface can contain/access a group of objects
• The type of objects that a Collection class
contains can be specified using generics <T>
• ArrayList class implements Collection
• Hence, polymorphism allows us to do these:
ArrayList<String> a = new ArrayList<String>();
Collection<String> c = a; // widening
ArrayList<String> d = (ArrayList<String>) c;
4
Collection Interface Methods
boolean add(T o)
addAll(Collection c)
void clear()
boolean contains(T o)
boolean containsAll(Collection c)
boolean equals(Object o)
int hashCode()
boolean isEmpty()
5
Collection Interface Methods
Iterator iterator()
boolean remove(T o)
boolean removeAll(Collection c)
boolean retainAll(Collection c)
int size()
Object [] toArray()
<T> T[] toArray(T[] a)
6
The Collection Interface Hierarchy
• Typically, the Collection interface is not
implemented directly by a class
• There is a hierarchy of interfaces that
extend the Collection interface
• Each subclass of the Collection interface
is designed to support a specific model for
access to the contents of the collection
– List, Set, Stack, Queue, etc.
7
Java Collection Hierarchy
Collection
AbstractCollection
TreeSet
Abstract Class
Interface
Class
Set
List
AbstractSet
AbstractList
HashSet
ArrayList
List Methods
•
boolean add(T elem)
void add(int index, T elem)
boolean addAll(int index, Collection c)
T get(int index)
T remove(int index)
T set(int index, T element)
int indexOf(Object o)
int lastIndexOf(Object o)
• Indexing is NOT a feature of all collections
• It is a feature of the List ADT
9
ArrayList methods
• ArrayList is a class that implements the
methods of the List interface. Therefore, all
the these methods can be called on an
ArrayList object. Ex:
ArrayList<String> list = new ArrayList();
list.add(“ABC”);
list.add(“EFG”);
System.out.println(list.get(1));
System.out.println(list.indexOf(“ABC”));
System.out.println(list.indexOf(“HJK”));
ArrayList methods
• ArrayList is an actual class that
implements the methods of the List
interface. Therefore, all the these methods
can be called on an ArrayList object. Ex:
ArrayList<String> list = new ArrayList();
list.add(“ABC”);
list.add(“EFG”);
System.out.println(list.get(1));
System.out.println(list.indexOf(“ABC”));
System.out.println(list.indexOf(“HJK”));
The Collection Interface Hierarchy
<<interface>>
Iterable
<<interface>>
Collection
<<interface>>
List
<<interface>>
Set
<<interface>>
SortedSet
<<interface>>
Queue
12
Iterating over a Collection
• Many times, we need to write code that
retrieves all the elements of a collection one
at a time in order to process them.
• We call this iterating over the collection.
• Java library has a way to conveniently
accomplish the process of accessing (visiting
or retrieving) each element of a collection
once.
• The core of this approach is based on two
13
interfaces:
Iterator<T>
• An iterator over a collection allows
programs to conveniently access each
element of a collection once and only once
without having to keep track of anything
related to the process of iteration (visiting
of each element) [an example of use of
encapsulation].
• Methods of Iterator<T> interface:
– boolean hasNext()
– T next()
Iterator Interface
• We don't create an object of type iterator
by itself, but we ask the collection object to
return us one:
ArrayList<Book> shelf = new ArrayList<Book>();
…
Iterator<Book> iter = shelf.iterator();
while(iter.hasNext()){
Book book = iter.next();
System.out.println(book.toString());
} (use simple for loop)
Iterable<T> Interface
• An object of type Iterable allows you obtain an
Iterator object to retrieve its elements. It has
only one method:
Iterator<T> iterator() returns an Iterator
object to access to the elements of this Iterable
group of objects.
• Collection interface extends the Iterable
interface:
Collection<T> extends
Iterable<T>
(which is another
16
Iterable Objects and Iterators
• Classes in the Java standard class library
that implement the Collection interface are
Iterable OR you can implement Iterable in
a class that you define.
• If bookList is an object of an Iterable
class that contains Book objects, we can
retrieve all the available Book objects in
either of two ways:
17
Iterable Objects and Loops
• We can obtain an Iterator object from an
Iterable object and use it to retrieve all the
items from the Iterable object indirectly:
Iterator itr = bookList.iterator();
while (itr.hasNext())
System.out.println (itr.next());
• The Java 5.0 for-each loop simplifies the
repetitive processing of the items available
from an Iterable object
for (Book myBook : bookList)
System.out.println (myBook);
18
Iterators and Loops
• If bookList is an object of an Iterator
class that contains Book objects, you can
access all the available objects directly:
while (bookList.hasNext())
System.out.println (bookList.next());
• You can not use a “for-each” loop on an
object of a class that only implements
Iterator() method but does not implement
Iterable.
19