Collections (Java) Collections Framework

Transcription

1 Collections (Java) Collection an object that groups multiple elements into a single unit. o store o retrieve o manipulate o communicate o aggregate data Collection sometimes called a container. Collections Framework Interfaces - abstract data types. Implementations. Algorithms searching, sorting Algorithms are said to be polymorphic - the same method can be used on many different implementations of the appropriate collection interface: Metodo parametrų tipus rekomenduojama nurodyti interface lygio, o ne tikslias realizacijas, t.y. List, o ne ArrayList arba LinkedList: public void spausdinti(list list) { for (Object o : list) { System.out.print(o + " "); System.out.println(""); public void spausdinti (Collection list) { for (Object o : list) { System.out.print(o + " "); System.out.println(""); public void spausdinti(list list) { Iterator it = list.iterator(); while (it.hasnext()) { System.out.print(it.next() + " "); System.out.println(""); ArrayList arr = new ArrayList(); LinkedList list = new LinkedList(); spausdinti(arr); spausdinti(list); public void spausdinti (Collection list) { Iterator it = list.iterator(); while (it.hasnext()) { System.out.print(it.next() + " "); System.out.println(""); Nerekomenduojama : public void spausdinti(arraylist list) { public void spausdinti(linkedlist list) { Collections / 1

2 Interfaces Set a collection that cannot contain duplicate elements. List an ordered collection (sometimes called a sequence). Lists can contain duplicate elements. The user of a List generally has precise control over where in the list each element is inserted and can access elements by their integer index (position). Queues typically, but do not necessarily, order elements in a FIFO (first-in, first-out) manner. Among the exceptions are priority queues, which order elements according to a supplied comparator or the elements' natural ordering (element implements Comparable interface). Deques can be used both as FIFO (first-in, first-out) and LIFO (last-in, first-out). In a deque all new elements can be inserted, retrieved and removed at both ends. Map an object that maps keys to values. A Map cannot contain duplicate keys; each key can map to at most one value. SortedSet a Set that maintains its elements in ascending order. SortedMap a Map that maintains its mappings in ascending key order. This is the Map analog of SortedSet. Sorted maps are used for naturally ordered collections of key/value pairs, such as dictionaries and telephone directories. Map is not a true Collection. Collections / 2

3 Collections / 3

4 The general-purpose implementations are summarized in the following table. Interfaces Hash table Implementations General-purpose Implementations Resizable array Implementations Tree Implementations Linked list Implementations Hash table + Linked list Implementations Set HashSet TreeSet LinkedHashSet List ArrayList LinkedList Queue Deque ArrayDeque LinkedList Map HashMap TreeMap LinkedHashMap Data Structure Time Complexity Space Complexity Average Worst Worst Access Search Insertion Deletion Access Search Insertion Deletion Array Θ(1) Θ(n) Θ(n) Θ(n) O(1) O(n) O(n) O(n) O(n) Stack Θ(n) Θ(n) Θ(1) Θ(1) O(n) O(n) O(1) O(1) O(n) Queue Θ(n) Θ(n) Θ(1) Θ(1) O(n) O(n) O(1) O(1) O(n) Singly-Linked List Θ(n) Θ(n) Θ(1) Θ(1) O(n) O(n) O(1) O(1) O(n) Doubly-Linked List Θ(n) Θ(n) Θ(1) Θ(1) O(n) O(n) O(1) O(1) O(n) Skip List Θ(log(n)) Θ(log(n)) Θ(log(n)) Θ(log(n)) O(n) O(n) O(n) O(n) O(n log(n)) Hash Table N/A Θ(1) Θ(1) Θ(1) N/A O(n) O(n) O(n) O(n) Binary Search Tree Θ(log(n)) Θ(log(n)) Θ(log(n)) Θ(log(n)) O(n) O(n) O(n) O(n) O(n) Cartesian Tree N/A Θ(log(n)) Θ(log(n)) Θ(log(n)) N/A O(n) O(n) O(n) O(n) B-Tree Θ(log(n)) Θ(log(n)) Θ(log(n)) Θ(log(n)) O(log(n)) O(log(n)) O(log(n)) O(log(n)) O(n) Red-Black Tree Θ(log(n)) Θ(log(n)) Θ(log(n)) Θ(log(n)) O(log(n)) O(log(n)) O(log(n)) O(log(n)) O(n) Splay Tree N/A Θ(log(n)) Θ(log(n)) Θ(log(n)) N/A O(log(n)) O(log(n)) O(log(n)) O(n) AVL Tree Θ(log(n)) Θ(log(n)) Θ(log(n)) Θ(log(n)) O(log(n)) O(log(n)) O(log(n)) O(log(n)) O(n) KD Tree Θ(log(n)) Θ(log(n)) Θ(log(n)) Θ(log(n)) O(n) O(n) O(n) O(n) O(n) Čia nurodyti greičiai grynai atitinkamos operacijos, pvz. Doubly Linked List ui įterpimo greitis O(1), bet dar reikia įvertinti laiką O(n), kurį sunaudosime, kol nukeliausime iki vietos, kur bus atliekamas įterpimas. Lentelėse dažnai būna norodomas tik grynas operacijos laikas, o kartais ir suminis (pvz. kaip Double Linked List ui sumuojama access time + insert time ). Collections / 4

5 Collection Interface Collection interface contains methods that perform basic operations: int size() boolean isempty() boolean contains(object element) boolean add(e element) boolean remove(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() Additional methods for array operations: Object[] toarray() <T> T[] toarray(t[] a) In JDK 8 and later, the Collection interface also exposes methods: Stream<E> stream() Stream<E> parallelstream() for obtaining sequential or parallel streams from the underlying collection. Collections / 5

6 Set Interface Set is a collection that cannot contain duplicate elements. Set implementations: HashSet TreeSet LinkedHashSet HashSet is Implemented using a hash table. Elements are not ordered. It is the best-performing implementation; however it makes no guarantees concerning the order of iteration. The add, remove, and contains methods have constant time complexity O(1). TreeSet is implemented using a red-black tree, orders its elements based on their values; it is substantially slower than HashSet. The elements in a set are sorted, but the add, remove, and contains methods has time complexity of O(log n). It offers several methods to deal with the ordered set like first(), last(), headset(), tailset(), etc. LinkedHashSet, which is implemented as a hash table with a linked list running through it, orders its elements based on the order in which they were inserted into the set (insertion-order). LinkedHashSet spares its clients from the unspecified, generally chaotic ordering provided by HashSet at a cost that is only slightly higher. LinkedHashSet is between HashSet and TreeSet. It is implemented as a hash table with a linked list running through it, so it provides the order of insertion. The time complexity of basic methods is O(1). add, remove, and contains methods: HashSet O(1) TreeSet O(log n) LinkedHashSet O(1) LinkedHashSet is that we pass the argument in the add(elemene E) that is E as a key in the LinkedHashMap. Now we need to associate some value to the key, so what Java apis developer did is to pass the Dummy value that is ( new Object () ) which is referred by Object reference PRESENT. So, actually when you are adding a line in LinkedHashSet like linkedhashset.add(5) what java does internally is that it will put that element E here 5 as a key in the LinkedHashMap(created during LinkedHashSet object creation) and some dummy value that is Object's object is passed as a value to the key. // Constructor 1 public LinkedHashSet (int initialcapacity, float loadfactor) { super(initialcapacity, loadfactor, true); // Constructor 2 public LinkedHashSet (int initialcapacity) { super(initialcapacity, 0.75f, true); Collections / 6

7 // Constructor 3 public LinkedHashSet () { super(16, 0.75f, true); // Constructor 4 public LinkedHashSet (Collection c) { super(math.max(2*c.size(),11), 0.75f, true); Above all the 4 constructors are calling the super class (i.e HashSet ) constructor, given below public HashSet (int initialcapacity, float loadfactor, boolean dummy) { map = new LinkedHashMap<>(initialCapacity, loadfactor); We are using extra boolean parameter dummy. It is used to distinguish other int, float constructors present in the HashSet class. Internally it is creating a LinkedHashMap object. Collections / 7

8 List Interface A List is an ordered Collection (sometimes called a sequence). Lists may contain duplicate elements. Java contains two general-purpose List implementations. ArrayList LinkedList ArrayList is implemented as a resizable array. Implements all optional list operations, and permits all elements, including null. As more elements are added to ArrayList, its size is increased dynamically. It's elements can be accessed directly by using the get and set methods, since ArrayList is essentially an array. LinkedList is implemented as a double linked list. Its performance on add and remove is better than Arraylist, but worse on get and set methods. This implementation is not synchronized. Vector is similar with ArrayList, but it is synchronized. ArrayList is a better choice if your program is thread-safe. Vector and ArrayList require more space as more elements are added. Vector each time doubles its array size, while ArrayList grow 50% of its size each time. LinkedList, however, also implements Queue interface which adds more methods than ArrayList and Vector, such as offer(), peek(), poll(), etc. Note: The default initial capacity of an ArrayList is pretty small. It is a good habit to construct the ArrayList with a higher initial capacity. This can avoid the resizing cost. ArrayList LinkedList get() O(1) O(n) add(int index, Element e) O(n) O(n) add(element e) //at the end O(1) O(1) remove(int index) O(n) O(n) remove() //at the end O(1) O(1) Access time for ArrayList: O(1). Access time for LinkedList: O(n). Deletion time for ArrayList: Access time + O(n). Deletion time for LinkedList: Access time + O(1). Insertion time for ArrayList: Access time + O(n). Insertion time for LinkedList: Access time + O(1). ArrayList has O(n) time complexity for arbitrary indices of add/remove, but O(1) for the operation at the end of the list. LinkedList has O(n) time complexity for arbitrary indices of add/remove, but O(1) for operations at the end/beginning of the List. Collections / 8

9 Queue Interface Queues typically, but not necessarily, order elements in a FIFO (first-in-first-out) manner. Among the exceptions are priority queues, which order elements according to their values see the Object Ordering section for details). Whatever ordering is used, the head of the queue is the element that would be removed by a call to remove or poll. In a FIFO queue, all new elements are inserted at the tail of the queue. Other kinds of queues may use different placement rules. Every Queue implementation must specify its ordering properties. Queue<Integer> queue = new LinkedList<Integer>(); Collections / 9

10 Map Interface There are 4 commonly used implementations of Map: HashMap is implemented as a hash table, and there is no ordering on keys or values. If the key of a HashMap is a self-defined object, then the equals() and hashcode() contract need to be followed. HashMap is unsynchronized and should be used if the program is thread-safe. TreeMap is implemented based on red-black tree structure, and it is ordered by the key. LinkedHashMap preserves the insertion order. Hashtable is synchronized, in contrast to HashMap. It has an overhead for synchronization. LinkedHashMap public class Dog { String name; Dog(String c) { name = public boolean equals(object o) { return ((Dog) public int hashcode() { int hash = 7; hash = 79 * hash + Objects.hashCode(this.name); System.out.println("Dog hash=" + hash); return hash; public String tostring(){ return name + " dog"; Collections / 10

11 Dog d1 = new Dog("vardas1"); Dog d2 = new Dog("vardas2"); Dog d3 = new Dog("vardas3"); Dog d4 = new Dog("vardas3"); LinkedHashMap<Dog, Integer> linkedhashmap = new LinkedHashMap<Dog, Integer>(); linkedhashmap.put(d2, 10); linkedhashmap.put(d1, 15); linkedhashmap.put(d3, 5); linkedhashmap.put(d4, 20); for (Entry<Dog, Integer> entry : linkedhashmap.entryset()) { System.out.println(entry.getKey() + " - " + entry.getvalue()); In the LinkedHashMap implementation, the LinkedHashMap.Entry class extends the HashMap.Entry class, by adding before and after fields. These fields are used to assemble the LinkedHashMap.Entry objects into an independent doubly-linked list that records the insertion order. So, in the LinkedHashMap class, the entry objects are in two distinct chains: a singly linked hash chain that is accessed via the main hash array, and a separate doubly linked list of all entries that is kept in entry insertion order. Entry of LinkedHashMap looks like this: static class Entry<K, V> { K key; V value; Entry<K,V> next; Entry<K,V> before, after; //For maintaining insertion order public Entry(K key, V value, Entry<K,V> next){ this.key = key; this.value = value; this.next = next; By using before and after - we keep track of newly added entry in LinkedHashMap, which helps us in maintaining insertion order. Before refer to previous entry and after refers to next entry in LinkedHashMap. Iterating through a LinkedHashMap is more efficient than iterating through a HashMap, but LinkedHashMap is less memory efficient. Collections / 11

12 Collections / 12