java之交换两个变量

转载自：http://blog.csdn.net/ylyg050518/article/details/48005077

在Java中大致有如下四种方法可以用于变量的交换。

1.中间变量法

方法大致结构如下：

int a,b,temp;

a=10,b=20;

temp=a;

b=temp;

a=b;

当然这种方法不仅限于整形变量，任意类型都是可以的，这是日常开发中经常用的交换变量值的方法，也是推荐使用的方法，在没有其他特定要求的情况下，这种方法最易于理解。

2.算数运算法

int a,b;
a=10;b=20;
a=b-a; //a=10;b=20
b=b-a; //a=10;b=10
a=b+a; //a=20;b=10
它的原理是：把a、b看做数轴上的点，围绕两点间的距离来进行计算。
具体过程：第一句“a=b-a”求出ab两点的距离，并且将其保存在a中；第二句“b=b-a”求出a到原点的距离（b到原点的距离与ab两点距离之差），并且将其保存在b中；第三句“a=b+a”求出b到原点的距离（a到原点距离与ab两点距离之和），并且将其保存在a中。完成交换。
此算法与标准算法相比，多了三个计算的过程，但是没有借助临时变量。

缺点：是只能用于数字类型，字符串之类的就不可以了。a+b有可能溢出(超出int的范围)，溢出是相对的， +了溢出了，-回来不就好了，所以溢出不溢出没关系，就是不安全。

3.位运算

int a=10,b=12; //a=1010^b=1100;
a=a^b; //a=0110^b=1100;
b=a^b; //a=0110^b=1010;
a=a^b; //a=1100=12;b=1010;
此算法能够实现是由异或运算的特点决定的，通过异或运算能够使数据中的某些位翻转，其他位不变。这就意味着任意一个数与任意一个给定的值连续异或两次，值不变。

 

4.栈实现

Integer a=10,b=20;
Stack<Integer> s=new Stack<Integer>();
s.push(a);//进栈
s.push(b);//进栈
a=s.peek();//取得栈顶元素
s.pop();//弹出栈顶元素
b=s.peek();//再次获取栈顶元素
此方法的缺点在于程序运行开销相比其他方式较大，仅仅是为了交换变量值需要在内存中维护一个栈结构，有点得不偿失，所以这种方法很少使用。
以下给出这四种方法的代码测试

[java]  view plain  copy

1. import java.util.Stack;  
2.   
3. public class Main {  
4.     /** 
5.      * Java中交换交换两个整形变量的方法 
6.      */  
7.   
8.     public static void main(String[] args) {  
9.         swap1();  
10.         swap2();  
11.         swap3();  
12.         swap4();  
13.     }  
14.   
15.     public static void swap1() {  
16.         int a = 10, b = 20;  
17.         // 方法1（中间临时变量法）  
18.         int temp;  
19.         temp = a;  
20.         a = b;  
21.         b = temp;  
22.         System.out.println("方法1交换后" + a + "," + b);  
23.     }  
24.   
25.     public static void swap2() {  
26.         int a = 10, b = 20;  
27.         // 方法2（做差法）  
28.         a = b - a;  
29.         b = b - a;  
30.         a = b + a;  
31.         System.out.println("方法2交换后" + a + "," + b);  
32.   
33.     }  
34.   
35.     public static void swap3() {  
36.         // 方法3（异或位运算）  
37.         int a = 10, b = 20;  
38.         a = a ^ b;  
39.         b = a ^ b;  
40.         a = a ^ b;  
41.         System.out.println("方法3交换后" + a + "," + b);  
42.   
43.     }  
44.   
45.     public static void swap4() {  
46.         // 方法4 （数据结构栈实现）  
47.         Integer a = 10, b = 20;  
48.         Stack<Integer> s = new Stack<Integer>();// 注意是int基本类型的包装类Integer  
49.         // 进栈  
50.         s.push(a);  
51.         s.push(b);  
52.         // 查看栈顶元素  
53.         a = s.peek();  
54.         // 弹出栈顶元素  
55.         s.pop();  
56.         b = s.peek();  
57.         // 清空栈  
58.         s.clear();  
59.         System.out.println("方法4交换后:" + a + "," + b);  
60.     }  
61.   
62. }  

运行结果：
方法1交换后20,10
方法2交换后20,10
方法3交换后20,10
方法4交换后:20,10