Download
lists and the collection interface n.
Skip this Video
Loading SlideShow in 5 Seconds..
Lists and the Collection Interface PowerPoint Presentation
Download Presentation
Lists and the Collection Interface

Lists and the Collection Interface

177 Vues Download Presentation
Télécharger la présentation

Lists and the Collection Interface

- - - - - - - - - - - - - - - - - - - - - - - - - - - E N D - - - - - - - - - - - - - - - - - - - - - - - - - - -
Presentation Transcript

  1. Lists and the Collection Interface Chapter 4

  2. 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

  3. 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

  4. 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 • Disadvantages of arrays: 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

  5. 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

  6. The List Interface and ArrayList Class (continued) Chapter 4: Lists and the Collection Interface

  7. 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 • For example: List<String> myList = new ArrayList<String>(); myList.add(“Bashful”); myList.add(“Awful”); myList.add(“Jumpy”); myList.add(“Happy”); Chapter 4: Lists and the Collection Interface

  8. The ArrayList Class • Then • After myList.add(2, “Doc”); • After myList.add(“Dopey”); Chapter 4: Lists and the Collection Interface

  9. The ArrayList Class (continued) • Suppose we have • Then myList.remove(1); • And myList.set(2, “Sneezy”); Chapter 4: Lists and the Collection Interface

  10. 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 one 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 are of type String. • A type parameter is analogous to a method parameter. Chapter 4: Lists and the Collection Interface

  11. Generic Collections • In Java, a non-generic collection is more general than a generic collection • Non-generic collection can store objects of different data types • In a generic collection, all objects must be of same type Chapter 4: Lists and the Collection Interface

  12. Creating a Generic Collection Chapter 4: Lists and the Collection Interface

  13. Non-generic Example • For example ArrayList yourList = new ArrayList(); yourList.add(new Integer(35));// element 0 is Integer yourList.add(“bunny”); // element 1 is String yourList.add(new Double(3.14));// element 2 is Double • Will this work? String animal = yourList.get(1); • Syntax error: incompatible types, since it is an Object • Must cast: String animal = (String) yourList.get(1); • Consider: String aTwo = (String) yourList.get(2); • Will compile, but gives runtime error… • This is bad! Chapter 4: Lists and the Collection Interface

  14. Generics • Advantages include… • Type incompatibility detected at compile time • Downcasting not necessary • Specific data types (e.g., String), not Object • The book likes generics • Book suggests you only use non-generics if need to store objects of different types in same collection Chapter 4: Lists and the Collection Interface

  15. Specification of the ArrayList Class Chapter 4: Lists and the Collection Interface

  16. 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 • Section 4.2 gives some examples • Phone Directory using ArrayList instead of array • Read Section 4.2 • It’s only 2 pages! Chapter 4: Lists and the Collection Interface

  17. KWArrayList Class • Authors implement their our own ArrayList class • Call it KWArrayList • Why are they doing this? • Illustrates how class actually works (not in every detail, but the basic ideas) • Can analyze the work involved • This work is all hidden when using ArrayList Chapter 4: Lists and the Collection Interface

  18. KWArrayList Class • KWArrayList is author’s implementation of an 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

  19. KWArrayList Class Definition publicclass KWArrayList < E > { // Data Fields /** The default initial capacity */ privatestaticfinalint INITIAL_CAPACITY = 10; /** The underlying data array */ private E[] theData; /** The current size */ privateint size = 0; /** The current capacity */ privateint capacity = 0; . . . . . Chapter 4: Lists and the Collection Interface

  20. KWArrayList Class Constructor public KWArrayList() { capacity = INITIAL_CAPACITY; theData = (E[]) new Object[capacity]; } • Note that theData = (E[]) new Object[capacity]; causes compiler to issue warning message: KWListArray.java uses unchecked or unsafe operations • Why? Chapter 4: Lists and the Collection Interface

  21. KWArrayList Class Constructor (Again) public KWArrayList() { capacity = INITIAL_CAPACITY; theData = (E[]) new Object[capacity]; } • Suppose that instead we use theData = new E[capacity]; • Will this work? • No, since type of E is not known at compile time, so must create general Object and downcast Chapter 4: Lists and the Collection Interface

  22. Add(E anEntry) Method • The algorithm… • Insert new item at position indicated by size • Increment the value of size • Return true to indicate success • The picture… Chapter 4: Lists and the Collection Interface

  23. Add(E anEntry) Method • The code… publicboolean add(E anEntry) { if (size == capacity) { reallocate(); } theData[size] = anEntry; size++; returntrue; } • Would this work? theData[size++] = anEntry; Chapter 4: Lists and the Collection Interface

  24. Add(int index,E anEntry) Method • The algorithm… • Make room by shifting data elements “up” • Insert anEntry at position index • The picture… Chapter 4: Lists and the Collection Interface

  25. Add(int index,E anEntry) Method • The code… publicvoid add(int index, E anEntry) { if (index < 0 || index > size) { throw new ArrayIndexOutOfBoundsException(index); } if (size == capacity) { reallocate(); } for (int i = size; i > index; i--) { theData[i] = theData[i - 1]; } theData[index] = anEntry; size++; } Chapter 4: Lists and the Collection Interface

  26. set Method • The algorithm and picture are fairly obvious… • The code… public E set(int index, E newValue) { if (index < 0 || index >= size) { thrownew ArrayIndexOutOfBoundsException(index); } E oldValue = theData[index]; theData[index] = newValue; return oldValue; } Chapter 4: Lists and the Collection Interface

  27. get Method • The algorithm and picture are even more obvious… • The code… public E get(int index) { if (index < 0 || index >= size) { thrownew ArrayIndexOutOfBoundsException(index); } return theData[index]; } Chapter 4: Lists and the Collection Interface

  28. remove Method • The algorithm… • Remove element • Shift “down” to fill in the gap • The picture… Chapter 4: Lists and the Collection Interface

  29. remove Method • The code… public E remove(int index) { if (index < 0 || index >= size) { thrownew ArrayIndexOutOfBoundsException(index); } E returnValue = theData[index]; for (int i = index + 1; i < size; i++) { theData[i - 1] = theData[i]; } size--; return returnValue; } Chapter 4: Lists and the Collection Interface

  30. reallocate Method • The algorithm… • Double the size of the underlying array • The picture… • Not necessary! • The code… privatevoid reallocate() { capacity = 2 * capacity; E[] newData = (E[]) new Object[capacity]; System.arraycopy(theData, 0, newData, 0, size); theData = newData; } Chapter 4: Lists and the Collection Interface

  31. KWArrayList as Collection of Objects • Suppose we don’t want a generic collection… publicclass KWArrayList { // Data Fields /** The default initial capacity */ privatestaticfinalint INITIAL_CAPACITY = 10; /** The current size */ privateint size = 0; . . . . . • And each reference to type E[] is now Object[] /** The underlying data array */ private Object[] theData; Chapter 4: Lists and the Collection Interface

  32. Performance of KWArrayList • Set and get methods execute in constant time • No loops, so O(1) • Inserting or removing elements is linear time • Shift (at most) n elements, so O(n) • What about reallocate? Chapter 4: Lists and the Collection Interface

  33. Vector Class • 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 • The Stack class is a subclass of Vector • But Stack class is actually useful (next chapter…) Chapter 4: Lists and the Collection Interface

  34. ArrayList Limitation • Suppose we have a (virtual) line of 4 students • Give each student a number, 0 thru 3 • Where number represents position in line • For example: Bob (0), Alice (1), Eve (2), Charlie (3) • Suppose Alice leaves • Then Eve and Charlie must be “renumbered” • In general, this is O(n) operation • This is what happens with ArrayList remove • Behind the scenes, of course • Is there a better way? Chapter 4: Lists and the Collection Interface

  35. Linked Lists • Again, suppose we have a (virtual) line of 4 students • Instead of numbering… • Tell each student who is behind them • For example: Bob  Alice  Eve  Charlie • Bob knows Alice is behind him, etc. • Now suppose Alice leaves the line • Only Bob needs to make a change • Bob  Eve  Charlie • How to implement this linked list data structure? Chapter 4: Lists and the Collection Interface

  36. Linked Lists • The ArrayListadd and remove methods operate in linear time because loop shift elements in an 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 node • This is known as a single-linked list • In a double-linked list, each node has a link to the next node and a link to the previous node Chapter 4: Lists and the Collection Interface

  37. List Node • A node contains a data item and one or more links • A link is a reference to a node • A node class generally defined inside another class • Inner class: node details should be private • Recall, private is visible to parent class Chapter 4: Lists and the Collection Interface

  38. Linked List: Insert • Suppose we want to insert “Bob” after “Harry” • First, set next of Bob to next of Harry • Second, change Harry’s next to point to Bob • Note that the order matters! Chapter 4: Lists and the Collection Interface

  39. Linked List: Remove • Suppose we want to remove “Dick” from the list • First, note that Tom comes before Dick in list • Second, change next of Tom to next of Dick • Note that we must know predecessor of Dick Chapter 4: Lists and the Collection Interface

  40. Traversing a Linked List • A fairly simple process: • Set nodeRef to reference of first node (head) • whilenodeRef is not null • do something with node referenced by nodeRef • Set nodeRef to nodeRef.next • At end of list, nodeRef = nodeRef.next; • Gives null, which is just fine • If you then execute this statement again, what happens? • The dreaded NullPointerException • You have fallen off the end of the linked list! Chapter 4: Lists and the Collection Interface

  41. Circular Linked List • No beginning and no end • Kinda like trying to graduate from SJSU… • How to create a circular linked list? • Set next of last element to point to first element • Advantage(s)? • Cannot fall off the end of the list • Disadvantage(s)? • Possible infinite loop Chapter 4: Lists and the Collection Interface

  42. 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 • These limitations are eliminated by adding a reference in each node to the previous node: double-linked list Chapter 4: Lists and the Collection Interface

  43. Double-Linked List: Example Chapter 4: Lists and the Collection Interface

  44. Double-Linked List: Insert • We want to insert Sharon between Harry and Sam • Set Sharon’s next to Sam • Set Sharon’s prev to Harry • Set next of Harry to Sharon • Set prev of Sam to Sharon Chapter 4: Lists and the Collection Interface

  45. Double-Linked List: Insert Chapter 4: Lists and the Collection Interface

  46. Double-Linked List: Insert Chapter 4: Lists and the Collection Interface

  47. Double-Linked List: Insert (Again) • We want to insert Sharon into list before Sam… • …only using references to Sam • Set sharon.next to sam • Set sharon.prev to sam.prev • Set sam.prev.next to sharon • Set sam.prev to sharon • Note that the order matters! • Must use sam.prev before changing it Chapter 4: Lists and the Collection Interface

  48. Double-Linked List: Insert (Again) Chapter 4: Lists and the Collection Interface

  49. Double-Linked List: Insert (Again) Chapter 4: Lists and the Collection Interface

  50. Double-Linked List: Remove • Suppose we want to remove Harry • Where Harry is after Dick and before Sharon • Set dick.next to sharon • Set sharon.prev to dick Chapter 4: Lists and the Collection Interface