Java Collection Framework

1
Java Collection Framework
2
Java 1.2...

• In Java 1.2, the language finally had a framework
  for handling collections. Collections are viewed
  as ways of organizing groups of things.

3
Partial Collection Framework
4
interface Collection

• boolean add(Object o)
•           Ensures that this collection contains
  the specified element (optional operation).
•  boolean addAll(Collection c)
•           Adds all of the elements in the
  specified collection to this collection (optional
  operation).
•  void clear()
•           Removes all of the elements from this
  collection (optional operation).
•  boolean contains(Object o)
•           Returns true if this collection
  contains the specified element.
•  boolean containsAll(Collection c)
•           Returns true if this collection
  contains all of the elements in the specified
  collection.
•  

5

• boolean equals(Object o)
•           Compares the specified object with this
  collection for equality.
•  int hashCode()
•           Returns the hash code value for this
  collection.
•  boolean isEmpty()
•           Returns true if this collection
  contains no elements.
•  Iterator iterator()
•           Returns an iterator over the elements
  in this collection.
•  boolean remove(Object o)
•           Removes a single instance of the
  specified element from this collection, if it is
  present (optional operation).
•  boolean removeAll(Collection c)
•           Removes all this collection's elements
  that are also contained in the specified
  collection (optional operation).
•  

6

• boolean retainAll(Collection c)
•           Retains only the elements in this
  collection that are contained in the specified
  collection (optional operation).
•  int size()
•           Returns the number of elements in this
  collection.
•  Object toArray()
•           Returns an array containing all of the
  elements in this collection.
•  Object toArray(Object a)
•           Returns an array containing all of the
  elements in this collection whose runtime type is
  that of the specified array.

7
interface Set

• public interface Set extends Collection
• A collection that contains no duplicate elements.
  More formally, sets contain no pair of elements
  e1 and e2 such that e1.equals(e2), and at most
  one null element. As implied by its name, this
  interface models the mathematical set abstraction.

8
interface List

• public interface List extends Collection
• An ordered collection (also known as a sequence).
  The user of this interface has precise control
  over where in the list each element is inserted.
  The user can access elements by their integer
  index (position in the list), and search for
  elements in the list.
• Unlike sets, lists typically allow duplicate
  elements. More formally, lists typically allow
  pairs of elements e1 and e2 such that
  e1.equals(e2), and they typically allow multiple
  null elements if they allow null elements at all.
  It is not inconceivable that someone might wish
  to implement a list that prohibits duplicates, by
  throwing runtime exceptions when the user
  attempts to insert them, but we expect this usage
  to be rare.

9
ArrayList

• public class ArrayList extends AbstractList
  implements List, Cloneable, Serializable
• Resizable-array implementation of the List
  interface. Implements all optional list
  operations, and permits all elements, including
  null. This class provides methods to manipulate
  the size of the array that is used to store the
  list.
• The size, isEmpty, get, set, iterator, and
  listIterator operations run in constant time. The
  add operation runs in amortized constant time,
  that is, adding n elements requires O(n) time.
  All of the other operations run in linear time
  (roughly speaking). The constant factor is low
  compared to that for the LinkedList
  implementation.
• Each ArrayList instance has a capacity. The
  capacity is the size of the array used to store
  the elements in the list. It is always at least
  as large as the list size. As elements are added
  an ArrayList, its capacity grows automatically.
• An application can increase the capacity of an
  ArrayList instance before adding a large number
  of elements using the ensureCapacity operation.

10
LinkedList

• public class LinkedList extends
  AbstractSequentialLis implements List, Cloneable,
  Serializable
• Linked list implementation of the List interface.
  Implements all optional list operations, and
  permits all elements (including null). In
  addition to implementing the List interface, the
  LinkedList class provides uniformly named methods
  to get, remove and insert an element at the
  beginning and end of the list. These operations
  allow linked lists to be used as a stack, queue,
  or double-ended queue (deque).
• All of the stack/queue/deque operations could be
  easily recast in terms of the standard list
  operations. They're included here primarily for
  convenience, though they may run slightly faster
  than the equivalent List operations.
• All of the operations perform as could be
  expected for a doubly-linked list. Operations
  that index into the list will traverse the list
  from the beginning or the end, whichever is
  closer to the specified index.

11
Trees

• Trees provide a two dimensional organization of
  data.
• Binary search trees are binary trees that impose
  an ordering on the elements.

12
Binary Tree

• A binary tree, t, is either empty or consists of
  an element called the root element and two
  distinct binary tree, call the left subtree and
  the right subtree.

13
root
14
Language

• root
• subtree
• leaf
• parent
• ancestor
• height
• full
• balanced

15
Value

• Binary search tree require logarithmic time
  (average) for inserting, removing, and searching
  (worst-case is linear).
• Java collections implements a red-black tree
  which is a balanced binary search tree.

16
class TreeMap

• A map is a collection in which each element is a
  key-value pair -- think (key,value). The keys are
  unique.
• TreeMap DOES NOT implement the collection
  interface.

17
TreeMap Implementation

• Implemented as a red-black tree.
• Searching, inserting, and removing log(n).
• TreeMap keys are stored according to the ordering
  of keys. If we iterate through a TreeMap of names
  we would access the names in alphabetical order.

18
methods

• TreeMap()
• Object put (Object key, Object value)
• boolean containsKey (Object key)
• boolean containsValue (Object value)
• Object remove (Object key)

19
class HashMap

• HashMap implement the map interface.
• HashMap is made for searching. put and remove
  methods run in constant time.

20
methods

• HashMap(int initialCapacity, float loadFactor)
• loadFactor is typically defined as the ratio of
  the number of elements to the capacity. In Java
  it is defined as the upper bound of that ratio.

21
Hashing

• Hashing is the process of transforming a key into
  an array index.
• hkey --gthashvalue --gt index
• Collision Resolution

22
Note

• The Java Collection Framework implementation of
  hashing uses a table containing a singly-linked
  list of elements whose key hashing to the index
  of that particular location.