The Java Collections Framework and Lists in Java Parts 1 & 2

Transcription

1 The Java Collections Framework and Lists in Java Parts 1 & 2 Chapter 9 Chapter 6 ( ) CS 2334 University of Oklahoma Brian F. Veale

2 Groups of Data Data are very important to Software Engineering Data is a plural word The concept of groups of objects is natural Storage or Manipulation of groups of objects is a very common development task. You will spend a lot of time working with groups of data in software development Many of the problems in Computer Science deal with manipulating large groups of data Page 2

3 Arrays If you ve taken a programming class, you ve used an array Arrays allow us to put similar data in a cohesive unit Implementation dependent myclass :Student :Student :Student :Student :Student Page 3

4 The Java Collections Framework The Java Collections Framework (JCF) includes many ways to manipulate groups of data Library of classes, objects, and methods for grouping data Also designed as a framework Skeletal support for something being constructed The JCF is designed to be systematically extended and reused Page 4

5 JCF Collections The most general object in the JCF is the Collection interface A group of generic Object elements Most of the collection interfaces work on Objects Type casting is common when using Collections Java removes a lot of the need for casting through the use of generics. instanceof operator ClassCastException Page 5

6 Page 6 Required Methods in Collection boolean contains(object target) - Returns true if target is one of the Objects stored in the Collection. boolean containsall(collection c) - Returns true if every element in Collection c is also one of the Objects stored in the Collection, and false otherwise. boolean isempty() Iterator iterator() - Used to list the Contents of the Collection in order. Object[] toarray() Object[] toarray(object[] typearray) - Returns an array containing the elements in this Collection whose type (not contents) comes from the type of elements in typearray. int size()

7 Page 7 Optional Methods in Collection boolean add(object element) boolean addall(collection objs) - Add all the elements from Collection objs to this Collection. boolean clear() boolean remove(object target) boolean removeall(collection c) - Remove all the elements in Collection c from this Collection. boolean retainall(collection c) -Remove all the elements in this Collection, except for those that are in Collection c.

8 The Collection Interface in Action Demo: CollectionDemo.java Page 8

9 Person and Student Design <<interface>> Comparable +compareto( obj: Object ): int -name: String -id: String -em ail: String Person +Person(pName: String, pid: String): void +getname(): String +getid(): String +get (): String +set (address: String): void + getstatus():int <<interface>> Cloneable Page 9 <<interface>> Serializable -hours: int -gpa: float Student +Student(pName: String, pidl String, phours: int, pg P A : float): void +gethours(): int +getgpa(): float +sethours(phours: int): void +setgpa(pgpa: float): void

10 Collections Classes that provide useful methods for manipulating objects that implement Collection Cannot be instantiated Not because it is an interface It has no public constructor, only static methods Similar to the Math class. Page 10

11 Useful methods from Collections Object min( Collection c ) Returns the smallest element in Collection c Object max( Collection c ) Returns the largest element in Collection c The classes of the objects contained in the Collection c must implement comparable Otherwise our friend ClassCastException will be thrown Page 11

12 Collections in Action Demo: CollectionSort.java Notice use of casting... In Java 1.4.* and earlier you must cast the String back into a String (as shown). For this code to compile without warnings you must use the following compilation command Javac -source 1.4 CollectionSort.java Page 12

13 Lists Lists are a common way to store data Grocery Lists Class Rosters Lists are more than a collection What does a list imply? What do we do to lists that we don't do to collections? Page 13

14 The List ADT Page 14 Lists are one of the most common ADTs Linear Elements are stored in a fixed order Collection by itself doesn't guarantee any type of ordering A collection can be unsorted or sorted in some order Alphabetically By size By date Etc. List is a interface ArrayList, LinkedList, etc. each implement List

15 Definitions: Ordered and Sorted A Collection is ordered if the elements are in a predictable sequence. A Collection is sorted if the elements are ordered according to some criterion like Strings being ordered alphabetically Page 15

16 Adding to a List Collection methods become more specific when included in a List ADT. add( Object element ) in Collection Says nothing about where the object is added, only that it is added. We will add an object to the end of a list Intuitive way to add to a list. Helps increase the efficiency of adding. We don't have to traverse the list to figure out where to add the element. Page 16

