« Previous | 1 | 2 | 3 | Next »

Java - Collections


Priorto Java 2, Java provided ad hoc classes such as Dictionary, Vector, Stack, and Properties to store and manipulate groups of objects. Although these classes were quite useful, they lacked a central, unifying theme. Thus, the way that you used Vector was different from the way that you used Properties.

The collections framework was designed to meet several goals.
  • The framework had to be high-performance. The implementations for the fundamental collections (dynamic arrays, linked lists, trees, and hashtables) are highly efficient.
  • The framework had to allow different types of collections to work in a similar manner and with a high degree of interoperability.
  • Extending and/or adapting a collection had to be easy.
Towards this end, the entire collections framework is designed around a set of standard interfaces. Several standard implementations such as LinkedList, HashSet, and TreeSet, of these interfaces are provided that you may use as-is and you may also implement your own collection, if you choose.

A collections framework is a unified architecture for representing and manipulating collections. All collections frameworks contain the following:
  • Interfaces: These are abstract data types that represent collections. Interfaces allow collections to be manipulated independently of the details of their representation. In object-oriented languages, interfaces generally form a hierarchy.
  • Implementations, i.e., Classes: These are the concrete implementations of the collection interfaces. In essence, they are reusable data structures.
  • Algorithms: These are the methods that perform useful computations, such as searching and sorting, on objects that implement collection interfaces. The algorithms are said to be polymorphic: that is, the same method can be used on many different implementations of the appropriate collection interface.
In addition to collections, the framework defines several map interfaces and classes. Maps store key/value pairs. Although maps are not collections in the proper use of the term, but they are fully integrated with collections.

The Collection Interfaces:

The collections framework defines several interfaces. This section provides an overview of each interface:
SNInterfaces with Description
1The Collection Interface
This enables you to work with groups of objects; it is at the top of the collections hierarchy.
2The List Interface
This extends Collection and an instance of List stores an ordered collection of elements.
3The Set
This extends Collection to handle sets, which must contain unique elements
4The SortedSet
This extends Set to handle sorted sets
5The Map
This maps unique keys to values.
6The Map.Entry
This describes an element (a key/value pair) in a map. This is an inner class of Map.
7The SortedMap
This extends Map so that the keys are maintained in ascending order.
8The Enumeration
This is legacy interface and defines the methods by which you can enumerate (obtain one at a time) the elements in a collection of objects. This legacy interface has been superceded by Iterator.
The Collection Classes:

Java provides a set of standard collection classes that implement Collection interfaces. Some of the classes provide full implementations that can be used as-is and others are abstract class, providing skeletal implementations that are used as starting points for creating concrete collections.

The standard collection classes are summarized in the following table:
SNClasses with Description
1AbstractCollection
Implements most of the Collection interface.
2AbstractList
Extends AbstractCollection and implements most of the List interface.
3AbstractSequentialList
Extends AbstractList for use by a collection that uses sequential rather than random access of its elements.
4LinkedList
Implements a linked list by extending AbstractSequentialList.
5ArrayList
Implements a dynamic array by extending AbstractList.
6AbstractSet
Extends AbstractCollection and implements most of the Set interface.
7HashSet
Extends AbstractSet for use with a hash table.
8LinkedHashSet
Extends HashSet to allow insertion-order iterations.
9TreeSet
Implements a set stored in a tree. Extends AbstractSet.
10AbstractMap
Implements most of the Map interface.
11HashMap
Extends AbstractMap to use a hash table.
12TreeMap
Extends AbstractMap to use a tree.
13WeakHashMap
Extends AbstractMap to use a hash table with weak keys.
14LinkedHashMap
Extends HashMap to allow insertion-order iterations.
15dentityHashMap
Extends AbstractMap and uses reference equality when comparing documents.
The AbstractCollection, AbstractSet, AbstractList, AbstractSequentialList and AbstractMap classes provide skeletal implementations of the core collection interfaces, to minimize the effort required to implement them.

