Empfohlen
Weitere ähnliche Inhalte
Was ist angesagt?
Was ist angesagt? (20)
Ähnlich wie Java-7: Collections
Ähnlich wie Java-7: Collections (20)
Mehr von Masudul Haque
Mehr von Masudul Haque (6)
Kürzlich hochgeladen
Kürzlich hochgeladen (20)
Java-7: Collections
- 2. A collection — sometimes called a container — is simply an object that groups multiple elements into a single unit. Collections are used to store, retrieve, manipulate, and communicate aggregate data.
- 4. Jdk 1.0: Vector, Stack, Dictionary, Hashtable, Enumeration Jdk 1.2: List, Set, Map, ArrayList, LinkedList, HashSet, TreeSet, HashMap, WeakHashMap Jdk 1.4: RandomAccess, IdentityHashMap, LinkedHashMap Jdk 1.5: Queue, java.util.concurrent Jdk 1.6: Deque, NavigableSet/Map Jdk 1.7: TransferQueue, LinkedTransferQueue
- 5. Reduces programming effort. Increases programming speed and quality. Allows interoperability of unrelated data. Reduces learning effort. Reduces effort of to design new APIs Foster software reuse.
- 11. Indexed access Uses offset from memory address for fast memory access In Java - fixed size memory block with VMlevel support
- 12. Dynamic structure made of pointers Easy to insert and delete new elements No indexed access
- 14. Think of an example with ArrayList: List<String> listA = new ArrayList<>(); listA.add("B"); listA.add("C"); listA.add("D"); listA.add("C"); for (String string : listA) { //Iteration if (string.equals("C")) { listA.remove("C"); //ConcurrentModificationExp } } System.out.println(listA);
- 15. List<String> listA = new CopyOnWriteArrayList<>(); listA.add("B"); listA.add("C"); listA.add("D"); listA.add("C"); for (String string : listA) { if (string.equals("C")) { listA.remove("C"); } } System.out.println(listA);
- 16. Thread safe. Never throws ConcurrentModificationEception. Copy-on-write operation. Snapshot iterator.
- 19. Fail-fast - work on live data, but become invalid when live data is modified Weakly consistent - work on live data, safe, reflect updates and deletes, but not inserts Snapshot - work on a snapshot of the live data, fast, safe, but possibly stale
- 21. first() : E last() : E headSet(E toElem) : SortedSet<E> subSet(E fromElem, E toElem) : SortedSet<E> tailSet(E fromElem) : SortedSet<E> comparator() : Comparator<? super E>
- 22. pollFirst() : E pollLast() : E subSet(E from, boolean inclusive, E to, boolean inclusive) : NavigableSet<E> headSet(E to, boolean inclusive) : NavigableSet<E> tailSet(E from, boolean inclusive) : NavigableSet<E> ceiling(E e) : E floor(E e) : E higher(E e) : E lower(E e) : E descendingSet() : NavigableSet<E> descendingIterator() : Iterator<E>
- 24. Data Structure Sorting Iterator Nulls? HashSet Hash table No Fail-fast Yes LinkedHash Set Hash table+ Linked list Insertion order Fail-fast Yes EnumSet Bit Vector Natural order Weekly Consistent No TreeSet Red-black tree Sorted Fail-fast Depends CopyOnWriteA rraySet Array No Snapshot Yes ConcurrentSki pListSet Skip list Sorted Weekly Consistent No
- 25. Series of linked list Reasonably fast search add and remove Lock free implementation
- 26. add contains next HashSet O(1) O(1) O(h/n) LinkedHash Set O(1) O(1) O(1) EnumSet O(1) O(1) O(1) TreeSet O(log n) O(log n) O(log n) CopyOnWriteArray Set O(n) O(n) O(1) ConcurrentSkipLis tSet O(log n) O(log n) O(1)
- 28. Throws exception Returns special value Insert add(e) offer(e) Remove remove() poll() Examine element() peek()
- 31. Balanced binary tree Root is always highest priority Inserts and removes cause re-balancing
- 32. Head:Throws Head: Special Tail: Throws exception value exception Insert Remove Examine Tail: Special value addFirst(e) offerFirst(e) addLast(e) offerLast(e) removeFirst() pollFirst() removeLast() pollLast() getLast() peekLast() Stack: push Queue: remove Stack:pop getFirst() Queue: element Queue: poll peekFirst() Queue:peek Stack:peek Queue: add Queue: offer
- 33. Head Throws exception Insert addFirst(e) Stack: push Special value Blocks Time out offerFirst(e) putFirst(e) offerFirst(e, time,unit) Queue: add Queue: offer takeFirst() pollFirst(e, time,unit) Special value Blocks Time out offerLast(e) putLast(e) offerLast(e, time, unit) Remove removeFirst() pollFirst() Examine getFirst() peekFirst() Queue: element Queue:peek Stack:peek Tail Throws exception Insert addLast(e) Remove Examine Queue: remove Stack: push removeLast() Queue: remove Stack:pop getLast() Queue: element Queue: poll pollLast() Queue: poll peekLast() Queue:peek Stack:peek Queue: put takeLast() Queue: offer pollLast(e, time, unit)
- 37. Producers wait for consumers to receive elements. Useful for message passing. Similar to a broader version of SynchronousQueue. hasWaitingConsumer() : boolean getWaitingConsumerCount() : int transfer(E e) tryTransfer(E e) : boolean tryTransfer(E e, long timeout, TimeUnit unit) : boolean
- 39. put(E key, V value) : V putAll(Map<? extends K, ? extends V> m) remove(Object key) : V clear() containsKey(Object key) : boolean containsValue(Object value) : boolean isEmpty() : boolean size() : int get(Object key) : V entrySet() : Set<Map.Entry<K,V>> keySet() : Set<K> values() : Collection<V>
- 40. firstKey() : K lastKey() : K headMap(K to) : SortedMap<K, V> subMap(K from, K to) : SortedMap<K, V> tailMap(K from) : SortedMap<K, V> comparator() : Comparator<? super K>
- 41. firstEntry() : Map.Entry<K,V> lastEntry() : Map.Entry<K,V> ceilingEntry(K key) : Map.Entry<K,V> ceilingKey(K key) : K floorEntry(K key) : Map.Entry<K,V> floorKey(K key) : K higherEntry(K key) : Map.Entry<K,V> higherKey(K key) : K lowerEntry() : Map.Entry<K,V> lowerEntry(K key) : K navigableKeySet() : NavigableSet<K> pollFirstEntry() : Map.Entry<K,V> pollLastEntry() : Map.Entry<K,V> headMap(K to, boolean inclusive) : NavigableMap<K,V> subMap(K from, boolean fromInc, K to, boolean toInc) : NavigableMap<K,V> tailMap(K from, boolean inclusive) : NavigableMap<K,V> descendingKeySet() : NavigableSet<K> descendingMap() : NavigableMap<K,V>
- 42. putIfAbsent(K key, V value) : V remove(Object key, Object value) : boolean replace(K key, V value) : V replace(K key, V oldValue, V newValue) : boolean