# Class ConstantTransformer<T,R>

java.lang.Object
org.apache.commons.collections4.functors.ConstantTransformer<T,R>

Type Parameters:
  `T` - the type of the input to the function.
  `R` - the type of the result of the function.

All Implemented Interfaces:
  `Serializable`, `Function<T,R>`, `Transformer<T,R>`

public class ConstantTransformer<T,R> extends Object implements Transformer<T,R>, Serializable
Transformer implementation that returns the same constant each time.

No check is made that the object is immutable. In general, only immutable objects should use the constant factory. Mutable objects should use the prototype factory.

Since:
  3.0
See Also:
  - Serialized Form

- ## Field Summary

  Fields
  Modifier and Type
  Field
  Description
  `static final Transformer`
  `NULL_INSTANCE`
  Returns null each time

- ## Constructor Summary

  Constructors
  Constructor
  Description
  `ConstantTransformer(R constantToReturn)`
  Constructor that performs no validation.

- ## Method Summary

  Modifier and Type
  Method
  Description
  `static <I, O> Transformer<I,O>`
  `constantTransformer(O constantToReturn)`
  Transformer method that performs validation.
  `boolean`
  `equals(Object obj)`
  `R`
  `getConstant()`
  Gets the constant.
  `int`
  `hashCode()`
  `static <I, O> Transformer<I,O>`
  `nullTransformer()`
  Gets a typed null instance.
  `R`
  `transform(T input)`
  Transforms the input by ignoring it and returning the stored constant instead.

  ### Methods inherited from class java.lang.Object

  `clone, finalize, getClass, notify, notifyAll, toString, wait, wait, wait`

  ### Methods inherited from interface java.util.function.Function

  `andThen, compose`

  ### Methods inherited from interface org.apache.commons.collections4.Transformer

  `apply`

- ## Field Details

  - ### NULL_INSTANCE

    public static final Transformer NULL_INSTANCE
    Returns null each time

- ## Constructor Details

  - ### ConstantTransformer

    public ConstantTransformer(R constantToReturn)
    Constructor that performs no validation. Use `constantTransformer` if you want that.
    Parameters:
      `constantToReturn` - the constant to return each time

- ## Method Details

  - ### constantTransformer

    public static <I, O> Transformer<I,O> constantTransformer(O constantToReturn)
    Transformer method that performs validation.
    Type Parameters:
      `I` - the input type
      `O` - the output type
    Parameters:
      `constantToReturn` - the constant object to return each time in the factory
    Returns:
      the `constant` factory.

  - ### nullTransformer

    public static <I, O> Transformer<I,O> nullTransformer()
    Gets a typed null instance.
    Type Parameters:
      `I` - the input type
      `O` - the output type
    Returns:
      Transformer<I, O> that always returns null.

  - ### equals

    public boolean equals(Object obj)
    Overrides:
      `equals` in class `Object`

  - ### getConstant

    public R getConstant()
    Gets the constant.
    Returns:
      the constant
    Since:
      3.1

  - ### hashCode

    public int hashCode()
    Overrides:
      `hashCode` in class `Object`

  - ### transform

    public R transform(T input)
    Transforms the input by ignoring it and returning the stored constant instead.
    Specified by:
      `transform` in interface `Transformer<T,R>`
    Parameters:
      `input` - the input object which is ignored
    Returns:
      the stored constant