public HashCodeBuilder() 
{
                        
        iConstant = 37;
        iTotal = 17;
}

Uses two hard coded choices for the constants needed to build a hashCode.

 public HashCodeBuilder(int initialNonZeroOddNumber,
    int multiplierNonZeroOddNumber) 
{
        if (initialNonZeroOddNumber == 0) {
            throw new IllegalArgumentException("HashCodeBuilder requires a non zero initial value");
        }
        if (initialNonZeroOddNumber % 2 == 0) {
            throw new IllegalArgumentException("HashCodeBuilder requires an odd initial value");
        }
        if (multiplierNonZeroOddNumber == 0) {
            throw new IllegalArgumentException("HashCodeBuilder requires a non zero multiplier");
        }
        if (multiplierNonZeroOddNumber % 2 == 0) {
            throw new IllegalArgumentException("HashCodeBuilder requires an odd multiplier");
        }
        iConstant = multiplierNonZeroOddNumber;
        iTotal = initialNonZeroOddNumber;
}

Two randomly chosen, non-zero, odd numbers must be passed in. Ideally these should be different for each class, however this is not vital.

Prime numbers are preferred, especially for the multiplier.

Parameters:

initialNonZeroOddNumber - a non-zero, odd number used as the initial value

multiplierNonZeroOddNumber - a non-zero, odd number used as the multiplier

Throws:

IllegalArgumentException - if the number is zero or even

 public HashCodeBuilder append(boolean value) 
{
        iTotal = iTotal * iConstant + (value ? 0 : 1);
        return this;
}

Append a hashCode for a boolean.

This adds iConstant * 1 to the hashCode and not a 1231 or 1237 as done in java.lang.Boolean. This is in accordance with the Effective Java design.

 public HashCodeBuilder append(boolean[] array) 
{
        if (array == null) {
            iTotal = iTotal * iConstant;
        } else {
            for (int i = 0; i <  array.length; i++) {
                append(array[i]);
            }
        }
        return this;
}

Append a hashCode for a boolean array.

 public HashCodeBuilder append(byte value) 
{
        iTotal = iTotal * iConstant + value;
        return this;
}

Append a hashCode for a byte.

 public HashCodeBuilder append(byte[] array) 
{
        if (array == null) {
            iTotal = iTotal * iConstant;
        } else {
            for (int i = 0; i <  array.length; i++) {
                append(array[i]);
            }
        }
        return this;
}

Append a hashCode for a byte array.

 public HashCodeBuilder append(char value) 
{
        iTotal = iTotal * iConstant + value;
        return this;
}

Append a hashCode for a char.

 public HashCodeBuilder append(char[] array) 
{
        if (array == null) {
            iTotal = iTotal * iConstant;
        } else {
            for (int i = 0; i <  array.length; i++) {
                append(array[i]);
            }
        }
        return this;
}

Append a hashCode for a char array.

 public HashCodeBuilder append(double value) 
{
        return append(Double.doubleToLongBits(value));
}

Append a hashCode for a double.

 public HashCodeBuilder append(double[] array) 
{
        if (array == null) {
            iTotal = iTotal * iConstant;
        } else {
            for (int i = 0; i <  array.length; i++) {
                append(array[i]);
            }
        }
        return this;
}

Append a hashCode for a double array.

 public HashCodeBuilder append(float value) 
{
        iTotal = iTotal * iConstant + Float.floatToIntBits(value);
        return this;
}

Append a hashCode for a float.

 public HashCodeBuilder append(float[] array) 
{
        if (array == null) {
            iTotal = iTotal * iConstant;
        } else {
            for (int i = 0; i <  array.length; i++) {
                append(array[i]);
            }
        }
        return this;
}

Append a hashCode for a float array.

 public HashCodeBuilder append(int value) 
{
        iTotal = iTotal * iConstant + value;
        return this;
}

Append a hashCode for an int.

 public HashCodeBuilder append(int[] array) 
{
        if (array == null) {
            iTotal = iTotal * iConstant;
        } else {
            for (int i = 0; i <  array.length; i++) {
                append(array[i]);
            }
        }
        return this;
}

Append a hashCode for an int array.

 public HashCodeBuilder append(long value) 
{
        iTotal = iTotal * iConstant + ((int) (value ^ (value  > > 32)));
        return this;
}

Append a hashCode for a long.

 public HashCodeBuilder append(long[] array) 
{
        if (array == null) {
            iTotal = iTotal * iConstant;
        } else {
            for (int i = 0; i <  array.length; i++) {
                append(array[i]);
            }
        }
        return this;
}

