1. Lists We’ve seen an array-based list implementation, the ArrayList. Advantage of an array-based implementation: –fast access to a specific index –typically less space usage than other options Disadvantage of an array-based implementation: –can be expensive to insert items –resizing is an expensive operation

2. Amortization Resizing of array-based data structures involves a tradeoff: –many insertions (as in our Bag) are very efficient since no allocation of space is required (an array is allocated as a big block of memory) –some insertions (as in our Bag) are very expensive since resizing must take place

3. Linked List A linked list is a list implementation which spreads out the cost of space allocation evenly to all insertions. Each insertion involves allocation of space

4. Advantages/Disadvantages Advantages –predictable cost of insertion –efficient insertion at any point in structure Disadvantages –extra space required to store links –inefficient indexing

5. Comparison of storage A pair has a first and a second element When pairs are used to construct lists, the first is called the “head” or the “car” the second is called the “tail”, “rest” or “cdr” the pair is called a “cons cell” or simply a “cons”.

6. Linked list implementations Textbook discusses a typical linked list implementation java.util.LinkedList is another typical implementation These implementations have procedural, not object-oriented, roots.

7. Traditional implementations provide a large number of methods – making it difficult to reuse if less functionality is desired; provide no means, beyond inheritance, to extend functionality to suit a specific situation; and adding functionality requires knowledge of internal structure of the list.

8. So… These implementations are inflexible, and do not exhibit good OO design. In lecture we will discuss a state-based list implementation which can be easily extended with new functionality.

9. Variant/Invariant decomposition Design principle which leads to cohesive and decoupled components That which is invariant is put into one component Variant properties/behaviors are factored out into separate components Compare this to what we saw with e.g. Observer pattern: –decoupling of event generation (invariant) from event handling (variant)

10. a list = a Linear Recursive Structure (LRS or LRStruct) What is a list? 1.the empty list is a list 2.a pair whose tail is a list is itself a list This is a recursive definition! (1) is called the base case, and (2) is called the recursive case. Note that traditional implementations do not follow this precise definition of what a list is: –many have no explicit representation of an empty list –none are recursive on the list; instead they recurse on a list node This has implications for how the structure can support extension (see Visitor support, in later slides)

11. States A list can therefore be in one of two states: –empty (corresponding to the base case) –non-empty (corresponding to the recursive case) The state-based implementation we will study makes this distinction explicit in the representation

12. Empty vs. NonEmpty state (look Ma, no NullPointerException!) An LRS object delegates all calls to its LRS State object – which can respond to all messages. Empty and NonEmpty states respond differently. There is never a null pointer in the structure! (Think about the implications of this for a while.)

13. What is basic (invariant) list functionality? insert new item at front remove item from front set/get first item (head) set/get rest (tail) plus (in Java) methods inherited from Object (toString, equals, etc)

14. How are these methods defined? public LRStruct insertFront(E item) { return _state.insertFront(this, item); } public E removeFront() { return _state.removeFront(this); } public LRStruct setDatum(E item) { return _state.setDatum(this, item); } public E getDatum() { return _state.getDatum(this); } public LRStruct setRest(LRStruct rest) { return _state.setRest(this, rest); } public LRStruct getRest() { return _state.getRest(this); }

15. LRStruct delegates to State! All of these methods delegate to the state of the LRStruct. States polymorphically determine what happens.

16. An empty LRS LRS a = new LRS(); _state LRSEmpty a

17. Inserting an item into an empty LRS a.insertFront(“fred”); _state LRSEmpty a

18. Inserting an item into an empty LRS a.insertFront(“fred”); _state LRS a Empty

19. Inserting an item into an empty LRS a.insertFront(“fred”); _state LRS NonEmpty a Empty _tail _dat= “fred”

20. Inserting an item into an empty LRS a.insertFront(“fred”); _state LRS NonEmpty a LRS Empty _state_tail _dat= “fred”

21. Inserting an item into an empty LRS a.insertFront(“fred”); _state LRS NonEmpty a LRS Empty _state_tail _dat= “fred”

22. Removing an item from an LRS a.removeFront(); _state LRS NonEmpty a LRS Empty _state_tail _dat= “fred”

23. Removing an item from an LRS a.removeFront(); _state LRS NonEmpty a LRS Empty _state_tail _dat= “fred” These gray objects will be garbage-collected at some point in the future

24. How about extensibility? Enter the Visitor pattern A visitor is an object which encapsulates an algorithm A visitor for the LRS defines what to do in each of the states: –emptyCase –nonEmptyCase

25. Visitor interface to LRS the execute method is also generic (I=input,O=output): public O execute(IAlgo algo, I arg) the first parameter, alg, is the visitor (the algorithm) the second parameter, arg, is optional input to the algorithm the return type of the method is of type O

26. execute definition in states Empty state: public O execute(IAlgo algo, LRStruct host, I arg) { return algo.emptyCase(host, arg); } NonEmpty state: public O execute(IAlgo algo, LRStruct host, I arg) { return algo.nonEmptyCase(host, arg); }

27. Designing a visitor (IAlgo) A visitor to solve a given problem must provide the answer in each of two cases: –the empty case –the non-empty case One example: finding the length of a list.

28. Length visitor (Java5 version: with generics & autoboxing) in the empty case the answer is zero in the non-empty case the answer is one more than the length of the rest of the list public Integer emptyCase(LRStruct host, Object _){ return 0; } public Integer nonEmptyCase(LRStruct host, Object _){ return 1 + host.getRest().execute(this,_); }

29. Another visitor How about a visitor for a list of Strings, which doubles each String Ex: –starting list: (Fred Wilma Pebbles) –resulting list: (FredFred WilmaWilma PebblesPebbles)

30. StringDouble visitor in the empty case there is nothing to do in the non-empty case the thing to do is to get the first, concatenate it to itself, and set the first to this new value public Object emptyCase(LRStruct host, Object _){ return null; } public Object nonEmptyCase(LRStruct host, Object _){ String s = host.getFirst(); host.setFirst(s+s); return host.getRest().execute(this,_); }