JavaBeans Comparison

Question

Does anyone know about a free open source library (utility class) which allows you to compare two instances of one Java bean and return a list/array of properties which values are different in those two instances? Please post a small sample.

Cheers
Tomas

Answer 1

BeanComparator can be used for collection sorting.
It is a Comparator implementation that compares beans based on a shared property value.

BeanComparators are generic comparators that can act upon any Java Bean. With a good underlying bean reflection system, they can handle a bean with bean properties, arrays, collections, and maps.

If we have a java.util.List of Java Beans of type Person —- where Person has an age that's an Integer, a name that's a String, and a country that's a Country bean (which itself has a String name) —- we can sort it anyway we want with a BeanComparator.

Some examples:

List people = ...; // list of Person objects

//sort by age
BeanComparator comp = new BeanComparator("age");
Collections.sort(list, comp);

//sort by name
BeanComparator comp = new BeanComparator("name");
Collections.sort(list, comp);

//sort by country name
BeanComparator comp = new BeanComparator("country.name");
Collections.sort(list, comp);

There is no need to write a PersonComparator with lots of property options to sort by . Instead, a single BeanComparator class takes care of it all.

---

You will find a full example here, with the following scenario:

If you were implementing a comparator to compare properties dynamically (e.g., think of sorting rows in a table on a Web page based on which column the customer selects), then you could put off building your comparator until you knew which property had been selected for sorting.

This is where BeanComparator really shines. The massive amounts of code you'd normally write to implement this behavior are reduced to a few lines when you use BeanComparator.

Answer 2

BeanComparator of Apache commons is what you are looking for.

Update. A simple example that compares JavaBeans with one property (comparation is made agains only one property, you should create as many BeanComparators as properties you want to match).

import org.apache.commons.beanutils.BeanComparator;

public class TestBeanComparator
{
    public TestBeanComparator()
    {
    }

    public class TestBean
    {
        int value;

        public TestBean()
        {
        }

        public int getValue()
        {
            return value;
        }

        public void setValue(int value)
        {
            this.value = value;
        }
    }

    public static void main(String[] args)
    {
        TestBeanComparator tbc = new TestBeanComparator();

        tbc.go();
    }

    public void go()
    {
        TestBean tbs [] = new TestBean[10];

        for (int i = 0; i < tbs.length; i++)
        {
            tbs[i] = new TestBeanComparator.TestBean();
            tbs[i].setValue((int) (Math.random() * 10));

            System.out.println("TestBean["+i+"] = " + tbs[i].getValue());
        }

        BeanComparator bc = new BeanComparator("value");

        System.out.println("");
        System.out.println("Value to match: " + tbs[0].getValue());
        for (int i = 1; i < tbs.length; i++)
        {
            if(bc.compare(tbs[i], tbs[0]) == 0)
            {
               System.out.println("Match found in bean "+ i); 
            }
        }
    }
}

After some tests one result is successful. This is the output:

TestBean[0] = 0
TestBean[1] = 4
TestBean[2] = 0
TestBean[3] = 2
TestBean[4] = 7
TestBean[5] = 3
TestBean[6] = 0
TestBean[7] = 3
TestBean[8] = 7
TestBean[9] = 3

Value to match: 0
Match found in bean 2
Match found in bean 6

Obviously increasing TestBean array size will increase the chances to get matches.

You need to import to your project the following jars: commons-logging-version.jar, commons-beanutils-version.jar, commons-beanutils-core-version.jar, commons-beanutils-bean-collections-version.jar, commons-collections-version.jar.

The files are included inside commons-logging, commons-beanutils and commons-collections APIs.