Google have a nice equals method to make boiler plate equals easier to read. Particularly good if you have many attributes in the method. http://publicobject.com/2007/09/coding-in-small-with-google-collections_8175.html
Be careful to check that your objects are consistent with equals though. I have mentioned this before.
Continue reading
But the devil is in the detail so here it is anyway.
I have this multi threaded application. One of the problems with integration testing it is, you can’t guarantee the order that messages will be written to a stream. So during the test I have to go to some trouble to split and order the lines written out. If I don’t do this the test fails sometimes. It depends on which thread writes first. The output though is correct, order is not important. Not exactly rocket science.
Here is the method I was using to massage the string.
public List<String> getSortedLines(String expectedString) {
String[] splitExpectedResultLines = expectedString.toString().split("\n");
List<String> resultLines = new ArrayList<String>();
for (String messageLine : resultLines) {
resultLines.add(messageLine);
}
Collections.sort(resultLines);
return resultLines;
}
There is nothing particularly wrong with the method. It takes a string, splits it into lines, loads a List, sorts and returns it. Thus when its used in an assertion later the expected and actual lists are the same.
With google collections its just three lines! The HashMultiset is designed to be used in equals methods. Its equal even if the order of the elements in collections being compared is different. From the API documentation: An extension of Collection that may contain duplicate values like a List, yet has order-independent equality like a Set. One typical use for a multiset is to represent a histogram.
Its possible to use the HashMultiSet.create static factory method, passing in an Iterable. i.e a Collection. So from the original code, both the loop and the Collections.sort are no longer required.
public HashMultiset<String> getOrderAgnosticCollection(String expectedString) {
String[] splitExpectedResultLines = expectedString.toString().split("\n");
Iterable<String> resultLines = Arrays.asList(splitExpectedResultLines);
HashMultiset<String> orderAgnosticResultLines =
HashMultiset.create(resultLines);
return orderAgnosticResultLines;
}
If there was something that performed the split, but returned an Iterable the method would be perfect! 
All good java programmers know the equals and hashcode methods are vitally important. I have seen some unpredictable behavior through bugs in these two methods.
If your about to click away to something more interesting fine, but first read my page with an example equals bug. See if you can spot the problem before I show the solution.
Writing a test for equals is so easy its tedious. Which is perhaps why so much code gets written and not tested. First from the javadoc what are the specifications for a good equals and hashcode implementations?
Its no revelation that Eclipse, Netbeans and others can generate code. Its particularly useful if getters, setters or constructors are required. Implementing an interface is very simple indeed as these IDE will stub out the interface methods. More complex methods though require some thought. Generation of the equals method is such a case.
How to write a good equals method is well documented by Joshua Bloch in Effective Java, Chapter 3 by Joshua Bloch.
Before we get deeper into the code here are two efforts at generating the equals method for this class:
public class SimpleBean {
private final BigDecimal bigDecimal;
public SimpleBean(BigDecimal bigDecimal) {
this.bigDecimal = bigDecimal;
}
}