and Lists the Collection Interface
Chapter 4
Chapter Objectives
To become familiar with the List interface To understand how to write an array-based implementation of the List interface To study the difference between single-, double-, and circular linked list data structures To learn how to implement the List interface using a linked-list To understand the Iterator interface
Chapter 4: Lists and the Collection Interface
2
Chapter Objective (continued)
To learn how to implement the iterator for a linked list To become familiar with the Java Collection framework
Chapter 4: Lists and the Collection Interface
3
The List Interface and ArrayList Class
An array is an indexed structure: can select its elements in arbitrary order using a subscript value Elements may be accessed in sequence using a loop that increments the subscript You cannot Increase or decrease the length Add an element at a specified position without shifting the other elements to make room Remove an element at a specified position without shifting other elements to fill in the resulting gap
Chapter 4: Lists and the Collection Interface 4
The List Interface and ArrayList Class (continued)
Allowed operations on the List interface include: Finding a specified target Adding an element to either end Removing an item from either end Traversing the list structure without a subscript Not all classes perform the allowed operations with the same degree of efficiency An array provides the ability to store primitive-type data whereas the List classes all store references to Objects. Autoboxing facilitates this.
Chapter 4: Lists and the Collection Interface 5
The List Interface and ArrayList Class (continued)
Chapter 4: Lists and the Collection Interface
6
The ArrayList Class
Simplest class that implements the List interface Improvement over an array object Used when a programmer wants to add new elements to the end of a list but still needs the capability to access the elements stored in the list in arbitrary order
Chapter 4: Lists and the Collection Interface
7
The ArrayList Class (continued)
Chapter 4: Lists and the Collection Interface
8
Generic Collections
Language feature introduced in Java 5.0 called generic collections (or generics) Generics allow you to define a collection that contains references to objects of a specific type
List<String> myList = new ArrayList<String>();
specifies that myList is a List of String where String is a type parameter Only references to objects of type String can be stored in myList, and all items retrieved would be of type String. A type parameter is analogous to a method parameter.
Chapter 4: Lists and the Collection Interface 9
Creating a Generic Collection
Chapter 4: Lists and the Collection Interface
10
Specification of the ArrayList Class
Chapter 4: Lists and the Collection Interface
11
Application of ArrayList
The ArrayList gives you additional capability beyond what an array provides Combining Autoboxing with Generic Collections you can store and retrieve primitive data types when working with an ArrayList
Chapter 4: Lists and the Collection Interface
12
Implementation of an ArrayList Class
KWArrayList: simple implementation of a ArrayList class Physical size of array indicated by data field capacity Number of data items indicated by the data field size
Chapter 4: Lists and the Collection Interface
13
Implementation of an ArrayList Class (continued)
Chapter 4: Lists and the Collection Interface
14
Performance of KWArrayList and the Vector Class
Set and get methods execute in constant time Inserting or removing elements is linear time Initial release of Java API contained the Vector class which has similar functionality to the ArrayList Both contain the same methods New applications should use ArrayList rather than Vector Stack is a subclass of Vector
Chapter 4: Lists and the Collection Interface
15
Single-Linked Lists and Double-Linked Lists
The ArrayList: add and remove methods operate in linear time because they require a loop to shift elements in the underlying array Linked list overcomes this by providing ability to add or remove items anywhere in the list in constant time Each element (node) in a linked list stores information and a link to the next, and optionally previous, node
Chapter 4: Lists and the Collection Interface
16
A List Node
A node contains a data item and one or more links A link is a reference to a node A node is generally defined inside of another class, making it an inner class The details of a node should be kept private
Chapter 4: Lists and the Collection Interface
17
Single-Linked Lists
Chapter 4: Lists and the Collection Interface
18
Double-Linked Lists
Limitations of a single-linked list include: Insertion at the front of the list is O(1). Insertion at other positions is O(n) where n is the size of the list. Can insert a node only after a referenced node Can remove a node only if we have a reference to its predecessor node Can traverse the list only in the forward direction Above limitations removed by adding a reference in each node to the previous node (double-linked list)
Chapter 4: Lists and the Collection Interface 19
Double-Linked Lists (continued)
Chapter 4: Lists and the Collection Interface
20
Inserting into a Double-Linked List
Chapter 4: Lists and the Collection Interface
21
Inserting into a Double-Linked List (continued)
Chapter 4: Lists and the Collection Interface
22
Removing from a Double-Linked List
Chapter 4: Lists and the Collection Interface
23
Circular Lists
Circular-linked list: link the last node of a double-linked list to the first node and the first to the last Advantage: can traverse in or forward reverse direction even after you have passed the last or first node Can visit all the list elements from any starting point Can never fall off the end of a list Disadvantage: infinite loop!
Chapter 4: Lists and the Collection Interface
24
Circular Lists Continued
Chapter 4: Lists and the Collection Interface
25
The LinkedList<E> Class
Part of the Java API Implements the List<E> interface using a double-linked list
Chapter 4: Lists and the Collection Interface
26
The Iterator<E> Interface
The interface Iterator is defined as part of API package java.util The List interface declares the method iterator, which returns an Iterator object that will iterate over the elements of that list An Iterator does not refer to or point to a particular node at any given time but points between nodes
Chapter 4: Lists and the Collection Interface
27
The Iterator<E> Interface (continued)
Chapter 4: Lists and the Collection Interface
28
The ListIterator<E> Interface
Iterator limitations
Can only traverse the List in the forward direction Provides only a remove method Must advance an iterator using your own loop if starting position is not at the beginning of the list
ListIterator<E> is an extension of the Iterator<E> interface for overcoming the above limitations Iterator should be thought of as being positioned between elements of the linked list
Chapter 4: Lists and the Collection Interface
29
The ListIterator<E> Interface (continued)
Chapter 4: Lists and the Collection Interface
30
The ListIterator<E> Interface (continued)
Chapter 4: Lists and the Collection Interface
31
Comparison of Iterator and ListIterator
ListIterator is a subinterface of Iterator; classes that implement ListIterator provide all the capabilities of both Iterator interface requires fewer methods and can be used to iterate over more general data structures but only in one direction Iterator is required by the Collection interface, whereas the ListIterator is required only by the List interface
Chapter 4: Lists and the Collection Interface
32
Conversion between a ListIterator and an Index
ListIterator has the methods nextIndex and previousIndex, which return the index values associated with the items that would be returned by a call to the next or previous methods The LinkedList class has the method listIterator(int index) Returns a ListIterator whose next call to next will return the item at position index
Chapter 4: Lists and the Collection Interface
33
The Enhanced for Statement
Chapter 4: Lists and the Collection Interface
34
The Iterable Interface
This interface requires only that a class that implements it provide an iterator method The Collection interface extends the Iterable interface, so all classes that implement the List interface (a subinterface of Collection) must provide an iterator method
Chapter 4: Lists and the Collection Interface
35
Implementation of a Double-Linked List
Chapter 4: Lists and the Collection Interface
36
Implementation of a Double-Linked List (continued)
Chapter 4: Lists and the Collection Interface
37
Implementation of a Double-Linked List (continued)
Chapter 4: Lists and the Collection Interface
38
Implementation of a Double-Linked List (continued)
Chapter 4: Lists and the Collection Interface
39
Implementation of a Double-Linked List (continued)
Chapter 4: Lists and the Coll...