/
MyType.java
117 lines (87 loc) · 4.04 KB
/
MyType.java
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
package io.github.ciscorucinski.hashcodeandequal;
import java.util.Arrays;
@SuppressWarnings("unused")
public class MyType {
private boolean booleanField;
private byte byteField;
private char charField;
private short shortField;
private int intField;
private long longField;
private float floatField;
private double doubleField;
private int[] arrayField;
private Object[] objArrayField;
private String referenceField;
private Object nullableReferenceField;
MyType(boolean _bool, byte _byte, char _char, short _short, int _int, long _long, float _float,
double _double, int[] _array, Object[] _objArray, String _string, Object _object) {
booleanField = _bool;
byteField = _byte;
charField = _char;
shortField = _short;
intField = _int;
longField = _long;
floatField = _float;
doubleField = _double;
arrayField = _array;
objArrayField = _objArray;
referenceField = _string;
nullableReferenceField = _object;
}
@Override
public int hashCode() {
// Start with a non-zero constant. Prime is preferred
int result = 17;
// Include a hash for each field.
// Primitives
result = 31 * result + (booleanField ? 1 : 0); // 1 bit » 32-bit
result = 31 * result + byteField; // 8 bits » 32-bit
result = 31 * result + charField; // 16 bits » 32-bit
result = 31 * result + shortField; // 16 bits » 32-bit
result = 31 * result + intField; // 32 bits » 32-bit
result = 31 * result + (int) (longField ^ (longField >>> 32)); // 64 bits » 32-bit
result = 31 * result + Float.floatToIntBits(floatField); // 32 bits » 32-bit
long doubleFieldBits = Double.doubleToLongBits(doubleField); // 64 bits (double) » 64-bit (long) » 32-bit (int)
result = 31 * result + (int) (doubleFieldBits ^ (doubleFieldBits >>> 32));
// Arrays
result = 31 * result + Arrays.hashCode(arrayField); // var bits » 32-bit
result = 31 * result + Arrays.hashCode(objArrayField); // var bits » 32-bit (nullable & non-nullable)
// Objects
result = 31 * result + referenceField.hashCode(); // var bits » 32-bit (non-nullable)
result = 31 * result + // var bits » 32-bit (nullable)
(nullableReferenceField == null
? 0
: nullableReferenceField.hashCode());
return result;
}
@Override
public boolean equals(Object o) {
// Optimization (not required).
if (this == o) {
return true;
}
// Return false if the other object has the wrong type, interface, or is null.
if (!(o instanceof MyType)) {
return false;
}
MyType lhs = (MyType) o; // lhs means "left hand side"
// Primitive fields
return this.booleanField == lhs.booleanField
&& this.byteField == lhs.byteField
&& this.charField == lhs.charField
&& this.shortField == lhs.shortField
&& this.intField == lhs.intField
&& this.longField == lhs.longField
&& this.floatField == lhs.floatField
&& this.doubleField == lhs.doubleField
// Arrays
&& Arrays.equals(this.arrayField, lhs.arrayField)
&& Arrays.equals(this.objArrayField, lhs.objArrayField)
// Objects
&& this.referenceField.equals(lhs.referenceField)
&& (this.nullableReferenceField == null
? lhs.nullableReferenceField == null
: this.nullableReferenceField.equals(lhs.nullableReferenceField));
}
}