Go语言视频零基础入门到精通

javalearner

1. 
   
2. 1. 概述
   
3. 在java中，参数传递是通过传值（对于对象类型，传递的是引用的拷贝），所以常规的交换实现不了两个对象的交换，下面是测试代码：
   
4. 
   
5. Java代码  
   
6. import org.apache.commons.beanutils.BeanUtils;   
   
7.   
   
8. public class Employee {   
   
9.     // Properties   
   
10.     private int id;   
    
11.     private String name;   
    
12.       
    
13.     // Constructors   
    
14.     public Employee() {   
    
15.     }   
    
16.       
    
17.     public Employee(int id, String name) {   
    
18.         this.id = id;   
    
19.         this.name = name;   
    
20.     }   
    
21.       
    
22.     // get、set methods   
    
23.     public int getId() {   
    
24.         return id;   
    
25.     }   
    
26.   
    
27.     public void setId(int id) {   
    
28.         this.id = id;   
    
29.     }   
    
30.   
    
31.     public String getName() {   
    
32.         return name;   
    
33.     }   
    
34.   
    
35.     public void setName(String name) {   
    
36.         this.name = name;   
    
37.     }   
    
38.       
    
39.     // 无效的交换   
    
40.     public static void swap(Employee x, Employee y) {   
    
41.         Employee temp = x;   
    
42.         x = y;   
    
43.         y = temp;   
    
44.     }   
    
45.       
    
46.     // 使用 BeanUtils 方法的有效交换   
    
47.     public static void swapByBeanUtils(Employee x, Employee y) {   
    
48.         try {   
    
49.             // clone x to temp   
    
50.             Employee temp = (Employee)BeanUtils.cloneBean(x);   
    
51.             // copyProperties from y to x   
    
52.             BeanUtils.copyProperties(x, y);   
    
53.             // copyProperties from temp to y   
    
54.             BeanUtils.copyProperties(y, temp);   
    
55.             // then, the Properties values of x,y has been swaped.   
    
56.         } catch (Exception e) {   
    
57.             e.printStackTrace();   
    
58.         }   
    
59.     }   
    
60.       
    
61.     // 有人提出使用交换数组等集合里的元素 来实现交换，这样也是无效的   
    
62.     public static void swapByArray(Object[] a, int i, int j) {   
    
63.         Object t = a[i];   
    
64.         a[i] = a[j];   
    
65.         a[j] = t;   
    
66.     }   
    
67.       
    
68.     public static void main(String[] args) {   
    
69.         Employee a = new Employee(1, "Bob");   
    
70.         Employee b = new Employee(2, "Jack");   
    
71.            
    
72.         // 直接方法调用交换 -- NO   
    
73. //      swap(a, b);   
    
74.            
    
75.         // 利用BeanUtils交换 -- YES   
    
76. //      swapByBeanUtils(a, b);   
    
77.            
    
78.         // 利用 交换数据 思想 -- NO   
    
79. //      Object[] o = {a, b};   
    
80. //      swapByArray(o, 0, 1);   
    
81.            
    
82.         // 直接交换 -- YES   
    
83. //      Employee temp = a;   
    
84. //      a = b;   
    
85. //      b = temp;   
    
86.            
    
87.         System.out.println(a);   
    
88.         System.out.println(b);         
    
89.     }   
    
90.       
    
91.     // method for print   
    
92.     public String toString() {   
    
93.         StringBuilder sb = new StringBuilder();   
    
94.         sb.append("id: ").append(id).append(" name: ").append(name);   
    
95.         return sb.toString();   
    
96.     }   
    
97. }  
    
98. import org.apache.commons.beanutils.BeanUtils;
    
99. public class Employee {
    
100.         // Properties
     
101.         private int id;
     
102.         private String name;
     
103.        
     
104.         // Constructors
     
105.         public Employee() {
     
106.         }
     
107.        
     
108.         public Employee(int id, String name) {
     
109.                 this.id = id;
     
110.                 this.name = name;
     
111.         }
     
112.        
     
113.         // get、set methods
     
114.         public int getId() {
     
115.                 return id;
     
116.         }
     
117.         public void setId(int id) {
     
118.                 this.id = id;
     
119.         }
     
120.         public String getName() {
     
121.                 return name;
     
122.         }
     
123.         public void setName(String name) {
     
124.                 this.name = name;
     
125.         }
     
126.        
     
127.         // 无效的交换
     
128.         public static void swap(Employee x, Employee y) {
     
129.                 Employee temp = x;
     
130.                 x = y;
     
131.                 y = temp;
     
132.         }
     
133.        
     
134.         // 使用 BeanUtils 方法的有效交换
     
135.         public static void swapByBeanUtils(Employee x, Employee y) {
     
136.                 try {
     
137.                         // clone x to temp
     
138.                         Employee temp = (Employee)BeanUtils.cloneBean(x);
     
139.                         // copyProperties from y to x
     
140.                         BeanUtils.copyProperties(x, y);
     
141.                         // copyProperties from temp to y
     
142.                         BeanUtils.copyProperties(y, temp);
     
143.                         // then, the Properties values of x,y has been swaped.
     
144.                 } catch (Exception e) {
     
145.                         e.printStackTrace();
     
146.                 }
     
147.         }
     
148.        
     
149.         // 有人提出使用交换数组等集合里的元素 来实现交换，这样也是无效的
     
150.         public static void swapByArray(Object[] a, int i, int j) {
     
151.             Object t = a[i];
     
152.             a[i] = a[j];
     
153.             a[j] = t;
     
154.         }
     
155.        
     
156.         public static void main(String[] args) {
     
157.                 Employee a = new Employee(1, "Bob");
     
158.                 Employee b = new Employee(2, "Jack");
     
159.                
     
160.                 // 直接方法调用交换 -- NO
     
161. //                swap(a, b);
     
162.                
     
163.                 // 利用BeanUtils交换 -- YES
     
164. //                swapByBeanUtils(a, b);
     
165.                
     
166.                 // 利用 交换数据 思想 -- NO
     
167. //                Object[] o = {a, b};
     
168. //                swapByArray(o, 0, 1);
     
169.                
     
170.                 // 直接交换 -- YES
     
171. //                Employee temp = a;
     
172. //                a = b;
     
173. //                b = temp;
     
174.                
     
175.                 System.out.println(a);
     
176.                 System.out.println(b);               
     
177.         }
     
178.        
     
179.         // method for print
     
180.         public String toString() {
     
181.                 StringBuilder sb = new StringBuilder();
     
182.                 sb.append("id: ").append(id).append(" name: ").append(name);
     
183.                 return sb.toString();
     
184.         }
     
185. }
     
186. 2. 结论
     
187. 在java中，对象引用是通过值来传递的，方法不能修改参数指向新的对象。
     
188. 
     
189. 注：需加载 BeanUtils包
     

复制代码