17 Adding to a List: Example Alex Freddie Brian Bob Cali Sammy add( Kristina ) Alex Freddie Brian Bob Cali Sammy Kristina Page 17

18 Removing from a List Page 18 Collection just guarantees that one copy of the object will be removed from the list Which copy to remove from a List should be clear. First? Last? Middle? Somewhat arbitrarily, we remove the first occurrence. These type of decisions should be very clear in the documentation for the ADT.

19 Removing from a List: Example Alex Cali Freddie Brian Bob Cali Sammy remove( Cali ) Alex Freddie Brian Bob Cali Sammy Page 19

20 Another way to add to a List Many of the Collection class methods are modified by List Some methods needed to support a List cannot be implemented in Collection void add( int index, Object element ) What about the element currently in that position? Will it be replaced? Will it be shifted by one position? To the left (up)? To the right (down)? Page 20

21 Indexed Adding to a List: Example Page 21 Alex Freddie Brian Bob Cali Sammy add( 2, Katrina ) replacing shifting Alex Freddie Katrina Bob Cali Sammy Alex Freddie Katrina Brian Bob Cali Sammy

22 Adding a Collection to a Collection List also supports adding an entire collection to the current collection addall( Collection c ) Can we just call add( Collection c )? This would add that the entire Collection as one object. This is not what you might expect. Page 22

23 Adding a Collection the wrong way Alex Freddie Brian Bob Cali Sammy Sue c James add( Collection c ) Carl Alex Freddie Brian Bob Cali Sammy James Sue Carl Page 23

24 Adding a Collection the right way Alex Freddie Brian Bob Cali Sammy c James addall( Collection c ) Carl Alex Freddie Brian Bob Cali Sammy James Sue Carl Sue Page 24

25 Replacing an element in the List We also want to be able to replace one element with another element This method follows the Java convention of set as a mutator It changes the contents of the List set( 2, Jenny ) Page 25

26 Replacing an element in a List: Example Alex Freddie Brian Bob Cali Sammy set( 2, Jenny ) Alex Freddie Jenny Bob Cali Sammy Page 26

27 List methods (only those changed or added to Collection): boolean add(object element) - Add element to the end of this List. boolean addall(collection objs) - Add all the elements from Collection objs to end of this List. void add(int index, Object element) - Add an element to the given index location. Shift the other elements down. void addall(int index, Collection objs) - Insert all the elements from Collection objs to starting at the indexed value. Shift elements down to make room. Object get(int index) ListIterator listiterator() - Returns a listiterator for this Collection Object set(int index, Object element) int indexof(object obj) int lastindexof(object obj) Page 27

28 List Demo ListDemo.java Notice what happens when we use addall() instead of add() on lines Page 28

29 Accessing the Elements in a Collection Programmers often want to traverse collections sequentially. Iterator an object that allows us to move in order through a collection from one element to another Iterators make this process uniform. It knows the details of the Collection Not us Order in which the iterator moves through a collection is dependent on the type of collection being operated on Page 29

30 The iterator() method in Collection The Collection interface defines a method with the signature: Iterator iterator() It returns an iterator for it's backing collection This is the collection that the iterator is connected to. All iterators implement at least three methods... Page 30

31 Iterator methods boolean hasnext() This method returns true if the iterator has more items. Obvious use: sentry value for while loops using iterator Object next() Returns the next item in the sequence and advances to the next position. Throws an exception if there is not a next position. void remove() Removes the object from the list that was last returned by next(). Not supported by all type of iterators. Throws exception if last operation was not next(). Page 31

32 The ListIterator Page 32 Lists can use a list iterator in addition to a regular Iterator ListIterator contain extra functionality because Lists are ordered Two methods exist in List to return a new ListIterator ListIterator listiterator() Returns a ListIterator object for the entire List ListIterator listiterator(int index) Returns a ListIterator that will return the element at position index first.

33 Methods that ListIterator adds to Iterator Page 33 boolean hasprevious() Returns true if the List has an element before the current one. int nextindex() Returns the index of the next element in the List Object previous() Returns the elements in the List before the current element. int previousindex() Returns the index of the previous element in the List