The following legacy classes defined by java.util have been discussed in previous tutorial:
SNClasses with Description
1Vector
This implements a dynamic array. It is similar to ArrayList, but with some differences.
2Stack
Stack is a subclass of Vector that implements a standard last-in, first-out stack.
3Dictionary
Dictionary is an abstract class that represents a key/value storage repository and operates much like Map.
4Hashtable
Hashtable was part of the original java.util and is a concrete implementation of a Dictionary.
5Properties
Properties is a subclass of Hashtable. It is used to maintain lists of values in which the key is a String and the value is also a String.
6BitSet
A BitSet class creates a special type of array that holds bit values. This array can increase in size as needed.
The Collection Algorithms:

The collections framework defines several algorithms that can be applied to collections and maps. These algorithms are defined as static methods within the Collections class.

Several of the methods can throw a ClassCastException, which occurs when an attempt is made to compare incompatible types, or an UnsupportedOperationException, which occurs when an attempt is made to modify an unmodifiable collection.

Collections define three static variables: EMPTY_SET, EMPTY_LIST, and EMPTY_MAP. All are immutable.
SNAlgorithms with Description
1The Collection Algorithms
Here is a list of all the algorithm implementation.
How to use an Iterator?

Often, you will want to cycle through the elements in a collection. For example, you might want to display each element.

The easiest way to do this is to employ an iterator, which is an object that implements either the Iterator or the ListIterator interface.

Iterator enables you to cycle through a collection, obtaining or removing elements. ListIterator extends Iterator to allow bidirectional traversal of a list and the modification of elements.
SNIterator Methods with Description
1Using Java Iterator
Here is a list of all the methods with examples provided by Iterator and ListIterator interfaces.
Using Java Iterator

Often, you will want to cycle through the elements in a collection. For example, you might want to display each element.

The easiest way to do this is to employ an iterator, which is an object that implements either the Iterator or the ListIterator interface.

Iterator enables you to cycle through a collection, obtaining or removing elements. ListIterator extends Iterator to allow bidirectional traversal of a list, and the modification of elements.

Before you can access a collection through an iterator, you must obtain one. Each of the collection classes provides an iterator( ) method that returns an iterator to the start of the collection. By using this iterator object, you can access each element in the collection, one element at a time.

In general, to use an iterator to cycle through the contents of a collection, follow these steps:
  • Obtain an iterator to the start of the collection by calling the collection's iterator( ) method.
  • Set up a loop that makes a call to hasNext( ). Have the loop iterate as long as hasNext( ) returns true.
  • Within the loop, obtain each element by calling next( ).
For collections that implement List, you can also obtain an iterator by calling ListIterator.

The Methods DeclaredbyIterator:
SNMethods with Description
1boolean hasNext( )
Returns true if there are more elements. Otherwise, returns false.
2Object next( )
Returns the next element. Throws NoSuchElementException if there is not a next element.
3void remove( )
Removes the current element. Throws IllegalStateException if an attempt is made to call remove( ) that is not preceded by a call to next( ).
The Methods Declared by ListIterator:
SNMethods with Description
1void add(Object obj)
Inserts obj into the list in front of the element that will be returned by the next call to next( ).
2boolean hasNext( )
Returns true if there is a next element. Otherwise, returns false.
3boolean hasPrevious( )
Returns true if there is a previous element. Otherwise, returns false.
4Object next( )
Returns the next element. A NoSuchElementException is thrown if there is not a next element.
5int nextIndex( )
Returns the index of the next element. If there is not a next element, returns the size of the list.
6Object previous( )
Returns the previous element. A NoSuchElementException is thrown if there is not a previous element.
7int previousIndex( )
Returns the index of the previous element. If there is not a previous element, returns -1.
8void remove( )
Removes the current element from the list. An IllegalStateException is thrown if remove( ) is called before next( ) or previous( ) is invoked.
9void set(Object obj)
Assigns obj to the current element. This is the element last returned by a call to either next( ) or previous( ).
Example:

Here is an example demonstrating both Iterator and ListIterator. It uses an ArrayList object, but the general principles apply to any type of collection.

Of course, ListIterator is available only to those collections that implement the List interface.

