1. Lists and the Collections Framework
4/1/2017
Chapter 2
Lists and the Collections Framework

2. Chapter Objectives The List interface
Writing an array-based implementation of List
Linked list data structures:
Singly-linked
Doubly-linked
Circular
Big-O notation and algorithm efficiency
Implementing the List interface as a linked list
The Iterator interface
Implementing Iterator for a linked list
Testing strategies
The Java Collections framework (hierarchy)

3. Introduction A list Iterators
a collection of elements, each with a position or index
Iterators
facilitate sequential access to a list
Classes ArrayList, Vector, and LinkedList
subclasses of abstract class AbstractList
implement the List interface

4. The List Interface and ArrayList Class
Section 2.1

5. Array, Java Array object
Array - an indexed structure
Random access
Sequential access
Java Array object
Fixed length
Hard to change its length
add an element
remove an element

6. List Interface part of JAVA API java.util List operations:
Obtain an element at a specified position
Replace an element at a specified position
Find a specified target value
Add an element at either end
Remove an element from either end
Insert or remove an element at any position
Traverse the list structure without managing a subscript

7. java.util.List Interface and its Implementers

8. ArrayList Class Implement List interface
It cannot store primitive types
Classes must store values as objects
How to store primitive types?

9. ArrayList Class, … more An improvement over an array object
adding new elements to the end of a list
access elements quickly in any order

10. Example List<String> myList = new ArrayList<String>();
Initial value - empty
initial capacity -10 elements
add elements to “myList”,
myList.add("Bashful");
myList.add("Awful");
myList.add("Jumpy");
myList.add("Happy");

11. Add in between Adding an element with subscript 2:
myList.add(2, "Doc");
Notice that the subscripts of "Jumpy" and "Happy" have changed from [2],[3] to [3],[4]

12. Add at the end
myList.add("Dopey");

13. Remove an element Removing an element:
myList.remove(1);
The strings referenced by [2] to [5] have changed to [1] to [4]

14. Replace an element
myList.set(2, "Sneezy");

15. Access an element
myList[1]? OR
String dwarf = myList.get(1);

16. Get index of an element myList.indexOf("Sneezy"); Returns?
myList.indexOf("Jumpy"); Returns?

17. List<String> myList = new ArrayList<String>();
Generic Collections
The statement
List<String> myList = new ArrayList<String>();
Generic collections or Generics
“String” -- type parameter
It sets the data type of all objects stored in a collection

18. Generic Collections: Primitive type example
General declaration
CollectionClassName<E> variable = new CollectionClassName<E>();
“E” is a type parameter
Adding a noncompatible type
How about primitive types ?
ArrayList<Integer> myList = new ArrayList<Integer>();
myList.add(new Integer(3)); // ok
myList.add(3); // also ok! 3 is automatically wrapped
in an Integer object
myList.add(new String("Hello")); // error!

19. Why Use Generic Collections?
Flexible
List<T>  List<int>, or List<string>,…
Enhance “type-checking”
List v = new ArrayList();
v.add("test");
Integer i = (Integer)v.get(0); // Run time error
List<String> v = new ArrayList<String>();
v.add("test");
Integer i = v.get(0); // (type error) Compile time error

20. ArrayList: Methods

21. Applications of ArrayList
Section 2.2

22. Application of ArrayList
ArrayList<Integer> someInts = new ArrayList<Integer>(); int[] nums = {5, 7, 2, 15}; for (int i = 0; i < nums.length; i++) { someInts.add(nums[i]); } // Display the sum int sum = 0; for (int i = 0; i < someInts.size(); i++) { sum += someInts.get(i); System.out.println("sum is " + sum);

23. nums[i] is an int; it is automatically wrapped in an Integer object
The Example
ArrayList<Integer> someInts = new ArrayList<Integer>(); int[] nums = {5, 7, 2, 15}; for (int i = 0; i < nums.length; i++) { someInts.add(nums[i]); } // Display the sum int sum = 0; for (int i = 0; i < someInts.size(); i++) { sum += someInts.get(i); System.out.println("sum is " + sum);
nums[i] is an int; it is automatically wrapped in an Integer object

24. Another Application:Phone Directory
public class DirectoryEntry {
String name;
String number; }
Create a class for objects stored in the directory

25. Phone Directory Example
public class DirectoryEntry { String name; String number; } private ArrayList<DirectoryEntry> theDirectory = new ArrayList<DirectoryEntry>();
Create the directory

26. Add a DirectoryEntry object
Add an Entry
Add a DirectoryEntry object
public class DirectoryEntry { String name; String number; } private ArrayList<DirectoryEntry> theDirectory = new ArrayList<DirectoryEntry>(); theDirectory.add(new DirectoryEntry("Jane Smith", " "));

27. Search Phone Directory by “Name”
Method indexOf searches theDirectory by applying the equals method for class DirectoryEntry. Assume DirectoryEntry's equals method compares name fields.
public class DirectoryEntry { String name; String number; } private ArrayList<DirectoryEntry> theDirectory = new ArrayList<DirectoryEntry>(); theDirectory.add(new DirectoryEntry("Jane Smith", " ")); int index = theDirectory.indexOf(new DirectoryEntry(aName, ""));

