1. Chapter 5 Array-Based Structures © 2006 Pearson Education Inc., Upper Saddle River, NJ. All rights reserved.

2. Overview ● General-Purpose Array-Based Structures – 5.1 Getting around fixed length arrays – 5.2 Stack and Queue interfaces – 5.3 List interface and the ArrayList class – 5.4 List traversal

3. Data and Methods Visibility in Java Modifier on members in a class Accessed from the same class Accessed from the same package Accessed from a subclass (child class) Accessed from a different package publicYes protectedYes No (default)Yes No privateYesNo

4. Shrinking and Stretching Arrays ● Array lengths are determined and fixed when allocated. ● Many times implementations require variable lengths of items.

5. Shrinking and Stretching Arrays ● A Deck holds a varying number of Cards, fewer as Cards are dealt.

6. Shrinking and Stretching Arrays ● A Card has two fields, rank and suit.

7. Shrinking and Stretching Arrays

10. ● By specifying a size, we can limit the range of available elements. ● The Deck capacity remains unchanged at 52.

11. Shrinking and Stretching Arrays

12. ● Getting the number of Cards in the Deck and testing for an empty Deck are trivial. i.e. get the size variable. ● Only method to modify the size is the deal() method which removes and returns one Card from the Deck. ● size is decremented but the array still references the last element.

13. Shrinking and Stretching Arrays ● shuffle() should position the Cards randomly through the Deck. ● For each position in the Deck, randomly select another position in the Deck and swap Cards.

14. Shrinking and Stretching Arrays ● What if a structure needs to grow beyond its original capacity? ● Copy the entire contents of the array into a new, larger array.

15. Implementing Stacks and Queues ● ArrayStack Class – Similar to Deck class in that it contains an array data and an int size.

16. Implementing Stacks and Queues ● The isEmpty() method is identical to the one from Deck. ● The pop() method is similar to deal().

17. Implementing Stacks and Queues ● The peek() method is simpler than pop().

18. Implementing Stacks and Queues ● If the push() method is called when the data array is full, the array must be streched.

19. Implementing Stacks and Queues

20. ● ArrayQueue Class – Adding something to an ArrayQueue is exactly like pushing it onto an ArrayStack. ● Removing an element must cause the front of the queue to move along the array.

21. Implementing Stacks and Queues ● When insertions runs up against the right end of the array, the queue must wrap around, so that the next element added goes at position 0. or Note: size is the number of items currently in this queue.

22. Implementing Stacks and Queues

25. The List Interface ● Stacks and queues limit access to the data to one end or the other. ● The List Interface has a more general-purpose use. ● A List is similar to an array, but it does not have a fixed size. ● A List can access any data item arbitrarily.

26. The List Interface

27. Note: There are two overloaded remove() methods.

28. The List Interface Input list.add("eggs"); list.add("bread"); list.add("tea"); list.contains("eggs"); list.contains("rutabagas"); list.get(1); list.isEmpty(); list.remove(0); list.remove("llamachow"); list.remove("tea"); list.size(); Return Value true false “bread” false true 1 List [ eggs ] [ eggs bread ] [ eggs bread tea ] [ bread tea ] [ bread ]

29. The List Interface ● The ArrayList's structure is similar to the ArrayStack and ArrayQueue.

30. The List Interface ● Some methods are trivial: – get(int index) – set(int index, E target) – add(E target) ● Some are identical to the ArrayStack methods: – isEmpty() – isFull() – size() – stretch()

31. The List Interface ● contains() method searches the list for an object.

32. The List Interface ● remove() removes and returns the item at a given location or removes the first occurrence of a particular item, if any.

33. The List Interface ● remove(2) (to remove C) shifts all subsequent elements one place to the left.

34. Iterators ● Often a List must be traversed. ● Because access to the data from outside of the class is limited, an Iterator interface can be used to traverse the List.

35. Iterators ● Iterator general use: ● Warning: Each call to next() advances the Iterator.

36. Iterators ● java.util.NoSuchElementException – Thrown when the Iterator has reach it's end and next() is called. – Avoided by preceding all next() calls by a hasNext() test. ● java.util.IllegalStateException – Thrown when next() has never been invoked, or has not been invoked since the last invocation of remove().

37. Iterators ● The Iterable interface requires one method. ● When using Iterators, an enhanced for loop can be used.

38. Iterators

39. ● The iterator() method for ArrayList creates an instance of ArrayIterator. ● The ArrayIterator references the ArrayList. ● An int is also used to indicate how far down the ArrayList we've traveled. ● A previous index is useful to the remove() method.

40. Iterators

45. ● Keep going until the sum of the players’ scores is 13. ● A player keeps playing until he must “Go Fish”.

46. Iterators

48. ● The computerTurn() method is similar to playerTurn() method but the rank is chosen randomly. ● Rather than repeat work to covert a number to a rank, a Card of the rank in question is created from the number. The suit doesn't matter (HEARTS is arbitrarily specified).

49. Iterators

51. ● Both of the give() and meldSets() methods in the GoFishHand class involve Iterators, so we import java.util.Iterator. ● give() transfers all Cards of a given rank from one hand to another and returns a boolean indicating if any were transferred. ● meldSets() removes all sets of 4 same-rank Cards and returns the total number of sets.

52. Iterators

54. Iterators (p150)

55. Java Collections Framework

56. ● The java ArrayList is similar to the one implemented in this chapter. ● The Vector class is still present for backward compatibility. New code should use the ArrayList class. ● The framework does not include a Stack interface, but it does include a Stack class that extends the Vector class. ● There is a Queue interface, but no array-based implementation.

57. Java Collections Framework ● List is implemented by the class AbstractList. ● Abstract class instances can only be created by instantiating non-abstract classes that extend it. ● An abstract class is similar to an interface in that is defines abstract methods. ● The difference is that abstract classes may contain fields and non-abstract methods.

58. Java Collections Framework

59. Summary ● Array sizes cannot be changed, but the array- based structures can maintain varying sizes of data. ● Lists such as ArrayList provide basic methods for accessing elements and return Iterators. ● An Iterator allows us to traverse the List, visiting each element. ● Java’s collections framework includes a List interface, an ArrayList class, a Stack class, and a Queue interface.

60. Chapter 5 Self-Study Homework ● Pages: 126-153 ● Exercises: 5.3, 5.5, 5.17, 5.20, 5.21, 5.22 ● Note: If necessary, hand in the error-free program and screenshot of the execution results for each exercise.