import java.util.*;
public class IteratorDemo {
public static void main(String args[]) {
Create an array list
ArrayList al = new ArrayList();
add elements to the array list
al.add("C");
al.add("A");
al.add("E");
al.add("B");
al.add("D");
al.add("F");
// Use iterator to display contents of al
System.out.print("Original contents of al: ");
Iterator itr = al.iterator();
while(itr.hasNext()) {
Object element = itr.next();
System.out.print(element + " ");
}
System.out.println();
// Modify objects being iterated
ListIterator litr = al.listIterator();
while(litr.hasNext()) {
Object element = litr.next();
litr.set(element + "+");
}
System.out.print("Modified contents of al: ");
itr = al.iterator();
while(itr.hasNext()) { Object element = itr.next();
System.out.print(element + " ");
}
System.out.println();
// Now, display the list backwards
System.out.print("Modified list backwards: ");
while(litr.hasPrevious()) {
Object element = litr.previous();
System.out.print(element + " ");
}
System.out.println();
}
}

This would produce the following result:

Original contents of al: C A E B D F
Modified contents of al: C+ A+ E+ B+ D+ F+
Modified list backwards: F+ D+ B+ E+ A+ C+

How to use a Comparator?

Both TreeSet and TreeMap store elements in sorted order. However, it is the comparator that defines precisely what sorted order means.

This interface lets us sort a given collection any number of different ways. Also, this interface can be used to sort any instances of any class(even classes we cannot modify).
SNIterator Methods with Description
1Using Java Comparator
Here is a list of all the methods with examples provided by Comparator Interface.
Using Java Comparator

Both TreeSet and TreeMap store elements in sorted order. However, it is the comparator that defines precisely what sorted order means.

The Comparator interface defines two methods: compare( ) and equals( ). The compare( ) method, shown here, compares two elements for order:

The compare Method:

int compare(Object obj1, Object obj2)

obj1 and obj2 are the objects to be compared. This method returns zero if the objects are equal. It returns a positive value if obj1 is greater than obj2. Otherwise, a negative value is returned.

By overriding compare( ), you can alter the way that objects are ordered. For example, to sort in reverse order, you can create a comparator that reverses the outcome of a comparison.

TheequalsMethod:

The equals( ) method, shown here, tests whether an object equals the invoking comparator:

boolean equals(Object obj)

obj is the object to be tested for equality. The method returns true if obj and the invoking object are both Comparator objects and use the same ordering. Otherwise, it returns false.

Overriding equals( ) is unnecessary, and most simple comparators will not do so.

Example:

class Dog implements Comparator<Dog>,
Comparable<Dog>{
private String name;
private int age;
Dog(){
}
Dog(String n, int a){
name = n;
age = a;
}
public String getDogName(){
return name;
}
public int getDogAge(){
return age;
}
// Overriding the compareTo method
public int compareTo(Dog d){
return (this.name).compareTo(d.name);
}
// Overriding the compare method to sort the age
public int compare(Dog d, Dog d1){
return d.age - d1.age;
}
}
public class Example{
public static void main(String args[]){
// Takes a list o Dog objects List<Dog>
list = new ArrayList<Dog>();
list.add(new Dog("Shaggy",3));
list.add(new Dog("Lacy",2));
list.add(new Dog("Roger",10));
list.add(new Dog("Tommy",4));
list.add(new Dog("Tammy",1));
Collections.sort(list);// Sorts the array list
for(Dog a: list)//printing the sorted list of names
System.out.print(a.getDogName() + ", ");
// Sorts the array list using comparator
Collections.sort(list, new Dog());
System.out.println(" ");
for(Dog a: list)//printing the sorted list of ages
System.out.print(a.getDogName() +" : "+
a.getDogAge() + ", ");
}
}

This would produce the following result:
Lacy,Roger,Shaggy,Tammy,Tommy,
Tammy : 1,Lacy : 2,Shaggy : 3,Tommy : 4,Roger : 10,
Note: Sorting of the Arrays class is as the same as the Collections.

Summary:

The Java collections framework gives the programmer access to prepackaged data structures as well as to algorithms for manipulating them.

A collection is an object that can hold references to other objects. The collection interfaces declare the operations that can be performed on each type of collection.

The classes and interfaces of the collections framework are in package java.util.
« Previous | 1 | 2 | 3 | Next »


copyright © 2014 - all rights riserved by javatechnologycenter.com