FilesExpand file tree

 master

/

Mcd.java

Copy path

Blame

More file actions

Blame

More file actions

Latest commit

 

History

History

History

131 lines (114 loc) · 4.7 KB

 master

/

Mcd.java

Copy path

Top

File metadata and controls

• Code
• Blame

131 lines (114 loc) · 4.7 KB

Raw

Copy raw file

Download raw file

Open symbols panel

Edit and raw actions

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

118

119

120

121

122

123

124

125

126

127

128

129

130

131

package com.equals;

/**

* Object默认的实现方式 : return this == obj。只有this和 obj引用同一个对象，才会返回true。

* 如果用equals来判断 2个对象是否等价，就要重写equals.

* 按照约定，equals要满足以下规则:

* （1）自反性：x.equals(x)必须返回true。

* （2）对称性：x.equals(y)与y.equals(x)的返回值必须相等。

* （3）传递性：x.equals(y)为true，y.equals(z)也为true，那么x.equals(z)必须为true。

* （4）一致性：如果对象x和y在equals()中使用的信息都没有改变，那么x.equals(y)值始终不变。

* （5）非null：x不是null，y为null，则x.equals(y)必须为false。

* @ClassName: Mcd

* @Description:

* @author ken

* @date 2018年3月15日 下午5:02:24

*/

public class Mcd {

private String id;

private String lonId;

private String unit;

private String side;

private String partsName;

private String feederType;

private String machine;

/**

* 通过前面的描述我们知道，重写hashCode需要遵守以下原则：

* （1）如果重写了equals()方法，检查条件“两个对象使用equals()方法判断为相等，则hashCode()方法也应该相等”是否成立，如果不成立，则重写hashCode()方法。

* （2）hashCode()方法不能太过简单，否则哈希冲突过多。

* （3）hashCode()方法不能太过复杂，否则计算复杂度过高，影响性能.

*

* 关于hashCode()计算过程中，为什么使用了数字31，主要有以下原因：

* 1、使用质数计算哈希码，由于质数的特性，它与其他数字相乘之后，计算结果唯一的概率更大，哈希冲突的概率更小。

* 2、使用的质数越大，哈希冲突的概率越小，但是计算的速度也越慢；31是哈希冲突和性能的折中，实际上是实验观测的结果。

* 3、JVM会自动对31进行优化：31 * i == (i << 5) – i

*

* 《Effective Java》中提出了一种简单通用的hashCode算法

* A、初始化一个整形变量，为此变量赋予一个非零的常数值，比如int hash = 17;

* B、选取equals方法中用于比较的所有域（之所以只选择equals()中使用的域，是为了保证上述原则的第1条），然后针对每个域的属性进行计算：

* (1) 如果是boolean值，则计算f ? 1:0

* (2) 如果是byte\char\short\int,则计算(int)f

* (3) 如果是long值，则计算(int)(f ^ (f >>> 32))

* (4) 如果是float值，则计算Float.floatToIntBits(f)

* (5) 如果是double值，则计算Double.doubleToLongBits(f)，然后返回的结果是long,再用规则(3)去处理long,得到int

* (6) 如果是对象应用，如果equals方法中采取递归调用的比较方式，那么hashCode中同样采取递归调用hashCode的方式。

* 否则需要为这个域计算一个范式，比如当这个域的值为null的时候，那么hashCode 值为0.

* (7) 如果是数组，那么需要为每个元素当做单独的域来处理。java.util.Arrays.hashCode方法包含了8种基本类型数组和引用数组的hashCode计算，算法同上。

*/

@Override

public int hashCode() {

int hash = 17;

hash = hash * 31 + (unit == null ? 0 : unit.hashCode());

hash = hash * 31 + (side == null ? 0 : side.hashCode());

hash = hash * 31 + (partsName == null ? 0 : partsName.hashCode());

return hash;

}

@Override

public boolean equals(Object obj) {

if (this == obj)

return true;

if (obj == null)

return false;

if (getClass() != obj.getClass())

return false;

if (obj instanceof Mcd) {

Mcd mcd = (Mcd) obj;

boolean bUnit = unit != null && unit.equals(mcd.unit);

boolean bSide = side != null && side.equals(mcd.side);

boolean bparts = partsName != null && partsName.equals(mcd.partsName);

return bparts && bUnit && bSide;

}

return false;

}

public String getId() {

return id;

}

public void setId(String id) {

this.id = id;

}

public String getLonId() {

return lonId;

}

public void setLonId(String lonId) {

this.lonId = lonId;

}

public String getUnit() {

return unit;

}

public void setUnit(String unit) {

this.unit = unit;

}

public String getSide() {

return side;

}

public void setSide(String side) {

this.side = side;

}

public String getPartsName() {

return partsName;

}

public void setPartsName(String partsName) {

this.partsName = partsName;

}

public String getFeederType() {

return feederType;

}

public void setFeederType(String feederType) {

this.feederType = feederType;

}

public String getMachine() {

return machine;

}

public void setMachine(String machine) {

this.machine = machine;

}

}