Java Industry News

Digg This!

A lot of the time I find myself writing code to iterate over a Map goes something like this

 Map map = getMap(); 
// I'd like to read the keys and values of the maps
Iterator keys = map.keySet().iterator(); 
while(keys.hasNext()){
  Object key = keys.next();  
  Object value = map.get(key); 
} 

This is basically because I've used the map to store things in a keyed fashion and want to iterate over the keys and the value for each. Problem is, each time I do it I find myself thinking how inefficient it must be. The keys iterator returns the keys so it has to walk the keys, however the get(key) has to lookup the key each time.Internally implementations like HashMap store keys and values as linked list pairs, so the API I'm wishing for it something like

Iterator keysAndValues = map.getKeysAndValues().iterator();
while(keys.hasNext()){ 
  Pair keyAndValue  = keysAndValues.next(); 
  Object key = keyAndValue.getKey(); 
  Object value = keyAndValue.getValue();
} 

This would need a new interface Pair that would have a getKey() and getVelue() method. It's basically similar to what Smalltalk does where you do code like

Dictionary d := Dictionary new.
d keysAndValuesDo: [ :key :value |] 

This code does require the use of Blocks, but it could still be done in Java by introducing a new interface called Pair that was an inner class interface of Map. To make the new API non breaking it would need doing on a new interface called, say, Map2.

 public interface Maps2 extends Map{
  public Collection getKeysAndValues(); 
  public interface Pair{ 
    public Object getKey();
    public Object getValue();
  }
} 

Each implementation of Map could do what it wants to implement Pair, so a default implementation could just return the key, hold a pointer to the Map, and do a get(key)  for the getValue() method. However implementations like HashMap that internally use linked lists could be more efficient.