## org.springframework.core
Class CollectionFactory

    java.lang.Object
      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.