1 /**
2 * Object通用方法:equals()、hashCode()、toString()、clone()
3 */
4 @Data
5 @NoArgsConstructor
6 @AllArgsConstructor
7 public class objectMethodExample {
8
9 private int x;
10 private int y;
11 private int z;
12
13 @Override
14 public boolean equals(Object o){
15 if (this == o) return true;
16 if (o == null || getClass()!= o.getClass()) return false;
17 objectMethodExample objectMethodExample = (objectMethodExample) o;
18
19 if (x!=objectMethodExample.x) return false;
20 if (y!=objectMethodExample.y) return false;
21 return z == objectMethodExample.z;
22 }
23
24 @Override
25 public int hashCode(){
26 int result = 17;
27 result = 31 * result + x;
28 result = 31 * result + y;
29 result = 31 * result + z;
30 return result;
31 }
32
33 /** equals
34 * 对于基本类型，==判断两个值是否相等，基本类型没有equals()方法
35 * 对于引用类型，==判断两个变量是否引用同一个对象，而equals()判断引用的对象是否等价
36 */
37 public void m1_equals(){
38 Integer x = new Integer(1);
39 Integer y = new Integer(1);
40 System.out.println(x.equals(y)); // true
41 System.out.println(x == y); // false
42
43 }
44
45 /** hashCode
46 * 等价的两个对象hashCode一定相等，hashCode相等的两个对象不一定等价
47 * 覆盖 equals() 方法时应当总是覆盖 hashCode() 方法，保证等价的两个对象散列值也相等
48 */
49 public void m2(){
50 objectMethodExample o1 = new objectMethodExample(1,2,3);
51 objectMethodExample o2 = new objectMethodExample(1,2,3);
52 System.out.println(o1.equals(o2)); // true
53
54 HashSet<objectMethodExample> set = new HashSet<>();
55 set.add(o1);
56 set.add(o2);
57 // 重写hashCode后这两个等价的对象被当作是一样的
58 System.out.println(set.size());
59
60 }
61
62 public static void main(String[] args) {
63 objectMethodExample objectMethodExample = new objectMethodExample();
64 objectMethodExample.m2();
65
66 }
67
68 }
69
70 /** Object-clone。clone是Object的一个protected方法
71 * Cloneable接口规定：如果一个类没有实现Cloneable又调用了clone()方法就会抛出CloneNotSupportedException
72 */
73 class cloneExample implements Cloneable{
74
75 @Override
76 protected Object clone() throws CloneNotSupportedException {
77 return super.clone();
78 }
79
80 public static void main(String[] args) throws CloneNotSupportedException {
81 cloneExample cloneExample = new cloneExample();
82 cloneExample c2 = (cloneExample) cloneExample.clone();
83 }
84
85 }
86
87 /** Object-clone，浅拷贝、深拷贝
88 */
89 class shallowCloneExample implements Cloneable{
90 private int[] arr;
91
92 public void set(int index,int value){
93 arr[index] = value;
94 }
95
96 public int get(int index){
97 return arr[index];
98 }
99
100 // 浅拷贝：拷贝对象和原始对象的引用类型引用同一个对象
101 // @Override
102 // public shallowCloneExample clone() throws CloneNotSupportedException {
103 // return (shallowCloneExample) super.clone();
104 // }
105
106 // 深拷贝：拷贝对象和原始对象的引用类型引用不同对象
107 @Override
108 public shallowCloneExample clone() throws CloneNotSupportedException {
109 shallowCloneExample result = (shallowCloneExample) super.clone();
110 // 新建一个arr用来拷贝原始arr的数据
111 result.arr = new int[arr.length];
112 System.arraycopy(arr, 0, result.arr, 0, arr.length);
113 return result;
114 }
115
116 public shallowCloneExample(){
117 arr = new int[10];
118 for (int i=0;i<arr.length;i++){
119 arr[i] = i;
120 }
121 }
122
123 public static void main(String[] args) {
124 shallowCloneExample s1 = new shallowCloneExample();
125 shallowCloneExample s2 = new shallowCloneExample();
126 try {
127 s2 = s1.clone();
128 } catch (CloneNotSupportedException e) {
129 e.printStackTrace();
130 }
131 s1.set(2,222);
132 System.out.println(s2.get(2));
133 }
134
135 }
136
137 /** Object-clone
138 * 使用clone()拷贝一个对象既复杂又有风险，会抛出异常，最好不要使用clone()，可以使用拷贝构造函数或拷贝工厂
139 */
140 class cloneConstructExample{
141 private int[] arr;
142
143 public void set(int index,int value){
144 arr[index] = value;
145 }
146
147 public int get(int index){
148 return arr[index];
149 }
150
151 public cloneConstructExample(){
152 arr = new int[10];
153 for (int i=0;i<arr.length;i++){
154 arr[i] = i;
155 }
156 }
157
158 // 拷贝构造函数
159 public cloneConstructExample(cloneConstructExample source){
160 arr = new int[source.arr.length];
161 System.arraycopy(arr,0,source.arr,0,source.arr.length);
162 }
163
164 public static void main(String[] args) {
165 cloneConstructExample c1 = new cloneConstructExample();
166 cloneConstructExample c2 = new cloneConstructExample();
167 c1.set(2,222);
168 System.out.println(c2.get(2));
169 }
170
171 }
