org.springframework.core
Class CollectionFactory

java.lang.Object
  extended by org.springframework.core.CollectionFactory

public abstract class CollectionFactory
extends Object

Factory for collections, being aware of Commons Collection 3.x's extended collections as well as of JDK 1.5+ concurrent collections and backport-concurrent collections. Mainly for internal use within the framework.

The goal of this class is to avoid runtime dependencies on JDK 1.5+ and Commons Collections 3.x, simply using the best collection implementation that is available at runtime. As of Spring 2.5, JDK 1.4 is required, so former adapter methods for JDK 1.3/1.4 always return the JDK 1.4 collections now. The adapter methods are still kept for supporting Spring-based applications/frameworks which were built to support JDK 1.3.

Since:
1.1.1
Author:
Juergen Hoeller

Constructor Summary
CollectionFactory()
           
 
Method Summary
static Collection createApproximateCollection(Object collection, int initialCapacity)
          Create the most approximate collection for the given collection.
static Map createApproximateMap(Object map, int initialCapacity)
          Create the most approximate map for the given map.
static ConcurrentMap createConcurrentMap(int initialCapacity)
          Create a concurrent Map with a dedicated ConcurrentMap interface, requiring JDK >= 1.5 or the backport-concurrent library on the classpath.
static Map createConcurrentMapIfPossible(int initialCapacity)
          Create a concurrent Map if possible: that is, if running on JDK >= 1.5 or if the backport-concurrent library is available.
static Set createCopyOnWriteSet()
          Create a copy-on-write Set (allowing for synchronization-less iteration), requiring JDK >= 1.5 or the backport-concurrent library on the classpath.
static Map createIdentityMapIfPossible(int initialCapacity)
          Deprecated. as of Spring 2.5, for usage on JDK 1.4 or higher
static Map createLinkedCaseInsensitiveMapIfPossible(int initialCapacity)
          Create a linked case-insensitive Map if possible: if Commons Collections 3.x is available, a CaseInsensitiveMap with ListOrderedMap decorator will be created.
static Map createLinkedMapIfPossible(int initialCapacity)
          Deprecated. as of Spring 2.5, for usage on JDK 1.4 or higher
static Set createLinkedSetIfPossible(int initialCapacity)
          Deprecated. as of Spring 2.5, for usage on JDK 1.4 or higher
static boolean isApproximableCollectionType(Class collectionType)
          Determine whether the given collection type is an approximable type, i.e. a type that createApproximateCollection(java.lang.Object, int) can approximate.
static boolean isApproximableMapType(Class mapType)
          Determine whether the given map type is an approximable type, i.e. a type that createApproximateMap(java.lang.Object, int) can approximate.
 
Methods inherited from class java.lang.Object
clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait
 

Constructor Detail

CollectionFactory

public CollectionFactory()
Method Detail

createLinkedSetIfPossible

public static Set createLinkedSetIfPossible(int initialCapacity)
Deprecated. as of Spring 2.5, for usage on JDK 1.4 or higher

Create a linked Set if possible: This implementation always creates a LinkedHashSet, since Spring 2.5 requires JDK 1.4 anyway.

Parameters:
initialCapacity - the initial capacity of the Set
Returns:
the new Set instance

createCopyOnWriteSet

public static Set createCopyOnWriteSet()
Create a copy-on-write Set (allowing for synchronization-less iteration), requiring JDK >= 1.5 or the backport-concurrent library on the classpath. Prefers a JDK 1.5+ CopyOnWriteArraySet to its backport-concurrent equivalent. Throws an IllegalStateException if no copy-on-write Set is available.

Returns:
the new Set instance
Throws:
IllegalStateException - if no copy-on-write Set is available
See Also:
ConcurrentHashMap, ConcurrentHashMap

createLinkedMapIfPossible

public static Map createLinkedMapIfPossible(int initialCapacity)
Deprecated. as of Spring 2.5, for usage on JDK 1.4 or higher

Create a linked Map if possible: This implementation always creates a LinkedHashMap, since Spring 2.5 requires JDK 1.4 anyway.

Parameters:
initialCapacity - the initial capacity of the Map
Returns:
the new Map instance

createLinkedCaseInsensitiveMapIfPossible

public static Map createLinkedCaseInsensitiveMapIfPossible(int initialCapacity)
Create a linked case-insensitive Map if possible: if Commons Collections 3.x is available, a CaseInsensitiveMap with ListOrderedMap decorator will be created. Else, a JDK LinkedHashMap will be used.

Parameters:
initialCapacity - the initial capacity of the Map
Returns:
the new Map instance
See Also:
CaseInsensitiveMap, ListOrderedMap

createIdentityMapIfPossible

public static Map createIdentityMapIfPossible(int initialCapacity)
Deprecated. as of Spring 2.5, for usage on JDK 1.4 or higher

Create an identity Map if possible: This implementation always creates a IdentityHashMap, since Spring 2.5 requires JDK 1.4 anyway.

Parameters:
initialCapacity - the initial capacity of the Map
Returns:
the new Map instance

createConcurrentMapIfPossible

public static Map createConcurrentMapIfPossible(int initialCapacity)
Create a concurrent Map if possible: that is, if running on JDK >= 1.5 or if the backport-concurrent library is available. Prefers a JDK 1.5+ ConcurrentHashMap to its backport-concurrent equivalent. Falls back to a plain synchronized HashMap if no concurrent Map is available.

Parameters:
initialCapacity - the initial capacity of the Map
Returns:
the new Map instance
See Also:
ConcurrentHashMap, ConcurrentHashMap

createConcurrentMap

public static ConcurrentMap createConcurrentMap(int initialCapacity)
Create a concurrent Map with a dedicated ConcurrentMap interface, requiring JDK >= 1.5 or the backport-concurrent library on the classpath. Prefers a JDK 1.5+ ConcurrentHashMap to its backport-concurrent equivalent. Throws an IllegalStateException if no concurrent Map is available.

Parameters:
initialCapacity - the initial capacity of the Map
Returns:
the new ConcurrentMap instance
Throws:
IllegalStateException - if no concurrent Map is available
See Also:
ConcurrentHashMap, ConcurrentHashMap

isApproximableCollectionType

public static boolean isApproximableCollectionType(Class collectionType)
Determine whether the given collection type is an approximable type, i.e. a type that createApproximateCollection(java.lang.Object, int) can approximate.

Parameters:
collectionType - the collection type to check
Returns:
true if the type is approximable, false if it is not

createApproximateCollection

public static Collection createApproximateCollection(Object collection,
                                                     int initialCapacity)
Create the most approximate collection for the given collection.

Creates an ArrayList, TreeSet or linked Set for a List, SortedSet or Set, respectively.

Parameters:
collection - the original collection object
initialCapacity - the initial capacity
Returns:
the new collection instance
See Also:
ArrayList, TreeSet, LinkedHashSet

isApproximableMapType

public static boolean isApproximableMapType(Class mapType)
Determine whether the given map type is an approximable type, i.e. a type that createApproximateMap(java.lang.Object, int) can approximate.

Parameters:
mapType - the map type to check
Returns:
true if the type is approximable, false if it is not

createApproximateMap

public static Map createApproximateMap(Object map,
                                       int initialCapacity)
Create the most approximate map for the given map.

Creates a TreeMap or linked Map for a SortedMap or Map, respectively.

Parameters:
map - the original map object
initialCapacity - the initial capacity
Returns:
the new collection instance
See Also:
TreeMap, LinkedHashMap


Copyright © 2002-2008 The Spring Framework.