sequencetreemap.java

java阿里巴巴代码

package tools.util;

import java.util.Collection;
import java.util.HashMap;
import java.util.TreeMap;

public class SequenceTreeMap
{
	//key set
	private HashMap khash = null;
	private TreeMap kmap = null;
	
	//value set
	private TreeMap vmap = null;
	
	//size of map
	private int size = 0;
	
	//sequence
	private int takeEqual = 0;
	private boolean desc = false;

	public SequenceTreeMap()
	{
	}
	
	public SequenceTreeMap(int takeEqual)
	{
		this.takeEqual = takeEqual;
	}
	
	public SequenceTreeMap(boolean desc)
	{
		this.desc = desc;
	}

	public SequenceTreeMap(int takeEqual, boolean desc)
	{
		this.takeEqual = takeEqual;
		this.desc = desc;
	}
	
    /**
     * Removes all mappings from this SequenceTreeMap.
     */
    public void clear()
    {
        size = 0;
        khash = null;
        kmap = null;
        vmap = null;
    }

    /**
     * Returns <tt>true</tt> if this map contains a mapping for the specified
     * key.
     *
     * @param key key whose presence in this map is to be tested.
     * 
     * @return <tt>true</tt> if this map contains a mapping for the
     *            specified key.
     * @throws ClassCastException if the key cannot be compared with the keys
     *                  currently in the map.
     * @throws NullPointerException key is <tt>null</tt> and this map uses
     *                  natural ordering, or its comparator does not tolerate
     *            <tt>null</tt> keys.
     */
    public boolean containsKey(Object key)
    {
		return (khash==null)?false:khash.containsKey(key);
    }

    /**
     * Returns <tt>true</tt> if this map maps one or more keys to the
     * specified value.  More formally, returns <tt>true</tt> if and only if
     * this map contains at least one mapping to a value <tt>v</tt> such
     * that <tt>(value==null ? v==null : value.equals(v))</tt>.  This
     * operation will probably require time linear in the Map size for most
     * implementations of Map.
     *
     * @param value value whose presence in this Map is to be tested.
     * @return  <tt>true</tt> if a mapping to <tt>value</tt> exists;
     *		<tt>false</tt> otherwise.
     * @since 1.2
     */
    public boolean containsValue(Object value)
    {
		return (vmap==null)?false:vmap.containsValue(value);
    }

    /**
     * Returns the value to which this map maps the specified key.  Returns
     * <tt>null</tt> if the map contains no mapping for this key.  A return
     * value of <tt>null</tt> does not <i>necessarily</i> indicate that the
     * map contains no mapping for the key; it's also possible that the map
     * explicitly maps the key to <tt>null</tt>.  The <tt>containsKey</tt>
     * operation may be used to distinguish these two cases.
     *
     * @param key key whose associated value is to be returned.
     * @return the value to which this map maps the specified key, or
     *               <tt>null</tt> if the map contains no mapping for the key.
     * @throws    ClassCastException key cannot be compared with the keys
     *                  currently in the map.
     * @throws NullPointerException key is <tt>null</tt> and this map uses
     *                  natural ordering, or its comparator does not tolerate
     *                  <tt>null</tt> keys.
     * 
     * @see #containsKey(Object)
     */
    public Object get(Object key)
    {
    	if (khash == null)
    		return null;
    	
		Integer k = (Integer)khash.get(key);
		if (k == null)
			return null;
		
		return vmap.get(k);
    }

    /**
     * Returns a Set view of the keys contained in this map.  The set's
     * iterator will return the keys in ascending order.  The map is backed by
     * this <tt>TreeMap</tt> instance, so changes to this map are reflected in
     * the Set, and vice-versa.  The Set supports element removal, which
     * removes the corresponding mapping from the map, via the
     * <tt>Iterator.remove</tt>, <tt>Set.remove</tt>, <tt>removeAll</tt>,
     * <tt>retainAll</tt>, and <tt>clear</tt> operations.  It does not support
     * the <tt>add</tt> or <tt>addAll</tt> operations.
     *
     * @return a set view of the keys contained in this TreeMap.
     */
    public Collection keySet()
	{
		return (kmap==null)?null:kmap.values();
	}

    /**
     * Associates the specified value with the specified key in this map.
     * If the map previously contained a mapping for this key, the old
     * value is replaced.
     *
     * @param key key with which the specified value is to be associated.
     * @param value value to be associated with the specified key.
     * 
     * @return previous value associated with specified key, or <tt>null</tt>
     *         if there was no mapping for key.  A <tt>null</tt> return can
     *         also indicate that the map previously associated <tt>null</tt>
     *         with the specified key.
     * @throws    ClassCastException key cannot be compared with the keys
     *            currently in the map.
     * @throws NullPointerException key is <tt>null</tt> and this map uses
     *         natural order, or its comparator does not tolerate
     *         <tt>null</tt> keys.
     */
    public Object put(Object k, Object value)
    {
    	if (k == null)
    		return null;
    	
    	if (khash == null){
    		khash = new HashMap();
    		kmap = new TreeMap(new IntegerComparator((takeEqual==0)?false:true, desc));
			vmap = new TreeMap(new IntegerComparator((takeEqual==0)?false:true, desc));
    	}
    	
    	if (!khash.containsKey(k))
    		size++;

    	khash.put(k, new Integer(size));
    	kmap.put(new Integer(size), k);
		Object obj = vmap.put(new Integer(size), value);

		return obj;
    }

    /**
     * Removes the mapping for this key from this TreeMap if present.
     *
     * @param  key key for which mapping should be removed
     * @return previous value associated with specified key, or <tt>null</tt>
     *         if there was no mapping for key.  A <tt>null</tt> return can
     *         also indicate that the map previously associated
     *         <tt>null</tt> with the specified key.
     * 
     * @throws    ClassCastException key cannot be compared with the keys
     *            currently in the map.
     * @throws NullPointerException key is <tt>null</tt> and this map uses
     *         natural order, or its comparator does not tolerate
     *         <tt>null</tt> keys.
     */
	public Object remove(Object key)
	{
		if (khash == null)
			return null;
		
    	if (khash.containsKey(key))
    		size--;

		Integer k = (Integer)khash.get(key);
		khash.remove(key);
		kmap.remove(k);

		return vmap.remove(k);
	}

    /**
     * Returns the number of key-value mappings in this map.
     *
     * @return the number of key-value mappings in this map.
     */
    public int size()
    {
        return size;
    }

    /**
     * Returns a collection view of the values contained in this map.  The
     * collection's iterator will return the values in the order that their
     * corresponding keys appear in the tree.  The collection is backed by
     * this <tt>TreeMap</tt> instance, so changes to this map are reflected in
     * the collection, and vice-versa.  The collection supports element
     * removal, which removes the corresponding mapping from the map through
     * the <tt>Iterator.remove</tt>, <tt>Collection.remove</tt>,
     * <tt>removeAll</tt>, <tt>retainAll</tt>, and <tt>clear</tt> operations.
     * It does not support the <tt>add</tt> or <tt>addAll</tt> operations.
     *
     * @return a collection view of the values contained in this map.
     */
    public Collection values()
    {
		return (vmap==null)?null:vmap.values();
    }
}