Re: Using java.util.map

From:

Robert Klemme <shortcutter@googlemail.com>

Newsgroups:

comp.lang.java.programmer

Date:

Tue, 15 Aug 2006 15:08:31 +0200

Message-ID:

<4kdvafFbkskpU1@individual.net>

On 15.08.2006 14:33, Christopher Benson-Manica wrote:

I sincerely hope I'm missing something about how java.util.map can be
used, but it seems that there is no way to update a single value
without traversing the map twice, at least not cleanly. As an
example, consider this code taken from the Sun autoboxing example:

public static void main(String[] args) {
  Map<String, Integer> m = new TreeMap<String, Integer>();
  for (String word : args) {
    Integer freq = m.get(word);
    m.put(word, (freq == null ? 1 : freq + 1));
  }
}

Notice how both get() and put() are invoked. Clearly this means that
the map is traversed twice - once to find the value, and once to

Not the whole map is traversed twice. There are two lookups which take
O(log n) for the TreeMap and O(1) for the HashMap.

figure out where to put a new value (which happens to be the same
place!). In C++ (where I come from), maps contain objects of type
pair<key, value>, and one can therefore retrieve the pair<> in
question and update the value with only one traversal of the map. Is
there any way to avoid two traversals in Java short of writing a kludgy
wrapper object such as

class WrapsAnInt {
  private int wrapped;

  public WrapsAnInt( int w ) { wrapped = w; }
  public void setWrapped( int w ) { wrapped = w; }
  public int getWrapped() { return wrapped; }
}

If you're worried about performance writing a mutable Integer is the
best solution. Note that this class then also should inherit
java.lang.Number.

Also, use a HashMap which does faster lookups.

and put *those* in the map? If not, why didn't Java simply introduce
the concept of a pair<> like C++ did and fix the problem?

Java != C++

Cheers

robert