List ADT. Announcements. The List interface. Implementing the List ADT

Transcription

1 Announcements Tutoring schedule revised Today s topic: ArrayList implementation Reading: Section 7.2 Break around 11:45am List ADT A list is defined as a finite ordered sequence of data items known as elements. List elements have a position attribute with an index. Note: ordered does not mean sorted. Basic operations: insert and remove elements anywhere in the list access any element (read or write access) in the list clear the list (empty it) grow and shrink as elements are inserted or removed search for an element in the list 1 2 The List interface Implementing the List ADT public interface List<E> extends Collection<E> { // Positional access E get(int index); E set(int index, E element); boolean add(e element); void add(int index, E element); E remove(int index); // Search int indexof(object o); int lastindexof(object o); // Iteration Iterator<E> iterator(); ListIterator<E> listiterator();...more... Two approaches to implementing the List ADT: arrays or linked list ArrayList<E> } 3 4 List<E> AbstractList<E> AbstractSequentialList<E> LinkedList<E> Oval: interface Rectangle: class 1

2 ArrayList vs. LinkedList Programming interface is the same (as we saw in IteratorExamples.java in the previous lecture) ArrayList full hierarchy Iterable<E> Underlying internal representations are different. contiguous memory (ArrayList) vs. linked non-contiguous chunks of memory (LinkedList) random access vs. sequential access Cloneable Collection<E> List<E> Object AbstractCollection<E> Because of implementation differences, their performance is quite different when, for example, inserting or deleting an element. RandomAccess AbstractList<E> Serializable ArrayList<E> Oval: interface Rectangle: class 5 6 ArrayList functionality Similar to Vector class They differ in their thread safeness (ArrayList is not thread-safe whereas Vector is) An ordered list of objects stored in contiguous memory in an array An integer index to access elements Random access Duplicate elements allowed Underlying array grows as needed Implementation An example implementation See ArrayList.java This one uses a nested class (inner class) to implement an iterator Nested class implementation is a preferred approach See non_nested/arraylist.java /ArrayListIterator.java /UseMyArrayList.java This uses a separate class rather than using an inner class 7 8 2

3 ArrayList performance Retrieving or setting one element? Uses index as an offset into the underlying array: Θ(1) Adding or removing an element at the end? Use a tail or size field to keep track of the end of the array: Θ(1). Well, not always! When is it not Θ(1)? Finding an element? Linear search: Θ(n) ArrayList performance (cont.) Inserting an element? Inserting an element at position k requires n-k elements to be shifted to make space: Θ(n). Worst case is at the head of the list since n elements have to be shifted: Θ(n). Average case is the middle of the list or n/2 shifts: Θ(n). Deleting an element? Deleting an element at position k requires n-k-1 elements to be shifted to fill the hole in the list: Θ(n). Worst case is at the head of the list since n-1 elements have to be shifted: Θ(n). Average case is the middle of the list or (n-1)/2 shifts: Θ(n). Inserting or deleting n distinct non-continuous elements? Θ(n 2 )! 9 10 Cloneable interface Should override clone() of Object If clone is inherited from Object, why do we also need to inherit Cloneable interface? A class implements the Cloneable interface to indicate to the Object.clone() method that it is legal for Object.clone() to make a fieldfor-field copy of instances of that class Invoking Object s clone on an instance that does not implement the Cloneable interface results in an exception (see the reference on Cloneable in the lecture notes area for further detail) Copying an object, e.g., an object with other objects composed into it Shallow copy Deep copy RandomAccess interface It is a marker interface (has no fields or methods) used by List implementations to indicate that they support fast (generally constant time) random access. See doc on java.util.randomaccess for further detail

4 java.util.serializable interface Also a marker interface transient keyword indicates non-serializable fields Why not include writeobject and readobject in it? Because only classes requiring special handling need them. What would be the effect then if they were included in Serializable anyhow? Serializability of a class is enabled by the class implementing the Serializable interface. Classes that do not implement this interface will not have any of their state serialized or deserialized. Classes that require special handling during serialization and deserialization must implement special methods with these exact signatures: private void writeobject(java.io.objectoutputstream out) throws IOException private void readobject(java.io.objectinputstream in) throws IOException, ClassNotFoundException Copy constructor public ArrayList (Collection<?> c) {... } Nested classes Nested Classes Have you noticed that we often write a bunch of little classes just to satisfy some local feature (data and ops)? These little classes can seem trivial but they are often really useful and even essential in supporting the larger more substantial classes. Creating lots of tiny top-level classes can be overkill though and a maintenance/support issue especially if they are exposed to other developers. Java allows these tiny classes to be embedded or encapsulated inside the larger class they are supporting

5 Inner classes Inner classes are classes that are defined inside a top-level class. They can be public, private, static, etc. just like other data fields and methods. Private inner classes are only visible inside the top-level class. Inner classes are often used as helper classes in conjunction with the top-level class. Inner classes Usefulness: inner classes are hidden from other classes (encapsulated) inner objects can access/modify the fields of the outer object Four types of inner/nested classes: static member class (referred to as nested top-level class) non-static member class (i.e., dynamic or instance) anonymous inner class (often used for GUI s) local inner class (often used for GUI s) Member classes An inner class that is declared non-static is also known as a member class. A member class must be created from an existing enclosing object and is tightly linked to the specific enclosing object. Think of each enclosing object as having its own independent copy of a member class. Member classes have access to all fields and methods, static and instance, of the enclosing class, even private ones. Correspondingly, the outer class has access to all the fields of the member class (public and private). Member classes are often used to create helper classes that need to know the state of the object to which it is linked. We will use them to implement iterators in collection classes Inner class syntax // outer (enclosing) class public class name {... } // inner (nested) class private class name {... } Only this file can see the inner class or make objects of it. Each inner object is associated with the outer object that created it, so it can access/modify that outer object's methods/fields. If necessary, can refer to outer object as OuterClassName.this

6 Static member classes Think of a static member class as an ordinary class and it happens to be defined static AND inside an enclosing or outer top-level class. It can access the enclosing class static fields and methods, even those declared private. Correspondingly, the outer class has full access to the static member class fields and methods. Next topic: Linked lists A static member class is similar to other static fields or static methods it belongs to the class not to an object. It must also obey all the same restrictions that static methods have it cannot access instance (non-static) fields and methods of the outer class