Abstract Data Types (ADTs) Example ADTs. Using an Abstract Data Type. Class #08: Linear Data Structures

Transcription

1 Abstract Data Types (ADTs) Class #08: Linear Data Structures Software Design III (CS 340): M. Allen, 08 Feb. 16 An ADT defines a kind of computational entity: A set of objects, with possible values A set of operations to perform Abstraction: the ADT does not say how operations are to be performed, exactly, only what they should do Described in terms of its interface How we interact with it, from an external point of view A Java class makes an ADT concrete Instance variables and methods implement the ADT Operations User Interface (visible) Implementation Details (hidden) 2 Example ADTs Primitive type like boolean can be given as an ADT: Values: true and false Operations:!, &&, The ADT for a more complex data structure like a Collection of objects is similar in structure: Values: sets of objects of some particular data-type Operations: ways to add, remove, find, those objects Using an Abstract Data Type Once we have defined the general form of the ADT, we can implement it in any number of ways Client code that uses the ADT should not need to know all the details of how this is actually done Java uses interface to define many ADTs The interface gives the abstract signature of a set of methods: defines the operations of the type in general terms A class that implements the interface will make these operations concrete in some manner We can then write code to use any such class based only on the interface itself, not the concrete implementation 3 4 1

2 The List ADT A list is a sequence of elements E 0, E 1, E 2,, E N-1 Any two elements in the list are related linearly: elements occur before or after one another The Java Collection Framework A built-in library of common ADTs and implementations java.util.collection General operations include the ability to: 1. Check the size of the list 2. Add or remove elements to or from the list 3. Check whether an object exists in the list 4. Iterate (loop) over elements of the list, in order java.util.set java.util.list java.util.queue java.util.linkedlist <class> java.util.arraylist <class> 5 6 Java Collection Interface public interface Collection<E> extends Iterable<E> int size(); boolean isempty(); boolean contains( Object element ); Iterator<E> iterator(); boolean containsall( Collection<?> c ); boolean addall( Collection<? extends E> c ); boolean removeall( Collection<?> c ); boolean retainall( Collection<?> c ); void clear(); Object[] toarray(); <T> T[] toarray( T[] a ); Collection is a sub-interface of another (Iterable, discussed later) 7 Collection Implementation Many of the Collection methods are defined, like the interface itself, in a generic fashion: boolean contains( Object element ); Iterator<E> iterator(); Object[] toarray(); <T> T[] toarray( T[] a ); E: actual type of object the Collection<E> contains T: a type supplied at runtime by input object Remember: when we use a generic type parameter (for the first time) in a method signature, we must declare it before we can use it in that method 8 2

3 Collection Implementation Other methods are given in terms of wildcard types: boolean containsall(collection<?> c); boolean containsall( Collection<?> c ); boolean boolean addall(collection<? Collection<? extends extends E> E> c); c ); boolean removeall(collection<?> c); c ); boolean retainall(collection<?> c); c ); <?>: Any type (usually should conform properly, or may cause runtime type exceptions) <? extends E>: guarantees that method calls only add objects that conform to Collection s type <E> Optional Collection Methods boolean addall( Collection<? extends E> c ); boolean removeall( Collection<?> c ); boolean retainall( Collection<?> c ); void clear(); Collections do not need to fully support destructive interface methods (i.e., those that change the collection from its current state) While these methods must be implemented as part of the interface (as per usual), some of these may simply throw java.lang.unsupportedoperationexception (Note: All of the standard Java Collection classes actually do implement all of these optional methods without exceptions, however.) 9 10 The Iterable/Iterator Interfaces Looping with Iterable/Iterator public interface Iterable<T> Iterator<T> iterator(); Iterable: superinterface of Collection. Every Collection will also be Iterable, and so will have iterator() method. public static <T> void print( Collection<T> coll ) Iterator<T> itr = coll.iterator(); while ( itr.hasnext() ) T item = itr.next(); System.out.println( item ); Basic Iterator starts off before first element of Collection. Each call to next() advances the Iterator onto an actual object (and returns reference) public interface Iterator<T> boolean hasnext(); T next(); default void remove(); Type returned by iterator() method. Also an interface, so whatever is actually returned must implement that interface and its methods. As of Java 8, the remove() method is supplied by default (just throws exception, unless overridden). for ( <Type_Name> <Var_Name> : <Collection_Name> ) <Code that does something to Var_Name> public static <T> void print( Collection<T> coll ) for( T item : coll ) System.out.println( item ); Any Iterable collection allows the for-each loop style. Handy compact notation for any loop that runs over all elements in order, start to end. (Works for arrays, too!)

4 Java List Interface List is a sub-interface of Collection, and therefore implements Iterator, too Iterator and ListIterator public interface List<E> extends Collection<E> // Positional access E get( int index ); E set( int index, E element ); void add( int index, E element ); E remove( int index ); boolean addall( int index, Collection<? extends E> c ); public interface Iterator<T> boolean hasnext(); T next(); default void remove(); ListIterator<T> is a subinterface of Iterator<T>. Extra abilities to add/set objects, move backwards as well as forwards, as well as access the numeric index of any element. // Search int indexof( Object o ); int lastindexof( Object o ); ListIterator<E> listiterator(); ListIterator<E> listiterator( int index ); // Range-view List<E> sublist( int from, int to ); Adds all elements of input c, starting with index, returns true if original changed Two kinds of iterators, with default starting at front of list, other starting from index public interface ListIterator<T> extends Iterator<T> boolean hasprevious(); T previous(); void add( T x ); void set( T newval ); int nextindex(); int previousindex(); Concrete Implementation To make use of the List interface in our programs, we need an actual concrete class that implements it Two basic approaches (with many variations): Direct access (ArrayList): Store elements in an array when we implement the basic List interface Linked access (LinkedList): Store elements in a chain of nodes, not necessarily contiguous, to implement List The java.util.arraylist Class ArrayList data: size: 4 A concrete implementation of the List interface/adt, using an array under the hood, but allowing dynamic re-sizing It has two basic attributes: capacity: the array it uses, with overall holding capacity size: the number of elements currently in the list A single, contiguous block of memory for accessing data

5 Using ArrayList ArrayList<String> teams = new ArrayList<>(); teams.add( "Steelers" ); teams.add( "Giants" ); teams.add( "Packers" ); System.out.println( teams.contains( "Packers" ) ); Iterator<String> iter = teams.iterator(); while ( iter.hasnext() ) System.out.println( iter.next() ); String old = teams.set( 0, "Eagles" ); System.out.println( "Used to contain: " + old ); System.out.println( "Now contains: " + teams.get( 0 ) ); for ( String t : teams ) System.out.println( t ); Iterator-style looping set() method does 2 things: inserts element at given index and returns previously stored element from that position Iterable-style for-each looping 17 This Week Topic: Linear Structures Read: Text, chapter 03 Meetings: as usual Monday Wednesday: 2205 Centennial Friday: Lab, 16/17 Wing Homework 01: due Friday, 15 Feb. (5:00 PM) Office Hours: Wing 210 Tuesday: 3:00 PM 4:00 PM Wednesday: 9:00 AM 10:30 AM Thursday: 2:00 PM 3:00 PM Friday: 9:00 AM 10:30 AM 18 5