Introduction to Java Collections
-
Upload
fallon-stanley -
Category
Documents
-
view
53 -
download
4
description
Transcript of Introduction to Java Collections
Introduction to Java Collections
Written by
Adam Carmi
Agenda
• About Collections• Core Collection Interfaces
– Collection, Set, List, Map
• Object Ordering– Comparable, Comparator
• More Core Collection interfaces– SortedSet, SortedMap
• Implementations• Algorithms
What is a Collection Framework?
• A collection (sometimes called a container) is an object that groups multiple elements into a single unit.
• A collection framework is a unified architecture for representing and manipulating collections.
• Java’s collection framework consists of– Collection interfaces– Concrete collection implementations (reusable data
structures)– Algorithms (reusable functionality)
C++’s Standard Template Library is also a collection framework
Benefits of a Collection Framework
• Reduces programming effort– Powerful data structures and algorithms
• Increases program speed and quality– High quality implementations– Fine tuning by switching implementations
• Reduces the effort of learning new APIs– Uniformity of the framework– APIs of applications
• Encourages software reuse– New data structures and algorithms
Core Collection Interfaces
Collection interfaces allow collections to be manipulated independently of the details of their representation
The Collection Interface
• Represents a group of objects, known as its elements.
• The JDK does not provide any direct implementations of this interface.
• Collection is used to pass collections around and manipulate them when maximum generality is desired.
• java.util.Collection
Iterator
• A mechanism for iterating over a collection’s elements.
• Represented by the Iterator interface.• Iterator allows the caller to remove elements from
the underlying collection during the iteration with well-defined semantics– The only safe way to modify a collection during
iteration
• java.util.Iterator
Example: Iterator
static void filter(Collection c) { for (Iterator it = c.iterator() ; it.hasNext(); ) if (!cond(it.next())) it.remove();} static void filter(Collection c) { Iterator it = c.iterator(); while (it.hasNext()) if (!cond(it.next())) it.remove();}
The Set Interface
• A collection that can not contain duplicate keys.
• Contains no methods other than those declared in the Collection interface.
• Two set objects are equal if they contain the same elements, regardless of their implementations.
• java.util.Set
Example: Set
import java.util.*;
public class FindDups { public static void main(String args[]) { Set s = new HashSet(); for (int i=0; i<args.length; i++) if (!s.add(args[i])) System.out.println("Duplicate detected: " + args[i]); System.out.println(s.size() + " distinct words" + " detected: " + s); }}
The List Interface
• An ordered collection (sometimes called a sequence)
• Lists may contain duplicate elements• Collection operations
– remove operation removes the first occurrence of the specified element
– add and addAll operations always appends new elements to the end of the list.
– Two List objects are equal if they contain the same elements in the same order.
The List Interface (cont)
• New List operations– Positional access– Search – Iteration (ordered, backward)– Range-view operations
• java.util.List
• java.util.ListIterator
Example: List
private static void swap(List a, int i, int j)
{
Object tmp = a.get(i);
a.set(i, a.get(j));
a.set(j, tmp);
}
for (ListIterator i=l.listIterator(l.size()); i.hasPrevious(); ) {
Foo f = (Foo)i.previous();
...
}Calls to next and previous can be
intermixed
Exampe: List (cont)
public static void replace(List l, Object val, List newVals)
{
for (ListIterator i = l.listIterator(); i.hasNext() ; ) {
if (val==null ? i.next()==null : val.equals(i.next())) {
i.remove();
for (Iterator j = newVals.iterator(); j.hasNext(); )
i.add(j.next());
}
}
} The add method inserts a new element into the list, immediately before the current cursor position
The Map Interface
• An object that maps keys to values.– A map cannot contain duplicate keys.– Each key cat map to at most one value.
• Every object can be used as a hash key– public int Object.hashCode()
– Equal objects (according to equals()) must produce the same hash code.
– The same hash code must be returned by an object throughout the execution of a Java application.
• Two Map objects are equal if they represent the same key-value mappings
The Map Interface (cont)
• Collection-view methods allow a Map to be viewed as a Collection– keySet – The Set of keys contained in the Map
– values – The Collection of values contained in the Map
– entrySet – The Set of key-value pairs contained in the Map
• With all three Collection-views, calling an Iterator's remove operation removes the associated entry from the backing Map.– This is the only safe way to modify a Map during iteration.
• java.util.Map
Example: Mapimport java.util.*;
public class Freq { private static final Integer ONE = new Integer(1); public static void main(String args[]) { Map m = new HashMap(); for (int i=0; i<args.length; i++) { Integer freq = (Integer)m.get(args[i]); m.put(args[i], (freq==null ? ONE : new Integer(freq.intValue() + 1))); } System.out.println(m.size() + " distinct words detected:"); System.out.println(m); }}
Example: Map (cont)
for (Iterator i = m.keySet().iterator() ; i.hasNext() ; )
System.out.println(i.next());
for (Iterator i = m.values().iterator(); i.hasNext() ; )
System.out.println(i.next());
for (Iterator i = m.entrySet().iterator(); i.hasNext() ; ) {
Map.Entry e = (Map.Entry)i.next();
System.out.println(e.getKey() + ": " + e.getValue());
}
Collection-views provide the only means to iterate over a Map.
Object Ordering
• A natural ordering can be defined for a class by implementing the Comparable interface
• Objects of classes that implement the Comparable interface may be sorted automatically
• Many JDK1 classes implement the Comparable interface:
Integer signed numerical
Double signed numerical
String lexicographic
Date chronological
1) Java Development Kit
Object Ordering (cont)
• The Comparable interface consists of a single method
public interface Comparable { public int compareTo(Object o);
}
• Natural ordering is not always sufficient– Ordering objects in some order other than their natural
order– Ordering objects that don't implement the Comparable
interface
compareTo returns a negative integer, zero or a positive
integer as the receiving object is less than, equal or greater
than the input object
Object Ordering (cont)
• A Comparator may be used to order objects when natural ordering does not suffice
public interface Comparable {
public int compare(Object o1, Object o2);
}
Example: Comparable
public class Name implements Comparable {
private String firstName, lastName;
...
public int compareTo(Object o)
{
Name n = (Name)o;
int lastCmp = lastName.compareTo(n.lastName);
return lastCmp != 0 ? lastCmp :
firstName.compareTo(n.firstName);
}
}
Example: Comparator
public class NameComparator implements Comparator {
public int compare(Object o1, Object o2)
{
Name n1 = (Name)o1;
Name n2 = (Name)o2;
int lastCmp = n1.getLastName().compareTo(n2.getLastName());
return lastCmp != 0 ? lastCmp :
n1.getFirstName().compareTo(n2.getFirstName());
}
}
SortedSet Interface
• A Set that maintains its elements in ascending order– according to elements' natural order
– according to a Comparator provided at SortedSet creation time
• Set operations– Iterator traverses the sorted set in order
• Additional operations– Range view – range operations
– Endpoints – return the first or last element
– Comparator access
• java.util.SortedSet
SortedMap Interface
• A Map that maintains its entries in ascending order– According to keys' natural order
– According to a Comparator provided at creation time.
• Map operations– Iterator traverses elements in any of the sorted map's collection-
views in key-order.
• Additional Operations– Range view
– End points
– Comparator access
• java.util.SortedMap
Implementations
• Implementations are the actual data objects used to store elements– Implement the core collection interfaces
• There are three kinds of implementations– General purpose implementations– Wrapper implementations– Convenience implementations
• Lesson: Implementations
General Purpose Implementations
Implementations
Hash Table
Resizeable Array
Balanced Tree
Linked List
Interfaces
Set HashSet TreeSet
List ArrayList LinkedList
Map HashMap TreeMap
Older Implementations
• The collections framework was introduced in JDK1.2.
• Earlier JDK versions included collection implementations that were not part of any framework– java.util.Vector
– java.util.Hashtable
• These implementations were extended to implement the core interfaces but still have all their legacy operations– Be careful to always manipulate them only through the core
interfaces.
Algorithms
• Polymorphic algorithms are pieces of reusable functionality provided by the JDK.– defined as static methods of the Collections class
• Provided algorithms– Sorting– Shuffling– Data manipulation
• reverse, fill, copy
– Searching– Extreme values
• Lesson: Algorithms
Example: Algorithmspublic static void sortNames(Name[] names) { List l = Arrays.asList(names); Collections.sort(l);}
public static void sortNames(Name[] names) { List l = Arrays.asList(names); Collections.sort(l, new Comparator() { public int compare(Object o1, Object o2) { Name n1 = (Name)o1; Name n2 = (Name)o2; int lastCmp = n1.getLastName().compareTo(n2.getLastName()); return lastCmp != 0 ? lastCmp : n1.getFirstName().compareTo(n2.getFirstName()); }});}
Arrays.asList is a Convenience implementation of the List interface• API Bridge• Performance