34 remove(), add(), and set() in ListIterator remove() ListIterator overrides the remove() method of Iterator remove() removes the object from the list that was last returned by next() or previous(). add() Inserts the new element into the list before/after the next element that would be returned by next()/previous(), respectively. set() Replaces the last element returned by next() or previous() Page 34

35 ListIterator example: ListIteratorDemo.java Page 35

36 Iterator or ListIterator? Page 36 Both can be used with a List Only Iterator can be used for a Collection Which to use depends on your needs Do you need the more specific ListIterator methods? If not necessary or useful, don t use a ListIterator. In general, don t use a more complex class if a simpler one will suffice.

37 The Collections class and Lists Collections class has many useful Listoriented methods Only make sense with List objects These methods deal with ordered and/or sorted Lists Since Collection does not imply an order, the methods aren t useful Page 37

38 Collections.sort() Page 38 The Collections class can sort a List based on its natural ordering The natural ordering is the one implemented in the compareto() method in your object. Must implement Comparable to use. Incredibly useful method Required for using some other Collections methods like binarysearch() Signature: Collections.sort(List list) Sorts the List list according to the order imposed by the compareto() method of the objects stored in the list.

39 Collections.binarySearch() Binary searches are much more efficient than linear ones Don t need to go through all the elements of a List to find our target Faster on some types of lists than others Page 39

40 Collections.binarySearch() Signature: int Collections.binarySearch(List list, Object key) Returns the index of the key if key is found in the list Returns (-(insertion point) - 1) if the key is not found in the List Insertion point is the index of where the key would be inserted if it was in the List Return (-(insertion point) - 1) to ensure that we only get a positive return value if the key is found in the List Page 40

41 Collections.sort() and Collections.binarySearch() Demo ListSortAndSearch.java Page 41

42 Programming with Lists We have been using ArrayList to implement a collection as a List ArrayList is not the only class that implements the List interface ArrayList LinkedList Vector Page 42

43 Implementation of ArrayList myclass Size is 3 Capacity is 5 :Student :Student :Student Page 43

44 Advantages of the ArrayList Implementation Random Access Suppose each object reference takes up one memory location If the reference to element at index 32 is stored at address 421, the reference to element at index 33 is stored at address 422. If array element 0 is stored at address 212, element 5 is stored at = 217 and element 50 is stored at = 262. Arrays have random access because you can navigate to any index position. In arrays this navigation can be done with only one operation! Page 44

45 Disadvantages of the ArrayList Implementation Array data must stored in contiguous memory. If we need to expand an array, we don t know if we ll have room adjacent to it in memory. To expand the array, it must be copied into a new larger array. This is extremely costly. Page 45

46 add(int index, Object element) Page 46 This is an expensive operation. The shifted data must be copied to a higher index in the array. If the data is added to the the front of the List, all of the data in the List must be shifted. Imagine doing this for a List with 5000 elements. If the array is at max capacity before the add, the data must also be relocated. Removing element from the Array can also be costly for the same reasons.

47 The other option: LinkedList Linked lists don t allocate memory all at once like an Array list. It is done incrementally, as needed. myclass null :Student :Student :Student Page 47

48 Disadvantages of LinkedList Cannot use simple addition to figure out address of certain element. We must go through the List sequentially to find an element i.e. to get to the element at index 4, we must first go to element 0, then 1, then 2, then 3, and then 4 Imagine this for a million element list. Access to a List element can be much slower than an Array element. Why would we ever want to use this implementation? Page 48

49 Advantages of LinkedList Adding an element to a position other than the end of the List can be much more efficient. Also true with removing elements Contains a few extra methods Which you should use will depend on what you want to do with the List. Page 49

50 How to Use LinkedList Declare the list like we declare an ArrayList List arraylist = new ArrayList(); List linkedlist = new LinkedList(); Page 50

51 Converting Code from ArrayList to LinkedList Page 51 If you declared the ArrayList as shown on the previous slide, just replace new ArrayList() with new LinkedList() If you declared the list as follows, then: Arraylist arraylist = new ArrayList(); Method calls that are specific to ArrayList will become invalid. Unless you need to use a specific method from ArrayList or LinkedList you should always declare the list as shown on the previous slide. In a similar fashion you can convert code that uses LinkedList to use ArrayList

52 Sample Exercises Chapter 9 Exercises 10, 12, 13 Page 52