the map interface does not declare a toArray method (which would make
little sense, since it stores pairs of values). You probably mean

elements.values().toArray()

If you are only looping through it once, then converting to an ArrayList
or array isn't going to help.

You mean that the value is of type Element. How about the key?

I can't quite see what you are trying to do. But here's some options.

Loop through each key:

for (
    Iterator/*<Key>*/ iter = map.keySet();
    iter.hasNext();
) {
    Key key = (Key)iter.next();
    // ... do stuff with key ...
}

Loop through each value:

for (
    Iterator/*<Value>*/ iter = map.values();
    iter.hasNext();
) {
    Value value = (Value)iter.next();
    // ... do stuff with value ...
}

Loop through each (key, value) pair:

for (
    Iterator/*<Map.Entry<Key,Value>>*/ iter = map.entrySet();
    iter.hasNext();
) {
    Map.Entry<Key,Value> entry = (Map.Entry)iter.next();
    Key key = (Key)entry.getKey();
    Value value = (Value)entry.getValue();
    // ... do stuff with key and value ...
}

Loop through each value lots of times:

Collection valuesCollection = map.values();
int num = valuesCollection.size();
Value[] values = new Value[num];
valuesCollection.toArray(values);

for (...) {
    for (int ct=0; ct<num; ++ct) {
        Value value = values[ct];
        // ... do stuff with value ...
    }
}

I've put the generics in comments. I highly recommend using JDK 5.0.
Generics makes things much clearer. Whether you like them or not you'd
better get used to them.

Tom Hawtin

   1) toArray() returns an array, not an ArrayList.
   2) Why not just get an iterator from the HashMap?

   - Oliver

A  compile error?  An exception? an unexpected result?

This is like  an assembly line medical clinic.  You need to be more
specific than saying "I don't feel well".  Where does it hurt, when?

Is this your own class?  Are you using it as key or data for your
HashMap?

a HashMap Iterator is going to be pretty quick.  All it does it loop
through the internal HashMap array chasing the chains and avoiding the
empty slots. It is not doing a keyed lookup of each element, computing
HashCodes or the like.

If you don't need the lookup, create an ArrayList in the first place.

If you need to iterate repeatedly, with no changes to the data, export
an array.

If you only iterate a few times it won't pay for the overhead where
"few" is determined by experiment.

If you make changes to the HashMap after you export, you now have the
problem your array/ArrayList is out of date.  You would either have to
change it too or regenerate it.

Element[] elts = hashMap.values().toArray( new Element[ hashMap.size()
] );