Java/Collections Data Structure/Collection

Содержание

1 A combination of two collections into a collection
2 Append, filter and get the size of collections
3 A utility class for working with attribute and parameter collections used by Spring Web FLow
4 Check whether the given Collection contains the given element instance.
5 Clone an array
6 Clones a map and prefixes the keys in the clone
7 Clones the lhs map and add all things from the rhs map.
8 Deep clone collection: Returns a new collection containing clones of all the items in the specified collection.
9 Disjoint two collections
10 Find a value of the given type in the given Collection
11 Get the difference of two collections
12 Is collection is empty, and all of its elements are empty
13 Return the first element in "candidates" that is contained in source
14 Return true if any element in "candidates" is contained in source
15 Simple implementation of a generic Bag
16 The collection related utilities
17 Whether Collection only contains a single unique object

A combination of two collections into a collection

   <source lang="java">

/* DualCollection.java {{IS_NOTE

 Purpose:
   
 Description:
   
 History:
   Sun Sep  2 21:29:38     2007, Created by tomyeh

 This program is distributed under GPL Version 3.0 in the hope that
 it will be useful, but WITHOUT ANY WARRANTY.

}}IS_RIGHT

/

import java.util.Collection; import java.util.Collections; import java.util.Iterator; import java.util.AbstractCollection; /**

* A combination of two collections into a collection.
*
* @author tomyeh
* @since 3.0.0
*/

public class DualCollection extends AbstractCollection implements java.io.Serializable {

 private final Collection _first, _second;
 /** Returns a collection by combining two collections.
  * It checks whether any of them is null, or equals. And, returns
  * the non-null one if another is null.
  * If both null, it returns null.
  */
 public static final
 Collection combine(Collection first, Collection second) {
   if (first == second) //we don"t use equals to have better performance
     return first;
   if (first != null)
     if (second != null)
       return new DualCollection(first, second);
     else
       return first;
   else
     return second;
 }
 /** Constructor.
  * It is better to use {@link #combine} instead of this method
  * since it checks whether any of them is null or equals.
  */
 public DualCollection(Collection first, Collection second) {
   _first = first != null ? first: Collections.EMPTY_LIST;
   _second = second != null ? second: Collections.EMPTY_LIST;
 }
 //Collection//
 public int size() {
   return _first.size() + _second.size();
 }
 public Iterator iterator() {
   return new Iter();
 }
 private class Iter implements Iterator {
   private Iterator _it;
   private boolean _bSecond;
   private Iter() {
     _it = _first.iterator();
   }
   public boolean hasNext() {
     return _it.hasNext() || (!_bSecond && !_second.isEmpty());
   }
   public Object next() {
     if (!_bSecond && !_it.hasNext()) {
       _it = _second.iterator();
       _bSecond = true;
     }
     return _it.next();
   }
   public void remove() {
     _it.remove();
   }
 }

}

 </source>

Append, filter and get the size of collections

   <source lang="java">

/**

* Licensed to the Apache Software Foundation (ASF) under one or more
* contributor license agreements.  See the NOTICE file distributed with
* this work for additional information regarding copyright ownership.
* The ASF licenses this file to You under the Apache License, Version 2.0
* (the "License"); you may not use this file except in compliance with
* the License.  You may obtain a copy of the License at
*
*      http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/

import java.lang.reflect.Array; import java.util.ArrayList; import java.util.Arrays; import java.util.Collection; import java.util.Iterator; import java.util.List; import java.util.Map; import org.w3c.dom.NodeList; /**

* A number of helper methods for working with collections
*
* @version $Revision: 747062 $
*/

public final class CollectionHelper {

