java.util
Class WeakHashMap<K,V>
- Map<K,V>
A weak hash map has only weak references to the key. This means that it
allows the key to be garbage collected if it is not used otherwise. If
this happens, the entry will eventually disappear from the map,
asynchronously.
A weak hash map makes most sense when the keys doesn't override the
equals method: If there is no other reference to the
key nobody can ever look up the key in this table and so the entry
can be removed. This table also works when the
equals
method is overloaded, such as String keys, but you should be prepared
to deal with some entries disappearing spontaneously.
Other strange behaviors to be aware of: The size of this map may
spontaneously shrink (even if you use a synchronized map and synchronize
it); it behaves as if another thread removes entries from this table
without synchronization. The entry set returned by
entrySet
has similar phenomenons: The size may spontaneously shrink, or an
entry, that was in the set before, suddenly disappears.
A weak hash map is not meant for caches; use a normal map, with
soft references as values instead, or try
LinkedHashMap.
The weak hash map supports null values and null keys. The null key
is never deleted from the map (except explictly of course). The
performance of the methods are similar to that of a hash map.
The value objects are strongly referenced by this table. So if a
value object maintains a strong reference to the key (either direct
or indirect) the key will never be removed from this map. According
to Sun, this problem may be fixed in a future release. It is not
possible to do it with the jdk 1.2 reference model, though.
WeakHashMap()- Creates a new weak hash map with default load factor and default
capacity.
|
WeakHashMap(extends K, V> m)- Construct a new WeakHashMap with the same mappings as the given map.
|
WeakHashMap(int initialCapacity)- Creates a new weak hash map with default load factor and the given
capacity.
|
WeakHashMap(int initialCapacity, float loadFactor)- Creates a new weak hash map with the given initial capacity and
load factor.
|
void | clear()- Clears all entries from this map.
|
boolean | containsKey(Object key)- Tells if the map contains the given key.
|
boolean | containsValue(Object value)- Returns true if the map contains at least one key which points to
the specified object as a value.
|
Set> | entrySet()- Returns a set representation of the entries in this map.
|
V | get(Object key)- Gets the value the key is mapped to.
|
boolean | isEmpty()- Tells if the map is empty.
|
Set | keySet()- Returns a set representation of the keys in this map.
|
V | put(K key, V value)- Adds a new key/value mapping to this map.
|
void | putAll(extends K, V> m)- Puts all of the mappings from the given map into this one.
|
V | remove(Object key)- Removes the key and the corresponding value from this map.
|
int | size()- Returns the size of this hash map.
|
Collection | values()- Returns a collection representation of the values in this map.
|
V>> entrySet, clear, clone, containsKey, containsValue, equals, get, hashCode, isEmpty, keySet, put, putAll, remove, size, toString, values |
clone, equals, extends Object> getClass, finalize, hashCode, notify, notifyAll, toString, wait, wait, wait |
WeakHashMap
public WeakHashMap()
Creates a new weak hash map with default load factor and default
capacity.
WeakHashMap
public WeakHashMap(extends K,
V> m) Construct a new WeakHashMap with the same mappings as the given map.
The WeakHashMap has a default load factor of 0.75.
WeakHashMap
public WeakHashMap(int initialCapacity)
Creates a new weak hash map with default load factor and the given
capacity.
initialCapacity - the initial capacity
WeakHashMap
public WeakHashMap(int initialCapacity,
float loadFactor) Creates a new weak hash map with the given initial capacity and
load factor.
initialCapacity - the initial capacity.loadFactor - the load factor (see class description of HashMap).
containsKey
public boolean containsKey(Object key)
Tells if the map contains the given key. Note that the result
may change spontanously, if the key was only weakly
reachable.
- containsKey in interface Map<K,V>
- containsKey in interface AbstractMap<K,V>
key - the key to look for
- true, iff the map contains an entry for the given key.
containsValue
public boolean containsValue(Object value)
Returns true if the map contains at least one key which points to
the specified object as a value. Note that the result
may change spontanously, if its key was only weakly reachable.
- containsValue in interface Map<K,V>
- containsValue in interface AbstractMap<K,V>
value - the value to search for
- true if it is found in the set.
entrySet
public Set> entrySet()
Returns a set representation of the entries in this map. This
set will not have strong references to the keys, so they can be
silently removed. The returned set has therefore the same
strange behaviour (shrinking size(), disappearing entries) as
this weak hash map.
- a set representation of the entries.
get
public V get(Object key)
Gets the value the key is mapped to.
- get in interface Map<K,V>
- get in interface AbstractMap<K,V>
- the value the key was mapped to. It returns null if
the key wasn't in this map, or if the mapped value was
explicitly set to null.
isEmpty
public boolean isEmpty()
Tells if the map is empty. Note that the result may change
spontanously, if all of the keys were only weakly reachable.
- isEmpty in interface Map<K,V>
- isEmpty in interface AbstractMap<K,V>
- true, iff the map is empty.
keySet
public Set keySet()
Returns a set representation of the keys in this map. This
set will not have strong references to the keys, so they can be
silently removed. The returned set has therefore the same
strange behaviour (shrinking size(), disappearing entries) as
this weak hash map.
- keySet in interface Map<K,V>
- keySet in interface AbstractMap<K,V>
- a set representation of the keys.
put
public V put(K key,
V value) Adds a new key/value mapping to this map.
- put in interface Map<K,V>
- put in interface AbstractMap<K,V>
key - the key, may be nullvalue - the value, may be null
- the value the key was mapped to previously. It returns
null if the key wasn't in this map, or if the mapped value
was explicitly set to null.
putAll
public void putAll(extends K,
V> m) Puts all of the mappings from the given map into this one. If the
key already exists in this map, its value is replaced.
- putAll in interface Map<K,V>
- putAll in interface AbstractMap<K,V>
remove
public V remove(Object key)
Removes the key and the corresponding value from this map.
- remove in interface Map<K,V>
- remove in interface AbstractMap<K,V>
key - the key. This may be null.
- the value the key was mapped to previously. It returns
null if the key wasn't in this map, or if the mapped value was
explicitly set to null.
size
public int size()
Returns the size of this hash map. Note that the size() may shrink
spontaneously, if the some of the keys were only weakly reachable.
- size in interface Map<K,V>
- size in interface AbstractMap<K,V>
- the number of entries in this hash map.
values
public Collection values()
Returns a collection representation of the values in this map. This
collection will not have strong references to the keys, so mappings
can be silently removed. The returned collection has therefore the same
strange behaviour (shrinking size(), disappearing entries) as
this weak hash map.
- values in interface Map<K,V>
- values in interface AbstractMap<K,V>
- a collection representation of the values.
WeakHashMap -- a hashtable that keeps only weak references
to its keys, allowing the virtual machine to reclaim them
Copyright (C) 1999, 2000, 2001, 2002, 2003, 2004, 2005 Free Software Foundation, Inc.
This file is part of GNU Classpath.
GNU Classpath is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation; either version 2, or (at your option)
any later version.
GNU Classpath is distributed in the hope that it will be useful, but
WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
General Public License for more details.
You should have received a copy of the GNU General Public License
along with GNU Classpath; see the file COPYING. If not, write to the
Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
02110-1301 USA.
Linking this library statically or dynamically with other modules is
making a combined work based on this library. Thus, the terms and
conditions of the GNU General Public License cover the whole
combination.
As a special exception, the copyright holders of this library give you
permission to link this library with independent modules to produce an
executable, regardless of the license terms of these independent
modules, and to copy and distribute the resulting executable under
terms of your choice, provided that you also meet, for each linked
independent module, the terms and conditions of the license of that
module. An independent module is a module which is not derived from
or based on this library. If you modify this library, you may extend
this exception to your version of the library, but you are not
obligated to do so. If you do not wish to do so, delete this
exception statement from your version.