Collections FAQ From Jguru

Collections FAQ From jGuru
Generated Sep 13, 2005 12:49:37 PM
Location: http://www.jguru.com/faq/Collections
Ownership: http://www.jguru.com/misc/user-agree.jsp#ownership.
Why is the Dictionary class not an interface?

Location: http://www.jguru.com/faq/view.jsp?EID=963
Created: Nov 14, 1999
Author: John Zukowski (http://www.jguru.com/guru/viewbio.jsp?EID=7)
Rumor has it that the Dictionary class is so old that the concept of interfaces didn't
exist yet. Once interfaces were introduced, nobody bothered to change Dictionary to
an interface.
What other frameworks are there for general data structures?

Created: Nov 14, 1999 Modified: 2000-07-25 21:34:44.324
The Generic Collection Library for Java - JGL from ObjectSpace has been around
since 1996 and the same version works with both JDK 1.1 and the Java 2 SDK. Doug
Lea's Collections Package is a precursor to the current Collections Framework. If you
are looking for template support, the Generic Java Language Extension includes a
retrofitted version of the Collections Framework with template support. A new entry
into the mix is Colt which is meant for scientific computing, and includes data
structures for numerical operations.
Comments and alternative answers
Trove4j, pcj, tclib...

Author: Sean Sullivan (http://www.jguru.com/guru/viewbio.jsp?EID=203382), Mar
10, 2003
Trove4j (aka GNU Trove): http://trove4j.sourceforge.net/
http://pcj.sourceforge.net/
http://www.sosnoski.com/opensrc/tclib/
Where can I find an article comparing JGL and the Collections Framework?
JavaWorld posted an article comparing the two frameworks back in their January
1999 issue: The battle of the container frameworks: which should you use?
Where can I learn how to use the Collections Framework?

The Java Developer Connection has a short course available at
http://developer.java.sun.com/developer/onlineTraining/collections/. In addition, the
online Java Tutorial book has a trail dedicated to the Collections Framework
available: http://java.sun.com/docs/books/tutorial/collections/.
Where do I get the Collections Framework for use with JDK 1.1?
The subset of the Collections Framework for use with JDK 1.1 is available with the
InfoBus information:
http://java.sun.com/beans/infobus/index.html#DOWNLOAD_COLLECTIONS.
What do I have to know about the Collections Framework to be a Certified

Java Programmer?
According to the exam objectives, you need to: "Make appropriate selection of
collection classes/interfaces to suit specified behavior requirements."
Helpfull....
Author: Ola Tartakovsky (http://www.jguru.com/guru/viewbio.jsp?EID=863596),
May 2, 2002
-
How do I use an Iterator to go through a Collection?

Collection collection = ...;

Iterator iterator = collection.iterator();
while (iterator.hasNext()) {
Object element = iterator.next();
// Do something with element
}
}
How do I use a ListIterator to go through a List backwards?

List list = ...;

ListIterator iterator = list.listIterator(list.size());
while (iterator.hasPrevious()) {
Object element = iterator.previous();
// Process element
}
How do I count the frequency of some word/object?

The Map interface can be used to count the number of times a word/object appears.
The following program demonstrates counting word frequency from the command
line:
import java.util.*;
public class MapExample {

public static void main(String args[]) {
Map map = new HashMap();
Integer ONE = new Integer(1);
for (int i=0, n=args.length; i<n; i++) {
String key = args[i];
Integer frequency = (Integer)map.get(key);
if (frequency == null) {
frequency = ONE;
} else {
int value = frequency.intValue();
frequency = new Integer(value + 1);
}
map.put(key, frequency);
}
System.out.println(map);
Map sortedMap = new TreeMap(map);
System.out.println(sortedMap);
}
}
How do I properly alphabetize (sort) a list of strings in a language-sensitive

manner?
This is actually outside the scope of the Collections Framework. Instead, it is part of
the java.text package with the Collator and CollationKey classes.
The following example demonstrates this capability:
import java.text.*;
import java.util.*;
public class CollatorTest {

public static void main(String args[]) {
Collator collator =
Collator.getInstance();
CollationKey key1 =
collator.getCollationKey("Tom");
CollationKey key2 =
collator.getCollationKey("tom");
CollationKey key3 =
collator.getCollationKey("thom");
CollationKey key4 =
collator.getCollationKey("Thom");
CollationKey key5 =
collator.getCollationKey("Thomas");
Set set = new TreeSet();

set.add(key1);
set.add(key2);
set.add(key3);
set.add(key4);
set.add(key5);
printCollection(set);
}
static private void printCollection(
Collection collection) {
boolean first = true;
Iterator iterator = collection.iterator();
System.out.print("[");
while (iterator.hasNext()) {
if (first) {
first = false;
} else {
System.out.print(", ");
}
CollationKey key =
(CollationKey)iterator.next();
System.out.print(key.getSourceString());
}
System.out.println("]");
}
}
can i pass a collection to a collator class

Author: ashwini iyer (http://www.jguru.com/guru/viewbio.jsp?EID=1084160), May
12, 2003
this code was really very helpful to me too
i have the same problem how do u pass collection to
collator it has 300 entries what will happen will there be
performance problems? will it slow down?
thanks a lot for the collator code!
IF I GET the collcetion to collator thing i would be
gratefull!

12, 2003
gratefull!

12, 2003
gratefull!
Sorting List Running Example

Author: Parag Agarwal (http://www.jguru.com/guru/viewbio.jsp?EID=1136228), Dec
30, 2003
import java.util.*; class Sort { private Vector list = new Vector(); public Sort()
{ list.addElement(new String("parag")); list.addElement(new String("amit"));
list.addElement(new String("priyank")); } public void sort() { Collections.sort(list); }
public void print() { System.out.println(list); } public static void main(String [] args)
{ Sort s = new Sort(); s.sort(); s.print(); } }

30, 2003
import java.util.*;
class Sort {
private Vector list = new Vector();

public Sort() {
list.addElement(new String("parag"));
list.addElement(new String("amit"));
list.addElement(new String("priyank"));
public void sort() {
Collections.sort(list);
public void print() {
System.out.println(list);
public static void main(String [] args) {
Sort s = new Sort();
s.sort();
s.print();

30, 2003
import java.util.*;
class Sort {
private Vector list = new Vector();
public Sort() {
list.addElement(new String("parag"));
list.addElement(new String("amit"));
list.addElement(new String("priyank"));
public void sort() {
Collections.sort(list);
public void print() {
System.out.println(list);
public static void main(String [] args) {
Sort s = new Sort();
s.sort();
s.print();
}
How do I do a case-insensitive string sort in a language-insensitive

manner?
You need to use a new Comparator, not the default Comparable. The String class
comes with a special Comparator you can use: String.CASE_INSENSITIVE_ORDER.
How do I sort objects into their reverse natural ordering?

The Collections.reverseOrder() method returns a Comparator that sorts objects that

implement the Comparable interface in reverse order.
How do I use Enumeration to iterate through a collection?

Enumeration enum = ...;

while (enum.hasMoreElements()) {
Object element = iterator.nextElement();
// process element
}
What newsgroups/mailing lists are available to ask questions about the

Collections Framework?
The comp.lang.java.programmer newsgroup is probably your best bet for Collections

Framework questions. There is mailing list specific to ObjectSpace JGL-questions that
you can subscribe to at http://www.objectspace.com/products/jglDiscGroups.htm.
The TreeMap documentation states that it is a red-black tree based

implementation of the SortedMap interface. What are red-black trees?
A red-black tree is a binary search tree where every node has two children or is a
leaf. It ensures O(log N) search times, at a cost of a more complicated insertion (and
deletion) process. In a red-black tree, every node is colored either red or black, with
a black root node, though a black root node isn't a requirement. In addition, if a
node is red, its children must be black and every path from root to leaf (or null child
node) must contain the same number of black nodes. These rather obscure rules
ensure the tree is balanced.
How do I make an array larger?

You cannot directly make an array larger. You must make a new (larger) array and
copy the original elements into it, usually with System.arraycopy(). If you find
yourself frequently doing this, the Vector class does this automatically for you, as
long as your arrays are not of primitive data types.
How do you store a primitive data type within a Vector or other collections
class?
You need to wrap the primitive data type into one of the wrapper classes found in the
java.lang package, like Integer, Float, or Double, as in:
Integer in = new Integer(5);
How do I create linked lists if there are no pointers?

No pointers does not mean no reference variables. You just can't deference them as
you can in C/C++ or perform pointer arithmetic. You can still use abstract data types
that require dynamic data structures. See the LinkedList class for an example of a
linked list implementation.
How do I use an array with the Collections Framework?

The Arrays.asList() method provides a fixed-length List view of an array, where

changes to the List are stored in the original array. The Arrays class also provides
additional support methods for sorting and searching an array.
Which is faster, synchronizing a HashMap or using a Hashtable for thread-
safe access?
Because a synchronized HashMap requires an extra method call, a Hashtable is faster

for synchronized access.
Where can I get the Collections Framework?

The Collections Framework is a core part of the Java 2 platform. You don't have to
download anything more than the Java 2 SDK. For more information about the
framework, the main documentation is available at
http://www.javasoft.com/products/jdk/1.2/docs/guide/collections/.
There also is a subset of the Collections Framework available for JDK 1.1, see
http://java.sun.com/beans/infobus/#collections.
Where can I find information about the design decisions made during the
development of the Collections Framework?
Sun provides a Design FAQ at

http://java.sun.com/products/jdk/1.2/docs/guide/collections/designfaq.html that
answers many questions concerning the design of the framework.
Which is the preferred collection class to use for storing database result
sets?
Created: Dec 9, 1999 Modified: 2000-07-30 09:48:38.772
When retrieving database results, the best collection implementation to use is the
LinkedList. The benefits include:
• Retains the original retrieval order

• Has quick insertion at the head/tail
• Doesn't have an internal size limitation like a Vector where when the size is
exceeded a new internal structure is created (or you have to find out size
beforehand to size properly)
• Permits user-controlled synchronization unlike the pre-Collections Vector
which is always synchronized
Basically:
ResultSet result = stmt.executeQuery("...");
List list = new LinkedList();
while(result.next()) {
list.add(result.getString("col"));
}
If there are multiple columns in the result set, you'll have to combine them into their
own data structure for each row. Arrays work well for that as you know the size,
though a custom class might be best so you can convert the contents to the proper
type when extracting from databse, instead of later.
Why doesn't the Iterator interface extend the Enumeration interface?

If the Iterator interface extended the Enumeration interface, the Iterator interface
would end up with five methods where two methods just called other methods in the
interface. The designers of the framework wanted to get rid of the cumbersome
Enumeration method names so had the Iterator interface stand on its own with new
shorter method names.
How do I print a Collection?

The Collection Framework implementation classes override the toString() method to

print out all the elements of the collection. If you create your own custom
implementation, as long as your class is a subclass of AbstractMap or
AbstractCollection you'll inherit this behavior. (Keep in mind that AbstractList and
AbstractSet subclass AbstractCollection.)

Author: Andrew Ferguson (http://www.jguru.com/guru/viewbio.jsp?EID=1022145),
Apr 16, 2003
i keep having to write this bit of code to get a readable format tho..
public static void print(Collection c) {

for(Iterator i = c.iterator(); i.hasNext(); )
System.out.println(i.next());
}

Author: Andrew Ferguson (http://www.jguru.com/guru/viewbio.jsp?EID=1022145),
Apr 16, 2003
i keep having to write this bit of code to get a readable format tho..
public static void print(Collection c) {

for(Iterator i = c.iterator(); i.hasNext(); )
System.out.println(i.next());
}
How do I synchronize a collection?

With the Collections Framework, the new implementations are all unsynchronized by
default. If you need synchronized access, you must synchronize things yourself. The
Collections class offers a wrapper method for each of the six core collection
interfaces that add synchronization to an arbitrary collections implementation. To
ensure thread-safety, direct access to the original backing collection must be
avoided.
For example, the following will synchronize an arbitrary List and lose the original
reference so you can't access it directly:
List list = ...;

list = Collections.synchronizedList(list);
Re: How do I synchronize a collection?

Author: Kalpeshkumar Soni (http://www.jguru.com/guru/viewbio.jsp?EID=916018),
Jun 2, 2003
It is imperative that the user manually synchronize on the returned collection when
iterating over it:
Collection c = Collections.synchronizedCollection(myCollection);
...
synchronized(c) {
Iterator i = c.iterator(); // Must be in the synchronized block
while (i.hasNext())
foo(i.next());
}
Failure to follow this advice may result in non-deterministic behavior
How do I do a case-sensitive sort in a language-insensitive manner?

If you have an array of primitives or an array of equivalent objects that implement

the Comparable interface, all you need to do is call the sort() method of the
java.util.Arrays class. If the class doesn't implement Comparable, you need to
provide your own Comparator implementation to the sort() method.
How do I get the length of an array?
To avoid getting an ArrayIndexOutOfBoundsException, you can check for the array

length from either the length instance variable or using reflection and calling
java.lang.reflect.Array.getLength(), passing the array as an argument to the method.
int length = args.length;
// or
int length2 = Array.getLength(args);
Note that Array.getLength(args) is only needed when...

Author: Doug Bell (http://www.jguru.com/guru/viewbio.jsp?EID=113602), Aug 1,
2000
Note that Array.getLength(args) is only needed when args is a generic Object
reference and args.getClass().isArray() is true. If args is a reference to an
array type, use args.length.
How can I speed up array accesses and turn off array bounds checking?
Created: Dec 20, 1999
You cannot. It is part of the security architecture of the Java runtime to ensure never
accessing invalid memory space.
Don't forget that dynamic compilation can sense when...

Author: Terence Parr (http://www.jguru.com/guru/viewbio.jsp?EID=1), Dec 22, 1999
Don't forget that dynamic compilation can sense when an array reference is in a loop
whose index is bounded within the array size. In this case, the bounds check is
superfluous and can be removed.
The null-pointer check can also be moved out of the loop via "loop-invariant code
motion" stuff.
Does any of this really happen? Haven't checked, but I hope so. ;) In principle,
dynamic compilers can do much more of this than a JIT or other a priori compiler.
Turning off Array Bounds Checking

Author: Richard Bremner (http://www.jguru.com/guru/viewbio.jsp?EID=976227),
Aug 5, 2002
I'm not sure if it still applies in the current family of jre's, but apparently you used
to be able to turn off the Array Bound checking by encapsulating your array
access in a try/catch;
try {
for (int i = 0; ; i++) {
myArray[i] = i;
catch (ArrayIndexOutOfBoundsException aioobe) {
//to be expected
}
Even if this did work, I expect it would only be faster for very large arrays,
richard
Re: Turning off Array Bounds Checking

Author: Bernd Eckenfels
(http://www.jguru.com/guru/viewbio.jsp?EID=1194484), Aug 20, 2004
If you do it this way you _force_ the JIT engine to do bounds checking. Because
the bounds checks are needed for the engine to raise the excaption.
See http://c2.com/cgi/wiki?CatchDontCheck
Greetings
Bernd
How do I get the list of system properties that tell me things like which
version of Java a user is running and their platform-specific line separator?
The System.getProperties() method will return the standard property set. However,
in untrusted applets, you can only ask for specific properties, as in
System.getProperty("java.version").
How do I sort an array?

Created: Feb 3, 2000 Modified: 2000-02-03 00:24:17.523
The Arrays class in java.util provides a series of sort() methods for sorting arrays. If
the array is an array of primitives or an array of a class that implements Comparable
then you can just call the method directly:
Arrays.sort(theArray);
If, however, it is an array of objects that don't implement the Comparable interface
then you need to provide a custom Comparator to help you sort the elements in the
array.
Arrays.sort(theArray, theComparator);
How can I implement a List (ordered collection) that keeps an index (i.e. a
Map) of its contents?
You can't. Each of the Map and List interfaces define a remove(Object o) method.
Each method returns a different type (Map returns an Object while List returns a
boolean). Because the compiler doesn't permit overloaded methods that differ by
only return type, you cannot create a class that implements both the List and Map
interface.
If you need a Map that maintains insertion order, see the LinkedHashMap added in
Java 1.4.
I've got open-source code that solves this, in two...

Author: Alex Chaffee (http://www.jguru.com/guru/viewbio.jsp?EID=3), Mar 1, 2000
I've got open-source code that solves this, in two different classes. My EntryList is a
List that stores key-value pairs; it adds get(Object key) and put(Object key,
Object value) and a few other methods to the standard ArrayList. My IndexedList
is a normal List that builds an index of its contents based on a callback function you
pass it - so, for example, if storing Person objects, you could provide a callback that
calls getName() for the index.
Both of my Lists also have a toMap() method which returns a true java.util.Map
object for you to play with.
Find them at http://www.purpletech.com/code/.
How can I save/load application settings that I would normally use .ini files
or the Windows Registry?
Created: Mar 5, 2000 Modified: 2005-09-12 14:42:49.101
Author: John Zukowski (http://www.jguru.com/guru/viewbio.jsp?EID=7) Question
originally posed by chih-ming yan
(http://www.jguru.com/guru/viewbio.jsp?EID=20234
You can use Java property files for storing settings for an application. Use the
java.util.Properties class, which includes a load and store method.
You can also use a PropertyResourceBundle, but there is no way to automatically

store these files built into the Java classes, only read them.
What collection works best for maintaining a family tree, where each node
can have multiple parents and multiple children, spouse relationships, etc.?
Author: Joseph Shelby (http://www.jguru.com/guru/viewbio.jsp?EID=26292)
Question originally posed by John Zukowski PREMIUM
With Collections by themselves, there isn't one. What you're asking for is a Labeled
Directed Graph (A directed graph where the graph edges have labels describing the
relationship). A rather complex object.
You'd have to design that yourself (though you can use Collection objects like Lists in
the implementation as a convenience), and design Comparators to support your final
implementation classes of a "FamilyTreePerson" for sorting purposes (like sort by
name or sort by birthdate, etc.).
After that, you have to decide what "Iteration" over the tree really means and define
Iterator classes over the Graph. After that, completing the Collection interface should
be pretty simple.
In other words, you've got a lot of design work to do, but designing it well can lead
to a rather flexible framework (or at least a source of Patterns) for future use. In
particular, keep in mind in building such a LabeledDirectedGraph beast on how you
can keep "Family Tree" concepts out of it. The Label provider should be an Interface
function object, like Comparator.
This is getting heavily into "Generic Programming", and I advise you read more
about that (most GP work is being done in connection with the STL from C++).
Is there a way to create a homogenous collection in Java?

How do I make a collection where all the elements within it are a specific
data type?
Author: Joseph Shelby (http://www.jguru.com/guru/viewbio.jsp?EID=26292)
Question originally posed by Tim Rohaly PREMIUM
You can wait for Generics to be added to Java or...

You'd have to build one yourself. Basically, you're creating a class that is a Proxy
(Gang Of Four design pattern) around the actual Collection.
This works similarly to the way the (hidden) Synchronized versions in Collections
work. They contain a reference to the original collection object that does the "real"
work, but restrict access to it by synchronizing all the access methods.
What you'd be doing in this case is restricting access by keeping a reference to the
Class object of the class you want to restrict your collection to contain, and throw
IllegalArgumentExceptions whenever there's an attempt to add an object not of that
class.
There's no way to enforce compile-time type safety in this manner. The API using
"Object" references can't be changed in Collection.
You can also wrap a collection by a Proxy that provides the alternative API that has
type-safe method signatures. This is what's done by the StringTokenizer API (which
implements Enumeration, and wraps Enumeration with String versions of the same
methods).
Otherwise, create your own class with its own signatures, and keep the Collection
strictly private. This is best done if you are designing a class for others to use.
What's the fastest way to traverse all the elements of a Vector?

Created: Apr 6, 2000 Modified: 2001-11-29 22:40:29.604
If speed is of the essence, do not use a Vector. Instead, use an ArrayList. All
accesses to a Vector are synchronized, whether you need it or not. If you know you
aren’t accessing the structure from multiple threads, the ArrayList will be much
faster.
With that said, what about if you need to stay with a Vector? There are at least four
ways to traverse through all the elements of a Vector:
• Using a for loop and accessing each element with elementAt(index) or

get(index)
• Using an Emumeration
• Using an Iterator
• Using an Enumeration/Iterator, but relying on an exception to catch ending
Of the four, there are neglible differences in performance. While looping through to a
specific index is a little faster, you lose the flexibility of changing to another data
structure at a later time. With the Enumeration / Iterator approach, there is the
added cost to create the Enumeration/Iterator to walk through. With the exception
approach, you are relying on NoSuchElementException to be thrown to catch the
ending of the walk through. While creating the exception takes time, this approach
avoids the repeated test of hasMoreElement(). As the structure gets larger, avoiding
the test condition can save lots of time.
Added by Doug Bell:
You left out what is often the fastest means to sequence though the members of a
Vector: get a copy of the elements in an array and sequence through the array. This
results in either synchronized calls, after which there is not any method overhead at
all:
Object[] elements = vector.toArray(); // JDK 1.2
or
Object[] elements;
synchronized (vector) { // needed if
concurrently accessed
elements = new Object[vector.size()];
vector.copyInto(elements);
}
Further, if you know the types of the elements in the Vector, you can put the copy of
the elements in an array of the known type and eliminate the casting overhead
necessary to cast the Object references to the known type.
JDK 1.1:
MyType[] elements;
synchronized (vector) { // needed if
concurrently accessed
elements = new MyType[vector.size()];
vector.copyInto(elements);
}
JDK 1.2:
MyType[] elements = new MyType[vector.size()];
elements = (MyType[])vector.toArray(elements);
Note that while System.arraycopy() still needs to check the types of the objects
when copying between arrays of different types, the check is performed much more
efficiently than performing the cast operation on each element individually.
Getting an array of elements is faster than the other suggested approaches for
vectors of more than a few elements. Although it does incur the overhead of
instantiating a copy of the array and copying the elements, these operations
generally take much less time than the repeated synchronization. As an added
benefit (usually at least, depends on what you're trying to do) the process of
iterating through the elements is predictable even in the presence of other threads
which modify the vector. (You can also achieve this using any of the other techniques
by placing the code that sequences the vector in a block synchronized on the
Vector object.)
A fifth way actually exists that is faster for traversal, but requires additional setup
and memory. Copy the elements out of the collection and into an array. You can even
make the array the right data type.
How does a Hashtable internally maintain the key-value pairs?

Created: May 2, 2000 Modified: 2000-05-02 05:15:12.121
Author: Frank Steidinger (http://www.jguru.com/guru/viewbio.jsp?EID=34216)
Question originally posed by Pramod Hirole
The Hashtable class uses an internal (private) class named Entry to hold the key-
value pairs. All entries of the Hashtable are stored in an array of Entry objects with
the hash value of the key serving as the index. If two or more different keys have
the same hash value these entries are stored as a linked list under the same index.
How do I look through each element of a HashMap?

Created: Jun 7, 2000 Modified: 2000-06-07 10:49:02.409
originally posed by Steffen Schlachter
To go through all the elements of a HashMap, or any class that implements the Map
interface, call the entrySet() or keySet() methods than loop through what is
returned. The entrySet() returns a group of Map.Entry elements, whereas the
keySet() method just returns a Set of key elements. If you then want what the key
refers to, you'd have to look them up.
Once you have a Set to work with, you would then use an Iterator to go through all
its elements. The following demonstrates:
Map map = some hash map

Set set = map.keySet();
Iterator it = set.iterator();
while (it.hasNext()) {
System.out.println(it.next());
}
How do I create a read-only collection?

Created: Jul 14, 2000 Modified: 2000-07-17 09:13:00.244
The Collections class has six methods to help out here:
• unmodifiableCollection(Collection c)
• unmodifiableList(List list)
• unmodifiableMap(Map m)
• unmodifiableSet(Set s)
• unmodifiableSortedMap(SortedMap m)
• unmodifiableSortedSet(SortedSet s)
If you then get an Iterator from one of these unmodifiable collections, when you call
remove() it will throw an UnsupportedOperationException.
How can I process through the keys of a Hashtable in sorted order?

originally posed by khyati patel
In order to get all the keys for a Hashtable, you use the keys() method to get an
Enumeration or the keySet() method to get a Set. If you are using Java 2, and can
use the collections framework, what you should do is get the key set of the
Hashtable and create a TreeSet from it. You can then get an iterator() from the
created TreeSet that will have the keys in order. If you can't use the collections
framework, you'll have the sort the Enumeration you get back from keys() yourself.
This does not answer the question.

Author: chris gutteridge (http://www.jguru.com/guru/viewbio.jsp?EID=1027896),
Nov 20, 2002
You say how to get a set out of it, but don't say how to sort that set. so it's not that
helpful.
Re: This does not answer the question.

Author: Andrew Hart (http://www.jguru.com/guru/viewbio.jsp?EID=935096), Jan
15, 2003
Yes, it does. A TreeSet is, by definition, sorted. So, when you construct a TreeSet
passing the constructor a collection, it is sorted. If you would like it spelled out:
Iterator it = new TreeSet (someHashtable.keySet()).iterator();
// Now, you're reading the key objects in
// the natural sort order...
YourKeyClass yourKey = (YourKeyClass) it.next();
// Refer to the original Hashtable for the

// corresponding value...
YourValue yourValue = (YourValue) someHashtable.get(yourKey);
So, not only does it answer the question, it does so in a very terse and elegant
manner.

15, 2003
manner.

15, 2003

manner.

Nov 20, 2002
You say how to get a set out of it, but don't say how to sort that set. so it's not that
helpful.

Nov 20, 2002
You say how to get a set out of it, but don't say how to sort that set. so it iss not that
helpful.
Which collections in Java are synchronized and which aren't?

originally posed by Jayaprakash Amballa
The original collection classes in Java are all synchronized: Vector and Hashtable,
along with their subclasses Stack and Properties. Those classes introduced with the
Java 2 Collections Framework are all NOT synchronized by default, the sets, lists, and
maps. If you need to synchronize those, see How do I synchronize a collection?.
What are the differences between ArrayList and LinkedList?

originally posed by Raymond Lui
An ArrayList is a List implementation backed by a Java array, similar to the Vector

class. As the number of elements in the collection increases, the internal array grows
to fit them. If there are lots of growth periods, performance degrades as the old
array needs to be copied into the new array. However, random access is very quick
as it uses an array index to access.
With a LinkedList, the List implementation is backed by a doubly linked list data
structure, allowing easy inserts/deletions anywhere in the structure, but really slow
random accesses as the access must start at an end to get to the specific position.
Which you use really depends on the type of operations you need to support.
Glen McCluskey posted a Tech Tip titled Using List...

Author: Aprameya Paduthonse (http://www.jguru.com/guru/viewbio.jsp?EID=4707),
Jan 16, 2001
Glen McCluskey posted a Tech Tip titled Using List Collections Efficiently at the
JDC that covers this in great detail, including timing differences.
Where can I find Java packages for expressing numerical formulas?

originally posed by ds you (http://www.jguru.com/guru/viewbio.jsp?EID=32792
Colt offers, among others, efficient and usable data structures and algorithms for
Off-line and On-line Data Analysis, Linear Algebra, Multi-dimensional arrays,
Statistics, Histogramming, Monte Carlo Simulation, Parallel & Concurrent
Programming.
Where can I find additional implementations of the Collections Framework

API?
originally posed by John Zukowski PREMIUM
Doug Lea offers several implementations of collection framework interfaces in his

library that help overcome concurrency problems.
You can also check out the Java Collections Clearinghouse.
If you know of any more, please feel free to submit feedback.
FYI The above link is dead.

Author: Spencer Marks (http://www.jguru.com/guru/viewbio.jsp?EID=24112), Oct
28, 2002
javacollections.org is no longer it seems.

Author: Spencer Marks (http://www.jguru.com/guru/viewbio.jsp?EID=24112), Oct
28, 2002
How do I read input from a stream "one word at a time"?

Created: Aug 7, 2000 Modified: 2001-08-18 17:57:08.874
originally posed by Muhammad Qureshi
What you need to do is use the java.util.StringTokenizer or

java.io.StreamTokenizer to parse your input into words. Each has a default set of
delimiters like white space that can be changed. The following demonstrates the
using of StringTokenizer to count words in a file.
import java.io.*;
import java.util.*;
public class Test {

static final Integer ONE = new Integer(1);
public static void main (String args[])

throws IOException {
Map map = new TreeMap();

FileReader fr = new FileReader(args[0]);
BufferedReader br = new BufferedReader(fr);
String line;
while ((line = br.readLine()) != null) {
processLine(line, map);
}
printMap(map);
}
static void processLine(String line, Map map) {
StringTokenizer st = new StringTokenizer(line);
while (st.hasMoreTokens()) {
addWord(map, st.nextToken());
}
}
static void addWord(Map map, String word) {
Object obj = map.get(word);
if (obj == null) {
map.put(word, ONE);
} else {
int i = ((Integer)obj).intValue() + 1;
map.put(word, new Integer(i));
}
}
static void printMap(Map map) {
Set set = map.entrySet();
Iterator it = set.iterator();
Map.Entry entry = (Map.Entry)it.next();
System.out.println(entry.getKey() +
": " + entry.getValue());
}
}
}
Do the keys() and elements() methods of a Hashtable enumerate things in

the same order?
Created: Aug 9, 2000 Modified: 2000-08-09 10:10:54.271
originally posed by Nimmi Shamdasani
There is no requirement that the elements are returned in the same order, only that
all of them are returned in the Enumeration. Your best bet for getting the element for
a key is to loop through the keys() returned and fetch the element for each. Or, if
you can use a HashMap instead of a Hashtable, work with the Map.Entry that is
returned by the keySet(). This includes both the key and value together, not
requiring a separate lookup.
How do I treat an object I get out of a Vector (collection) as the type I put
into it?
Created: Sep 15, 2000 Modified: 2000-09-15 14:09:12.012
originally posed by Li Changen
When you get an object out of a Vector (or any collection), the object is returned as
being of type Object. You need to cast it back into the object type you put into the
data structure if you need to call or treat the object as the original type.
For instance, if you add an array to a vector:
String args[] = {"1", "2", "3"};

Vector v = new Vector();
v.addElement(args);
Then, when you get the object out of the vector, you need to cast it back to the
original type:
String args2[] = (String[])v.firstElement();
System.out.println(args2.length);
What is the difference between a singly linked list and doubley linked list?
originally posed by Prabhakar Pamula
A singly linked list is one that has only a pointer/reference to the next element in the
list. A doubley linked list has both a previous and next pointer/reference.
Single link list is link list in which you can traverse...

Author: Rahul kumar Gupta (http://www.jguru.com/guru/viewbio.jsp?EID=4809),
Sep 22, 2000
Single link list is link list in which you can traverse only in one direction while
doubly link list you can traverse in both direction.
Here is example - arrows show direction of movement
single link list
Node 1 -> Node2 -> Node3 ....->Node n
double link list

Node 1 <-> Node2 <-> Node3 ....<->Node n
What is a polymorphic algorithm?

Author: Avi Kak (http://www.jguru.com/guru/viewbio.jsp?EID=26410)
In general, an algorithm is called polymorphic if it can achieve the same functionality

using different data structures. For example, if the same sorting or searching
algorithm could be used with different types of containers, such as vectors, lists,
maps, etc., then that algorithm would be called polymorphic. As a case in point, the
generic algorithms of the STL library in C++ are polymorphic because they can be
used for different container classes.
In the context of Java collections, the polymorphic algorithms are all supplied by the
various static methods of the java.util.Collections class. Consider, for example, the
method sort(List list). This method is capable of sorting any collection that has
implemented the List interface, and that includes containers of types ArrayList,
LinkedList, Vector, etc.
What is meant by natural ordering of objects in the context of the

collections framework?
Java documentation refers to the natural ordering of objects when describing various
algorithms and data structures in the collections framework. Object ordering is
obviously needed by the sorting algorithms. It is also needed by the specifications of
the interfaces such as SortedSet, SortedMap, etc., and the data structures used for
container classes such as TreeSet, TreeMap, etc. Unless instructed otherwise via a
Comparator object supplied as an argument to the constructor, the default behavior
of a class such as TreeSet is to store its objects in an ascending natural order.
The objects of a class exhibit natural ordering if the class has implemented the
java.lang.Comparable interface. Such a class must provide an implementation for the
compareTo method -- referred to as the class's natural comparison method -- that
can then be used by the algorithms and the data structures for comparing data
objects. The compareTo method must return a negative integer, a zero, or a positive
integer if the object on which it is invoked is less than, equal to, or greater than the
argument object.
It is strongly recommended that a class's natural ordering as dictated by the

implementation of the compareTo method be consistent with equals. This
consistency is achieved if and only if e1.compareTo( (Object) e2 ) == 0 has the
same boolean value as e1.equals( (Object) e2 ) for every pair of objects e1 and e2 of
the class. Lack of this consistency could elicit strange behavior from the data
structures that need to compare objects.
Many of the system supplied classes possess natural ordering. These include String,
Integer, Float, Double, Date, File and many others. For the String class, the natural
order is lexicographic; it is chronological for the Date class; lexicographic on the
pathname for the File class, etc.
What is a fail-fast iterator?

Created: Oct 3, 2000 Modified: 2005-08-17 01:37:03.148
An iterator is considered fail-fast if it throws a ConcurrentModificationException

under either of the following two conditions:
1. In multithreaded processing: if one thread is trying to modify a Collection

while another thread is iterating over it.
2. In single-threaded or in multithreaded processing: if after the creation of the
Iterator, the container is modified at any time by any method other than the
Iterator's own remove or add methods.
Note in particular what is implied by the second condition: After we create a

container's iterator, during a loop that iterates over the container we must only use
the remove (and when applicable add) methods defined for the iterator and that we
must NOT use the same methods defined for the container itself. To illustrate this
point, suppose we declare and initialize a List in the following manner
List list = new ArrayList();
list.add("Peter");
list.add("Paul");
list.add("Mary");
Let's say we wish to iterate over this list. We'd need to declare a ListIterator as
follows:
ListIterator iter = list.listIterator();
Having created this iterator, we could now set up a loop like:
while(iter1.hasNext()){
String str = iter1.next();
// do something with str
}
Because iter is fail-fast, we are not allowed to invoke List's add or remove methods
inside the loop. Inside the loop, we are only allowed to use ListIterator's add and
remove methods. This makes sense because it is the Iterator object that knows
where it is in a List as the List is being scanned. The List object itself would have no
idea of that.
The Iterators supported by all the work-horse container classes, such as ArrayList,
LinkedList, TreeSet, and HashSet, are fail-fast. The Iterator type retrofitted to the
older container class Vector is also fail-fast. For associative containers, such as
HashMap and the older HashTable, the Iterator type for the Collections
corresponding to either the keys or the values or the <key, value> pairs are fail-fast
with respect to the container itself. That means that even if you are iterating over,
say, just the keys of the container, any illegal concurrent modifications to the
underlying container would be detected.
One final note regarding iterators versus enumerations: It is also possible to use an
Enumeration object returned by the elements() method for iterating over the older
container types such as Vector. However, Enumerations do not provide a fail-fast
method. On the other hand, the more modern Iterator returned by a Vector's
iterator() and listIterator() methods are fail-fast. Hence, iterators are recommended
over enumerations for iterating over the elements of the older container types.
fail-fast iterators are not guaranteed to detect concurrent modifications

Author: Steven Feist (http://www.jguru.com/guru/viewbio.jsp?EID=966332), Jul 26,
2002
This item implies that fail-fast iterators will always detect concurrent modifications,
but this is not the case: they throw ConcurrentModificationException on a "best-
effort" basis. See
http://java.sun.com/j2se/1.4/docs/api/java/util/ConcurrentModificationException.html.
How do you sort the elements of a vector?

originally posed by Ravi Sankar Kavula
Since the Vector class implements the List interface, you can call the
Collections.sort() method to sort the elements in place. You can also manually insert
elements into a Vector to keep the vector sorted. Of course, if keeping sorted access
is such a big deal, you should consider using a different, more appropriate data
structure like a TreeSet.
For 1.1 Java users, you'll need to sort the elements yourself. There is no built-in
support for this. A better option might be to sort the elements as you insert each
element.
What is stable sorting?

The collections framework specification requires that the sorting algorithms be

stable. Stated succinctly, a sorting algorithm is stable if it does not reorder equal
elements. But what does that really mean? The goal of this posting is to illustrate
this concept.
Stability in sorting becomes an issue for class-type objects with two or more data
members. We'd obviously need to choose a data member whose values will be used
to order the objects for sorting. Let's say we have multiple objects in a list whose
values for the data member chosen for comparison are the same, but whose values
for the other data members are different. A stable sorting algorithm will leave the
original order of such objects untouched.
Stability in sorting, or lack thereof, is best illustrated by comparing the sorted order
obtained through the quicksort algorithm with the sorted order obtained through the
mergesort algorithm. An optimized implementation of quicksort is slightly faster than
an optimized implementation of mergesort but does not guarantee stability. On the
other hand, mergesort guarantees stability.
To show the comparative results obtained with quicksort and mergesort, let's define
the following class:
class Person {
String name;
int rank;
Person( String nam, int r )
{
name = new String( nam );
rank = r;
}
String getName() { return name; };
public String toString() { return name + " " + rank; }
}
We will sort Person objects by using the following Comparator object:
class PersonComparator implements Comparator {
public int compare( Object o1, Object o2 )

{
Person p1 = ( Person ) o1;
Person p2 = ( Person ) o2;
return p1.getName().compareTo( p2.getName() );
}
}
This will compare Person objects on the basis of the name field. For the purpose of
sorting, let's now construct a list of Person objects by
List perList = new ArrayList();
perList.add( new Person( "Zaphod", 0 ) );

perList.add( new Person( "Betelgeuse", 0 ) );
perList.add( new Person( "Trillion", 0 ) );
A stable sorting algorithm will reorder the names in the list, but for each name will
leave untouched the order of appearance with respect to the rank. We can sort this
list by a mergesort algorithm by invoking
Collections.sort( perList, new PersonComparator() );
The sorted listed will be as follows:
Betelgeuse 0
Betelgeuse 1
Betelgeuse 2
Trillion 0
Trillion 1
Trillion 2
Zaphod 0
Zaphod 1
Zaphod 2
where the name is followed by the associated rank in each Person object.
On the other hand, if we sort the same original list with a quicksort algorithm using
again the name field for comparison, we get
Betelgeuse 0
Betelgeuse 2
Betelgeuse 1
Trillion 2
Trillion 0
Trillion 1
Zaphod 0
Zaphod 2
Zaphod 1
Notice that objects that are equal with respect to the name field are getting shuffled
by the quicksort algorithm.
The quicksort results I showed above were obtained with a C++ program that
invoked the well-known qsort function with the following invocation
qsort( perList, 9, sizeof( Person* ), comparePersons );

where the list of Person objects was declared as
Person* perList[9];
with each element of the list instantiated by a statement like
perList[0] = new Person( "Zaphod", 0 );
perList[1] = new Person( "Zaphod", 1 );
...
...
The comparison function needed for the fourth argument of qsort was defined by
int comparePersons( const void* arg1, const void* arg2 )

{
string str1 = (*( Person** )arg1)->name;
string str2 = (*( Person** )arg2)->name;
return ( str1 ).compare( str2 );
}
What is a WeakHashMap? What is its use and when should you use it?
originally posed by piyush sheth
A WeakHashMap is a special Map implementation where the keys of the map are
stored in a java.lang.ref.WeakReference. By storing the keys in a weak reference,
key-value pairs can dynamically be dropped from the map when the only reference
to the key is from the weak reference. This makes the WeakHashMap an excellent
implementation for a weakly referenced list, where entries that aren't used
elsewhere may be dropped with no side effects. Also, just because a key may be
dropped, doesn't mean it will immediately be dropped. If the system has sufficient
resources, the weak key reference that isn't externally referenced could stay around
for a long time.
For additional information on Reachability, you can find it in the java.lang.ref package
summary.
That's almost completely bogus. Here's a better an...

Author: Kevin Riff (http://www.jguru.com/guru/viewbio.jsp?EID=2057), Nov 8, 2000
That's almost completely bogus. Here's a better answer:
WeakHashMap is a special implementation of the Map interface that references its

keys via weak references. This allows the garbage collector to reclaim the key even
though its still referenced by the hashmap. If the garbage collector does reclaim the
key then WeakHashMap automatically cleans out the key and its associated value.
WeakHashMaps work best when the keys are objects which are equal only to
themselves. This is the default implementation in the Object class and is sometimes
called "identity equality". If the keys implement "value equality" (where the equals
method compares the object's contents, not their references) then you can sometimes
observe odd behavior. In particular, if you attempt to lookup a value using a different
but equal key you may find that the WeakHashMap no longer has a mapping for it.
This would happen if the original key was dereferenced and garbage collected prior to
your search.
A good example of WeakHashMap in action is the ThreadLocal class. ThreadLocal

uses a WeakHashMap internally where the keys are Threads. When you call get(), the
ThreadLocal class gets a reference to the current thread and looks up its value in the
WeakHashMap. When the thread dies, it becomes unreachable and the WeakHashMap
automatically removes its mapping. If ThreadLocal used a regular HashMap, then the
Threads stored in it would never become unreachable and they could hang around for
a long, long time. This would essentially be a memory leak.
Re: That's almost completely bogus. Here's a better an...

Author: John Zukowski (http://www.jguru.com/guru/viewbio.jsp?EID=7), Jul 24,
2001
1.3 does not use a WeakHashMap with ThreadLocal, only 1.2 did. And as of 1.4,
ThreadLocal uses an IdentifyHashMap.
Re: Re: That's almost completely bogus. Here's a better an...

Author: Kevin Riff (http://www.jguru.com/guru/viewbio.jsp?EID=2057), Jul 25,
2001
You're right. I checked 1.3 and see that instead of a WeakHashMap where the
threads are the keys, it uses a standard HashMap in each Thread object where
the keys are the ThreadLocal objects (actually they use a hack that approximates
the behaviour of an IdentityHashMap to prevent spoof attacks). It's a much
better design because it eliminates the thread contention on the ThreadLocal's
lock. I haven't looked at the JDK 1.4 source code yet, but I imagine it uses an
IdentityHashMap in order to drop the ugly hack.
In my defense I can only say that I probably only had JDK 1.2.2 to use in my
investigations. I can't be held responsible if Sun changed the implementation.
Besides, I only used ThreadLocal as an example because I can't think of any
other situation where you would want to use a WeakHashMap.
PS - Please forgive the tone of my previous post. I was obviously in a very foul
mood that day. I can't seem to remember what it was that I found so
objectionable in the original answer.
See also...
2001
What is a weak reference and what are they used fo...
Re: See also...

Author: lang qiu (http://www.jguru.com/guru/viewbio.jsp?EID=518165), Apr 15,
2003
Read the article from the OnJava about the WeakHashMap
http://www.onjava.com/lpt/a/989
Re: See also...

2003
Re: See also...

2003
What is the function of a load factor in a Hashtable?

Author: Jef Newsom (http://www.jguru.com/guru/viewbio.jsp?EID=129583)
Question originally posed by Siddhartha Mehta
The load factor determines how full a hashtable may get before it expands its
capacity. I think that the comments on the Hashtable API docs explain it very well:
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 hashtable
exceeds the product of the load factor and the current capacity, the capacity is
increased by calling the rehash method.
Generally, the default load factor (.75) offers a good tradeoff between time and
space costs. Higher values decrease the space overhead but increase the time cost to
look up an entry (which is reflected in most Hashtable operations, including get and
put).
How do you control growth of vectors when their internal arrays are full?
The vector constructor can include either an initial capacity or a capacity and growth
increment. When not specified, the initial size of the vector is 10 and growth will
double when necessary. Otherwise, initialize size and growth will grow when needed
as specified by the arguments to the constructor.
If the argument to the constructor is a collection, the initial size of the internal
structure is 10% larger than the collection. Since there is no second argument to
control growth, the capacity will double when necessary.
How to sort the messages in JavaMail?

originally posed by guan ho (http://www.jguru.com/guru/viewbio.jsp?EID=126860
Within the JavaMail classes there is no support for this. However, once you get the
array of messages back from a folder, you can call the Arrays.sort() method in the
collections framework to sort the messges. Since MimeMessage doesn't implement
Comparable, you'll need to provide your own Comparator specifying how you want
the messages to be sorted.
Could you post some example code on this....?

Author: Kevin Baker (http://www.jguru.com/guru/viewbio.jsp?EID=882634), Oct 9,
2002
Could you post some example code on this....?
Re: Could you post some example code on this....?

Author: John Zukowski (http://www.jguru.com/guru/viewbio.jsp?EID=7), Oct 9,
2002
The Compartor interface requires you to implement the compareTo method, which
accepts two args (the messages to compare for here). Compare the two fields of
the message you want to sort by. If message1 comes first, return -1, if equal, return
0, if message2 comes first, return 1.
When did Strings start caching their hash codes?

Starting with the 1.3 release of Java, the java.lang.String class will only calculate the
hashcode once, when its first needed. Future calls to hashCode() will return the
previously calculated value.
How can you retrieve the Hashtable's load factor?

Created: Jan 14, 2001 Modified: 2001-01-14 09:16:51.742
originally posed by Jen Ngew
There is no public interface to access the load factor setting.
Some choices you can do to expose this value...
• Subclass Hashtable and add a read-only accessor method

• Use reflection to access the private field (only possible in trusted
environment)
• Serialize the Hashtable and get the value from the stream (when reading back
the stream, you'll have to figure out where the appropriate field is)
Why can't I add a collection to itself?

This will cause a stack overflow exception to be generated on calls to methods like
toString() and hashCode(), which recursively call the method on the elements of the
collection.
What is meant by compatible equals() and hashCode() methods?

In order for the Java Collections to work properly (and everything else in Java), the
equals() and hashCode() methods must be compatible. Here, compatible means that
if equals() reports that two instances are the same, then the hashCode() of both
instances must be the same value.
Since Properties extends Hashtable, can I use the Hashtable methods to add
elements to a Properties list?
Technically speaking you can. However, you have to make sure you only add key-
value pairs where both are strings. If you add something other than a String, the
listing, loading, and saving methods won't work as expected.
Like the Stack/Vector subclass relationship, Properties/Hashtable should be a has-a

relationship, not an is-a/subclass relationship.
When I wrap a collection to be read-only or synchronized, why can't I call

any of the collection methods via reflection without getting an
IllegalAccessException?
originally posed by Brandon Wiley
When you wrap a collection through the static methods of the Collections class, this
creates an instance of a package-private (default access) class. Because you don't
have access to these classes, you can't call their methods via reflection (though you
can call their methods directly through the appropriate interface).
What is a weak reference and what are they used for?

Author: Rob Wilson (http://www.jguru.com/guru/viewbio.jsp?EID=313998) Question
originally posed by Ravikumar Gopalankutty
Normally the Java garbage collector plays safe. It will only free up the memory used
by an object when that object can no longer be accessed by the program. Once an
object become impossible to reach it is eligible for collection, and eventually its
memory will be reclaimed.
This eliminates one of the most common programming errors in some other
languages (like C++), where code accidentally tries to access an object that has
been freed. Unfortunately it can lead to another problem, where you leave open a
potential access route to an object that you don't need any more. Memory fills up,
and the program slows down or reports an "Out of Memory" error.
To avoid this, you can be very careful to close off access paths to an object once you
have finished using it. Java 2 introduces another alternative, the weak reference.
Weak references provide access to an object without preventing it from being freed.
When you use a weak reference you have to accept that the object referred to may
have disappeared, which results in the reference being automatically set to null. On
the other hand, the weak reference will not hold the object in memory once it is
inaccessible via normal references (or via "soft" references - see below). Weak
references are not appropriate in all circumstances, but sometimes they can make
code easier to write and understand.
The most common use of weak references is indirect - they are used internally by
the WeakHashMap class. Like HashMap, WeakHashMap associates key objects with
values. However, once the key object becomes inaccessible via stronger references it
becomes eligible for garbage collection. When it is freed, the map entry magically
disappears. The assumption here is that if you are not using the key anywhere other
than in the map you will have no need to look it up, so it should be freed.
Other specialist references are soft references (which inhibit collection until memory
runs short), and phantom references (used for cleanup when objects are freed).
For more detailed (and precise) information, see the java.lang.ref API docs, and also
the article Reference Objects and Garbage Collection at the Sun website.
See also...
2001
What is a WeakHashMap? What is its use and when sh...
What is the minimum number of key-value pairs for which it makes sense to
use a HashMap, as opposed to using a pair of arrays (one for keys, the other
for values) with brute-force key searches?
Many people often need maps for very small numbers (2-5) of key-value
pairs. When does it make sense to forgo the convenience of the HashMap to
avoid the associated overhead?
Author: Ryan Breidenbach (http://www.jguru.com/guru/viewbio.jsp?EID=45212)
Question originally posed by Michael Wax
Well, is there really that much of a performance loss using a HashMap? There is no
synchronization penalty (unless you impose your own). You can tune the sizing by
adjusting the initial size and load factor. Plus, do you really want to be responsible for
"rolling your own" code to handle the dynamic resizing of the key and value arrays,
inserting/removing data from these arrays, optimizing the searching algorithm, etc.
Yuck!
In general, the performance hit associated with using a general purpose Map (such
as the HashMap) is far outweighed by the benefits of using a simple interface backed
by a tested algorithm.
The only reason I could see wanting to use arrays is to guaruntee the type of your
key/values to add type checking and avoid casting. Still, if this is a critical aspect of
your application, you can wrap your HashMap in another object to provide type-
safety, and the casting overhead should be minimal.
Another alternative to creating a custom solution is to explore other collection

classes, such as ObjectSpaces's JGL Libraries. There may be something there that
would suit your needs.
So, to answer your question, I would say that the fewer the key-value pairs you
have, the more reason you have to use a HashMap. Since the fewer the keys, the
faster the search, why not use it for 2-5 key-value pairs. I would think that only
when you get to many pairs (tens of thousands) and there is a performance problem
you should consider an alternative. Basically, exhaust your search of tried-and-true
collections before you try a custom solution. Let other people create these collections
so you can focus on your application.
[Editor note: HashMaps of 10K pairs will function fine, assuming a good hashing
algorithm for hashCode() [with evenly spread out keys]. Keep using it at 10K and
beyond with no problems.]
How does ArrayList increase its capacity?
Unlike Vector where you can specify a capacity increment, ArrayList doesn't support
this. Instead, ArrayList will increase capacity by about a half when it runs out of
space. The refernece implementation uses the forumla:
newCapacity = (oldCapacity * 3)/2 + 1
though, this isn't part of the class definition so others can implement it differently.
How can I implement a priority queue in Java? Has anyone created an open
source version?
Author: michele arpaia (http://www.jguru.com/guru/viewbio.jsp?EID=227978)
As referenced from the Java Collections Clearinghouse, you can find a priority queue
implemented as part of MIT's FLEX compiler imfrastructure. Source code is licensed
under the GNU GPL.
There is also source for one in my Java Collections book.
What is the default initial size for a Hashtable / HashMap?

This depends on what version of Java you are using. For JDK 1.2, the size was 101.
For JDK 1.3, the size changed to 11.
How do you create a multi-dimensional List?

originally posed by Pankaj Sud
Since the elements of a List are objects, in order to make the List multi-dimensional,
each object in the outer list needs to be a List, too. For instance, ...
List list = new ArrayList(10);

for (int i=0; i<10; i++) {
list.set(i, new LinkedList());
}
Then just fill up each inner list with items.
In a TreeMap, can I use a sorting algorithm other than the natural sorting
for the keys?
Created: Apr 5, 2001
originally posed by Shailesh Mangal
You can pass a Comparator to the TreeMap constructor to use a sorting order other
than the natural order.
What are the differences between HashMap and Hashtable?

Created: May 29, 2001
originally posed by elango maragtham
Both provide key-value access to data. The Hashtable is one of the original collection
classes in Java. HashMap is part of the new Collections Framework, added with Java
2, v1.2.
The key difference between the two is that access to the Hashtable is synchronized
on the table while access to the HashMap isn't. You can add it, but it isn't there by
default.
Another difference is that iterator in the HashMap is fail-safe while the enumerator
for the Hashtable isn't. If you change the map while iterating, you'll know.
And, a third difference is that HashMap permits null values in it, while Hashtable
doesn't.
For new code, I would tend to always use HashMap.
What is synchronize in this context? What is fail-safe property?

Author: Bhuricha S. (http://www.jguru.com/guru/viewbio.jsp?EID=1029536), Nov
23, 2002
I am sorry for asking easy question. I wonder when will the synchronized object be
useful? Can you give me some example? And what is the fail-safe in this context. Is
there any reference where I can read more about it? Thanks
Re: What is synchronize in this context? What is fail-safe property?

Author: Dheerendra Pandey
(http://www.jguru.com/guru/viewbio.jsp?EID=1224636), Feb 2, 2005
1)Synchronized means only one thread can modify a hash table at one point of
time.Basically, it means that any thread before performing an update on a
hashtable will have to acquire a lock on the object while others will wait for lock
to be released.
2)Fail-safe is relevant from the context of iterators.If an iterator has been created
on a collection object and some other thread tries to modify the collection object
"structurally",a concurrent modification exception will be thrown.It is possible for
other threads though to invoke "set" method since it doesnt modify the collection
"structurally".However, if prior to calling "set", the collection has been modified
structurally, "IllegalArgumentException" will be thrown.
What is synchronize in this context? What is fail-safe property?

Author: Bhuricha S. (http://www.jguru.com/guru/viewbio.jsp?EID=1029536), Nov
23, 2002
I am sorry for asking easy question. I wonder when will the synchronized object be
useful? Can you give me some example? And what is the fail-safe in this context. Is
there any reference where I can read more about it? Thanks
Null Values
Author: Sujatha Vengaiah (http://www.jguru.com/guru/viewbio.jsp?EID=1054003),
Feb 5, 2003
Hashtable doesnt allow NULL Values...does it mean for both key and value or just the
key....
Re: Null Values

Author: Zia Raees (http://www.jguru.com/guru/viewbio.jsp?EID=1175092), May
31, 2004
It means that the hashtable cannot have null value across a key.
Re: Null Values

Author: keertikar pandey (http://www.jguru.com/guru/viewbio.jsp?EID=1177623),
Jun 10, 2004
Key field should never be null , because only on basis of keys , one can access the
corresponding values.
Re: Null Values

Author: keertikar pandey
(http://www.jguru.com/guru/viewbio.jsp?EID=1177623), Jun 10, 2004
Key field should never be null , because only on basis of keys , one can access the
corresponding values.
Null Values
Author: Sujatha Vengaiah (http://www.jguru.com/guru/viewbio.jsp?EID=1054003),
Feb 5, 2003
Hashtable doesnt allow NULL Values...does it mean for both key and value entry or
just the key entry....
Re: Null Values

Author: Shamit Sen (http://www.jguru.com/guru/viewbio.jsp?EID=1160219), Apr
5, 2004
Hashtable does not permit null values for the keys
Re: Null Values
Author: Shamit Sen (http://www.jguru.com/guru/viewbio.jsp?EID=1160219), Apr
5, 2004
Hashtable does not permit null values for the keys.
Where can I learn (more) about Java's support for developing multi-
threaded programs?
Created: May 30, 2001
Author: John Mitchell (http://www.jguru.com/guru/viewbio.jsp?EID=4)
Check out the jGuru Threads FAQ.
What are the differences between Vector and ArrayList? Which is best to
use?
Created: Jun 3, 2001
Author: Alessandro A. Garbagnati
(http://www.jguru.com/guru/viewbio.jsp?EID=32727) Question originally posed by
elango maragtham (http://www.jguru.com/guru/viewbio.jsp?EID=248437
Vector and ArrayList are very similar. Both of them represent a 'growable array',
where you access to the elements in it through an index.
ArrayList it's part of the Java Collection Framework, and has been added with version
1.2, while Vector it's an object that is present since the first version of the JDK.
Vector, anyway, has been retrofitted to implement the List interface.
The main difference is that Vector it's a synchronized object, while ArrayList it's not.
While the iterator that are returned by both classes are fail-fast (they cleanly thrown
a ConcurrentModificationException when the orignal object has been modified), the
Enumeration returned by Vector are not.
Unless you have strong reason to use a Vector, the suggestion is to use the ArrayList.
OnJava.com article...
Author: John Zukowski (http://www.jguru.com/guru/viewbio.jsp?EID=7), Jun 18,
2001
For additional information, you can read an article comparing the performance at The
Performance of Java's Lists.
Not Satisfied
Author: kapil pruthi (http://www.jguru.com/guru/viewbio.jsp?EID=909671), Jun 11,
2002
totally not satisfied with the answer provided.please elaborate..
Java.util.Collection
Author: Rohit Anand (http://www.jguru.com/guru/viewbio.jsp?EID=1088769), Oct
31, 2003
one more difference can be ArrayList implements Iterator Interface for traversing
While Vector implements Innumerator Interface for traverse.
here is the elaborate answer

Author: san mack (http://www.jguru.com/guru/viewbio.jsp?EID=1124796), Mar 23,
2004
Sometimes Vector is better; sometimes ArrayList is better; sometimes you don't want
to use either. I hope you weren't looking for an easy answer because the answer
depends upon what you are doing. There are four factors to consider: API
Synchronization Data growth Usage patterns Let's explore each in turn.
API In The Java Programming Language (Addison-Wesley, June 2000) Ken Arnold,
James Gosling, and David Holmes describe the Vector as an analog to the ArrayList.
So, from an API perspective, the two classes are very similar. However, there are still
some major differences between the two classes.
Synchronization Vectors are synchronized. Any method that touches the Vector's
contents is thread safe. ArrayList, on the other hand, is unsynchronized, making them,
therefore, not thread safe. With that difference in mind, using synchronization will
incur a performance hit. So if you don't need a thread-safe collection, use the
ArrayList. Why pay the price of synchronization unnecessarily?
Data growth Internally, both the ArrayList and Vector hold onto their contents using
an Array. You need to keep this fact in mind while using either in your programs.
When you insert an element into an ArrayList or a Vector, the object will need to
expand its internal array if it runs out of room. A Vector defaults to doubling the size
of its array, while the ArrayList increases its array size by 50 percent. Depending on
how you use these classes, you could end up taking a large performance hit while
adding new elements. It's always best to set the object's initial capacity to the largest
capacity that your program will need. By carefully setting the capacity, you can avoid
paying the penalty needed to resize the internal array later. If you don't know how
much data you'll have, but you do know the rate at which it grows, Vector does
possess a slight advantage since you can set the increment value. Usage patterns Both
the ArrayList and Vector are good for retrieving elements from a specific position in
the container or for adding and removing elements from the end of the container. All
of these operations can be performed in constant time -- O(1). However, adding and
removing elements from any other position proves more expensive -- linear to be
exact: O(n-i), where n is the number of elements and i is the index of the element
added or removed. These operations are more expensive because you have to shift all
elements at index i and higher over by one element. So what does this all mean? It
means that if you want to index elements or add and remove elements at the end of
the array, use either a Vector or an ArrayList. If you want to do anything else to the
contents, go find yourself another container class. For example, the LinkedList can
add or remove an element at any position in constant time -- O(1). However, indexing
an element is a bit slower -- O(i) where i is the index of the element. Traversing an
ArrayList is also easier since you can simply use an index instead of having to create
an iterator. The LinkedList also creates an internal object for each element inserted.
So you have to be aware of the extra garbage being created. Finally, in "PRAXIS 41"
from Practical Java (Addison-Wesley, Feb. 2000) Peter Haggar suggests that you use
a plain old array in place of either Vector or ArrayList -- especially for performance-
critical code. By using an array you can avoid synchronization, extra method calls,
and suboptimal resizing. You just pay the cost of extra development time.
Another Difference
Author: shreehari gopal (http://www.jguru.com/guru/viewbio.jsp?EID=1163112),
May 18, 2004
There is also an another difference between Vectors and ArrayLists, not very
important but it will be an added advantage. If we insert an element beyond the border
of a vector it will increases the size by double of its orginal size.but an ArrayList will
increases its size by 50% of the orginal list
How should I implement object comparisons in a flexible manner? For

example, I have a Person class and sometimes I will compare based on
name and sometimes I will compare based on age.
Author: Ryan Breidenbach (http://www.jguru.com/guru/viewbio.jsp?EID=45212)
Question originally posed by yangontha Maung
Instead of having the Person class implement the Comparable interface, you could
delegate the comparing to another class. Perhaps you could have a
PersonComparator interface that you could implement for the various types of
comparisons. For example:
public interface Person {
public String getName();
public int getAge();
}
public interface PersonComparator {

public int compare(Person p1, Person p2);
}
public class AgeComparator implements PersonComparator {

public int compare(Person p1, Person p2) {
if (p1.getAge() == p2.getAge()) return 0;
return p1.getAge() > p2.getAge() ? 1 : -1;
}
}
public class NameComparator implements PersonComparator {

public int compare(Person p1, Person p2) {
return p1.getName().compareTo(p2.getName());
}
}
This is a very simple example of the Strategy Pattern. This allows your comparisons
and your object to change independent of one another.
Additional Information
Author: christophe tcheng (http://www.jguru.com/guru/viewbio.jsp?EID=269636), Jul
2, 2001
You should consider implementing the Comparator interface (java.util), and not your
own PersonComparator interface. Indeed, this interface is known used in the JDK,
and therefore you will be able to sort arrays or collections very easily.
Collections.sort( ... );
Arrays.sort( ... );
Christophe.
Just use the standard Comparable interface + get/setSort methods.

Author: Cat Cat (http://www.jguru.com/guru/viewbio.jsp?EID=462569), Jul 26, 2001
You can hide the implementation details inside the class and just change the way the
data is sorted with get/set methods.
public class Person implements Comparable{

private static final int NAMESORT = 0;
private static final int AGESORT = 1;
private int m_nSort = NAMESORT;
public int compareTo(Object obj){

int nComparison = 0;//equal default
//probably use switch here for

//more complex cases
if(m_nSort == NAMESORT){
//code to sort by name
}
else{
//code to sort by age
}
return nComparison;
}
public void setSort(int nSort){

if((nSort > 0)&&(nSort <= AGESORT)){
m_nSort = nSort;
}
}
public int getSort(){

return m_nSort;
}
}
Thanks for the question it helped to clarify a problem I was trying to solve. Cat
Re: Just use the standard Comparable interface + get/setSort methods.

Author: Cat Cat (http://www.jguru.com/guru/viewbio.jsp?EID=462569), Jul 26,
2001
Should obviously be......
..
public static final int NAMESORT = 0;
public static final int AGESORT = 0;
..
Not
...
private static final int NAMESORT = 0;
private static final int AGESORT = 1;
...
Cat
Re: Just use the standard Comparable interface + get/setSort methods.

Author: Gaddy Barchana Lorand
(http://www.jguru.com/guru/viewbio.jsp?EID=230945), Aug 13, 2001
That might cause some problems. What happens when you sort the same objects
concurrently (e.g. sorting two arrays that have the same entries, each with tis
sorting order).
You can get situations where a.compareTo(b) and b.compareTo(a) are inconsistent
(if a and b were called with different sort methods).
Re: Re: Just use the standard Comparable interface + get/setSort

methods.
Author: Cat Cat (http://www.jguru.com/guru/viewbio.jsp?EID=462569), Aug
13, 2001
Good point. My response would be to make certain that you could only
compare apples with apples.
One way to handle this would be to override the compareTo method so that it
used the getSort method to check the sort type and threw an
IllegalArgumentException if they where different.
My personal opinion is that it represents the simplest solution to the problem.

And given the flexablility of the compareTo method I doubt that you would
have a situation in which it definitively couldn't be solved this way.
It is nice to have a general purpose framework like this. It certainly saves you
from having to do your own sorting algorithms 95% of the time. Which for
mere mortals is a real pain.
Cat
Does the equals() method of an array do element-level checking?

Created: Jul 14, 2001
If you have two arrays in memory with the same elements, and ask
first.equals(second), this does not do an element-by-element comparison. Instead, it
behaves just like Object's equals() method, essentially asking if the variables point to
the same place in memory:
int a[] = {1, 2, 3};
int b[] = {1, 2, 3};
// This prints false
System.out.println(a.equals(b));
To check for equality of two arrays, use Arrays.equals().
// This prints true
System.out.println(Arrays.equals(a,b));
How about "==" operator of an array?

Author: Michael Guo (http://www.jguru.com/guru/viewbio.jsp?EID=748914), Feb 6,
2002
According to this, the "==" operator and "equals()" method should work same for
array. Is that right?
Then how about for String?
Re: How about "==" operator of an array?

Author: ashwini iyer (http://www.jguru.com/guru/viewbio.jsp?EID=1170181),
May 12, 2004
for a string == does a reference checking and .equals() matches the exact words
How can I retrieve the items in my HashSet / HashMap in the order they
were added?
Prior to Java 1.4, you had to manage a separate insertion order list yourself. Starting
with Java 1.4, you can use the new LinkedHashMap / LinkedHashSet classes. The
iterators you get back from them return the items in insertion order.
Give me an example
Author: James Liu (http://www.jguru.com/guru/viewbio.jsp?EID=1032513), Dec 1,
2002
Please give me an examole for the answer.
An Example
Author: Shiladitya Sircar
(http://www.jguru.com/guru/viewbio.jsp?EID=1173860), May 26, 2004
LinkedHashMap is essentially similar to the LinkedHashSet, its just that you need
a key/value pair for each element. Example :
String Englishmonths[] = new DateFormatSymbols().getMonths();
String frenchMonths[] = new
DateFormatSymbols(Locale.ITALIAN).getMonths();
Map orderedMap = new LinkedHashMap();
for (int i = 0, n = months.length; i & lt; n; i++)
{
orderedMap.put(months[i], italianMonths[i]);
}
Check to see that iterators for this are aware of the insertion order. So you can
walk through the values of the insertion order.
Collection values = orderedMap.values();
for (Iterator i = values.iterator(); i.hasNext();
{
System.out.println(i.next()));
}
How do you sort an ArrayList (or any list) of user-defined objects?

Author: Luigi Viggiano (http://www.jguru.com/guru/viewbio.jsp?EID=101985)
Question originally posed by Anup Darvatkar
Create an implementation of the java.lang.Comparable interface that knows how to

order your objects and pass it to java.util.Collections.sort(List, Comparator).
See also: Sort algorithm on an ArrayList.
How can you get the hash code for an instance of a class if the class
overrode hashCode()?
Created: Aug 7, 2001
The System class method identityHashCode() allows you to get this information:
int code = System.identityHashCode(anObject);
HashCode
30, 2003
YourClass obj;
System.out.println(obj.hashCode());
has nothing to do with Collections ....

Author: Yilmaz Mete (http://www.jguru.com/guru/viewbio.jsp?EID=1250231), Jun
24, 2005
Object.hashCode() is the method otherwise.
How can I easily shift the elements in a List / Vector such that all the
elements rotate n elements?
The Java 1.4 API adds a rotate() method to the Collections class: rotate(List
list, int distance) that will shift the elements for you.
What's the most optimum way of swapping two elements in a List?

The 1.4 version of Collections has a swap() method to do this for you. However, for
earlier version of Java, you can swap two elements w/o an intermediate variable
with:
list.set(index1, list.set(index2, list.get(index1)));
This works because the set() method returns the original element.
What's the purpose of the IdentityHashMap?
The IdentityHashMap uses == for equality checking instead of equals(). This can be
used for both performance reasons, if you know that two different elements will
never be equals and for preventing spoofing, where an object tries to imitate
another.
How do I convert an old-style Enumeration to something in the Collections

Framework?
Prior to Java 1.4, any conversion had to be manually done. With the introduction of
1.4, you can call Collections.list(enumeration) to automatically convert the
Enumeration to an ArrayList.
How do I retrieve the values of a Hashtable/HashMap in sorted order?

originally posed by Ajay Tejwani
Basically, you can't directly do this. What you can do is get the Collection of
values() back from the map and create a sorted collection, or maintain two maps,
one in each direction, and keep the second map sorted by being a TreeMap. Which
you use depends on the frequency you must sort the elements.
Sorted Hashtable
Author: Sualeh Fatehi (http://www.jguru.com/guru/viewbio.jsp?EID=404605), Jun 4,
2002
Here is something you may be able to use - you will have to do your own debugging,
though ;-)
import java.util.Enumeration;
import java.util.Hashtable;
import java.util.Vector;
/**
* @author Sualeh Fatehi
*/
public class SortedHashtable
{
protected Hashtable hashSortedHashtable = new Hashtable();

protected Vector vectSortedHashtable = new Vector();
public Enumeration keys()
{
return vectSortedHashtable.elements();
public void clear()

{
hashSortedHashtable = new Hashtable();

vectSortedHashtable = new Vector();
public synchronized void put(String key, Entity value)

{
boolean bSorted = false;
for (int i = 0; i < vectSortedHashtable.size(); i++) {

Entity base = (Entity)
hashSortedHashtable.get(vectSortedHashtable.elementAt(i));
if (base.compareTo(value) > 0) {
vectSortedHashtable.insertElementAt(key, i);
bSorted = true;
break;
}
}
if (!bSorted) {
bSorted = true;
vectSortedHashtable.addElement(key);
}
hashSortedHashtable.put(key, value);
protected synchronized void internalPut(String key, Entity value)

{
public Entity get(String key)

{
return (Entity) hashSortedHashtable.get(key);

}
public synchronized void remove(String key)

{
vectSortedHashtable.remove(key);
hashSortedHashtable.remove(key);
} // end SortedHashtable
Re: Sorted Hashtable

Author: manish janjani (http://www.jguru.com/guru/viewbio.jsp?EID=1184790),
Jul 8, 2004
Can u provide me some simpler solution to get the values from a hash map? The
method u hav given is quiet confusing. My need is to read a text file which can be
used as a cinfig file. The file will hav some options as true and false or something
like that. so m looking for a solution which is smaller and as desired. Thnks
Sorted Hashtable
Author: Sualeh Fatehi (http://www.jguru.com/guru/viewbio.jsp?EID=404605), Jun 4,
2002
Here is something you may be able to use - you will have to do your own debugging,
though ;-)
/**
* @author Sualeh Fatehi
*/
public class SortedHashtable
{
protected Hashtable hashSortedHashtable = new Hashtable();

protected Vector vectSortedHashtable = new Vector();
public Enumeration keys()

{
return vectSortedHashtable.elements();
}
public void clear()
{
hashSortedHashtable = new Hashtable();

vectSortedHashtable = new Vector();
public synchronized void put(String key, Entity value)

{
for (int i = 0; i < vectSortedHashtable.size(); i++) {

Entity base = (Entity)
hashSortedHashtable.get(vectSortedHashtable.elementAt(i));
if (base.compareTo(value) > 0) {
vectSortedHashtable.insertElementAt(key, i);
bSorted = true;
break;
}
}
if (!bSorted) {
bSorted = true;
}
protected synchronized void internalPut(String key, Entity value)

{
public Entity get(String key)

{
return (Entity) hashSortedHashtable.get(key);
public synchronized void remove(String key)

{
vectSortedHashtable.remove(key);
hashSortedHashtable.remove(key);
}
} // end SortedHashtable
Re: Sorted Hashtable

Author: Graham Williamson
(http://www.jguru.com/guru/viewbio.jsp?EID=1067855), Mar 19, 2003
If you want to maintain a sorted hashtable - either by key or object (item) then you
should really extend hashtable and re-implement only the methods that you need
to. Call the super methods where you need to. This way it will work with existing
code that expects a hashtable. As follows...
import java.lang.StringBuffer;
public class SortedKeyHashtable extends Hashtable {
private Vector keyVector = new Vector();
public Enumeration keys () {

return keyVector.elements();
}//keys
public void clear () {

super.clear();
keyVector = new Vector();
}//clear
public void put (String key, Vector value) {

for (int i = 0; i < keyVector.size(); i++) {
if ((Integer.parseInt(key)) >
(Integer.parseInt(
(String)keyVector.elementAt(i)))) {
keyVector.insertElementAt(key, i);
bSorted = true;
break;
}//i
}//f
if (!bSorted) {
bSorted = true;
keyVector.addElement(key);
}//i
super.put(key,value);
}//put
public String toString () {

StringBuffer strBuf = new StringBuffer();
String key = "";
for (int i = 0; i < keyVector.size(); i++) {
key = (String)keyVector.elementAt(i);
System.out.println(key);
strBuf.append("\n"+key+": "+super.get(key));
}//f
return strBuf.toString();
}//toString
}//SortedKeyHashtable
How do i retrieve the data from a hashmap

Author: manish janjani (http://www.jguru.com/guru/viewbio.jsp?EID=1184790), Jul
8, 2004
The method that is shown is quiet confusing... can u suggest some simple method to
get the values ? thnks
How can I add a Collection to another Collection?

Created: Sep 29, 2001
Author: Alessandro A. Garbagnati
(http://www.jguru.com/guru/viewbio.jsp?EID=32727) Question originally posed by
Chris Adams (http://www.jguru.com/guru/viewbio.jsp?EID=414696
The java.util.Collection interface includes an addAll(Collection c) method to add

one collection to another.
Union of many vectors with unicite garantee

Author: Ben ismail Atef (http://www.jguru.com/guru/viewbio.jsp?EID=1122692), Oct
20, 2003
In case of Vector the method addAll garantees the unicity of the added elements in the
Vector. If not can you help me with an efficient source code? Thanks.
Where can I find performance comparisons between the different collection
implementations?
An interresting benchmark about Java collections has been done by Bruce Eckel's in
his (online) book Thinking in Java. You'll find them in Chapter 9.
Performance benchmaks
Author: Naren Varma (http://www.jguru.com/guru/viewbio.jsp?EID=750962), Feb 7,
2002
You can also find performance benchmarks in the website www.precisejava.com
2002
2002
How can I use two iterators to go through a collection?

Author: Nils Kulk (http://www.jguru.com/guru/viewbio.jsp?EID=337581) Question
originally posed by Dohyeon KIM
Just get a separate iterator for each loop:

Collection l = ...;
for(Iterator i = l.iterator(); ...) {
for(Iterator j = l.iterator();...) {
}
}
When will Java have support for type-safe collections?

originally posed by John Zukowski PREMIUM
It looks like JSR 14 will make it into the 1.5 releae of Java some time around 2003.
How do I traverse a map backwards?

Created: Oct 11, 2001
originally posed by Dmitry Savvateev
Just keep getting the last key and the head map before it:
if (!map.isEmpty()) {
Object last = map.lastKey();
do {
if (!first) {
}
System.out.print(last);
last=map.headMap(last).lastKey();
first=false;
} while (last != map.firstKey());
System.out.println();
}
(Taken from my Java Collections book.)
How do I traverse a sorted set backwards?

Just keep getting the last element and the head set before it:
if (!set.isEmpty()) {
Object last = set.last();
do {
if (!first) {
}
System.out.print(last);
last=set.headSet(last).last();
first=false;
} while (last != set.first());
}
Alternative?
Author: Troy Molander (http://www.jguru.com/guru/viewbio.jsp?EID=508870), Oct
12, 2001
John,
Can you comment on the pro's and con's to this approach vs. the approach you
presented:
List list = new LinkedList(set);
Collections.reverse(list);
for (Iterator it = list.iterator(); it.hasNext();){
System.out.println(it.next());
}
Thanks.
repeating ".headset()"
Author: zira mona (http://www.jguru.com/guru/viewbio.jsp?EID=525506), Oct 19,
2001
If the implementation of the container is buggy, it can cause each head set have a
pointer to its parent set, and this can lead to an almost infinite chain of references.
beware.
How can I go through an Iterator mulitple times?

originally posed by Eric Tetz (http://www.jguru.com/guru/viewbio.jsp?EID=409815
There is no direct support for this. You'll need to create your own caching
mechanism. For instance, as you go through the Iterator the first time, add the
elements to a LinkedList. Then, you can just get an Iterator from the LinkedList for
the second pass through.
What's new to the Collections Framework in Java 1.4?

There are three new implementations:
• LinkedHashSet
• LinkedHashMap
• IdentityHashMap
One marker interface:
• RandomAccess
And six new utility methods for the Collections class:
• rotate(List list, int distance)

• replaceAll(List list, Object oldVal, Object newVal)
• indexOfSubList(List source, List target)
• lastIndexOfSubList(List source, List target)
• swap(List list, int i, int j)
• list(Enumeration e)
How can I add an array of objects to a collection?

First you need to convert the array to a Collection. This can be done with
Arrays.asList(objectArray). Once you have the array as a List, you can add it to
another Collection with theCollection.addAll(theList).
Is Vector's clone method thread-safe?

Author: Bozidar Dangubic (http://www.jguru.com/guru/viewbio.jsp?EID=433955)
Question originally posed by Huan Li
Sure it is, since it is a Vector which is thread-safe.

One way to test this

Author: Alex Chaffee (http://www.jguru.com/guru/viewbio.jsp?EID=3), Nov 4, 2001
One way to check this is to run
javap java.util.Vector
which will say, among other things, the line
public synchronized java.lang.Object clone();
which more-or-less proves that the method is thread-safe.
(It doesn't -really- prove that it's thread-safe, since merely using synchronized
doesn't guarantee thread safety -- the method could call a non-thread-safe shared
object, for instance -- but it's a good indication.)
Where can I find an example of the Java 1.4 LinkedHashSet and

LinkedHashMap classes?
There is an article at IBM's developerworks: Magic with Merlin: Maintaining insertion

order that demonstrates their usage.
How do I load property settings with the Properties class?

Question originally posed by tyris d
java.util.Properties objects can load values from a file using the method
load(InputStream).
Here is the code you need:
Properties props = new Properties();

props.load(new FileInputStream("propertyfile.properties"));
String value = props.getProperty("propertyname");
//Just a trick: in a web archive (war) you can get the InputStream
inside the war archive using
ClassLoader cl = this.getClass().getClassLoader();
InputStream is =
cl.getResourceAsStream("it/package/application.properties");
This is better than using a FileInputStream, because you are loading the file within
the archive as it was a resource. You should use this.getClass().getClassLoader() to
use the same ClassLoader as the one used the servlet container to load your
JSP/Servlet. This code is snipped from a JSP page inside Tomcat.
How do I save properties settings with the Properties class?

Author: Kenneth Tennek (http://www.jguru.com/guru/viewbio.jsp?EID=414359)
Question originally posed by tyris d
Try this:
Properties prop = new Properties();
FileOutputStream output = new FileOutputStream("Test.properties");
prop.store(output,"my testproperties");
output.flush();
output.close();
You'll need to catch an IOException.
What happens if two threads perform a get of one hashmap at the same
time?
Created: Jan 21, 2003
Author: Muruganantham Mani
(http://www.jguru.com/guru/viewbio.jsp?EID=1041080) Question originally posed
by Enrique Monton (http://www.jguru.com/guru/viewbio.jsp?EID=755656
[I know a HashMap object is not synchronized if not done explicitly, so in a case

where you have to write and read data in a hashmap from different threads you need
to synchronize it (or use another object).
However in my case I am writing to the HashMap (put) only once and it is done at
the beginnig. Once the HashMap is filled I am going to read it from different threads
at the same time. Do I need to synchronize these reads?]
Synchronization needs to be done only when there is a chance of changing the data
from different threads simultaneously. In your case, it is simply going to be a read,
the synchronization is not required. If you need to remove or modify the values in
the hashmap, then you [may] need to synchronize that.
For synchronizing a HashMap, you can use Collections.synchronizedMap(<your

hashmap reference>) which will return a synchronized map for you, which is
thread-safe.
Remember, synchronization will cause a performance problem. So, it needs to be

used carefully, when really required.
very good one

Author: sudhakar sadasivuni
(http://www.jguru.com/guru/viewbio.jsp?EID=1101359), Jul 14, 2003
This is a famous question for many of job interviews..godd one.
JDK javadoc is not lucid about it.

Author: Kirill Fakhroutdinov (http://www.jguru.com/guru/viewbio.jsp?EID=501201),
Aug 4, 2003
Actually, JDK javadoc is not lucid about it. They said that "implementation is not
synchronized" but gave as an example only structural modification.
But let's say, we have several threads trying to get objects from the same HashMap
using different keys:
... hm.get("21");
... hm.get("10");
... hm.get("44");
at the same time.
If we are sure that get method is implemented as "atomic" operation that approach is
probably OK. But let's say, that get method is implemented to first save the key we
provided as a private field of HashMap internal state and then makes the search. In
this case results could be unpredictable - while looking for the object with the key
"21" we might get back the object corresponding to the key "44".
So to be sure that the get method returns proper value corresponding to the key we
have to be sure that it is NOT modifying internal state of the shared HashMap object
while searching. We can only hope for that as JDK API says nothing about it, just
"implementation is not synchronized".
Re: JDK javadoc is not lucid about it.

Author: Alexandru Leconiuc
(http://www.jguru.com/guru/viewbio.jsp?EID=1118185), Sep 26, 2003
jdk 1.4.1 javadoc for HashMap is quite clear about synchronization issues:
If multiple threads access this map concurrently, and at least one of the threads
modifies the map structurally, it must be synchronized externally. (A structural
modification is any operation that adds or deletes one or more mappings; merely
changing the value associated with a key that an instance already contains is not a
structural modification.)
Re[2]: JDK javadoc is not lucid about it.

Author: Kirill Fakhroutdinov
(http://www.jguru.com/guru/viewbio.jsp?EID=501201), Sep 26, 2003
When they say "implementation is not synchronized" it usually means that all
methods executed on the instance of the object potentially could be not thread-
safe - whether those are getters or setters (with or without internal structural
modifications). For example, even access to a long or double variable is not
thread-safe in Java because it could be treated nonatomic way:
http://java.sun.com/docs/books/jls/second_edition/html/memory.doc.html#28733
The examples/explanations that JDK is giving further could be expressed merely

as:
- structural modifications of HashMap are not thread-safe;
- other methods including getters and setters are thread-safe but only if there are
no concurrent structural modifications.
Still it is not lucid - at list for me - whether those explanations provided by JDK
should be considered as examples of "implementation is not synchronized" or
clarifications on how exactly "implementation is not synchronized".
How can I convert a Collection to an Array then back to a Collection?

Author: Brandon Rohlfs (http://www.jguru.com/guru/viewbio.jsp?EID=1245666)
The Collection interface provides a mechanism to turn a Collection into an Array

using the methods <T> T[] toArray(T[] a) or Object[] toArray(). The first method will
return a Array containing all the elements of the Collection with the array being that
of the type provided in the method call. The second method just returns an array
being of an Object[] type.
The Arrays class provides the opposite. A way to turn an array into a List using the
List<T> asList(Array[] a) method. The List returned is of a fixed length with any
attempts to add an element throwing an UnsupportedOperationException.
import java.util.*;
public class G{
public static void main(String[] args){
List<String> sun = new ArrayList<String>();
sun.add("Feel");
sun.add("the");
sun.add("power");
sun.add("of");
sun.add("the");
sun.add("Sun");
String[] s1 = sun.toArray(new String[0]); //Collection to array
for(int i = 0; i < s1.length; ++i){
String contents = s1[i];
System.out.print(contents);
}
List<String> sun2 = Arrays.asList(s1); //Array back to Collection
for(String s2: sun2){
String s3 = s2; System.out.print(s3);
}
//sun2.add(new String("Hello")); // throws
UnsupportedOperationException
}
}
How can I create a Collection based on another Collection?

Every concrete implementation provides a constructor, which takes a Collection as an

argument. Care must be taken when creating a Collection based another Collection,
this is because depending on the target concrete implementation being created,
specific rules regarding duplicates may be be enforced. Such as creating a Set based
on a List.
The following is a short list of the constructors provided by some of the concrete
Classes of the JCF (Java Collections Framework), which enable the creation of a
Collection based an another implementation.
ArrayList(Collection<? extends E> c)

LinkedList(Collection<? extends E> c)
Vector(Collection<? extends E> c)
TreeSet(Collection<? extends E> c)
Creating a Collection based on another Collection is quite easy. The hard part is
knowing which Collection to use based on performance and other issues.
For example the ArrayList created will contain the same elements in the same order
as the first ArrayList created.
List<String> slist = new ArrayList<String>();

slist.add("g");
slist.add("a");
slist.add("d");
slist.add("a");
slist.add("f");
slist.add("e");
slist.add("c");
slist.add("b");
for(String s : slist){
System.out.print(s + "\t");
}
List<String> s2list = new ArrayList<String>(slist);
for(String s : s2list){
}
When creating a Set based on an existing List the Set will be void of duplicates.
slist.add("g");
slist.add("a");
slist.add("d");
slist.add("a");
slist.add("f");
slist.add("e");
slist.add("c");
slist.add("b");
for(String s : slist){
}
Set<String> s2set = new TreeSet<String>(slist);
for(String s : s2set){
}
How can I define my own Comparable type so that it can be naturally sorted
within a List?
Created: Jun 29, 2005
When taking a peek at the Java docs you will notice certain classes implement an
interface named Comparable. Take a look at some of the subclasses of Number such
as Byte, Integer, Long, Float or some of the classes like String and Date. What the
Comparable interface provides is a way for a class to be sorted by it's natural
ordering. So what do we mean by natural ordering? Depending on the type wishing
to be sorted the natural ordering can be different things. If we are sorting Strings the
ordering is lexicographic or alphabetic if we are sorting Dates the ordering is
chronological if we are sorting Integers the ordering is numerical.
Comparable only contains one method that needs to be implemented by the class
wishing to be sorted naturally. Remember if you try and sort a list that contains
elements that do not implement the Comparable interface then Collections.sort() will
throw an exception specifically a ClassCastException.
public interface Comparable<T>{

public int compareTo(T o);
}
The following is a short example on how to implement the Comparable interface and
use the compareTo(T o) method.
import java.util.*;
public final class Alpha implements Comparable<Alpha>{

List<Alpha> alpha = new ArrayList<Alpha>();
alpha.add(new Alpha("z"));
alpha.add(new Alpha("g"));
alpha.add(new Alpha("k"));
alpha.add(new Alpha("q"));
alpha.add(new Alpha("a"));
alpha.add(new Alpha("b"));
alpha.add(new Alpha("o"));
alpha.add(new Alpha("v"));
alpha.add(new Alpha("c"));
Collections.sort(alpha);
System.out.println(alpha);
}
private String letter;
public Alpha(String letter){
if(letter == null){throw new NullPointerException();}
this.letter = letter;
}
public String toString(){return letter;}
public boolean equals(Alpha a){
if(!(a instanceof Alpha))
return false;
return letter.equals(a.letter);
}
public int compareTo(Alpha a){
int i = letter.compareTo(a.letter);
return i;
}
}
More complex examples might included sorting on multiple fields. Most things that
you would have to sort probably have more then one part like a name for instance
(First:Middle:Last) or maybe you have to sort in (Brand:Model) order.
import java.util.*;
public final class Car implements Comparable<Car>{

Car[] cararry = {new Car("Toyota","Celica"), new Car("Honda","Civic"),
new Car("Ford","Mustang"), new Car("Lexus","ES"), new
Car("Acura","Integra"),
new Car("Honda","Accord"), new Car("Acura","RL"), new
Car("Toyota","Avalon")
};
List<Car> car = Arrays.asList(cararry);
Collections.sort(car);
System.out.println(car);
}
private String brand;
private String model;
public Car(String brand, String model){
if(brand == null || model == null){throw new NullPointerException();}
this.brand = brand;
this.model = model;
}
public String toString(){return brand + " " + model;}
public boolean equals(Car car){
if(!(car instanceof Car))
return false;
boolean samebrand = brand.equals(car.brand);
return samebrand != true ? samebrand: model.equals(car.model);
}
public int compareTo(Car car){
int i = brand.compareTo(car.brand);
return(i != 0 ? i : model.compareTo(car.model));
}
}
What are Generics and how can I use them?

One of the biggest additions since the creation of the Collections framework is
Generics.This long awaited update to the type system is a welcomed feature, which
C++ developers have had in their toolbox for years using the STL. A generic type is
defined using one or more type variables with it's contained methods using that type
variable as a place holder to mark a parameter or return type. For instance the
interface List has now been defined as.
public interface List<E>{

public add(E e);
Iterator<E> iterator();
}
public interface Iterator<E>{

E next();
boolean hasNext();
}
Type Safe Collections
So you might ask. What are Generics and why should I use them? Generics are a
way to restrict a data structure to hold only a specific type thus providing compile
time type checking. One of the added bonuses is that it is no longer necessary to
cast a returned Object to a specific type because the compiler is aware of what type
is being held by the Collection and what type is to be returned.
Set s = new SortedSet();

s.add(new String("Java"));
String j = (String) s.get(0); // cast required;
// java 5
Set<String> s = new SortedSet<String>();
s.addElement(new String("String Type"));
String s = s.get(0); // no cast required!
Having a type safe system not only obviates the need to cast to a specific type but
shields the programmer against miss-casting or casting to an unrelated type at
runtime.
String s = "Java, write once run anywhere";

List l = new ArrayList();
l.add(new String("Java"));
Integer i = (Integer)l.get(0); // Runtime exception!
ClassCastException!
// Using Generics the compiler catches

String s = "Java. Write once run anywhere!";
List<String> l = new ArrayList<String>();
Integer i = l.get(0);
Generics and Subtyping
Generics do not share some of the things that are commonly held true in the Java
language and one of them is subtyping. One would assume the following perfectly
legal since it is true that Object is a supertype of String. But the following is in fact
illegal and will cause a compile time error.
List<Object> l = new ArrayList<String>();
As a rule. If X is a superclass or superinterface of Y and E is a generic type

declaration then it not the case that E<X> is a supertype of E<Y>. So if E<Object>
is not a super type of E<String> then what is the super type of E<String>? Read on
and find out!
Wild Cards
Wild Cards represent what is called "the unknown type". Essentially they can be
thought of as the supertype of any Collection. Wildcards allow some flexibility in
certain situations where it is needed that a type be abstracted out. For instance what
if we define the following method, printSet(Collection<Object> x). We just saw in the
previous example that E<Object> is not the super type of E<String> or any other
type for that matter. In this case we can change the printSet's parameter to
Collection<?>. This allows us to pass in E<X> where X is any type.
public void printElements(Collection<?> c){

for(Object o: c){
System.out.println(o);
}
}
When working with wildcards it is always legal to read and assign the contents to an
Object type
List<String> l = new ArrayList<String>();

Object o = getElement(l, 0); // legal
public Object getElement(List<?> l, int index){
Object o = null;
try{
o = l.get(0);
}catch(IndexOutOfBoundsException e){
//.......
}
return o;
}
assigning values is another matter. The add() method takes an argument of type E
which is the type that the Collection is to hold. Any type wishing to be added to the
Collection would have to be of the same type. Since<?> represents an unknown type
it is impossible to determine what the type parameter of the collection represents.
Bounded Wildcards
A Bounded Wildcard allows as type to be constrained. Bounded Wildcards are useful

when there is some type of partial knowledge about the type arguments. While it is
still illegal to try and add an element to a unknown Collection with a bounded type
they come in handy in other situations. One use is to be able to pass not only types
into a method but sub-types also. In doing this we are able to implement
polymorphic behavior.
import java.util.*;
class Printer{
public void print(String s){
for(int i = 0; i < s.length(); i++){
System.out.print(s.charAt(i));
}
}
}
class ReversePrinter extends Printer{
public void print(String s){
for(int i = s.length() - 1 ; i >= 0; i--){
System.out.print(s.charAt(i));
}
}
}
public class G{
String s = "Nothing like a good cup of Java in the morning!";
List<Printer> l = new ArrayList<Printer>();
l.add(new Printer());
printElements(l,s);
List<ReversePrinter> rl = new ArrayList<ReversePrinter>();
rl.add(new ReversePrinter());
printElements(rl,s);
}
public static void printElements(List<? extends Printer> l, String s){
Printer printer = l.get(0);
printer.print(s);
}
}
How can I shuffle the elements of a Collection?

The Collections class which can be found within the java.util namespace provides two
methods which suffle the elements of a Collection.
static void shuffle(List<?> list)

static void shuffle(List<?> list, Random rnd)
The first method shuffles the elements according to a default source of randomness,
with the second using a specified source of randomness.
import java.util.*;
public class ShuffleTest{

List<String> sl = new ArrayList<String>();
sl.add("One");
sl.add("Two");
sl.add("Three");
sl.add("Four");
sl.add("Five");
sl.add("Six");
for(String s: sl){
System.out.println(s);
}
Collections.shuffle(sl);
for(String s: sl){
System.out.println(s);
}
}
}
How can i tell if two Collections contain the same elements or have no
elements in common?
Two methods are needed in this case.
boolean containsAll(Collection<?> c)
boolean disjoint(Collection<?>c1 Collection<?>c2)
Since containsAll(Collection<?> c) is defined within the Collection interface all
concrete implementations will be able to use this method. disjoint(Collection<?>c1
Collection<?>c2) is defined within the Collections class.
Using both of these methods is pretty straightforward. containsAll(Collection<?> c) is

an instance method so naturally it must be invoked on an object.
disjoint(Collection<?>c1 Collection<?>c2) is defined as Static within the Collections
class so all that is needed is to invoke it using the class name ie
Collections.disjoint(Collection<?>c1 Collection<?>c2)
How can I traverse a List backwards?

In order to traverse a List backwards a ListIterator must be used. The List interface
provides a method, which returns a ListIterator.
ListIterator<E> listIterator()
Using a returned ListIterator, concrete implementations of List can be traverse

backwards using the following methods.
boolean hasPrevious()
E previous()
Since ListIterator extends the Iterator interface forward direction is still possible via
Iterators methods.
boolean hasNext()
E next()
import java.util.List;
import java.util.ArrayList;
import java.util.ListIterator;
public class {
slist.add("1");
slist.add("2");
slist.add("3");
slist.add("4");
ListIterator i = slist.listIterator();
while(i.hasNext()){
System.out.print(i.next());
}
while(i.hasPrevious()){
System.out.print(i.previous());
}
}
}
Starting at the end

Author: Brad Rust (http://www.jguru.com/guru/viewbio.jsp?EID=1259080), Aug 22,
2005
You can start at the end of the list with a ListIterator li = list.listIterator(list.size())
There are lots of examples on the next which iterate down the list and then back up.
You may not want that functionality.
How can I get a sorted list of keys that are contained within a Map?
The Map interface defines a method named keySet() which concrete classes such as
HashMap and TreeMap implement. Depending on the implementation on which
keySet() is invoked the returned Set might not contain it's elements (keys) in sorted
order. For instance the HashMap class makes no guarantees as to the order of the
elements contained within. Whereas the TreeMap class does guarantee element
ordering since it implements the SortedMap interface.
/* TreeMap used. Keys stored in ascending order */
Map<String,String> book = new TreeMap<String,String>();

book.put(new String("Java"),new String("A trademark used for a
programming language designed to develop applications, especially ones
for the Internet, that can operate on different platforms."));
book.put(new String("C#"),new String("An object-oriented language
devised and promoted by Microsoft, intended to replace Java, which it
strongly resembles."));
book.put(new String("Python"),new String("A simple, high-level
interpreted language by Guido van Rossum"));
book.put(new String("LISP"),new String("A programming language designed
to process data consisting of lists. It is widely used in artificial
intelligence research."));
Set words = book.keySet();

for(Iterator i = words.iterator();i.hasNext();){
System.out.print(i.next() + "\t");
}
getting sorted list of keys from a map

Author: sandeep sharma (http://www.jguru.com/guru/viewbio.jsp?EID=1261951),
Sep 12, 2005
Create a TreeMap from the given map.
Map maptree = new TreeMap(map);
Iterator it = maptree.keySet().iterator();
while(it.hasNext()){
String st = it.next().toString();
System.out.println(st);
}
If ur keys r not primitive type then u need to implement comparable
interface or use comparator and overrride compareto() method which is
used while sorting.
How can I create a read only Collection?

Unmodifiable Collections can be easily created using various static methods which
the Collections class provides. Any attempts to modify the returned Collection,
whether direct or via its iterator, result in an UnsupportedOperationException.
Collection<T> unmodifiableCollection(Collection<? extends T> c)

List<T> unmodifiableList(List<? extends T> list)
Set<T> unmodifiableSet(Set<? extends T> s)
SortedSet<T> unmodifiableSortedSet(SortedSet<T> s)
import java.util.*;
public class Unmod{

List<String> strlist = new ArrayList<String>();
strlist.add("C");
strlist.add("B");
strlist.add("A");
Collection<String> unmodstrlist = Unmod.makeUnmodifiable(strlist);
// unmodstrlist.add("G"); throws UnsupportedOperationException
Set<String> strset = new TreeSet<String>();

strset.add("C");
strset.add("B");
strset.add("A");
Collection<String> unmodstrset = Unmod.makeUnmodifiable(strset);
// unmodstrset.add("G"); throws UnsupportedOperationException
}
public static Collection<String> makeUnmodifiable(Collection<String>

c){
return(Collections.unmodifiableCollection(c));
}
}
Is there a way determine how many times an Object occurs within a

Collection?
The Collections class provides a method which returns the number of times an Object
appears within a given Collection.
public static int frequency(Collection<?> c, Object o)

If a null Collection is passed in then a NullPointerException is thrown.
import java.util.*;
public class Freq {

List<Integer> password = new ArrayList<Integer>();
password.add(new Integer(4));
Integer passwordelement = new Integer(4);
System.out.println(passwordelement + " appears "
+ getFrequency(password,passwordelement) + " times within
password");
}
private static int getFrequency(Collection c, Object o){
return(Collections.frequency(c,o));
}
}
What is the easiest way to obtain a Map Entry?

The easiest way to obtain a Map Entry or (key-value pair) is by invoking the following
method provided by the Map interface.
Set<Map.Entry<K,V>> entrySet();
The entrySet() method returns a Set which is populated with Map.Entry objects. The
only way to obtain a reference to a Map.Entry is by using an Iterator on the returned
Set view. Once a reference to a Map.Entry is obtained the follow methods can be
invoked which return the key and value corresponding to the entry.
K getKey()
V getValue()
import java.util.Map;
import java.util.Set;
import java.util.TreeMap;
import java.util.Iterator;
public class Emps{

Map<String,String> empmap = new TreeMap<String,String>();
empmap.put("956544","Bob Jones");
empmap.put("132485","Phil Harris");
empmap.put("102161","Kamal Uganda");
empmap.put("226545","Bill Russel");
empmap.put("116423","Dorris Smith");
Set s = empmap.entrySet();
for(Iterator i = s.iterator();i.hasNext();){
Map.Entry me = (Map.Entry)i.next();
System.out.println(me.getKey() + " : " + me.getValue());
}
}
}
Fully generified version

Author: Hans-Peter Schmid (http://www.jguru.com/guru/viewbio.jsp?EID=1070432),
Sep 11, 2005
Here is the fully "generified" version of the code (the only changes are in the loop at
the end). Note that you could use an explicit iterator, but unless you want to call
remove on the iterator, the new for loop syntax seems preferable for its brevity.
import java.util.Map;
import java.util.TreeMap;
import java.util.Iterator;
public class Emps{

Map<String,String> empmap = new TreeMap<String,String>();
empmap.put("956544","Bob Jones");
empmap.put("132485","Phil Harris");
empmap.put("102161","Kamal Uganda");
empmap.put("226545","Bill Russel");
empmap.put("116423","Dorris Smith");
for (Map.Entry<String,String> entry: empmap.entrySet()){

System.out.println(
entry.getKey() + " : " + entry.getValue());
}
}
}
Re: Fully generified version

Author: Brandon Rohlfs (http://www.jguru.com/guru/viewbio.jsp?EID=1245666),
Sep 12, 2005
Pretty cool Peter! Thanks for the update.
How can I find the maximum element contained within a Collection?

Finding the maximum element within a Collection is easy. The following method can
be used which can be found within the Collections class.
public static <T extends Object & Comparable<? super T>> T

max(Collection<? extends T> coll)
This method returns the maximum element of the given Collection according to the
natural ordering of it's elements. This means that all elements must implement the
Comparable interface. With the following code below the implementation of the
Comparable interface is already taken care of since the class Byte already
implements this interface.
import java.util.Collection;
import java.util.Collections;
public class Max{
Collection<Byte> numl = new ArrayList<Byte>();
numl.add(new Byte("2"));
System.out.print("Max element is " + getMax(numl));
}
public static Byte getMax(Collection<Byte> c){
return Collections.max(c);
}
}
If the element type being store within the Collection is user defined, implementation
of the Comparable interface must be provided.
import java.util.Collection;
import java.util.Collections;
public class Max{

Collection<Num> numl = new ArrayList<Num>();
numl.add(new Num("2"));
System.out.print("Max element is " + getMax(numl).getNum());
}
public static Num getMax(Collection<Num> c){
return Collections.max(c);
}
}
class Num implements Comparable<Num>{
private String i;
public Num(String i){
this.i = i;
}
public int compareTo(Num num){
int x = i.compareTo(num.i);
return x;
}
public String getNum(){
return i;
}
}

Collections FAQ From Jguru

Hochgeladen von

Dokumentinformationen

Originalbeschreibung:

Originaltitel

Copyright

Verfügbare Formate

Dieses Dokument teilen

Dokument teilen oder einbetten

Freigabeoptionen

Stufen Sie dieses Dokument als nützlich ein?

Sind diese Inhalte unangemessen?

Copyright:

Verfügbare Formate

Collections FAQ From Jguru

Hochgeladen von

Copyright:

Verfügbare Formate

Collections FAQ From jGuru

Generated Sep 13, 2005 12:49:37 PM

Why is the Dictionary class not an interface?

What other frameworks are there for general data structures?

Trove4j, pcj, tclib...

Where can I learn how to use the Collections Framework?

What do I have to know about the Collections Framework to be a Certified

How do I use an Iterator to go through a Collection?

Collection collection = ...;

How do I use a ListIterator to go through a List backwards?

List list = ...;

How do I count the frequency of some word/object?

public class MapExample {

How do I properly alphabetize (sort) a list of strings in a language-sensitive

The following example demonstrates this capability:

public class CollatorTest {

Set set = new TreeSet();

can i pass a collection to a collator class

can i pass a collection to a collator class

can i pass a collection to a collator class

Sorting List Running Example

Sorting List Running Example

private Vector list = new Vector();

public void sort() {

public void print() {

public static void main(String [] args) {

Sort s = new Sort();

Sorting List Running Example

private Vector list = new Vector();

public void sort() {

public void print() {

public static void main(String [] args) {

Sort s = new Sort();

How do I do a case-insensitive string sort in a language-insensitive

How do I sort objects into their reverse natural ordering?

The Collections.reverseOrder() method returns a Comparator that sorts objects that

How do I use Enumeration to iterate through a collection?

Enumeration enum = ...;

What newsgroups/mailing lists are available to ask questions about the

The comp.lang.java.programmer newsgroup is probably your best bet for Collections

The TreeMap documentation states that it is a red-black tree based

How do I make an array larger?

Integer in = new Integer(5);

How do I create linked lists if there are no pointers?

How do I use an array with the Collections Framework?

The Arrays.asList() method provides a fixed-length List view of an array, where

Because a synchronized HashMap requires an extra method call, a Hashtable is faster

Where can I get the Collections Framework?

Sun provides a Design FAQ at

• Retains the original retrieval order

Why doesn't the Iterator interface extend the Enumeration interface?

How do I print a Collection?

The Collection Framework implementation classes override the toString() method to

How do I print a Collection?

public static void print(Collection c) {

How do I print a Collection?

public static void print(Collection c) {

How do I synchronize a collection?

List list = ...;

Re: How do I synchronize a collection?

Failure to follow this advice may result in non-deterministic behavior

How do I do a case-sensitive sort in a language-insensitive manner?