   /**
    * Utility classes should not have a public constructor.
    */
   private CollectionHelper() {
   }
   /**
    * Returns the size of the collection if it can be determined to be a collection
    *
    * @param value the collection
    * @return the size, or null if not a collection
    */
   public static Integer size(Object value) {
       if (value != null) {
           if (value instanceof Collection) {
               Collection collection = (Collection)value;
               return collection.size();
           } else if (value instanceof Map) {
               Map map = (Map)value;
               return map.size();
           } else if (value instanceof Object[]) {
               Object[] array = (Object[])value;
               return array.length;
           } else if (value.getClass().isArray()) {
               return Array.getLength(value);
           } else if (value instanceof NodeList) {
               NodeList nodeList = (NodeList)value;
               return nodeList.getLength();
           }
       }
       return null;
   }
   /**
    * Sets the value of the entry in the map for the given key, though if the
    * map already contains a value for the given key then the value is appended
    * to a list of values.
    *
    * @param map the map to add the entry to
    * @param key the key in the map
    * @param value the value to put in the map
    */
   @SuppressWarnings("unchecked")
   public static void appendValue(Map map, Object key, Object value) {
       Object oldValue = map.get(key);
       if (oldValue != null) {
           List list;
           if (oldValue instanceof List) {
               list = (List)oldValue;
           } else {
               list = new ArrayList();
               list.add(oldValue);
           }
           list.add(value);
       } else {
           map.put(key, value);
       }
   }
   /**
    * Filters the given list to skip instanceof filter objects.
    * 
    * @param list  the list
    * @param filters  objects to skip
    * @return a new list without the filtered objects
    */
   @SuppressWarnings("unchecked")
   public static List filterList(List list, Object... filters) {
       List answer = new ArrayList();
       for (Object o : list) {
           for (Object filter : filters) {
               if (!o.getClass().isInstance(filter)) {
                   answer.add(o);
               }
           }
       }
       return answer;
   }
   public static String collectionAsCommaDelimitedString(String[] col) {
       if (col == null || col.length == 0) {
           return "";
       }
       return collectionAsCommaDelimitedString(Arrays.asList(col));
   }
   public static String collectionAsCommaDelimitedString(Collection col) {
       if (col == null || col.isEmpty()) {
           return "";
       }
       StringBuilder sb = new StringBuilder();
       Iterator it = col.iterator();
       while (it.hasNext()) {
           sb.append(it.next());
           if (it.hasNext()) {
               sb.append(",");
           }
       }
       return sb.toString();
   }

}

 </source>

A utility class for working with attribute and parameter collections used by Spring Web FLow

   <source lang="java">

/*

* Copyright 2004-2008 the original author or authors.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
*      http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/

import java.io.Serializable; import java.util.Collections; import java.util.Enumeration; import java.util.Iterator; import java.util.List; /**

* A utility class for working with attribute and parameter collections used by Spring Web FLow.
* 
* @author Keith Donald
* @author Erwin Vervaet
*/

public class CollectionUtils {

 /**
  * The shared, singleton empty iterator instance.
  */
 public static final Iterator EMPTY_ITERATOR = new EmptyIterator();
 /**
  * Private constructor to avoid instantiation.
  */
 private CollectionUtils() {
 }
 /**
  * Factory method that adapts an enumeration to an iterator.
  * @param enumeration the enumeration
  * @return the iterator
  */
 public static Iterator toIterator(Enumeration enumeration) {
   return new EnumerationIterator(enumeration);
 }

 /**
  * Add all given objects to given target list. No duplicates will be added. The contains() method of the given
  * target list will be used to determine whether or not an object is already in the list.
  * @param target the collection to which to objects will be added
  * @param objects the objects to add
  * @return whether or not the target collection changed
  */
 public static boolean addAllNoDuplicates(List target, Object[] objects) {
   if (objects == null || objects.length == 0) {
     return false;
   } else {
     boolean changed = false;
     for (int i = 0; i < objects.length; i++) {
       if (!target.contains(objects[i])) {
         target.add(objects[i]);
         changed = true;
       }
     }
     return changed;
   }
 }
 /**
  * Iterator iterating over no elements (hasNext() always returns false).
  */
 private static class EmptyIterator implements Iterator, Serializable {
   private EmptyIterator() {
   }
   public boolean hasNext() {
     return false;
   }
   public Object next() {
     throw new UnsupportedOperationException("There are no elements");
   }
   public void remove() {
     throw new UnsupportedOperationException("There are no elements");
   }
 }
 /**
  * Iterator wrapping an Enumeration.
  */
 private static class EnumerationIterator implements Iterator {
   private Enumeration enumeration;
   public EnumerationIterator(Enumeration enumeration) {
     this.enumeration = enumeration;
   }
   public boolean hasNext() {
     return enumeration.hasMoreElements();
   }
   public Object next() {
     return enumeration.nextElement();
   }
   public void remove() throws UnsupportedOperationException {
     throw new UnsupportedOperationException("Not supported");
   }
 }

}

 </source>

Check whether the given Collection contains the given element instance.

   <source lang="java">