Append a hashCode for a long array.

 public HashCodeBuilder append(Object object) 
{
        if (object == null) {
            iTotal = iTotal * iConstant;
        } else {
                // 'Switch' on type of array, to dispatch to the correct handler
                // This handles multi dimensional arrays
                if (object instanceof long[]) {
                    append((long[]) object);
                } else if (object instanceof int[]) {
                    append((int[]) object);
                } else if (object instanceof short[]) {
                    append((short[]) object);
                } else if (object instanceof char[]) {
                    append((char[]) object);
                } else if (object instanceof byte[]) {
                    append((byte[]) object);
                } else if (object instanceof double[]) {
                    append((double[]) object);
                } else if (object instanceof float[]) {
                    append((float[]) object);
                } else if (object instanceof boolean[]) {
                    append((boolean[]) object);
                } else if (object instanceof Object[]) {
                    // Not an array of primitives
                    append((Object[]) object);
                } else {
                    iTotal = iTotal * iConstant + object.hashCode();
                }
        }
        return this;
}

Append a hashCode for an Object.

 public HashCodeBuilder append(Object[] array) 
{
        if (array == null) {
            iTotal = iTotal * iConstant;
        } else {
            for (int i = 0; i <  array.length; i++) {
                append(array[i]);
            }
        }
        return this;
}

Append a hashCode for an Object array.

 public HashCodeBuilder append(short value) 
{
        iTotal = iTotal * iConstant + value;
        return this;
}

Append a hashCode for a short.

 public HashCodeBuilder append(short[] array) 
{
        if (array == null) {
            iTotal = iTotal * iConstant;
        } else {
            for (int i = 0; i <  array.length; i++) {
                append(array[i]);
            }
        }
        return this;
}

Append a hashCode for a short array.

 public HashCodeBuilder appendSuper(int superHashCode) 
{
        iTotal = iTotal * iConstant + superHashCode;
        return this;
}

Adds the result of super.hashCode() to this builder.

 static Set getRegistry() 
{
                                     
        return (Set) registry.get();
}

Returns the registry of objects being traversed by the reflection methods in the current thread.

 static boolean isRegistered(Object value) 
{
        return getRegistry().contains(toIdentityHashCodeInteger(value));
}

Returns true if the registry contains the given object. Used by the reflection methods to avoid infinite loops.

 public static int reflectionHashCode(Object object) 
{
        return reflectionHashCode(17, 37, object, false, null, null);
}

This method uses reflection to build a valid hash code.

This constructor uses two hard coded choices for the constants needed to build a hash code.

It uses AccessibleObject.setAccessible to gain access to private fields. This means that it will throw a security exception if run under a security manager, if the permissions are not set up correctly. It is also not as efficient as testing explicitly.

Transient members will be not be used, as they are likely derived fields, and not part of the value of the Object.

Static fields will not be tested. Superclass fields will be included.

 public static int reflectionHashCode(Object object,
    boolean testTransients) 
{
        return reflectionHashCode(17, 37, object, testTransients, null, null);
}

This method uses reflection to build a valid hash code.

This constructor uses two hard coded choices for the constants needed to build a hash code.

It uses AccessibleObject.setAccessible to gain access to private fields. This means that it will throw a security exception if run under a security manager, if the permissions are not set up correctly. It is also not as efficient as testing explicitly.

If the TestTransients parameter is set to true, transient members will be tested, otherwise they are ignored, as they are likely derived fields, and not part of the value of the Object.

Static fields will not be tested. Superclass fields will be included.

 public static int reflectionHashCode(Object object,
    Collection excludeFields) 
{
        return reflectionHashCode(object, ReflectionToStringBuilder.toNoNullStringArray(excludeFields));
}

This method uses reflection to build a valid hash code.

This constructor uses two hard coded choices for the constants needed to build a hash code.

It uses AccessibleObject.setAccessible to gain access to private fields. This means that it will throw a security exception if run under a security manager, if the permissions are not set up correctly. It is also not as efficient as testing explicitly.

Transient members will be not be used, as they are likely derived fields, and not part of the value of the Object.

Static fields will not be tested. Superclass fields will be included.

 public static int reflectionHashCode(Object object,
    String[] excludeFields) 
{
        return reflectionHashCode(17, 37, object, false, null, excludeFields);
}

This method uses reflection to build a valid hash code.

