SUMMARY INTRODUCTION COLLECTIONS FRAMEWORK. Introduction Collections and iterators Linked list Array list Hash set Tree set Maps Collections framework

Transcription

1 SUMMARY COLLECTIONS FRAMEWORK PROGRAMMAZIONE CONCORRENTE E DISTR. Università degli Studi di Padova Dipartimento di Matematica Corso di Laurea in Informatica, A.A Introduction Collections and iterators Linked list Array list Hash set Tree set Maps Collections framework rcardin@math.unipd.it 2 INTRODUCTION INTRODUCTION Data structures can make a big difference in programming Do you need to search quickly? Do you need to rapidly insert and remove element?... The first version of Java was supplied with a very small set of classes Vector, Stack, Hashtable, BitSet and Enumeration Java needed a serious data structure library Without the complexity of C++ STL With the benefit of «generic algorithms» of C++ STL The collections framework satisfies those needs Java collection framework separates interfaces and implementations It defines a set of interfaces that represents abstract data structures Each interface is then implemented in different ways, each with main focus on some aspects For example, fast insertion, fast search, fixed memory consumption,... Using interfaces, you can change the implementation simply modifying a single statement // ArrayList optimizes random access, LinkedList modification stmts List<Integer> list = new ArrayList<>(); list = new LinkedList<>() 3 4

