Use CollectionUtils.transform()
. Supply a Collection
and a Transformer
to this method, and
this utility will pass each element in the Collection
to that Transformer
, returning a new Collection
containing the results of each
transformation. The following example demonstrates the use of transform( )
with a custom Transformer
object:
import java.util.*; import org.apache.commons.collections.Transformer; import org.apache.commons.collections.CollectionUtils; import org.apache.commons.lang.ArrayUtils; import org.apache.commons.lang.StringUtils; // Create a transformer that reverses strings. Transformer reversingTransformer = new Transformer( ) { public Object transform(Object object) { String string = (String) object; return StringUtils.reverse( string ); } } String[] array = new String[] { "Aznar", "Blair", "Chirac", "Putin", "Bush" }; List stringList = Arrays.asList( ArrayUtils.clone( array ) ); // Transform each element with a Transformer CollectionUtils.transform( stringList, reversingTransformer ); System.out.println( "Original: " + ArrayUtils.toString( array ) ); System.out.println( "Transformed: " + ArrayUtils.toString( stringList.toArray( ) ) );
This example creates a List
of
strings, transforming each element with a Transformer
that produces reversed strings.
The List
is transformed in-place,
which means that the contents of the List
are replaced with the output from the
transform( )
method of the Transformer
. As expected, the transformed
List
contains reversed
strings:
Original: Aznar, Blair, Chirac, Putin, Bush Transformed: ranzA, rialB, carihC, nituP, hsuB
CollectionUtils.transform( )
does not only apply to Lists
; any
object implementing the Collection
interface can be used with this utility.
Transformer
s are another form
of functor that transforms one object into another, leaving the original
object unchanged. Transformer
is a
very straightforward interface, simply requiring the presence of a
transform( )
method. The Transformer
interface, like Predicate
, is augmented by a number of useful
built-in implementations, which can combine the effects of multiple
transformers. One of these Transformer
implementations is the ChainedTransformer
, which allows you to create
a linear pipeline of transformations. The following example demonstrates
the use of a ChainedTransformer
to
transform the contents of a Collection
:
import java.util.*; import org.apache.commons.collections.Transformer; import org.apache.commons.collections.finctors.ChainedTransformer; import org.apache.commons.collections.CollectionUtils; import org.apache.commons.lang.ArrayUtils; import org.apache.commons.lang.StringUtils; // Create a transformer that multiplies a number by 10 Transformer multiplyTransform = new Transformer( ) { public Object transform(Object object) { Integer integer = (Integer) object; return new Integer( integer.intValue( ) * 10 ); } } // Create a transformer that subtracts 20 from a number Transformer subtractTransform = new Transformer( ) { public Object transform(Object object) { Integer integer = (Integer) object; return new Integer( integer.intValue( ) - 20 ); } } // Chain the transformers together Transformer transformChain = new ChainedTransformer( new Transformer[] { multiplyTransform, subtractTransform } ); // Create a List of Integer objects int[] array = new int[] { 1, 2, 3, 4, 5, 6, 7, 8 }; List intList = Arrays.asList( ArrayUtils.toObject( array ) ); CollectionUtils.transform( intList, transformChain ); System.out.println( "Original: " + ArrayUtils.toString( array ) ); System.out.println( "Transformed: " + ArrayUtils.toString( intList.toArray( ) ) );
Two transformers, multiplyTransform
and subtractTransform
, are defined as anonymous
inner classes, which implement the Transformer
interface. These two Transformer
s are combined in a ChainedTransformer
. An array of int
primitives is converted to an array of
Integer
objects using ArrayUtils.toObject( )
. This object array is
then converted to a List
, which is
transformed using CollectionUtils.transform(
)
. The transformation multiples each element by 10 and
subtracts 20, producing the following output:
Original: 1, 2, 3, 4, 5, 6, 7, 8 Transformed: -10, 0, 10, 20, 30, 40, 50, 60
In addition to the ChainedTransformer
, there are a number of other
useful Transformer
implementations
that ship with Commons Collections. The ChainedTransformer
and other Transformer
implementations are discussed in
depth in Chapter 4. For more information
about the various implementations of Transformer
, see the Commons Collections
project (http://commons.apache.org/collections).