List of usage examples for java.util AbstractMap subclass-usage
From source file IntHashMap.java
/** * A Map that accepts int or Integer keys only. This class is not thread-safe. * * @author Brian S O'Neill */ public class IntHashMap<V> extends AbstractMap<Integer, V> implements Map<Integer, V>, Cloneable, Serializable {
From source file SoftValueMap.java
/**
* A <code>java.util.Map</code> implementation using reference values.
* <p>
* The values are stored in the map as references.
* If the garbage collector clears the reference, the corresponding key is
* automatically removed from the map.
From source file CharMap.java
/**
* A space-optimized map for associating {@code char} keys with values.<p>
*
* This class makes a trade off for reduced space usage at the cost of decreased
* performace. The {@code put}, {@code get}, {@code containsKey} and {@code
* get} operations are all logarithmic when the map is unmodified. If a new
From source file SoftHashMap.java
/**
* A hashtable-based <tt>Map</tt> implementation with <em>soft keys</em>.
* An entry in a <tt>SoftHashMap</tt> will automatically be removed when
* its key is no longer in ordinary use.
* More precisely, the presence of a mapping for a given key will not prevent
* the key from being discarded by the garbage collector, that is, made
From source file org.apache.ojb.broker.util.ReferenceMap.java
/**
* <p>
* Modified version of {@link org.apache.commons.collections.ReferenceMap}, using
* object identity for key comparison (). This class
* simply extended {@link org.apache.commons.collections.ReferenceMap} with an extra field
* "useSystemIdentity" which is initialized in constructor and is used every time we
From source file jenkins.model.lazy.AbstractLazyLoadRunMap.java
/**
* {@link SortedMap} that keeps build records by their build numbers, in the descending order
* (newer ones first.)
*
* <p>
* The main thing about this class is that it encapsulates the lazy loading logic.
From source file ConcurrentWeakHashMap.java
/**
* A hash table with <em>weak keys</em>, full concurrency of retrievals, and
* adjustable expected concurrency for updates. Similar to
* {@link java.util.WeakHashMap}, entries of this table are periodically
* removed once their corresponding keys are no longer referenced outside of
* this table. In other words, this table will not prevent a key from being
From source file ConcurrentHashMap.java
/**
* A version of Hashtable supporting concurrency for both retrievals and
* updates:
*
* <dl>
* <dt> Retrievals
From source file ConcurrentReaderHashMap.java
/**
* A version of Hashtable that supports mostly-concurrent reading, but exclusive
* writing. Because reads are not limited to periods without writes, a
* concurrent reader policy is weaker than a classic reader/writer policy, but
* is generally faster and allows more concurrency. This class is a good choice
* especially for tables that are mainly created by one thread during the
From source file WeakIdentityMap.java
/**
* WeakIdentityMap is like WeakHashMap, except it uses a key's identity
* hashcode and equals methods. WeakIdentityMap is not thread-safe and must be
* wrapped with Collections.synchronizedMap to be made thread-safe.
* <p>
* The documentation for WeakHashMap states that it is intended primarily for