不要轻易相信按用按位运算符的速度高很多！

[wuxk]

今天做了一个测试，主要是交换两个变量的数值。
一个使用按位异或运算完成，另一个使用了一个临时变量，进行了n多次循环的交换，发现了用位运算符进行交换的性能远远不如用临时变量进行交换的。而且，程序的可读性几乎没有。
所以，我觉得在能不用位运算的时候，尽量不使用位运算为佳，尽管可能某些情况下会快一些，但增加了维护的时候的困难，而性能并不见得到了提高。
测试代码如下:
public class FirstDebug {

/*
* Construct for FirstDebug
*/
public FirstDebug(){

}
public static void main(String[] args){
long a=1;
long b=1;
long timeCount;
Calendar endC;
Calendar startC;

System.out.println("交换以下两数:");
System.out.println("a=" + a);
System.out.println("b=" + b);

System.out.println("第一批交换开始!");
startC = new GregorianCalendar();
for(long i=0;i<99999999;i++){
a = a ^ b;
b = a ^ b;
a = a ^ b;
}
endC = new GregorianCalendar();
timeCount = endC.getTimeInMillis() - startC.getTimeInMillis();
System.out.println("第二批交换运行完成,所花时间(毫秒):" + timeCount);

startC = new GregorianCalendar();
System.out.println("第二批交换开始!");
long c=0;
for(long i=0;i<99999999;i++){
c=a;
a=b;
b=c;
}
endC = new GregorianCalendar();
timeCount = endC.getTimeInMillis() -startC.getTimeInMillis();
System.out.println("第二批交换运行完成,所花时间(毫秒):" + timeCount);
}
}

运行结果如下：

交换以下两数:
a=1
b=1
第一批交换开始!
第二批交换运行完成,所花时间(毫秒):1500
第二批交换开始!
第二批交换运行完成,所花时间(毫秒):1375

[wuxk]

将倒数第三行的"第二批"改为"第一批"呵呵。

[xiaohaiz]

不要只在一个平台下实验就得出结论,先给你看看我在
P4 2.0G 256M Redhat Linux 9.0 下 jdk1.4.1_02 运行的结果:

第一次运行:
=====================================================
a=1
b=1
第一批交换开始!
第二批交换运行完成,所花时间(毫秒):1060
第二批交换开始!
第二批交换运行完成,所花时间(毫秒):1073

第二次运行:
=====================================================
交换以下两数:
a=1
b=1
第一批交换开始!
第二批交换运行完成,所花时间(毫秒):1101
第二批交换开始!
第二批交换运行完成,所花时间(毫秒):1170

第三次运行:
=====================================================
交换以下两数:
a=1
b=1
第一批交换开始!
第二批交换运行完成,所花时间(毫秒):1058
第二批交换开始!
第二批交换运行完成,所花时间(毫秒):1167

如果只是从你的测试来看,并不能够下此结论.

[xiaohaiz]

可能在各个平台上表现不一样,不过按照你的程序的算法理论上应该临时变量快.
为了分析这点,我改造了你的算法成为两个类C1和C2.
C1使用位运算进行交换,C2使用临时变量进行交换.
源码如下:
public class C1 {
public static void main(String[] args) {
long a = 1;
long b = 1;
a = a ^ b;
b = a ^ b;
a = a ^ b;
}
}
public class C2 {
public static void main(String[] args) {
long a = 1;
long b = 1;
long c = 0;
c = a;
a = b;
b = c;
}
}
编译成为class之后使用javap -c 反编译得到结果:
C1:
==============================
Method void main(java.lang.String[])
0 lconst_1
1 lstore_1
2 lconst_1
3 lstore_3 // 以上是a与b的赋值

4 lload_1 // 取出a的值
5 lload_3 // 取出b的值
6 lxor // 异或
7 lstore_1 // 存回a. 以上执行 a = a ^ b

8 lload_1 // 取出a的值
9 lload_3 // 取出b的值
10 lxor // 异或
11 lstore_3 // 存回b. 以上执行 b=a^b

12 lload_1 // 取a
13 lload_3 // 取b
14 lxor // 异或
15 lstore_1 // 存回a. 以上执行a=a^b

16 return

C2:
==============================
Method void main(java.lang.String[])
0 lconst_1
1 lstore_1
2 lconst_1
3 lstore_3 // a, b初始化

4 lconst_0
5 lstore 5 // c,初始化

7 lload_1 // 取a
8 lstore 5 // 存c

10 lload_3 // 取b
11 lstore_1 // 存a

12 lload 5 // 取c
14 lstore_3 // 存b

15 return

C1每一个循环需要12条指令, 而C2每一个循环只需要6条指令.
所以我觉得C2的效率会更高.

但是在我的机器上执行的结果确实是C1<C2. 无法解释,是否与平台相关?

[wuxk]

对，可能和平台有关系，据说在windows下编译出来的代码在LINUX上运行就比在Linux下编译的代码要快一点，这也是别人测试的。
在各种平台下的表现不一致，我觉得这可能算是Java不够成熟的体现吧。

我的机器是p4 1.7G,512M内存的，效率比你的可就低多了呵呵,看样子瓶颈在CPU上了。

不过两种算法这么微小的差别，使用异或进行交换可能只在内存容量比较小的机器上使用比较适合吧。否则考虑到程序的可读性等等,还是用临时变量交换要好一些吧。