Java 交换两数的方法

错误示范

1. 直接交换

public class SwapNumbers  {

	// 直接交换
	public static void swap(int a, int b) {
		int temp = a;
		a = b;
		b = temp;
	};

	public static void main(String[] args) {
		int a = 10;
		int b = 20;
		System.out.println("交换前： a = " + a + "； b = " + b);
		swap(a, b);
		System.out.println("交换后： a = " + a + "； b = " + b);
	}
}

输出结果：

交换前： a = 10； b = 20
交换后： a = 10； b = 20

2. 包装类交换

public class SwapNumbers {

	// 包装类交换
	public static void swap(Integer a, Integer b) {
		Integer temp = a;
		a = b;
		b = temp;
	};

	public static void main(String[] args) {
		Integer a = new Integer(10);
		Integer b = new Integer(20);
		System.out.println("交换前： a = " + a + "； b = " + b);
		swap(a, b);
		System.out.println("交换后： a = " + a + "； b = " + b);
	}
}

输出结果：

交换前： a = 10； b = 20
交换后： a = 10； b = 20

正确示范

1. 数组交换

public class SwapNumbers {

	// 数组交换
	public static void swap(int[] arr) {
		int temp = arr[0];
		arr[0] = arr[1];
		arr[1] = temp;
	};

	public static void main(String[] args) {
		int[] arr = { 10, 20 };
		System.out.println("交换前： a = " + arr[0] + "； b = " + arr[1]);
		swap(arr);
		System.out.println("交换后： a = " + arr[0] + "； b = " + arr[1]);
	}
}

输出结果：

交换前： a = 10； b = 20
交换后： a = 20； b = 10

2. 成员变量交换

public class SwapNumbers {
	public int a;
	public int b;

	// 成员对象交换
	public void swap(int a, int b) {
		this.a = b;
		this.b = a;
	};

	public static void main(String[] args) {
		SwapNumbers sn = new SwapNumbers();
		int a = sn.a = 10;
		int b = sn.b = 20;
		System.out.println("交换前： a = " + sn.a + " b=" + sn.b);
		sn.swap(a, b);
		System.out.println("交换前： a = " + sn.a + " b=" + sn.b);
	}
}

输出结果：

交换前： a = 10； b = 20
交换后： a = 20； b = 10

交换两个数的方法

1. 通过临时变量存放交换

public class SwapNumbers {

	public static void swap(int[] arr) {
		int temp = arr[0];
		arr[0] = arr[1];
		arr[1] = temp;
	};

	public static void main(String[] args) {
		int[] arr = { 10, 20 };
		System.out.println("交换前： a = " + arr[0] + "； b = " + arr[1]);
		swap(arr);
		System.out.println("交换后： a = " + arr[0] + "； b = " + arr[1]);
	}
}

输出结果：

交换前： a = 10； b = 20
交换后： a = 20； b = 10

2. 通过加减计算交换

public class SwapNumbers {

	public static void swap(int[] arr) {
		arr[0] = arr[0] + arr[1];  
		arr[1] = arr[0] - arr[1];  
		arr[0] = arr[0] - arr[1]; 
	};

	public static void main(String[] args) {
		int[] arr = { 10, 20 };
		System.out.println("交换前： a = " + arr[0] + "； b = " + arr[1]);
		swap(arr);
		System.out.println("交换后： a = " + arr[0] + "； b = " + arr[1]);
	}
}

输出结果：

交换前： a = 10； b = 20
交换后： a = 20； b = 10

3. 通过异或运算交换

public class SwapNumbers {

	public static void swap(int[] arr) {
		arr[0] = arr[0] ^ arr[1];  
		arr[1] = arr[0] ^ arr[1];  
		arr[0] = arr[0] ^ arr[1]; 
	};

	public static void main(String[] args) {
		int[] arr = { 10, 20 };
		System.out.println("交换前： a = " + arr[0] + "； b = " + arr[1]);
		swap(arr);
		System.out.println("交换后： a = " + arr[0] + "； b = " + arr[1]);
	}
}

输出结果：

交换前： a = 10； b = 20
交换后： a = 20； b = 10

通过异或运算交换的原理

按位异或运算是指两个相应的二进制相同时结果为0，否则为1。

a ^ b ^ b 、 (a^b)b 和 a^(bb) 结果是相同的。

主要的原理是：

（1）一个变量按位异或自己的结果为0，即：a ^ a = 0；

（2）一个变量按位异或0的结果为自己，即：a ^ 0 = a；

a = a ^ b; 		// 语句1

b = a ^ b; 		// 语句2

a = a ^ b;		// 语句3

于是，在上面的三条语句中，

语句1可以看做把变量a、b保存到a的存储空间中（当然这只是一种理解方式）；

语句2消去了b（原理1），于是剩下了a（原理2），赋值到b的存储空间，此刻，b变量已经得到了a的值；

语句3中，原本a变量存储空间内已经同时保存了a、b，此刻，b已经变成了a，所以两个按位异或后，便消去了a（原理1），只剩下了b（原理2），将它赋值给a，

至此，交换变量的过程结束。

总结

方式一是最常见的，可读性高，但是需要在内存中存放临时变量，但是对于现在来说，需要的内存空间很小，而且存放临时变量的内存很快就会释放，不存在问题。

方式二有缺陷，当两个数相加之后，可能其结果超出了变量类型能表达的最大范围，这个时候结果就会出问题，不推荐使用

方式三效率是最高的，但是可读性不是很好。

在程序中尽可能的使用方式一，提高程序的可读性。但是需要了解方式三，以及方式三的原理。