This constructor uses two hard coded choices for the constants needed to build a hash code.

It uses AccessibleObject.setAccessible to gain access to private fields. This means that it will throw a security exception if run under a security manager, if the permissions are not set up correctly. It is also not as efficient as testing explicitly.

Transient members will be not be used, as they are likely derived fields, and not part of the value of the Object.

Static fields will not be tested. Superclass fields will be included.

 public static int reflectionHashCode(int initialNonZeroOddNumber,
    int multiplierNonZeroOddNumber,
    Object object) 
{
        return reflectionHashCode(initialNonZeroOddNumber, multiplierNonZeroOddNumber, object, false, null, null);
}

This method uses reflection to build a valid hash code.

It uses AccessibleObject.setAccessible to gain access to private fields. This means that it will throw a security exception if run under a security manager, if the permissions are not set up correctly. It is also not as efficient as testing explicitly.

Transient members will be not be used, as they are likely derived fields, and not part of the value of the Object.

Static fields will not be tested. Superclass fields will be included.

Two randomly chosen, non-zero, odd numbers must be passed in. Ideally these should be different for each class, however this is not vital. Prime numbers are preferred, especially for the multiplier.

 public static int reflectionHashCode(int initialNonZeroOddNumber,
    int multiplierNonZeroOddNumber,
    Object object,
    boolean testTransients) 
{
        return reflectionHashCode(initialNonZeroOddNumber, multiplierNonZeroOddNumber, object, testTransients, null,
                null);
}

This method uses reflection to build a valid hash code.

It uses AccessibleObject.setAccessible to gain access to private fields. This means that it will throw a security exception if run under a security manager, if the permissions are not set up correctly. It is also not as efficient as testing explicitly.

If the TestTransients parameter is set to true, transient members will be tested, otherwise they are ignored, as they are likely derived fields, and not part of the value of the Object.

Static fields will not be tested. Superclass fields will be included.

Two randomly chosen, non-zero, odd numbers must be passed in. Ideally these should be different for each class, however this is not vital. Prime numbers are preferred, especially for the multiplier.

 public static int reflectionHashCode(int initialNonZeroOddNumber,
    int multiplierNonZeroOddNumber,
    Object object,
    boolean testTransients,
    Class reflectUpToClass) 
{
        return reflectionHashCode(initialNonZeroOddNumber, multiplierNonZeroOddNumber, object, testTransients,
                reflectUpToClass, null);
}

Calls #reflectionHashCode(int, int, Object, boolean, Class, String[]) with excludeFields set to null.

 public static int reflectionHashCode(int initialNonZeroOddNumber,
    int multiplierNonZeroOddNumber,
    Object object,
    boolean testTransients,
    Class reflectUpToClass,
    String[] excludeFields) 
{
        if (object == null) {
            throw new IllegalArgumentException("The object to build a hash code for must not be null");
        }
        HashCodeBuilder builder = new HashCodeBuilder(initialNonZeroOddNumber, multiplierNonZeroOddNumber);
        Class clazz = object.getClass();
        reflectionAppend(object, clazz, builder, testTransients, excludeFields);
        while (clazz.getSuperclass() != null && clazz != reflectUpToClass) {
            clazz = clazz.getSuperclass();
            reflectionAppend(object, clazz, builder, testTransients, excludeFields);
        }
        return builder.toHashCode();
}

This method uses reflection to build a valid hash code.

It uses AccessibleObject.setAccessible to gain access to private fields. This means that it will throw a security exception if run under a security manager, if the permissions are not set up correctly. It is also not as efficient as testing explicitly.

If the TestTransients parameter is set to true, transient members will be tested, otherwise they are ignored, as they are likely derived fields, and not part of the value of the Object.

Static fields will not be included. Superclass fields will be included up to and including the specified superclass. A null superclass is treated as java.lang.Object.

Two randomly chosen, non-zero, odd numbers must be passed in. Ideally these should be different for each class, however this is not vital. Prime numbers are preferred, especially for the multiplier.

 static  void register(Object value) 
{
        getRegistry().add(toIdentityHashCodeInteger(value));
}

Registers the given object. Used by the reflection methods to avoid infinite loops.

 public int toHashCode() 
{
        return iTotal;
}

Return the computed hashCode.

 static  void unregister(Object value) 
{
        getRegistry().remove(toIdentityHashCodeInteger(value));
}

Unregisters the given object.

Used by the reflection methods to avoid infinite loops.