org.apache.commons.beanutils

## Class BeanComparator<T>

- java.lang.Object
- - org.apache.commons.beanutils.BeanComparator<T>

- Type Parameters:
    `T` - the type of beans to be compared by this `Comparator`
  All Implemented Interfaces:
    Serializable, Comparator<T>

      public class BeanComparator<T>
      extends Object
      implements Comparator<T>, Serializable

  This comparator compares two beans by the specified bean property. It is also possible to compare beans based on nested, indexed, combined, mapped bean properties. Please see the `PropertyUtilsBean` documentation for all property name possibilities.

  Note: The BeanComparator passes the values of the specified bean property to a ComparableComparator, if no comparator is specified in the constructor. If you are comparing two beans based on a property that could contain "null" values, a suitable `Comparator` or `ComparatorChain` should be supplied in the constructor. Note that the passed in `Comparator` must be able to handle the passed in objects. Because the type of the property to be compared is not known at compile time no type checks can be performed by the compiler. Thus `ClassCastException` exceptions can be thrown if unexpected property values occur.

  Version:
    $Id: BeanComparator.java 1632171 2014-10-15 20:15:17Z ggregory $
  See Also:
    Serialized Form

- - ### Constructor Summary

    Constructors
    Constructor and Description
    `BeanComparator()` Constructs a Bean Comparator without a property set.
    `BeanComparator(String property)` Constructs a property-based comparator for beans.
    `BeanComparator(String property, Comparator<?> comparator)` Constructs a property-based comparator for beans.

  - ### Method Summary

    All Methods Instance Methods Concrete Methods
    Modifier and Type | Method and Description
    --- | ---
    `int` | `compare(T o1, T o2)` Compare two JavaBeans by their shared property.
    `boolean` | `equals(Object o)` Two `BeanComparator`'s are equals if and only if the wrapped comparators and the property names to be compared are equal.
    `Comparator<?>` | `getComparator()` Gets the Comparator being used to compare beans.
    `String` | `getProperty()` Gets the property attribute of the BeanComparator
    `int` | `hashCode()` Hashcode compatible with equals.
    `void` | `setProperty(String property)` Sets the method to be called to compare two JavaBeans

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

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

    - ### Methods inherited from interface java.util.Comparator

      `comparing, comparing, comparingDouble, comparingInt, comparingLong, naturalOrder, nullsFirst, nullsLast, reversed, reverseOrder, thenComparing, thenComparing, thenComparing, thenComparingDouble, thenComparingInt, thenComparingLong`

- - ### Constructor Detail

    - #### BeanComparator

          public BeanComparator()

      Constructs a Bean Comparator without a property set.

      Note that this is intended to be used only in bean-centric environments.

      Until `setProperty(java.lang.String)` is called with a non-null value. this comparator will compare the Objects only.

    - #### BeanComparator

          public BeanComparator(String property)

      Constructs a property-based comparator for beans. This compares two beans by the property specified in the property parameter. This constructor creates a `BeanComparator` that uses a `ComparableComparator` to compare the property values.

      Passing "null" to this constructor will cause the BeanComparator to compare objects based on natural order, that is `java.lang.Comparable`.

      Parameters:
        `property` - String Name of a bean property, which may contain the name of a simple, nested, indexed, mapped, or combined property. See `PropertyUtilsBean` for property query language syntax. If the property passed in is null then the actual objects will be compared

    - #### BeanComparator

          public BeanComparator(String property,
                                Comparator<?> comparator)

      Constructs a property-based comparator for beans. This constructor creates a BeanComparator that uses the supplied Comparator to compare the property values.
      Parameters:
        `property` - Name of a bean property, can contain the name of a simple, nested, indexed, mapped, or combined property. See `PropertyUtilsBean` for property query language syntax.
        `comparator` - BeanComparator will pass the values of the specified bean property to this Comparator. If your bean property is not a comparable or contains null values, a suitable comparator may be supplied in this constructor.

  - ### Method Detail

    - #### setProperty

          public void setProperty(String property)

      Sets the method to be called to compare two JavaBeans
      Parameters:
        `property` - String method name to call to compare If the property passed in is null then the actual objects will be compared

    - #### getProperty

          public String getProperty()

      Gets the property attribute of the BeanComparator
      Returns:
        String method name to call to compare. A null value indicates that the actual objects will be compared

    - #### getComparator

          public Comparator<?> getComparator()

      Gets the Comparator being used to compare beans.
      Returns:
        the Comparator being used to compare beans

    - #### compare

          public int compare(T o1,
                             T o2)

      Compare two JavaBeans by their shared property. If `getProperty()` is null then the actual objects will be compared.
      Specified by:
        `compare` in interface `Comparator<T>`
      Parameters:
        `o1` - Object The first bean to get data from to compare against
        `o2` - Object The second bean to get data from to compare
      Returns:
        int negative or positive based on order

    - #### equals

          public boolean equals(Object o)

      Two `BeanComparator`'s are equals if and only if the wrapped comparators and the property names to be compared are equal.
      Specified by:
        `equals` in interface `Comparator<T>`
      Overrides:
        `equals` in class `Object`
      Parameters:
        `o` - Comparator to compare to
      Returns:
        whether the the comparators are equal or not

    - #### hashCode

          public int hashCode()

      Hashcode compatible with equals.
      Overrides:
        `hashCode` in class `Object`
      Returns:
        the hash code for this comparator

Copyright © 2000–2016 The Apache Software Foundation. All rights reserved.