Java Collection Framework -
Collection Interface
|
The
Collection interface is used to represent any group of ojects, or elements.
Here is a list of the public methods of the Collection Interface.
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. |
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). |
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; the runtime type of the returned array is that of the specified array. |
The
interface supports basic operations like adding and removing. When you try to
remove an element, only a single instance of the element in the collection is
removed, if present.
boolean add (Object o)
boolean remove(Object o)
boolean add (Object o)
boolean remove(Object o)
The
Collection interface also supports query operations
int
size()
boolean isEmpty()
boolean contains(Object o)
Iterator iterator()
Explore the other Interface and Classes of Java Collection Framework
boolean isEmpty()
boolean contains(Object o)
Iterator iterator()
Explore the other Interface and Classes of Java Collection Framework
Java Collection Framework -
Iterator Interface
|
The
iterator() method of the Collection interface returns and Iterator. An Iterator
is similar to the Enumeration interface, Iterators differ from enumerations in
two ways:
1.Iterators allow the caller to remove elements from the underlying collection during the iteration with well-defined semantics.
2. Method names have been improved.
1.Iterators allow the caller to remove elements from the underlying collection during the iteration with well-defined semantics.
2. Method names have been improved.
boolean
|
hasNext()
Returns true if the iteration has more elements. |
Object
|
next()
Returns the next element in the iteration. |
void
|
remove()
Removes from the underlying collection the last element returned by the iterator (optional operation). |
The remove method is optionally suported by the underlying collection. When called and supported, the element returned by the last next() call is removed.
Java Collection Framework - Set
Interface
|
The
set interface extends the Collection interface and, by definition, forbids
duplicates within the collection. All the original methods are present and no
new method is introduced. The concrete Set implementation classes rely on the
equals() method of the object added to check for equality.
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. |
||
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). |
||
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; the runtime type of the returned array is that of the specified array. |
||
Java Collection Framework - List
Interface
|
This
is an ordered collection (also known as a sequence). The List interface extends
the Collection interface to define an ordered collection, permitting
duplicates. 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.
void
|
add(int index,
Object element)
Inserts the specified element at the specified position in this list (optional operation). |
boolean
|
add(Object o)
Appends the specified element to the end of this list (optional operation). |
boolean
|
addAll(Collection c)
Appends all of the elements in the specified collection to the end of this list, in the order that they are returned by the specified collection's iterator (optional operation). |
boolean
|
addAll(int index,
Collection c)
Inserts all of the elements in the specified collection into this list at the specified position (optional operation). |
void
|
clear()
Removes all of the elements from this list (optional operation). |
boolean
|
contains(Object o)
Returns true if this list contains the specified element. |
boolean
|
containsAll(Collection c)
Returns true if this list contains all of the elements of the specified collection. |
boolean
|
equals(Object o)
Compares the specified object with this list for equality. |
Object
|
get(int index)
Returns the element at the specified position in this list. |
int
|
hashCode()
Returns the hash code value for this list. |
int
|
indexOf(Object o)
Returns the index in this list of the first occurrence of the specified element, or -1 if this list does not contain this element. |
boolean
|
isEmpty()
Returns true if this list contains no elements. |
Iterator
|
iterator()
Returns an iterator over the elements in this list in proper sequence. |
int
|
lastIndexOf(Object o)
Returns the index in this list of the last occurrence of the specified element, or -1 if this list does not contain this element. |
ListIterator
|
listIterator()
Returns a list iterator of the elements in this list (in proper sequence). |
ListIterator
|
listIterator(int index)
Returns a list iterator of the elements in this list (in proper sequence), starting at the specified position in this list. |
Object
|
remove(int index)
Removes the element at the specified position in this list (optional operation). |
boolean
|
remove(Object o)
Removes the first occurrence in this list of the specified element (optional operation). |
boolean
|
removeAll(Collection c)
Removes from this list all the elements that are contained in the specified collection (optional operation). |
boolean
|
retainAll(Collection c)
Retains only the elements in this list that are contained in the specified collection (optional operation). |
Object
|
set(int index,
Object element)
Replaces the element at the specified position in this list with the specified element (optional operation). |
int
|
size()
Returns the number of elements in this list. |
List
|
subList(int fromIndex, int toIndex)
Returns a view of the portion of this list between the specified fromIndex, inclusive, and toIndex, exclusive. |
Object[]
|
toArray()
Returns an array containing all of the elements in this list in proper sequence. |
Object[]
|
toArray(Object[] a)
Returns an array containing all of the elements in this list in proper sequence; the runtime type of the returned array is that of the specified array. |
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.
The
List interface places additional stipulations, beyond those specified in the
Collection interface, on the contracts of the iterator, add, remove, equals,
and hashCode methods. Declarations for other inherited methods are also
included here for convenience.
The
List interface provides four methods for positional (indexed) access to list
elements. Lists (like Java arrays) are zero based. Note that these operations
may execute in time proportional to the index value for some implementations
(the LinkedList class, for example). Thus, iterating over the elements in a
list is typically preferable to indexing through it if the caller does not know
the implementation.
The
List interface provides a special iterator, called a ListIterator, that allows
element insertion and replacement, and bidirectional access in addition to the
normal operations that the Iterator interface provides. A method is provided to
obtain a list iterator that starts at a specified position in the list.
The
List interface provides two methods to search for a specified object. From a
performance standpoint, these methods should be used with caution. In many
implementations they will perform costly linear searches.
The
List interface provides two methods to efficiently insert and remove multiple
elements at an arbitrary point in the list.
Note:
While it is permissible for lists to contain themselves as elements, extreme
caution is advised: the equals and hashCode methods are no longer well defined
on a such a list.
Some
list implementations have restrictions on the elements that they may contain.
For example, some implementations prohibit null elements, and some have
restrictions on the types of their elements. Attempting to add an ineligible
element throws an unchecked exception, typically NullPointerException or
ClassCastException. Attempting to query the presence of an ineligible element
may throw an exception, or it may simply return false; some implementations
will exhibit the former behavior and some will exhibit the latter. More
generally, attempting an operation on an ineligible element whose completion
would not result in the insertion of an ineligible element into the list may
throw an exception or it may succeed, at the option of the implementation. Such
exceptions are marked as "optional" in the specification for this
interface.
Java Collection Framework -
ListIterator Interface
|
The
ListIterator interface extends the Iterator interface to support bi-directional
access as well as adding or removing or changing elements in the underlying
collection.
An iterator for lists that allows the programmer to traverse the list in either direction, modify the list during iteration, and obtain the iterator's current position in the list. A ListIterator has no current element; its cursor position always lies between the element that would be returned by a call to previous() and the element that would be returned by a call to next(). In a list of length n, there are n+1 valid index values, from 0 to n, inclusive.
An iterator for lists that allows the programmer to traverse the list in either direction, modify the list during iteration, and obtain the iterator's current position in the list. A ListIterator has no current element; its cursor position always lies between the element that would be returned by a call to previous() and the element that would be returned by a call to next(). In a list of length n, there are n+1 valid index values, from 0 to n, inclusive.
void
|
add(int index,
Object element)
Inserts the specified element at the specified position in this list (optional operation). |
boolean
|
add(Object o)
Appends the specified element to the end of this list (optional operation). |
boolean
|
addAll(Collection c)
Appends all of the elements in the specified collection to the end of this list, in the order that they are returned by the specified collection's iterator (optional operation). |
boolean
|
addAll(int index,
Collection c)
Inserts all of the elements in the specified collection into this list at the specified position (optional operation). |
void
|
clear()
Removes all of the elements from this list (optional operation). |
boolean
|
contains(Object o)
Returns true if this list contains the specified element. |
boolean
|
containsAll(Collection c)
Returns true if this list contains all of the elements of the specified collection. |
boolean
|
equals(Object o)
Compares the specified object with this list for equality. |
Object
|
get(int index)
Returns the element at the specified position in this list. |
int
|
hashCode()
Returns the hash code value for this list. |
int
|
indexOf(Object o)
Returns the index in this list of the first occurrence of the specified element, or -1 if this list does not contain this element. |
boolean
|
isEmpty()
Returns true if this list contains no elements. |
Iterator
|
iterator()
Returns an iterator over the elements in this list in proper sequence. |
int
|
lastIndexOf(Object o)
Returns the index in this list of the last occurrence of the specified element, or -1 if this list does not contain this element. |
ListIterator
|
listIterator()
Returns a list iterator of the elements in this list (in proper sequence). |
ListIterator
|
listIterator(int index)
Returns a list iterator of the elements in this list (in proper sequence), starting at the specified position in this list. |
Object
|
remove(int index)
Removes the element at the specified position in this list (optional operation). |
boolean
|
remove(Object o)
Removes the first occurrence in this list of the specified element (optional operation). |
boolean
|
removeAll(Collection c)
Removes from this list all the elements that are contained in the specified collection (optional operation). |
boolean
|
retainAll(Collection c)
Retains only the elements in this list that are contained in the specified collection (optional operation). |
Object
|
set(int index,
Object element)
Replaces the element at the specified position in this list with the specified element (optional operation). |
int
|
size()
Returns the number of elements in this list. |
List
|
subList(int fromIndex, int toIndex)
Returns a view of the portion of this list between the specified fromIndex, inclusive, and toIndex, exclusive. |
Object[]
|
toArray()
Returns an array containing all of the elements in this list in proper sequence. |
Object[]
|
toArray(Object[] a)
Returns an array containing all of the elements in this list in proper sequence; the runtime type of the returned array is that of the specified array. |
The add(0 operation requires a little bit of explanation, also Adding an element results in the new element being added immediately prior to the implicit cursor. This calling preious after adding an element would return the new element and calling next would have no effect, returning what would hav been the next element prior to the add operation.
Java Collection Framework - Map
Interface
|
The
Map interface is not an extension of Collection interface. Instead the
interface starts of it’s own interface hierarchy, for maintaining key-value
associations. The interface describes a mapping from keys to values, without
duplicate keys, by defination.
The Map interface provides three collection views, which allow a map's contents to be viewed as a set of keys, collection of values, or set of key-value mappings. The order of a map is defined as the order in which the iterators on the map's collection views return their elements. Some map implementations, like the TreeMap class, make specific guarantees as to their order; others, like the HashMap class, do not.
The Map interface provides three collection views, which allow a map's contents to be viewed as a set of keys, collection of values, or set of key-value mappings. The order of a map is defined as the order in which the iterators on the map's collection views return their elements. Some map implementations, like the TreeMap class, make specific guarantees as to their order; others, like the HashMap class, do not.
void
|
clear()
Removes all mappings from this map (optional operation). |
boolean
|
containsKey(Object key)
Returns true if this map contains a mapping for the specified key. |
boolean
|
containsValue(Object value)
Returns true if this map maps one or more keys to the specified value. |
Set
|
entrySet()
Returns a set view of the mappings contained in this map. |
boolean
|
equals(Object o)
Compares the specified object with this map for equality. |
Object
|
get(Object key)
Returns the value to which this map maps the specified key. |
int
|
hashCode()
Returns the hash code value for this map. |
boolean
|
isEmpty()
Returns true if this map contains no key-value mappings. |
Set
|
keySet()
Returns a set view of the keys contained in this map. |
Object
|
put(Object key,
Object value)
Associates the specified value with the specified key in this map (optional operation). |
void
|
putAll(Map t)
Copies all of the mappings from the specified map to this map (optional operation). |
Object
|
remove(Object key)
Removes the mapping for this key from this map if it is present (optional operation). |
int
|
size()
Returns the number of key-value mappings in this map. |
Collection
|
values()
Returns a collection view of the values contained in this map. |
The
interface methods can be broken down into three sets of operations: altering,
querying and providing alternative views
The
alteration operation allows you to add and remove key-value pairs from the map.
Both the key and value can be null. However you should not add a Map to itself
as a key or value.
Object put(Object key, Object value)
Object remove(Object key)
void putAll(Map t)
void clear()
The query operations allow you to check on the contents of the map
Object get(Object key)
boolean containsKey(Object key)
boolean containsValue(Object value)
int size()
boolean isEmpty()
The set methods allow you to work with the group ofkeys or values as a collection
Set keySet()
Collection values()
Set entrySet()
Object put(Object key, Object value)
Object remove(Object key)
void putAll(Map t)
void clear()
The query operations allow you to check on the contents of the map
Object get(Object key)
boolean containsKey(Object key)
boolean containsValue(Object value)
int size()
boolean isEmpty()
The set methods allow you to work with the group ofkeys or values as a collection
Set keySet()
Collection values()
Set entrySet()
Explore
the other Interface and Classes of Java Collection Framework
Java Collection Framework -
SortedSet Interface
|
The
Collection Framework provides a special Set interface for maintaining elements
in a sorted order called SortedSet.
Comparator
|
comparator()
Returns the comparator associated with this sorted set, or null if it uses its elements' natural ordering. |
Object
|
first()
Returns the first (lowest) element currently in this sorted set. |
SortedSet
|
headSet(Object toElement)
Returns a view of the portion of this sorted set whose elements are strictly less than toElement. |
Object
|
last()
Returns the last (highest) element currently in this sorted set. |
SortedSet
|
subSet(Object fromElement,
Object toElement)
Returns a view of the portion of this sorted set whose elements range from fromElement, inclusive, to toElement, exclusive. |
SortedSet
|
tailSet(Object fromElement)
Returns a view of the portion of this sorted set whose elements are greater than or equal to fromElement. |
The
interface provides access methods to the ends of the set as well to subsets of
the set. When working with subsets of the list, changes to the subset are
reflected in the source set. In addition changes to the source set are
reflected in the subset. This works because subsets are identical by elements
at the end point, not indices. In addition , if the formElement is part of the
source set , it is part of the subset. However, if the toElement is part of the
source ser, it is not part of the subset. If you would like a particular
to-element to be in the subset, you must find the next element. In the case of
a string, the next element is the same strong with a null character appended
(string+”\0”).;
The element added to a SortedSet must either implement Comparable or you must provide a Comparator to the constructor to its implementation class: TreeSet.
This example uses the reverse order Comprator available from the Collection calss.
Comparator comparator= Collections.reverseOrder();
Set reverseSer= new TreeSet(comparator);
revereseSet.add("one");
revereseSet.add("two");
revereseSet.add("three");
revereseSet.add("four");
revereseSet.add("one");
System.out.println(reverseSet);
Output of this program
[two, three, one, four]
The element added to a SortedSet must either implement Comparable or you must provide a Comparator to the constructor to its implementation class: TreeSet.
This example uses the reverse order Comprator available from the Collection calss.
Comparator comparator= Collections.reverseOrder();
Set reverseSer= new TreeSet(comparator);
revereseSet.add("one");
revereseSet.add("two");
revereseSet.add("three");
revereseSet.add("four");
revereseSet.add("one");
System.out.println(reverseSet);
Output of this program
[two, three, one, four]
Java Collection Framework - Sorted
Map Interface
|
The
Collection Framework provides a special Map interface for maintaining elements
in a sorted order called SortedMap.
The interface provides access methods to the ends of the map as well to subsets of the set. Working with a SortedMap is just like a SortedSet, except the sort is done on the map keys. The implementation class provided by the Collection Framework is a TreeMap.
The interface provides access methods to the ends of the map as well to subsets of the set. Working with a SortedMap is just like a SortedSet, except the sort is done on the map keys. The implementation class provided by the Collection Framework is a TreeMap.
Comparator
|
comparator()
Returns the comparator associated with this sorted map, or null if it uses its keys' natural ordering. |
||
Object
|
firstKey()
Returns the first (lowest) key currently in this sorted map. |
||
SortedMap
|
headMap(Object toKey)
Returns a view of the portion of this sorted map whose keys are strictly less than toKey. |
||
Object
|
lastKey()
Returns the last (highest) key currently in this sorted map. |
||
SortedMap
|
subMap(Object fromKey,
Object toKey)
Returns a view of the portion of this sorted map whose keys range from fromKey, inclusive, to toKey, exclusive. |
||
SortedMap
|
tailMap(Object fromKey)
Returns a view of the portion of this sorted map whose keys are greater than or equal to fromKey. |
||
Java Collection Framework -
HashSet & TreeSet Classes
|
|||
The
Collection Framework provides two general purpose implementations often Set
interface, HashSet and TreeSet. More often than not you will use a HashSet for
storing your duplicate-free collection. For efficiency objects added to a
HashSet need to implement the hashCode() method in a manner that properly
distributes the hash codes. While most system classes override the default
hashCode() implementation of the Object, when creating your own class to add to
a HashSet remember to override hashCode().
The
TreeSet implementations useful when you need to extract elements from a
collection in a sorted manner. It is generally faster to add elements to the
HasSet then convert the collection to a TreeeSet for sorted traversal.
To optimize HashSet space usage , you can tune initial capacity and load factor. TreeSet has no tuning options, as the tree is always balanced, ensuring log(n0 performance for insertions, deletions and queries.
Example
To optimize HashSet space usage , you can tune initial capacity and load factor. TreeSet has no tuning options, as the tree is always balanced, ensuring log(n0 performance for insertions, deletions and queries.
Example
import java.util.*;
public class HashTreeSetEx{ |
|||
|
public static void main (String
args[]){
|
||
|
|
Set
set = new HashSet(){
|
|
|
|
|
set.add("one");
set.add("two"); set.add("three"); set.add("four"); set.add("one"); System.out.println(set); Set sortedSet= new TreeSet(set); System.out.println(SortedSet); |
|
|
}
|
|
|
}
|
|
|
}
|
|
|
The
program produces the following output. The duplicate entry is olypresent once
and the second line outputs sorted
[one, two, three, four]
[four, one, three, two]
Note that these implementation is not synchronized. If multiple threads access a set concurrently, and at least one of the threads modifies the set, it must be synchronized externally. This is typically accomplished by synchronizing on some object that naturally encapsulates the set. If no such object exists, the set should be "wrapped" using the Collections.synchronizedSet method. This is best done at creation time, to prevent accidental unsynchronized access to the set:
[one, two, three, four]
[four, one, three, two]
Note that these implementation is not synchronized. If multiple threads access a set concurrently, and at least one of the threads modifies the set, it must be synchronized externally. This is typically accomplished by synchronizing on some object that naturally encapsulates the set. If no such object exists, the set should be "wrapped" using the Collections.synchronizedSet method. This is best done at creation time, to prevent accidental unsynchronized access to the set:
Set
s = Collections.synchronizedSet(new HashSet(...));
SortedSet s = Collections.synchronizedSortedSet(new TreeSet(...));
SortedSet s = Collections.synchronizedSortedSet(new TreeSet(...));
Java Collection Framework -
ArrayList & LinkedList Classes
|
There
are two general-purpose List implementations in the Collection Framework,
ArrayList and LinkedList, which of the two List implementations you use depends
on your specific needs. If you need to support random access, without inserting
or removing elements from any place to other than the end, then ArrayList
offers you the optimal collection, the LinkedList class provides uniformly
named methods to get, remove and insert an element at the beginning and end of
the list.
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. The details of the growth policy are not specified beyond the fact that adding an element has constant amortized time cost.
An application can increase the capacity of an ArrayList instance before adding a large number of elements using the ensureCapacity operation. This may reduce the amount of incremental reallocation.
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. The details of the growth policy are not specified beyond the fact that adding an element has constant amortized time cost.
An application can increase the capacity of an ArrayList instance before adding a large number of elements using the ensureCapacity operation. This may reduce the amount of incremental reallocation.
Note
that these implementation is not synchronized. If multiple threads access a set
concurrently, and at least one of the threads modifies the set, it must be
synchronized externally. This is typically accomplished by synchronizing on
some object that naturally encapsulates the set. If no such object exists, the
set should be "wrapped" using the Collections.synchronizedSet method.
This is best done at creation time, to prevent accidental unsynchronized access
to the set:
List
list = Collections.synchronizedList(new LinkedList(...));
List list = Collections.synchronizedList(new ArrayList(...));
List list = Collections.synchronizedList(new ArrayList(...));
Java Collection Framework -
HashMap & TreeMap Classes
|
The
Collection Framework provides two general-purpose Map implementation: HashMap
and TreeMap. As with all the concrete implementations, which implement you use
depends on your specific needs. For inserting, deleting and locating elements
in a Map the HashMap offers best alternatively. If however you need to traverse
the keys in a sorted order then TreeMap is better alternative. Depending upon
your size of your collection, it may be faster to add elements to a HashMap
then convert the Map to a TreeMap for sorted key traversal. Using a HashMap
requires that the class of key added have a well-defined hashCode()
implementation. With the TreeMap implementation elements added to the Map must
be sortable.
To optimize HashMap usage you can tune the initial capacity and load factor. The TreeMap has no tuning options as the tree is always balanced
To optimize HashMap usage you can tune the initial capacity and load factor. The TreeMap has no tuning options as the tree is always balanced
An
instance of HashMap has two parameters that affect its performance: initial
capacity and load factor. The capacity is the number of buckets in the hash
table, and the initial capacity is simply the capacity at the time the hash
table is created. The load factor is a measure of how full the hash table is
allowed to get before its capacity is automatically increased. When the number
of entries in the hash table exceeds the product of the load factor and the
current capacity, the capacity is roughly doubled by calling the rehash method.
As
a general rule, the default load factor (.75) offers a good tradeoff between
time and space costs. Higher values decrease the space overhead but increase
the lookup cost (reflected in most of the operations of the HashMap class,
including get and put). The expected number of entries in the map and its load
factor should be taken into account when setting its initial capacity, so as to
minimize the number of rehash operations. If the initial capacity is greater
than the maximum number of entries divided by the load factor, no rehash
operations will ever occur.
Note that these implementation is not synchronized. If multiple threads access a set concurrently, and at least one of the threads modifies the set, it must be synchronized externally. This is typically accomplished by synchronizing on some object that naturally encapsulates the set. If no such object exists, the set should be "wrapped" using the Collections.synchronizedSet method. This is best done at creation time, to prevent accidental unsynchronized access to the set:
Note that these implementation is not synchronized. If multiple threads access a set concurrently, and at least one of the threads modifies the set, it must be synchronized externally. This is typically accomplished by synchronizing on some object that naturally encapsulates the set. If no such object exists, the set should be "wrapped" using the Collections.synchronizedSet method. This is best done at creation time, to prevent accidental unsynchronized access to the set:
Map
m = Collections.synchronizedMap(new HashMap(...));
Map m = Collections.synchronizedMap(new TreeMap(...));
Map m = Collections.synchronizedMap(new TreeMap(...));
Java Collection Framework- Vector
& Stack Classes
|
A
Vector is an historical collection class that acts like a growable array, but
can store heterogeneous data elements.
Each
vector tries to optimize storage management by maintaining a capacity and a
capacityIncrement. The capacity is always at least as large as the vector size;
it is usually larger because as components are added to the vector, the
vector's storage increases in chunks the size of capacityIncrement. An
application can increase the capacity of a vector before inserting a large
number of components; this reduces the amount of incremental reallocation.
The Stack class represents a last-in-first-out (LIFO) stack of objects. It extends class Vector with five operations that allow a vector to be treated as a stack. The usual push and pop operations are provided, as well as a method to peek at the top item on the stack, a method to test for whether the stack is empty, and a method to search the stack for an item and discover how far it is from the top.
The Stack class represents a last-in-first-out (LIFO) stack of objects. It extends class Vector with five operations that allow a vector to be treated as a stack. The usual push and pop operations are provided, as well as a method to peek at the top item on the stack, a method to test for whether the stack is empty, and a method to search the stack for an item and discover how far it is from the top.
Explore
the other Interface and Classes of Java Collection Framework
Collection Interface
Iterator Interface
Set Interface
List Interface
ListIterator Interface
Map Interface
SortedSet Interface
SortedMap Interface
HashSet & TreeSet Classes
ArrayList & LinkedList Classes
HashMap & Treemap Classes
Vector and Stack Classes
Collection Interface
Iterator Interface
Set Interface
List Interface
ListIterator Interface
Map Interface
SortedSet Interface
SortedMap Interface
HashSet & TreeSet Classes
ArrayList & LinkedList Classes
HashMap & Treemap Classes
Vector and Stack Classes
No comments:
Post a Comment