2 INTRODUCTION The fundamental interface for collection is the Collection interface public interface Collection<E> { boolean add(e element); Iterator<E> iterator(); //... The add method adds an element ot the collection Returns true if the collection was changed by the addition Iterators are used visit elements in the collection Implements the Iterator design pattern public interface Iterator<E> { E next(); boolean hasnext(); void remove(); 5 6 Using iterators we have decoupled a collection from the traversing policies The order in which elements are visited depends on the the collection type Using the next method the collection is visited one element at time If the end of the collection is reached an NoSuchElementException is thrown Use the hasnext method to check if the collection has more elements to visit Think of Java iterators as being between elements The iterator jumps over the next element Think of Java iterators as being between elements While moving, the iterator returns the current element 7 8

3 Using next and hasnext it is possibile to traverse the collection Collection<String> c = /*... */; Iterator<String> iter = c.iterator(); while (iter.hasnext()) { String element = iter.next(); // do something with element As of Java 5, there is an elegant shortcut to looping a collection using iterators for (String element : c) { // do something with element To use the for each loop the data structure must implement Iterable<E> interface Using an iterator it possibile to remove elements from a collection The remove method removes the element that was returned by the last call to next There is a strong dependency between next and remove: it is illegal to call remove if it wasn t preceded by a call to next for (Iterator<String> iterator = list.iterator(); iterator.hasnext();) { // Point the iterator to the current element String string = iterator.next(); iterator.remove(); This is the only way to safely modify a collection after the creation of an iterator 9 10 CONCRETE COLLECTIONS All concrete collections implement Collection or Map interfaces We will introduce only few of them Collection type ArrayList LinkedList HashSet TreeSet HashMap Description An indexed sequence that grows and shrinks dynamically An ordered sequence that allows efficient insertion and removal at any location An unordered collection that rejects duplicates A sorted set A data structure that stores key/value associations 11 12

4 LINKED LIST LINKED LIST A LinkedList<E> is an ordered data structure that stores each object in a link Each link store a reference to the next link of the seq. In Java, a linked list is always doubly linked Very efficient for remove and add operations These ops are made through an Iterator Other elements in the list have not to be repositioned after removal of an element Implements List<E> interface LINKED LIST LINKED LIST Also di add operation is made efficiently through an iterator of type ListIterator<E> interface ListIterator<E> extends Iterator<E> { void add(e element); E previous() boolean hasprevious() Use List.listIterator method to get one New element is added before the current position of the iterator Be carefull of concurrent modification using iterators Linked list are very inefficient in random access Adding a new element changes at most two references for (int i = 0; i < list.size(); i++) // do something with list.get(i); 15 16

5 ARRAY LIST ARRAY LIST An ArrayList<E> is an ordered data structure that is very efficient in random access ops. It encapsulate a dynamically reallocated array of objects Adding and removing operation are not so efficient Reallocation of elements is needed Use ArrayList instead of Vector More efficient due to its not synchronized methods HASH SET HASH SET A Set<E> is a data structure that doesn t care about element s ordering A set contain the same element only once Search operation performs very efficiently A set is a Collection An HashSet<E> uses hash codes to distinguish among elements An hashcode is a number that can be derived from object data You must provide an hash function to your classes The function must be compatible with the equals method Hash codes have to be computed quickly Hash functions have some hash collision Using the correct hash function the number of collision should be unlikely Hash table are implemented as an array of linked lists buckets Using an hash function, the bucket in which inserting a new element is equal to hash(element) % #bucket If the hash function produceds values that are randomly distributed, collision should be rare 19 20

6 HASH SET TREE SET An HashSet is implemented using an hash table The contains method is very efficient, because it has to lookup the element only in one bucket An iterator to hash set visit each bucket in turn Because of scattering, they are visited in a seemingly random order The add method adds an element if it is not already present Don t mutate an element in a set once inserted If the hash code of an element were to change, the element would no longer be in the correct position A TreeSet<E> is a sorted set While iterating over the collection, the elements are presented in sorted order It uses a red black tree to store data Insertion is slower than insertion in an hash table, but it is still much faster than insertion in an array or linked list...but a tree set automatically sorts the elements ;) The type of the elements may implement Comparable<T> public interface Comparable<T> { // It returns a value that is < 0, = 0 or > 0 int compareto(t other); TREE SET TREE SET What if elements do not implement Comparable or if you need more than on compation alg? Provide a Comparator during set construction public interface Comparator<T> { // Defines how two elements of type T have to be compared int compare(t a, T b); The compare method acts like the compareto method Function object (lambda anyone?!) Using an HashSet or a TreeSet? There must be a total ordering defined on elements You have to implement also the Comparator interface Do you neeed elements to be sorted? 23 24

7 MAPS MAPS A Map<K,V> is a data structure that allows you to search an element using a key A map stores key/value pairs // HashMap implements Map Map<String, Employee> staff = new HashMap<>(); Employee harry = new Employee("Harry Hacker"); staff.put(" ", harry); Key must be unique: If you call the put method twice with the same key, the second value replaces the first one. String s = " "; e = staff.get(s); // gets harry If no info is associated with a key, get returns null In sets to find an element you must have a copy of it An HashMap hashes the keys The collection framework does not consider a map itself as a Collection It is possible to obtain views of the map Set<K> keyset() // Set of keys Collection<K> values() // Collection of values Set<Map.Entry<K, V>> entryset() // Set of pairs (key,value) If you are interested in all the values of a map, loop over the enumeration of its entries for (Map.Entry<String, Employee> entry : staff.entryset()) { String key = entry.getkey(); Employee value = entry.getvalue(); // do something with key, value Iterators on views cannot add elements to the map An UnsupportedOperationException is thrown THE FRAMEWORK THE FRAMEWORK A framework is a set of classes that form the basis for building advanced functionality The Collection framework defines classes to implement collections The main interfaces are Collection and Map Insertion interfaces are different between the two types // To insert an element in a Collection boolean add(e element) // To store a key/value pair in a Map V put(k key, V value) To get the elements from a Collection, just iterate over it To get a value from a Map, use the get method V get(k key) A List is an ordered collection There is the concept of position of an element void add(int index, E element) E get(int index) void remove(int index) A list provides random access methods Lists provides a specialized iterator, ListIterator void add(e element) A Set is a Collection with no duplicates The add method can reject a value if already present Methods equals and hashcode are used to maintain elements inside the set 27 28

8 THE FRAMEWORK THE FRAMEWORK The framework provides some wrappers The framework have some companion objects The Arrays type allows to trasform arrays into List static <T> List<T> aslist(t... a) The list returned is a view on the array: it is not possible to change the size of the list; elements are the same The Collections type have a bunch of utilities The method ncopies builds an illusory immutable list List<String> settings = Collections.nCopies(100, "DEFAULT"); Object is stored only once Method singleton returns an illusory set with one element Collections.singleton(anObject) And so on THE FRAMEWORK EXAMPLES snippets 31 32

9 REFERENCES Chap. 13 «Collections», Core Java Volume I Fundamentals, Cay Horstmann, Gary Cornell, 2012, Prentice Hall 33