Start line:  
End line:  

Snippet Preview

Snippet HTML Code

Stack Overflow Questions
  /*
   * Conditions Of Use
   *
   * This software was developed by employees of the National Institute of
   * Standards and Technology (NIST), an agency of the Federal Government.
   * Pursuant to title 15 Untied States Code Section 105, works of NIST
   * employees are not subject to copyright protection in the United States
   * and are considered to be in the public domain.  As a result, a formal
   * license is not needed to use the software.
  *
  * This software is provided by NIST as a service and is expressly
  * provided "AS IS."  NIST MAKES NO WARRANTY OF ANY KIND, EXPRESS, IMPLIED
  * OR STATUTORY, INCLUDING, WITHOUT LIMITATION, THE IMPLIED WARRANTY OF
  * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE, NON-INFRINGEMENT
  * AND DATA ACCURACY.  NIST does not warrant or make any representations
  * regarding the use of the software or the results thereof, including but
  * not limited to the correctness, accuracy, reliability or usefulness of
  * the software.
  *
  * Permission to use this software is contingent upon your acceptance
  * of the terms of this agreement.
  *
  */
 package gov.nist.core;
 
 import java.util.List;
 import java.util.Map;
 import java.util.Set;
 
 public class MultiValueMapImpl<V> implements MultiValueMap<String, V>, Cloneable {
 	// jeand : lazy init of the map to reduce mem consumption
     private HashMap<StringArrayList<V>> map = null;
 
     private static final long serialVersionUID = 4275505380960964605L;
 
     public MultiValueMapImpl() {
         super();
     }
 
     public List<V> put(String key, V value) {    	
         ArrayList<V> keyList = null;
         if( != null) {
         	keyList = .get(key);
         }
         if (keyList == null) {
             keyList = new ArrayList<V>();
             getMap().put(keykeyList);
         }
 
         keyList.add(value);
         return keyList;
     }
 
     public boolean containsValue(Object value) {
         Set pairs = null;
         if( != null) {
         	pairs = .entrySet();
         }
         if (pairs == null)
             return false;
 
         Iterator pairsIterator = pairs.iterator();
         while (pairsIterator.hasNext()) {
             Map.Entry keyValuePair = (Map.Entry) (pairsIterator.next());
             ArrayList list = (ArrayList) (keyValuePair.getValue());
             if (list.contains(value))
                 return true;
         }
         return false;
     }
 
     public void clear() {
     	if( != null) {
 	        Set pairs = .entrySet();
 	        Iterator pairsIterator = pairs.iterator();
 	        while (pairsIterator.hasNext()) {
 	            Map.Entry keyValuePair = (Map.Entry) (pairsIterator.next());
 	            ArrayList list = (ArrayList) (keyValuePair.getValue());
 	            list.clear();
 	        }
 	        .clear();
     	}
     }
 
     public Collection values() {
     	if( == null) {
     		return new ArrayList();
     	}
         ArrayList returnList = new ArrayList(.size());
 
         Set pairs = .entrySet();
         Iterator pairsIterator = pairs.iterator();
         while (pairsIterator.hasNext()) {
             Map.Entry keyValuePair = (Map.Entry) (pairsIterator.next());
            ArrayList list = (ArrayList) (keyValuePair.getValue());
            Object[] values = list.toArray();
            for (int ii = 0; ii < values.lengthii++) {
                returnList.add(values[ii]);
            }
        }
        return returnList;
    }
    public Object clone() {
        MultiValueMapImpl obj = new MultiValueMapImpl<V>();
        if( != null) {
        	obj.map = (HashMap<ObjectArrayList<V>>) this..clone();
        }
        return obj;
    }
    public int size() {
    	if( == null) {
    		return 0;
    	}
        return this..size();
    }
    public boolean containsKey(Object key) {
    	if( == null) {
    		return false;
    	}
        return .containsKey(key);
    }
    public Set entrySet() {
    	if( == null) {
    		return new HashSet();
    	}
        return .entrySet();
    }
    public boolean isEmpty() {
    	if( == null) {
    		return true;
    	}
        return .isEmpty();
    }
    public Set<StringkeySet() {
    	if( == null) {
    		return new HashSet<String>();
    	}
        return this..keySet();
    }
    public Object remove(String key, V item) {
    	if( == null) {
    		return null;
    	}
        ArrayList<V> list = this..get(key);
        if (list == null) {
            return null;
        } else {
            return list.remove(item);
        }
    }
    public List<V> get(Object key) {
    	if( == null) {
    		return null;
    	}
        return .get(key);
    }
    public List<V> put(String keyList<V> value) {
        return this.getMap().put(key,(ArrayList<V>) value);
    }
    public List<V> remove(Object key) {
    	if( == null) {
    		return null;
    	}
        return .remove(key);
    }
    
    public void putAll(Map< ? extends String, ? extends List<V>> mapToPut) {
        for (String k : mapToPut.keySet()) {
            ArrayList<V> al = new ArrayList<V>();
            al.addAll(mapToPut.get(k));
            getMap().put(kal);
        }  
    }


Returns:
the map
	public HashMap<StringArrayList<V>> getMap() {
		if( == null) {
			 = new HashMap<StringArrayList<V>>(0);
		}
		return ;
	}
New to GrepCode? Check out our FAQ X