Lists

1. Lists Chapter 4

2. Chapter Contents • Specifications for the ADT List • Redefining the Specifications • Using the ADT List • Java Class Library: The Interface List • Using a List Is Like Using a Vending Machine

3. Specifications for the ADT List • A list provides a way to organize data lists are “sequential” Fig. 4-1 A to-do list. not accidental http://en.wikipedia.org/wiki/Abstract_data_type

4. Specifications for the ADT List • Operations on lists • Add new entry – at end, or anywhere • Remove an item • Remove all items • Replace an entry • Look at any entry • Look for an entry of a specific value • Count how many entries • Check if list is empty, full • Display all the entries

5. Specifications for the ADT List • To specify an ADT list • Describe its data • Specify the operations (fewer than prev slide) • ADT list must be considered in general without regard to implementation. • Not necessarily a list of strings • Note specification, page 83, 84

6. Example importance of toString() in verifying spec Fig. 4-2 The effect of ADT list operations on an initially empty list

7. Potential Problem Operations • add, remove, replace, getEntry work OK when valid position given • remove, replace and getEntry not meaningful on empty lists • A list could become full, what happens to add?

8. Possible Solutions impose preconditions • Assume the invalid situations will not occur • Ignore the invalid situations • Make reasonable assumptions, act in predictable way • Return boolean value indicating success or failure of the operation • Throw an exception no exceptions robust implementation Step 1: Identify unusual situations Step 2: Specify how your ADT will behave.

9. Listing 4-1 (1): /** An interface for the ADT list. * Entries in the list have positions that begin with 1. */ public interface ListInterface { /** Task: Adds a new entry to the end of the list. * @param newEntry the object to be added as a new entry * @return true if the addition is successful, or false if not */ public boolean add(Object newEntry); /** Task: Adds a new entry at a specified position within * the list. Entries originally at and above the specified * position are at the next higher position within the list. * The listâs size is increased by 1. * @param newPosition an integer that specifies the desired * position of the new entry; newPosition >= 1 * and newPosition <= getLength()+1 * @param newEntry the object to be added as a new entry * @return true if the addition is successful, or false if not */ public boolean add(int newPosition, Object newEntry);

10. Listing 4-1 (2): /** Task: Removes the entry at a given position from the list. * Entries originally at positions higher than the given * position are at the next lower position within the list, * and the listâs size is decreased by 1. * @param givenPosition an integer that indicates the position of * the entry to be removed; givenPosition >= 1 * and givenPosition <= getLength() * @return either the entry at position givenPosition, if the removal * was successful, or null */ public Object remove(int givenPosition); /** Task: Removes all entries from the list. */ public void clear();

11. Listing 4-1 (3): /** Task: Replaces the entry at a given position in the list. * @param givenPosition an integer that indicates the position of the * entry to be replaced; givenPosition >= 1 * and givenPosition <= getLength() * @param newEntry the object that will replace the entry at the * position givenPosition * @return true if the replacement occurs, or false if either the * list was empty or givenPosition is invalid */ public boolean replace(int givenPosition, Object newEntry); /** Task: Retrieves the entry at a given position in the list. * @param givenPosition an integer that indicates the position of * the desired entry; givenPosition >= 1 * and givenPosition <= getLength() * @return a reference to the indicated list entry, if found, * otherwise returns null */ public Object getEntry(int givenPosition);

12. Listing 4-1 (4): /** Task: Determines whether the list contains a given entry. * @param anEntry the object that is the desired entry * @return true if the list contains anEntry, or false if not */ public boolean contains(Object anEntry); /** Task: Gets the length of the list. * @return the integer number of entries currently in the list */ public int getLength(); /** Task: Determines whether the list is empty. * @return true if the list is empty, or false if not */ public boolean isEmpty(); /** Task: Determines whether the list is full. * @return true if the list is full, or false if not */ public boolean isFull(); /** Task: Displays all entries that are in the list, one per * line, in the order in which they occur in the list. */ public void display(); } // end ListInterface better to use toString()

13. Redefining Specifications • A first draft of an ADT specifications may ignore potential problems • Simplifies the first draft • Concentrate on details after major portions of specifications written • Makes the specifications complete • After writing specifications, implementations • Write Java statements to use the ADT • Checks understanding, suitability of the specifications test code

14. Using the ADT List Fig. 4-3 A list of numbers that identify runners in the order in which they finish a race

15. Using the ADT List public class ListClient { public static void main(String[] args) { testList(); } // end main public static void testList() { ListInterface runnerList = new AList(); // has only methods // in ListInterface runnerList.add("16"); // winner runnerList.add(" 4"); // second place runnerList.add("33"); // third place runnerList.add("27"); // fourth place runnerList.display(); } // end testList } // end ListClient can only call ListInterface methods AList implements interface ListInterface pg. 88, 89 of text.

16. Java Class Library: The Interface List • The standard package contains a list interface – called List • Methods provided public boolean add(Object newEntry) public void add(int index, Object newEntry) public Object remove(int index) public void clear() public Object set(int index, Object anEntry) // like replace public Object get(int index) // like getEntry public boolean contains(Object anEntry) public int size() // like getLength public boolean isEmpty() Exercise: Find exceptions thrown by these methods add: UnsupportedOperationException ClassCastException NullPointerException IllegalArgumentException

17. What if you don’t Implement all Methods: public interface MyInterface<T> { public void add(T t) throws UnsupportedOperationException ; . . . } public class MyClass<T> implements MyInterface<T> { public void add(T t) { throw new UnsupportedOperationException(“Not implemented”); } . . . }

18. A List is Like a Vending Machine all about the user interface: - only do certain things - you need to understand these things - can’t get inside - don’t need to get inside - replacing the insides won’t affect how you use the machine Fig 4-4 A vending machine.

19. A List is Like a Vending Machine Observations about vending machines • Can perform only tasks shown on interface • Must understand the tasks • Cannot see inside the machine • Can use the machine even though don’t know what happens inside • If inside of machine replaced with new improved version • Interface remains unchanged • Customer uses machine in same way as before

20. A List is Like a Vending Machine Observations about clients and List ADT • Client can perform only operations from the ADT List • Client must adhere to specifications • Client cannot access data without an ADT operation • Client can use the list – even though unable to access entries directly • If implementation is changed, client still uses list in same way as before