public class EqualsBuilder extends Object
Assists in implementing Object.equals(Object) methods.
This class provides methods to build a good equals method for any
class. It follows rules laid out in
Effective Java
, by Joshua Bloch. In particular the rule for comparing doubles,
floats, and arrays can be tricky. Also, making sure that
equals() and hashCode() are consistent can be
difficult.
Two Objects that compare as equals must generate the same hash code, but two Objects with the same hash code do not have to be equal.
All relevant fields should be included in the calculation of equals. Derived fields may be ignored. In particular, any field used in generating a hash code must be used in the equals method, and vice versa.
Typical use for the code is as follows:
public boolean equals(Object obj) {
if (obj == null) { return false; }
if (obj == this) { return true; }
if (obj.getClass() != getClass()) {
return false;
}
MyClass rhs = (MyClass) obj;
return new EqualsBuilder()
.appendSuper(super.equals(obj))
.append(field1, rhs.field1)
.append(field2, rhs.field2)
.append(field3, rhs.field3)
.isEquals();
}
Alternatively, there is a method that uses reflection to determine
the fields to test. Because these fields are usually private, the method,
reflectionEquals, uses AccessibleObject.setAccessible to
change the visibility of the fields. This will fail under a security
manager, unless the appropriate permissions are set up correctly. It is
also slower than testing explicitly.
A typical invocation for this method would look like:
public boolean equals(Object obj) {
return EqualsBuilder.reflectionEquals(this, obj);
}
| Constructor and Description |
|---|
EqualsBuilder()
Constructor for EqualsBuilder.
|
| Modifier and Type | Method and Description |
|---|---|
EqualsBuilder |
append(boolean[] lhs,
boolean[] rhs)
Deep comparison of array of
boolean. |
EqualsBuilder |
append(boolean lhs,
boolean rhs)
Test if two
booleanss are equal. |
EqualsBuilder |
append(byte[] lhs,
byte[] rhs)
Deep comparison of array of
byte. |
EqualsBuilder |
append(byte lhs,
byte rhs)
Test if two
bytes are equal. |
EqualsBuilder |
append(char[] lhs,
char[] rhs)
Deep comparison of array of
char. |
EqualsBuilder |
append(char lhs,
char rhs)
Test if two
chars are equal. |
EqualsBuilder |
append(double[] lhs,
double[] rhs)
Deep comparison of array of
double. |
EqualsBuilder |
append(double lhs,
double rhs)
Test if two
doubles are equal by testing that the
pattern of bits returned by doubleToLong are equal. |
EqualsBuilder |
append(float[] lhs,
float[] rhs)
Deep comparison of array of
float. |
EqualsBuilder |
append(float lhs,
float rhs)
Test if two
floats are equal byt testing that the
pattern of bits returned by doubleToLong are equal. |
EqualsBuilder |
append(int[] lhs,
int[] rhs)
Deep comparison of array of
int. |
EqualsBuilder |
append(int lhs,
int rhs)
Test if two
ints are equal. |
EqualsBuilder |
append(List<?> lhs,
List<?> rhs) |
EqualsBuilder |
append(long[] lhs,
long[] rhs)
Deep comparison of array of
long. |
EqualsBuilder |
append(long lhs,
long rhs)
Test if two
long s are equal. |
EqualsBuilder |
append(Object[] lhs,
Object[] rhs)
Performs a deep comparison of two
Object arrays. |
EqualsBuilder |
append(Object lhs,
Object rhs)
Test if two
Objects are equal using their
equals method. |
EqualsBuilder |
append(short[] lhs,
short[] rhs)
Deep comparison of array of
short. |
EqualsBuilder |
append(short lhs,
short rhs)
Test if two
shorts are equal. |
EqualsBuilder |
appendSuper(boolean superEquals)
Adds the result of
super.equals() to this builder. |
boolean |
isEquals()
Returns
true if the fields that have been checked
are all equal. |
void |
reset()
Reset the EqualsBuilder so you can use the same object again
|
protected void |
setEquals(boolean isEquals)
Sets the
isEquals value. |
public EqualsBuilder()
Constructor for EqualsBuilder.
Starts off assuming that equals is true.
Object.equals(Object)public EqualsBuilder appendSuper(boolean superEquals)
Adds the result of super.equals() to this builder.
superEquals - the result of calling super.equals()public EqualsBuilder append(List<?> lhs, List<?> rhs)
public EqualsBuilder append(Object lhs, Object rhs)
Test if two Objects are equal using their
equals method.
lhs - the left hand objectrhs - the right hand objectpublic EqualsBuilder append(long lhs, long rhs)
Test if two long s are equal.
lhs - the left hand longrhs - the right hand longpublic EqualsBuilder append(int lhs, int rhs)
Test if two ints are equal.
lhs - the left hand intrhs - the right hand intpublic EqualsBuilder append(short lhs, short rhs)
Test if two shorts are equal.
lhs - the left hand shortrhs - the right hand shortpublic EqualsBuilder append(char lhs, char rhs)
Test if two chars are equal.
lhs - the left hand charrhs - the right hand charpublic EqualsBuilder append(byte lhs, byte rhs)
Test if two bytes are equal.
lhs - the left hand byterhs - the right hand bytepublic EqualsBuilder append(double lhs, double rhs)
Test if two doubles are equal by testing that the
pattern of bits returned by doubleToLong are equal.
This handles NaNs, Infinities, and -0.0.
It is compatible with the hash code generated by
HashCodeBuilder.
lhs - the left hand doublerhs - the right hand doublepublic EqualsBuilder append(float lhs, float rhs)
Test if two floats are equal byt testing that the
pattern of bits returned by doubleToLong are equal.
This handles NaNs, Infinities, and -0.0.
It is compatible with the hash code generated by
HashCodeBuilder.
lhs - the left hand floatrhs - the right hand floatpublic EqualsBuilder append(boolean lhs, boolean rhs)
Test if two booleanss are equal.
lhs - the left hand booleanrhs - the right hand booleanpublic EqualsBuilder append(Object[] lhs, Object[] rhs)
Performs a deep comparison of two Object arrays.
This also will be called for the top level of multi-dimensional, ragged, and multi-typed arrays.
lhs - the left hand Object[]rhs - the right hand Object[]public EqualsBuilder append(long[] lhs, long[] rhs)
Deep comparison of array of long. Length and all
values are compared.
The method append(long, long) is used.
lhs - the left hand long[]rhs - the right hand long[]public EqualsBuilder append(int[] lhs, int[] rhs)
Deep comparison of array of int. Length and all
values are compared.
The method append(int, int) is used.
lhs - the left hand int[]rhs - the right hand int[]public EqualsBuilder append(short[] lhs, short[] rhs)
Deep comparison of array of short. Length and all
values are compared.
The method append(short, short) is used.
lhs - the left hand short[]rhs - the right hand short[]public EqualsBuilder append(char[] lhs, char[] rhs)
Deep comparison of array of char. Length and all
values are compared.
The method append(char, char) is used.
lhs - the left hand char[]rhs - the right hand char[]public EqualsBuilder append(byte[] lhs, byte[] rhs)
Deep comparison of array of byte. Length and all
values are compared.
The method append(byte, byte) is used.
lhs - the left hand byte[]rhs - the right hand byte[]public EqualsBuilder append(double[] lhs, double[] rhs)
Deep comparison of array of double. Length and all
values are compared.
The method append(double, double) is used.
lhs - the left hand double[]rhs - the right hand double[]public EqualsBuilder append(float[] lhs, float[] rhs)
Deep comparison of array of float. Length and all
values are compared.
The method append(float, float) is used.
lhs - the left hand float[]rhs - the right hand float[]public EqualsBuilder append(boolean[] lhs, boolean[] rhs)
Deep comparison of array of boolean. Length and all
values are compared.
The method append(boolean, boolean) is used.
lhs - the left hand boolean[]rhs - the right hand boolean[]public boolean isEquals()
Returns true if the fields that have been checked
are all equal.
protected void setEquals(boolean isEquals)
isEquals value.isEquals - The value to set.public void reset()