28. Access Phone Directory by “index”
public class DirectoryEntry { String name; String number; } private ArrayList<DirectoryEntry> theDirectory = new ArrayList<DirectoryEntry>(); theDirectory.add(new DirectoryEntry("Jane Smith", " ")); int index = theDirectory.indexOf(new DirectoryEntry(aName, "")); if (index != -1) dE = theDirectory.get(index); else dE = null;

29. Implementation of an ArrayList Class
Section 2.3

30. Fields: Capacity and Size
KWArrayList:
Capacity: Physical size
Size: Number of data items stroed

31. KWArrayList Fields
import java.util.*; /** This class implements some of the methods of the Java ArrayList class */ public class KWArrayList<E> { // Data fields /** The default initial capacity */ private static final int INITIAL_CAPACITY = 10; /** The underlying data array */ private E[] theData; /** The current size */ private int size = 0; /** The current capacity */ private int capacity = 0; }

32. KWArrayList Constructor
public KWArrayList () {
capacity = INITIAL_CAPACITY;
theData = (E[]) new Object[capacity]; }
This statement allocates storage for an array of type Object(superclass for all types) and then casts the array object to type E[]
Although this may cause a compiler warning, it's ok

33. Implementing ArrayList.add(E)
Two add methods
append at the end of the list
insert an item at a specified position

34. Add at the end Check the size
insert the new item at the “size” position
size=size++

35. Implementing Add in between ArrayList.add(int index,E anEntry)
Check size
size = size + 1
Make room first
Insert at “index” position

36. Implementing ArrayList.add(index,E)
public void add (int index, E anEntry) {
// check bounds
if (index < 0 || index > size) {
throw new ArrayIndexOutOfBoundsException(index); }
// Make sure there is room
if (size >= capacity) {
reallocate();
// shift data
for (int i = size; i > index; i--) {
theData[i] = theData[i-1];
// insert item
theData[index] = anEntry;
size++;

37. set and get Methods public E get (int index) {
if (index < 0 || index >= size) {
throw new ArrayIndexOutOfBoundsException(index); }
return theData[index];
public E set (int index, E newValue) {
E oldValue = theData[index];
theData[index] = newValue;
return oldValue;

38. remove Method: idea
Check “index”
Shift left
size = size - 1

39. remove Method: the code
public E remove (int index) { if (index < 0 || index >= size) { throw new ArrayIndexOutOfBoundsException(index); } E returnValue = theData[index]; for (int i = index + 1; i < size; i++) { theData[i-1] = theData[i]; size--; return returnValue;

40. reallocate Method Create a new array with double size
Copy the contents of the new array
private void reallocate () {
capacity *= 2;
theData = Arrays.copyOf(theData, capacity); }

41. reallocate Method: doubling
private void reallocate () { capacity *= 2; theData = Arrays.copyOf(theData, capacity); }
The reason for doubling is to spread out the cost of copying; we discuss this further in the next section

42. KWArrayList as a Collection of Objects: old version
Earlier versions of Java did not support generics; all collections contained only Object elements
To implement KWArrayList this way,
remove the parameter type <E> from the class heading,
replace each reference to data type E by Object
The underlying data array becomes
private Object[] theData;

43. Vector/ArrayList Class
Vector and ArrayList are similar
ArrayList is more efficient
Vector class is synchronized
Support multiple threads access a Vector object without confliction

44. Algorithm Efficiency and Big-O
Section 2.4

45. Algorithm Efficiency/Big-O
the performance of an algorithm
Hard to measure precisely
Big-O notation is a choice
Big-O notation
Function of the size of a problem
Used to compare the algorithms’ efficiency

46. Linear Growth Rate
The processing time is proportional to the problem size
the algorithm grows at a linear rate
public static int search(int[] x, int target) {
for(int i=0; i < x.length; i++) {
if (x[i]==target)
return i; }
return -1; // target not found

47. Linear Growth Rate
If the target is not present, the for loop will execute x.length times
If the target is present the for loop will execute (on average) (x.length + 1)/2 times
Therefore, the total execution time is directly proportional to x.length
This is described as a growth rate of order n OR
O(n)
public static int search(int[] x, int target) { for(int i=0; i < x.length; i++) { if (x[i]==target) return i; } return -1; // target not found

48. n x m Growth Rate
Processing time can be dependent on two different inputs
public static boolean areDifferent(int[] x, int[] y) {
for(int i=0; i < x.length; i++) {
if (search(y, x[i]) != -1)
return false; }
return true;

49. n x m Growth Rate (cont.) The for loop will execute x.length times
But it will call search, which will execute y.length times
The total execution time is proportional to (x.length * y.length)
The growth rate has an order of n x m or
O(n x m)
public static boolean areDifferent(int[] x, int[] y) {
for(int i=0; i < x.length; i++) {
if (search(y, x[i]) != -1)
return false; }
return true;

50. Quadratic Growth Rate
If n==m, thethe algorithm grows at a quadratic rate
public static boolean areUnique(int[] x) {
for(int i=0; i < x.length; i++) {
for(int j=0; j < x.length; j++) {
if (i != j && x[i] == x[j])
return false; }
return true;

51. Quadratic Growth Rate (cont.)
The for loop with i as index will execute x.length times
The for loop with j as index will execute x.length times
The total number of times the inner loop will execute is (x.length)2
The growth rate has an order of n2 or
O(n2)
public static boolean areUnique(int[] x) {
for(int i=0; i < x.length; i++) {
for(int j=0; j < x.length; j++) {
if (i != j && x[i] == x[j])
return false; }
return true;

52. Big-O Notation order of magnitude Determined by the loops/nested loops
Examples
a single loop is O(n)
a pair of nested loops is O(n2)
a nested pair of loops inside another is O(n3)
and so on . . .

53. Logarithmic Growth Rate
Example
for(i=1; i < x.length; i *= 2) {
// Do something with x[i] }
‘i’ has the following values: , 2, 4, 8, 16, . . ., 2k
The loop body will execute k-1 times
O(log n)
Logarithmic function grows slowly as the size n increases

54. Example of Big-O Consider the following program structure:
for (int i = 0; i < n; i++) {
for (int j = 0; j < n; j++) {
Simple Statement }
Simple Statement 1
Simple Statement 2
Simple Statement 3
Simple Statement 4
Simple Statement 5
Simple Statement 6
Simple Statement 7
...
Simple Statement 30

55. Example of Big-O (Cont.)
Consider the following program structure:
for (int i = 0; i < n; i++) {
for (int j = 0; j < n; j++) {
Simple Statement }
Simple Statement 1
Simple Statement 2
Simple Statement 3
Simple Statement 4
Simple Statement 5
Simple Statement 6
Simple Statement 7
...
Simple Statement 30
This nested loop executes a Simple Statement n2 times

56. Example of Big-O (Cont.)
Consider the following program structure:
for (int i = 0; i < n; i++) {
for (int j = 0; j < n; j++) {
Simple Statement }
Simple Statement 1
Simple Statement 2
Simple Statement 3
Simple Statement 4
Simple Statement 5
Simple Statement 6
Simple Statement 7
...
Simple Statement 30
This loop executes 5 Simple Statements n times (5n)

57. Example of Big-O (cont.)
Consider the following program structure:
for (int i = 0; i < n; i++) {
for (int j = 0; j < n; j++) {
Simple Statement }
Simple Statement 1
Simple Statement 2
Simple Statement 3
Simple Statement 4
Simple Statement 5
Simple Statement 6
Simple Statement 7
...
Simple Statement 30
Finally, 25 Simple Statements are executed

58. Example of Big-O (cont.)
Consider the following program structure:
for (int i = 0; i < n; i++) {
for (int j = 0; j < n; j++) {
Simple Statement }
Simple Statement 1
Simple Statement 2
Simple Statement 3
Simple Statement 4
Simple Statement 5
Simple Statement 6
Simple Statement 7
...
Simple Statement 30
We can conclude that the relationship between processing time and n (the number of date items processed) is:
T(n) = n2 + 5n + 25

59. Big-O Boundary In terms of T(n), T(n) = O(f(n)) There exist
two constants, n0 and c, greater than zero, and
a function, f(n),
such that for all n > n0, cf(n) =
T(n) ≤ cf(n) as n gets sufficiently large
cf(n) is an upper bound on performance

60. Big-O boundary for the example
The growth rate of f(n) is determined by the highest order term
O(n2 + 5n + 25) O(n2)
ignore all constants and drop the lower-order terms

61. boundary for the Example
Given T(n) = n2 + 5n + 25, show that this is O(n2)
Find constants n0 and c so that, for all n > n0, cn2 > n2 + 5n + 25
When n0 is 5, and c is 3, we have 3n2 > n2 + 5n for all n > 5

62. Graph representation

63. Big-O Example 2 Consider the following loop
for (int i = 0; i < n; i++) {
for (int j = i + 1; j < n; j++) {
3 simple statements }
T(n) = 3(n – 1) + 3 (n – 2) + … + 3
Factoring out the 3,
3(n – 1 + n – 2 + n – 3 + … + 1)
… + n – 1 = (n x (n-1))/2

64. Big-O Example 2 (cont.) Therefore T(n) = 1.5n2 – 1.5n
When n = 0, the polynomial has the value 0
For values of n > 1, 1.5n2 > 1.5n2 – 1.5n
Therefore T(n) is O(n2) when n0 is 1 and c is 1.5

65. Big-O Example 2 (cont.)

66. Symbols Used in Quantifying Performance

67. Common Growth Rates

68. Different Growth Rates

69. Effects of Different Growth Rates

70. Exponential/Factorial Growth Rates
exponential and factorial growth rates are very sensitive to the size of the problem
With an O(2n) algorithm
100 inputs will take 1 hour
101 inputs will take 2 hours
105 inputs will take 32 hours
114 inputs will take 16,384 hours (almost 2 years!)

71. Applications of Exponential/Factorial Growth Rates
4/1/2017
Applications of Exponential/Factorial Growth Rates
Encryption algorithms take advantage of this
Some cryptographic algorithms can be broken in O(2n) time, where n is the number of bits in the key
If n==40 is considered breakable by a modern computer,
but if n==100, would take a billion-billion (1018) times longer than n==40

72. Performance of KWArrayList
The set and get methods execute in constant time: O(1)
Inserting or removing general elements is linear time: O(n)
Adding at the end is (usually) constant time: O(1)
With our reallocation technique the average is O(1)
The worst case is O(n) because of reallocation

73. Single-Linked Lists
Section 2.5

74. Single-Linked Lists Why need Linked List? (Add, Remove Performance)
ArrayList O(n)
Linked List O(1)

75. A List Node A node can contain: a data item (E)
one or more links (next)

76. List Nodes for Single-Linked Lists
private static class Node<E> { private E data; private Node<E> next; /** Creates a new node with a null next dataItem The data stored */ private Node(E dataItem) { data = dataItem; next = null; } /** Creates a new node that references another nodeRef The node referenced by new node private Node(E dataItem, Node<E> nodeRef) { next = nodeRef;

77. List Nodes for Single-Linked Lists (cont.)
private static class Node<E> { private E data; private Node<E> next; /** Creates a new node with a null next dataItem The data stored */ private Node(E data) { data = dataItem; next = null; } /** Creates a new node that references another nodeRef The node referenced by new node private Node(E dataItem, Node<E> nodeRef) { next = nodeRef;
The keyword static indicates that the Node<E> class will not reference its outer class
Static inner classes are also called nested classes

78. List Nodes for Single-Linked Lists (cont.)
private static class Node<E> { private E data; private Node<E> next; /** Creates a new node with a null next dataItem The data stored */ private Node(E dataItem) { data = dataItem; next = null; } /** Creates a new node that references another nodeRef The node referenced by new node private Node(E dataItem, Node<E> nodeRef) { next = nodeRef;
Generally, all details of the Node class should be private. This applies also to the data fields and constructors.

79. Creating and Connecting Nodes
Node<String> tom = new Node<String>("Tom"); Node<String> dick = new Node<String>("Dick"); Node<String> harry = new Node<String>("Harry"); Node<String> sam = new Node<String>("Sam"); tom.next = dick; dick.next = harry; harry.next = sam;

80. Example of Connecting Nodes

81. A Single-Linked List Class
Not a single node
Linked nodes
How to link the nodes?
A SingleLinkedList
a data field head
Let head point to the first node
public class SingleLinkedList<E> {
private Node<E> head = null;
private int size = 0;
... }

82. SLList: An Example List
head =
SLList<String>
next =
data = "Tom"
Node<String>
next =
data = "Dick"
Node<String>

83. Implementing idea:SLList.addFirst(E item)
head =
SLList<String>
next =
data = "Tom"
Node<String>
next =
data = "Dick"
Node<String>
next =
data = "Ann"
Node<String>
The element added to the list

84. Code SLList.addFirst(E item)
private void addFirst (E item) {
Node<E> temp = new Node<E>(item, head);
head = temp;
size++; }
or, more simply ...
head = new Node<E>(item, head);
This works even if head is null

85. Implementing Idea addAfter(Node<E> node, E item)
head =
SLList<String>
next =
data = "Tom"
Node<String>
next =
data = "Dick"
Node<String>
next =
data = "Ann"
Node<String>
The element added to the list

86. Implementing Code: addAfter(Node<E> node, E item)
private void addAfter (Node<E> node, E item) {
Node<E> temp = new Node<E>(item, node.next);
node.next = temp;
size++; }
or, more simply ...
node.next = new Node<E>(item, node.next);
We declare this method private since it should not be called from outside the class. Later we will see how this method is used to implement the public add methods.

87. Implementing Idea removeAfter(Node<E> node)
temp
head =
SLList<String>
next =
data = "Tom"
Node<String>
next =
data = "Dick"
Node<String>
next =
data = "Ann"
Node<String>
The Node parameter

88. Implementing Code: removeAfter(Node<E> node)
private E removeAfter (Node<E> node) { Node<E> temp = node.next; if (temp != null) { node.next = temp.next; size--; return temp.data; } else { return null; }

89. Implementing Idea: SLList.removeFirst()
head =
SLList<String>
next =
data = "Dick"
Node<String>
next =
data = "Tom"
Node<String>
temp

90. Implementing Code: SLList.removeFirst()
private E removeFirst () {
Node<E> temp = head;
if (head != null) {
head = head.next; }
if (temp != null) {
size--;
return temp.data
} else {
return null;

91. Single-Linked List Traversing Idea
head =
SLList<String>
next =
data = "Tom"
Node<String>
next =
data = "Dick"
Node<String>
Do something with nodeRef
Do something with nodeRef
Do something with nodeRef
next =
data = "Ann"
null
Node<String>
nodeRef

92. Single-Linked List Traversing Code
toString()can be implemented with a traversal:
public String toString() {
Node<String> nodeRef = head;
StringBuilder result = new StringBuilder();
while (nodeRef != null) {
result.append(nodeRef.data);
if (nodeRef.next != null) {
result.append(" ==> "); }
nodeRef = nodeRef.next;
return result.toString();

93. SLList.getNode(int) private Node<E> getNode(int index) {
Node<E> node = head;
for (int i=0; i<index && node != null; i++) {
node = node.next; }
return node;

94. SingleLinkedList Class More Methods

95. public E get(int index)
if (index < 0 || index >= size) {
throw new IndexOutOfBoundsException(Integer.toString(index)); }
Node<E> node = getNode(index);
return node.data;

96. public E set(int index, E newValue)
public E set (int index, E anEntry) {
if (index < 0 || index >= size) {
throw new IndexOutOfBoundsException(Integer.toString(index)); }
Node<E> node = getNode(index);
E result = node.data;
node.data = anEntry;
return result;

97. public void add(int index, E item)
public void add (int index, E item) { if (index < 0 || index > size) { throw new IndexOutOfBoundsException(Integer.toString(index)); } if (index == 0) { addFirst(item); } else { Node<E> node = getNode(index-1); addAfter(node, item);

98. public boolean add(E item)
To add an item to the end of the list
public boolean add (E item) {
add(size, item);
return true; }

99. Double-Linked Lists and Circular Lists
Section 2.6

100. Limitations of Single-Linked Lists
Insertion
front is O(1)
other positions is O(n)
Removing
requires a reference to the previous node
Traversing
Only in one direction
What is the solution ?

101. Double-Linked Lists Example

102. Node Class Definition
private static class Node<E> { private E data; private Node<E> next = null; private Node<E> prev = null; private Node(E dataItem) { data = dataItem; }

103. Inserting into a Double-Linked List
sam
from predecessor
next =
= prev
data = "Harry"
Node
next = null
= prev
data = "Sam"
Node
to predecessor
Node<E> sharon = new Node<E>("Sharon");
sharon.next = sam;
sharon.prev = sam.prev;
sam.prev.next = sharon;
sam.prev = sharon
sharon
next =
= prev
data = "Sharon"
Node

104. Removing from a Double-Linked List
harry
next =
= prev
data = "Dick"
Node
next =
= prev
data = "Sharon"
Node
next =
= prev
data = "Harry"
Node
harry.prev.next = harry.next
harry.next.prev = harry.prev

105. A Double-Linked List Class
Data fields:
head (a reference to the first list Node)
tail (a reference to the last list Node)
size
Good news
Insertion at either end is O(1);
Bad news
insertion elsewhere is still O(n) or O(n/2)

106. Circular Lists Double-linked circular list:
Link last node to the first node, and
Link first node to the last node
Single-linked circular lists:
Traverse in forward direction only
Advantages:
Circular
Traverse from node
Disadvantage:
Infinite loop!

107. Circular Lists Example

108. The LinkedList Class and the Iterator, ListIterator, and Iterable Interfaces
Section 2.7

109. The LinkedList Class: Methods

110. The Iterator Moving place marker Starts from the first node
keeps track of the current position in a linked list
Starts from the first node
Move the Iterator
next method
An Iterator traversing performance
O(n) vs. O(n2) (?) with get() of a list

111. Iterator Interface Defined in java.util
‘Iterator’ Method is Declared in the List interface

112. Iterator idea Conceptually between elements
Not refer to any particular object

113. Using Iterator Traverse a List<Integer>
Iterator<Integer> iter = aList.iterator();
while (iter.hasNext()) {
int value = iter.next();
// Do something with value
... }

114. Remove Elements with Iterator
Use Iterator remove()
remove() deletes the most recent element returned
next()must be called before each remove();
OtherwiseIllegalStateException
LinkedList.remove vs. Iterator.remove:
LinkedList.remove O(n2) (?)
Iterator.remove O(n)

115. ‘Remove’ Example remove certain elements
public static void removeDivisibleBy(LinkedList<Integer> aList, int div) {
Iterator<Integer> iter = aList.iterator();
while (iter.hasNext()) {
int nextInt = iter.next();
if (nextInt % div == 0) {
iter.remove(); }

116. Iterator Limitations Iterator limitations One direction ‘Traverse’
No add method
Hard to start from a certain position of a list
Solution
Using ListIterator

117. ListIterator Interface
Conceptually positioned between elements of the list
Positions are indexed from 0 to size

118. ListIterator Interface: Methods

119. ListIterator Interface (cont.)

120. Iterator vs. ListIterator
sub-interface of Iterator
Iterator/ListIterator
fewer methods/more
general data structures/list only

121. ListIterator and an Index
nextIndex()returns the index of item to be returned by next()
previousIndex() returns the index of item to be returned by previous()
listIterator(int index)
Returns a ListIterator positioned before index term

122. Cont. The listIterator (int index)
creates a new ListIterator with O(n) operation

123. Enhanced for Statement
Supported from Java 5.0
The enhanced for statement
creates an Iterator object
implicitly calls its hasNext and next methods
Other methods, such as “remove”, not available

124. Enhanced for Example-1 Apply to a linked list count = 0;
for (String nextStr : myList) {
if (target.equals(nextStr)) {
count++; }

125. Enhanced for Example-2 Apply to a linked list sum = 0;
for (int nextInt : myList) {
sum += nextInt; }

126. Enhanced for Example-3 Apply to Array } for (char nextCh : chars) {
System.out.println(nextCh); }

127. Iterable Interface Iterable  Collection  List
Iterator() declared in Iterable interface
public interface Iterable<E> {
/** returns an iterator over the elements in this collection. */
Iterator<E> iterator(); }

128. Implementation of a Double-Linked List Class
Section 2.8 (Optional)

129. KWLinkedList
We will define a KWLinkedList class which implements some of the methods of the List interface
The KWLinkedList class is for demonstration purposes only; Java provides a standard LinkedList class in java.util which you should use in your programs

130. KWLinkedList (cont.)
import java.util.*; /** Class KWLinkedList implements a double linked list and * a ListIterator. */ public class KWLinkedList <E> { // Data Fields private Node <E> head = null; private Node <E> tail = null; private int size = 0; . . .

131. Add Method
Obtain a reference, nodeRef, to the node at position index
Insert a new Node containing obj before the node referenced by nodeRef
To use a ListIterator object to implement add:
Obtain an iterator that is positioned just before the Node at position index
Insert a new Node containing obj before the Node currently referenced by this iterator
/** Add an item at the specified index The index at which the object is to be obj The object to be IndexOutOfBoundsException if the index is out of range (i < 0 || i > size()) */ public void add(int index, E obj) { listIterator(index).add(obj); }
It is not necessary to declare a local ListIterator; the method call listIterator returns an anonymous listIterator object

132. Get Method Obtain a reference, nodeRef, to the node at position index
Return the contents of the Node referenced by nodeRef
/** Get the element at position index Position of item to be The item at index */ public E get(int index) { return listIterator(index).next(); }

133. Other Add and Get Methods
public void addFirst(E item) { add(0, item); } public void addLast(E item) { add(size, item); public E getFirst() { return head.data; public E getLast() { return tail.data;

134. Implementing the ListIterator Interface
KWListIter is an inner class of KWLinkedList which implements the ListIterator interface

135. Implementing the ListIterator Interface (cont.)

136. Implementing the ListIterator Interface (cont.)
private class KWListIter implements ListIterator<E> { private Node <E> nextItem; private Node <E> lastItemReturned; private int index = 0; ...

137. Constructor
public KWListIter(int i) { // Validate i parameter. if (i < 0 || i > size) { throw new IndexOutOfBoundsException("Invalid index " + i); } lastItemReturned = null; // No item returned yet. // Special case of last item if (i == size) { index = size; nextItem = null; else { // Start at the beginning nextItem = head; for (index = 0; index < i; index++) { nextItem = nextItem.next;

138. The hasNext()Method tests to see if nextItem is null
public boolean hasnext() {
return nextItem != null; }

139. Advancing the Iterator
KWLinkedList
head
tail
size 3
next
prev null
data "Tom"
Node
next
prev
Node
next
prev
data "Sam"
Node
data "Harry"
KWListIter
nextItem
lastItemReturned
index 1
public E next() {
if (!hasNext()) {
throw new NoSuchElementException(); }
lastItemReturned = nextItem;
nextItem = nextItem.next;
index++;
return lastItemReturned.data; 2

140. Previous Methods
public boolean hasPrevious() { return (nextItem == null && size != 0) || nextItem.prev != null; } public E previous() { if (!hasPrevious()) { throw new NoSuchElementException(); if (nextItem == null) { // Iterator past the last element nextItem = tail; else { nextItem = nextItem.prev; lastItemReturned = nextItem; index--; return lastItemReturned.data;

141. The Add Method When adding, there are four cases to address:
Add to an empty list
Add to the head of the list
Add to the tail of the list
Add to the middle of the list

142. Adding to an Empty List (after insertion) if (head == null) {
head = new Node<E>(obj);
tail = head; }
...
size++

143. Adding to the Head of the List
KWListIter
nextItem = lastItemReturned = null
index = 0 1
Node
next =
null = prev
data = "Tom"
Node
Node
next = null
= prev
data = "Sam"
next =
= prev
data = "Harry"
KWLinkedList
head = null
tail = null
size = 3 4
if (nextItem == head) {
Node<E> newNode = new Node<E>(obj);
newNode.next = nextItem;
nextItem.prev = newNode;
head = newNode; }
...
size++;
index++;
next = null
null = prev
data = "Ann"
Node
newNode

144. Adding to the Tail of the List
KWListIter
nextItem = null lastItemReturned = null
index = 2
Node
next =
prev = null
data = "Tom"
Node
Node
next = null
= prev
data = "Sam" 3
next =
= prev
data = "Ann"
KWLinkedList
head = null
tail = null
size = 3 4
if (nextItem == null) {
Node<E> newNode = new Node<E>(obj);
tail.next = newNode;
newNode.prev = tail;
tail = newNode }
...
size++;
index++;
next = null
null = prev
data = "Bob"
Node
newNode

145. Adding to the Middle of the List
KWListIter
nextItem = null lastItemReturned = null
index = 1
Node
next =
prev = null
data = "Tom"
Node
Node
next = null
= prev
data = "Sam" 2
next =
= prev
data = "Ann"
KWLinkedList
head = null
tail = null
size = 3 4
next = null
null = prev
data = "Bob"
Node
newNode
else {
Node<E> newNode = new Node<E>(obj);
newNode.prev = nextItem.prev;
nextItem.prev.next = newNode;
newNode.next = nextItem;
nextItem.prev = newNode; }
...
size++;
index++;

146. Inner Classes: Static and Nonstatic
KWLinkedList contains two inner classes:
Node<E> is declared static: there is no need for it to access the data fields of its parent class, KWLinkedList
KWListIter cannot be declared static because its methods access and modify data fields of KWLinkedList’s parent object which created it
An inner class which is not static contains an implicit reference to its parent object and can reference the fields of its parent object
Since its parent class is already defined with the parament <E>, KWListIter cannot be declared as KWListIter<E>; if it were, an incompatible types syntax error would occur

147. The Collections Framework Design
Section 2.9

148. The Collection Interface
excluding
add(int, E)
get(int)
remove(int)
set(int, E)
but including
add(E)
remove(Object)
the iterator method

149. The Collection Framework
<<interface>>
Iterable<
<<interface>>
Collection
<<interface>>
Queue<
<<interface>>
List<
AbstractCollection
<<interface>>
Set
<<interface>>
Deque
AbstractList
AbstractSet
<<interface>>
SortedSet
AbstractSequentialList
Vector
ArrayList
HashSet
<<interface>>
NavigableSet<
LinkedHashSet
TreeSet
LinkedList
Stack
ConcurrentSkipListSet

150. Common Features of Collections
grow as needed
hold references to objects
at least two constructors
one to create an empty collection
one to make a copy of another collection

151. Common Methods of Collections
general Collection
the order of elements is not specified
Collections implementing the List interface
the order of the elements is determined by the index

152. Common Features of Collections
For a general Collection
the position where an object is inserted is not specified
But for ArrayList and LinkedList
add(E) always inserts at the end and always returns true

153. AbstractCollection, AbstractList, and AbstractSequentialList
"helper" abstract classes
help to build implementations of their corresponding interfaces
Providing implementations for interface methods not used
the helper classes require the programmer to extend the AbstractCollection class and
implement only the desired methods

154. Implementing Collection<E> interface
Extend AbstractCollection<E>, which implements most operations
You need to implement only:
add(E)
size()
iterator()
an inner class that implements Iterator<E>

155. Implementing a List<E> interface
Extend AbstractList<E>
You need to implement only:
add(int, E)
get(int)
remove(int)
set(int, E)
size()
AbstractList implements Iterator<E> using the index

156. AbstractCollection, AbstractList, and AbstractSequentialList
Another more complete way to declare KWArrayList is:
public class KWArrayList<E> extends AbstractList<E> implements List<E>
Another more complete, way to declare KWLinkedLinkedList is:
public class KWLinkedList<E> extends AbstractSequentialList<E> implements List<E>

157. List and RandomAccess Interfaces
Accessing a LinkedList using an index
O(n) traversal of the list until the index is located
The RandomAccess interface
Marker interface, no methods
An algorithm design
Index list--OK
If not, --- Optimize it

158. Application of the LinkedList Class
Section 2.10

159. An Application: Ordered Lists
Task: Maintain a list of names in alphabetical order
Approach
Develop an OrderedList class
Implement a Comparable interface by providing a compareTo(E) method
Use a LinkedList class as a component of the OrderedList
if OrderedList extended LinkedList, the user could use LinkedList's add methods to add an element out of order

160. Class Diagram for OrderedList

161. Design

162. Inserting into an OrderedList
Strategy for inserting new element e:
Find first item > e
Insert e before that item
Refined with an iterator:
Create ListIterator that starts at the beginning of the list
While the ListIterator is not at the end of the list and e >= the next item
Advance the ListIterator
Insert e before the current ListIterator position

163. Inserting Diagrammed

164. Inserting Diagrammed (cont.)

165. OrderedList.add
public void add (E e) { ListIterator<E> iter = theList.listIterator(); while (iter.hasNext()) { if (e.compareTo(iter.next()) < 0) { // found element > new one iter.previous(); // back up by one iter.add(e); // add new one return; // done } iter.add(e); // will add at end

166. Using Delegation to Implement the Other Methods
public E get (int index) { return theList.get(index); } public int size () { return theList.size(); public E remove (E e) { return theList.remove(e); // returns an iterator positioned before the first element public Iterator iterator() { return theList.iterator();

167. Testing
Section 2.11 (on yourself)

168. Testing
Testing runs a program or part of a program under controlled conditions to verify that results are as expected
Testing detects program defects after the program compiles (all syntax error have been removed)
While extremely useful, testing cannot detect the absence of all defects in complex programs

169. Testing Levels
Unit testing: tests the smallest testable piece of the software, often a class or a sufficiently complex method
Integration testing: tests integration among units
System testing: tests the whole program in the context in which it will be used
Acceptance testing: system testing designed to show that a program meets its functional requirements

170. Types of Testing Black-box testing:
tests the item (method, class, or program) based on its interfaces and functional requirements
is also called closed-box or functional testing
is accomplished by varying input parameters across the allowed range and outside the allowed range, and comparing with independently calculated results

171. Types of Testing (cont.)
White-box testing:
tests the item (method, class, or program) with knowledge of its internal structure
is also called glass-box, open-box, or coverage testing
exercises as many paths through the element as possible
provides appropriate coverage
statement – ensures each statement is executed at least once
branch – ensures each choice of branch (if , switch, loops) is taken
path – tests each path through a method

172. Preparations for Testing
A test plan should be developed early in the design stage—the earlier an error is detected, the easier and less expensive it is to correct it
Aspects of test plans include deciding:
how the software will be tested
when the tests will occur
who will do the testing
what test data will be used

173. Testing Tips for Program Systems
Carefully document method operation, parameter, and class attributes using comments; follow Javadoc conventions
Leave a trace of execution by displaying the method name as you enter it
Display values of all input parameters upon entering a method and values of any class attributes accessed by the method
Display values of all method outputs after returning from a method, together with any class attributes that are modified by a method

174. Testing Tips for Program Systems (cont.)
An efficient way to display values of parameters, return values, and class attributes:
private static final boolean TESTING = true; // or false to // disable
if (TESTING) {
// Code for output statements }
Remove these features when you are satisfied with the testing results
You can define different boolean flags for different tests

175. Developing the Test Data
In black-box testing, test data should check for all expected inputs as well as unanticipated data
In white-box testing, test data should be designed to ensure all combinations of paths through the code are executed

176. Testing Boundary Conditions
Example
for (int i = 0; i < x.length; i++) {
if (x[i] == target)
return i; }
Test the boundary conditions (for white-box and black- box testing) when target is:
first element (x[0] == target is true)
last element (x[length-1] == target is true)
not in array (x[i] == target is always false)
present multiple times (x[i] == target for more than one value of i)

177. Testing Boundary Conditions (cont.)
for (int i = 0; i < x.length; i++) {
if (x[i] == target)
return i; }
Test for the typical situation when target is:
somewhere in the middle
and for the boundary conditions when the array has
only one element
no elements

178. Testing Boundary Conditions (cont.)
public static void main(String[] args) { int[] x = {5, 12, 15, 4, 8, 12, 7}; // Array to search. // Test for target as first element. verify(x, 5, 0); // Test for target as last element. verify(x, 7, 6); // Test for target not in array. verify(x, -5, -1); // Test for multiple occurrences of target. verify(x, 12, 1); // Test for target somewhere in middle. verify(x, 4, 3); // Test for 1-element array. x = new int[1]; x[0] = 10; verify(x, 10, 0); verify(x, -10, -1); // Test for an empty array. x = new int[0]; verify(x, 10, -1); }

179. Testing Boundary Conditions (cont.)
private static void verify(int[] x, int target, int expected) { int actual = search(x, target); System.out.print("search(x, " + target + ") is " + actual + ", expected " + expected); if (actual == expected) System.out.println(": Pass"); else System.out.println(": ****Fail"); }

180. Testing Boundary Conditions (cont.)

181. Stubs
Stubs are method placeholders for methods called by other classes, but not yet implemented
Stubs allowing testing as classes are being developed
A sample stub:
public void save() {
System.out.println("Stub for save has been called");
modified = false; }

182. Stubs (cont.) Stubs can print out value of inputs
assign predictable values to outputs
change the state of variables

183. Preconditions and Postconditions
A precondition is a statement of any assumptions or constraints on the input parameters before a method begins execution
A postcondition describes the result of executing the method, including any change to the object’s state
A method's preconditions and postconditions serve as a contract between a method caller and the method programmer
/** Method Save
pre: the initial directory contents are read from a data file
post: writes the directory contents back to a data file */
public void save() {
. . . }

184. Drivers Another testing tool A driver program
declares any necessary object instances and variables
assigns values to any of the method's inputs (specified by the preconditions)
calls the method
displays the outputs returned by the method
Driver program code can be added to a class's main method (each class can have a main method; only one main method - the one you designate to execute - will run)

185. Finally
JUnit, a popular program for Java projects, helps you develop testing programs (see Appendix C)
Many IDEs are shipped with debugger programs you can use for testing

186. Testing OrderedList To test an OrderedList,
store a collection of randomly generated integers in an OrderedList
test insertion at beginning of list: insert a negative integer
test insertion at end of list: insert an integer larger than any integer in the list
create an iterator and iterate through the list, displaying an error if any element is smaller than the previous element
remove the first element, the last element, and a middle element, then traverse to show that order is maintained

187. Testing OrderedList (cont.)
Class TestOrderedList
import java.util.*;
public class TestOrderedList {
/** Traverses ordered list and displays each element.
Displays an error message if an element is out of order.
@param testList An ordered list of integers */
public static void traverseAndShow(OrderedList<Integer> testList) {
int prevItem = testList.get(0);
// Traverse ordered list and display any value that
// is out of order.
for (int thisItem : testList) {
System.out.println(thisItem);
if (prevItem > thisItem)
System.out.println("*** FAILED, value is "
+ thisItem);
prevItem = thisItem; }
public static void main(String[] args) {
OrderedList<Integer> testList = new OrderedList<Integer>();
final int MAX_INT = 500;
final int START_SIZE = 100;
(cont. on next slide)

188. Testing OrderedList (cont.)
// Create a random number generator. Random random = new Random(); for (int i = 0; i < START_SIZE; i++) { int anInteger = random.nextInt(MAX_INT); testList.add(anInteger); } // Add to beginning and end of list. testList.add(-1); testList.add(MAX_INT + 1); traverseAndShow(testList); // Traverse and display. // Remove first, last, and middle elements. Integer first = testList.get(0); Integer last = testList.get(testList.size() - 1); Integer middle = testList.get(testList.size() / 2); testList.remove(first); testList.remove(last); testList.remove(middle);