import java.util.Arrays; import java.util.Collection; import java.util.Enumeration; import java.util.Iterator; import java.util.List; import java.util.Map; import java.util.Properties; /*

* Copyright 2002-2007 the original author or authors.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
*      http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/

/**

* Miscellaneous collection utility methods.
* Mainly for internal use within the framework.
*
* @author Juergen Hoeller
* @author Rob Harrop
* @since 1.1.3
*/

abstract class CollectionUtils {

 /**
  * Check whether the given Collection contains the given element instance.

*

Enforces the given instance to be present, rather than returning * true for an equal element as well. * @param collection the Collection to check * @param element the element to look for * @return true if found, false else */ public static boolean containsInstance(Collection collection, Object element) { if (collection != null) { for (Iterator it = collection.iterator(); it.hasNext();) { Object candidate = it.next(); if (candidate == element) { return true; } } } return false; } /** * Return true if the supplied Collection is null * or empty. Otherwise, return false. * @param collection the Collection to check * @return whether the given Collection is empty */ public static boolean isEmpty(Collection collection) { return (collection == null || collection.isEmpty()); } /** * Return true if the supplied Map is null * or empty. Otherwise, return false. * @param map the Map to check * @return whether the given Map is empty */ public static boolean isEmpty(Map map) { return (map == null || map.isEmpty()); } /** * Return true if any element in "candidates" is * contained in "source"; otherwise returns false. * @param source the source Collection * @param candidates the candidates to search for * @return whether any of the candidates has been found */ public static boolean containsAny(Collection source, Collection candidates) { if (isEmpty(source) || isEmpty(candidates)) { return false; } for (Iterator it = candidates.iterator(); it.hasNext();) { if (source.contains(it.next())) { return true; } } return false; } /** * Return the first element in "candidates" that is contained in * "source". If no element in "candidates" is present in * "source" returns null. Iteration order is * {@link Collection} implementation specific. * @param source the source Collection * @param candidates the candidates to search for * @return the first present object, or null if not found */ public static Object findFirstMatch(Collection source, Collection candidates) { if (isEmpty(source) || isEmpty(candidates)) { return null; } for (Iterator it = candidates.iterator(); it.hasNext();) { Object candidate = it.next(); if (source.contains(candidate)) { return candidate; } } return null; } /** * Find a value of the given type in the given Collection. * @param collection the Collection to search * @param type the type to look for * @return a value of the given type found, or null if none * @throws IllegalArgumentException if more than one value of the given type found */ public static Object findValueOfType(Collection collection, Class type) throws IllegalArgumentException { if (isEmpty(collection)) { return null; } Class typeToUse = (type != null ? type : Object.class); Object value = null; for (Iterator it = collection.iterator(); it.hasNext();) { Object obj = it.next(); if (typeToUse.isInstance(obj)) { if (value != null) { throw new IllegalArgumentException("More than one value of type [" + typeToUse.getName() + "] found"); } value = obj; } } return value; } /** * Determine whether the given Collection only contains a single unique object. * @param collection the Collection to check * @return true if the collection contains a single reference or * multiple references to the same instance, false else */ public static boolean hasUniqueObject(Collection collection) { if (isEmpty(collection)) { return false; } boolean hasCandidate = false; Object candidate = null; for (Iterator it = collection.iterator(); it.hasNext();) { Object elem = it.next(); if (!hasCandidate) { hasCandidate = true; candidate = elem; } else if (candidate != elem) { return false; } } return true; } } </source>

Clone an array

   <source lang="java">

/*

* Licensed to the Apache Software Foundation (ASF) under one or more
*  contributor license agreements.  See the NOTICE file distributed with
*  this work for additional information regarding copyright ownership.
*  The ASF licenses this file to You under the Apache License, Version 2.0
*  (the "License"); you may not use this file except in compliance with
*  the License.  You may obtain a copy of the License at
*
*      http://www.apache.org/licenses/LICENSE-2.0
*
*  Unless required by applicable law or agreed to in writing, software
*  distributed under the License is distributed on an "AS IS" BASIS,
*  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
*  See the License for the specific language governing permissions and
*  limitations under the License.
*
*
*/

/**

* @author Stephen Colebourne
* @author Moritz Petersen
* @author 
* @author Maarten Coene
* @since 2.0
* @version $Id: ArrayUtils.java 632503 2008-03-01 00:21:52Z ggregory $
*/

public class Main {

 // Clone
 //-----------------------------------------------------------------------
 /**
  * <p>Shallow clones an array returning a typecast result and handling

* null.

*

The objects in the array are not cloned, thus there is no special * handling for multi-dimensional arrays.

*