View Javadoc
   package com.bonevich.util;
   
   import java.util.*;
   
   /***
    * Utilities for operating on collections (join, reverse, map,
    * deep-equals (i.e. not identity), and list-to-map transform).
    * Creation date: (3/20/00 3:46:25 AM)
    * @author: jbonevic
   * @version $Id: CollectionUtilities.html,v 1.1 2009/03/07 17:55:37 jbonevic Exp $
   */
  public class CollectionUtilities
  {
  	private CollectionUtilities() {}
  
  	/***
  	 * An Object-safe join method.
  	 * Creation date: (3/20/00 3:47:57 AM)
  	 * @return String
  	 * @param strings java.util.Vector
  	 * @param joiner java.lang.String
  	 */
  	public static String join(String joiner, Object[] strings) 
  	{
  		if (strings == null)
  		{
  			return "";
  		}
  
  		return join(joiner, java.util.Arrays.asList(strings));
  	}
  
  	/***
  	 * An Object-safe join method.
  	 * Creation date: (3/20/00 3:47:57 AM)
  	 * @return String
  	 * @param strings java.util.Vector
  	 * @param joiner java.lang.String
  	 */
  	public static String join(String joiner, Collection strings)
  	{
  		if (strings == null)
  		{
  			return "";
  		}
  
  		StringBuffer buf = new StringBuffer();
  		String str = null;
  
  		// Iterate thru the vector, stringifying each item and adding it to the buffer
  		// and separating each string item with the joiner string
  		for (Iterator itr = strings.iterator(); itr.hasNext(); ) 
  		{
  			Object element=itr.next();
  			str = (element==null) ? "" : element.toString();
  			buf.append(str);
  			if ( itr.hasNext() ) 
  			{
  				buf.append(joiner);
  			}
  		}
  		return buf.toString();
  	}
  
  	/***
  	 * Danger! This modifies the List!
  	 * Creation date: (5/7/00 14:32:20)
  	 * @return java.util.Vector
  	 * @param v java.util.Vector
  	 */
  	public static List reverse(List v)
  	{
  		if (v == null)
  		{
  			return null;
  		}
  		Collections.reverse(v);
  		return v;
  	}
  
  	/***
  	 * Actual "equality".
  	 * Map.equals() is true if the hashMaps have the same keys, values being irrelevant.
  	 * Equal if
  	 * Both maps have same key=>value's && are same size.
  	 * Thus, null==null, empty==empty
  	 * NB: uses value.equal(). You've been warned.
  	 *
  	 * Creation date: (11/17/00 17:26:46)
  	 * @return boolean
  	 * @param a java.util.HashMap
  	 * @param b java.util.HashMap
  	 */
  	public static boolean equals(Map a, Map b)
  	{
  		// null case
  		if (a == null || b == null) 
  		{
  			return a==b;
 		}
 
 		// different sizes
 		if (a.size() != b.size()) 
 		{
 			return false;
 		}
 
 		// Each key from a has to be in b
 		// and since they have the same size, that's all the keys
 		for (Iterator itor = a.entrySet().iterator(); itor.hasNext();)
 		{
 			Map.Entry e = (Map.Entry) itor.next();
 
 			// have to check for "has" because get() may return null
 			Object k=e.getKey();
 			if (!b.containsKey(k)) 
 			{
 				return false;
 			}
 
 			// check for value equality
 			Object va=e.getValue();
 			Object vb=b.get(k);
 
 			// null case
 			if ((va==null || vb==null) && va!=vb) 
 			{
 				return false;
 			}
 
 			// special case Map's
 			if (va instanceof Map)
 			{
 				if (!equals((Map)va,(Map)vb)) 
 				{
 					return false;
 				}
 			}
 			else
 			{
 				if(! va.equals(vb)) 
 				{
 					return false;
 				}
 			}
 		}
 		return true;
 	}
 
 	/***
 	 * Turns an array of (key, value, key, value....) into a hashMap
 	 * Drops the last "key" if there is an odd number of elements.
 	 * the "key" is NOT toString()'d
 	 * Meant as a convenience for constructing hashes inline:
 	 * CollectionUtilities.toHashMap(new Object[] {k,v, k2, v2})
 	 * Creation date: (11/17/00 16:11:36)
 	 * @return java.util.HashMap
 	 * @param keyValueArray java.lang.Object[]
 	 */
 	public static HashMap toHashMap(Object[] keyValueArray)
 	{
 		if (keyValueArray == null)
 		{
 			return null;
 		}
 
 		int s = keyValueArray.length;
 		HashMap theHash = new HashMap(s);
 
 		for (int i=0; i<s/2; i++)
 		{
 			theHash.put(keyValueArray[i*2], keyValueArray[i*2+1]);
 		}
 		return theHash;
 	}
 
 	/***
 	 * Returns a vector, where each element NEW[i] = theFunctor.function(OLD[i]).
 	 * I.e. transforms each element, giving a new vector.
 	 * Takes any Collection, only uses the iterator() to obtain each object, and size().
 	 * Returns null if iterable is null.
 	 * NB: theFunctor.function(Object o) should handle the case of o==null.
 	 * Creation date: (3/20/00 3:47:57 AM)
 	 * @return String
 	 * @param strings java.util.Vector
 	 * @param joiner java.lang.String
 	 */
 	public static Vector map(Functor f, Collection iterable) 
 		//throws FunctorException
 	{
 		if (iterable == null)
 		{
 			return null;
 		}
 
 		Vector result = new Vector(iterable.size());
 		for (Iterator itr = iterable.iterator(); itr.hasNext(); ) 
 		{
 			Object r = f.function(itr.next());
 			result.addElement(r);
 		}
 		return result;
 	}
 
 	/***
 	 * Map across an Array
 	 * Creation date: (3/20/00 3:47:57 AM)
 	 * @return String
 	 * @param strings java.util.Vector
 	 * @param joiner java.lang.String
 	 */
 	public static Vector map(Functor f, Object[] anArray)
 		//throws FunctorException
 	{
 		if (anArray == null)
 		{
 			return null;
 		}
 
 		return map(f, java.util.Arrays.asList(anArray));
 	}
 
 	/***
 	 * Map across a Map: simply calls the functor with each Map.EntrySet (see JoinMapEntry for example)
 	 * Creation date: (3/20/00 3:47:57 AM)
 	 * @return String
 	 * @param strings java.util.Vector
 	 * @param joiner java.lang.String
 	 */
 	public static Vector map(Functor f, Map aMap)
 		//throws FunctorException
 	{
 		if (aMap == null)
 		{
 			return null;
 		}
 
 		return map(f, aMap.entrySet());
 	}
 
 }