Java中的位运算骚操作，异或交换它真的比中间量temp交换快吗？

这里直接给出要最终结论：
temp交换更快，异或交换稍慢；
异或交换花费时间较temp交换大概多出1/15。

什么是异或交换？

异或交换就是使用 位运算符 ^ 进行两整数数值的交换

什么是异或？就是两个数的二进制形式进行按位异或运算
规则是位值不同得到1，位值相同得到0

运算规则1：按位比较，不同得1，相同得0

如：要进行该运算： 0000 1111(b) ^ 1111 0000(b)
过程：

所以：0000 1111(b) ^ 1111 0000(b) = 1111 1111(b)

那么如何使用异或进行交换呢？我们这里还有一个关于异或的重点！
那就是自己和自己异或 等于 0 ！

运算规则2：自己和自己异或结果为0

如：和自己异或：1010 1010(b) ^ 1010 1010(b)
过程：

因为每个位都是相同的啊，所以结果就都是0

运算规则3：任何数和0异或都是它本身

如：1110 0101(b) ^ 0000 0000(b)
过程:

所以：1110 0101(b) ^ 0000 0000(b) = 1110 0101(b)
运算结果还是自己啊！

利用规则2和规则3就可以实现两数交换！

让我们来看一下这段代码

public static void swapBit(int[] arr,int a,int b) {
        arr[a] = arr[a]^arr[b];
        arr[b] = arr[a]^arr[b];
        arr[a] = arr[a]^arr[b];
    }

在这段代码中，居然连续异或就能交换数组arr中的两个值？
我们来分析一下：

这就是异或的灵活运用，但是还需要注意的是 a 和 b 不能是同一个对象或者数值，为什么呢？
因为a 和 b如果相同，那么在第一次操作后就是0了，直接改变了数值！这是很严重的问题，所以我们需要在程序上做一点改变

public static void swapBit(int[] arr,int a,int b) {
		//必须是不同的对象
        if (a == b) {
            return;
        }
        arr[a] = arr[a]^arr[b];
        arr[b] = arr[a]^arr[b];
        arr[a] = arr[a]^arr[b];
    }

异或交换这么骚，那它到底快不快？

通常的交换方式：中间变量temp法

public static void swapTemp(int[] arr,int a,int b ) {
        int temp = arr[a];
        arr[a] = arr[b];
        arr[b] = temp;
    }

两者性能比较，temp优胜

由于异或涉及计算机底层的汇编语言，然而在现代计算机中，使用异或的汇编会比直接赋值多出几句寄存器指令
所以在性能上temp的更快！
异或交换的唯一优势是节省内存空间，不用为中间引用开辟内存！

那么temp具体有多快？

我们使用常见的交换排序算法冒泡排序测试两者的具体差异

异或交换：

public class ConcreteStrategy0 extends Strategy{
    @Override
    public void operate(int[] arr) {
        //一共排n-1个最大的到后面,剩一个最小的在第一个，所以第一层循环只要n-1次就行 arr.length-1
        //冒泡排序，较大的移到第n-i-1位置
        for (int i = 0; i < arr.length-1; i++) {
            for (int j = 0; j < arr.length-1-i; j++) {
                if (arr[j] > arr[j + 1]) {
                    Swap.swapBit(arr,j,j+1);
                }
            }
        }
    }
}

temp交换：

public class ConcreteStrategy2 extends Strategy{
    @Override
    public void operate(int[] arr) {
        //一共排n-1个最大的到后面,剩一个最小的在第一个，所以第一层循环只要n-1次就行 arr.length-1
        //冒泡排序，较大的移到第n-i-1位置
        for (int i = 0; i < arr.length-1; i++) {
            for (int j = 0; j < arr.length-1-i; j++) {
                if (arr[j] > arr[j + 1]) {
                    Swap.swapTemp(arr,j,j+1);//temp交换
                }
            }
        }
    }
}

public class Test01 {
    public static void main(String[] args) {
        long start, end;
        final int LIMIT = 100000;
        //生成一个乱序的10万长度数组
        int[] arr1 = new int[LIMIT];
        for (int i = 0; i < LIMIT; i++) {
            arr1[i] = -LIMIT + (int) (Math.random() * LIMIT); //随机值为【-10万,10万】
        }

        int[] arr2 = new int[LIMIT];
        System.arraycopy(arr1, 0, arr2, 0, LIMIT);

        //2个算法策略
        Strategy strategy0 = new ConcreteStrategy0();
        Strategy strategy2 = new ConcreteStrategy2();

        //封装策略容器
        Context context1 = new Context(strategy0);
        Context context2 = new Context(strategy2);

        //使用策略0看看————异或交换冒泡排序
        start = System.currentTimeMillis();
        context1.executeStrategy(arr1);
        end = System.currentTimeMillis();
        System.out.println("策略0异或交换冒泡排序花费时间是:" + (end - start) + "ms");

        //使用策略2看看————temp交换冒泡排序
        start = System.currentTimeMillis();
        context2.executeStrategy(arr2);
        end = System.currentTimeMillis();
        System.out.println("策略2temp冒泡排序花费时间是:" + (end - start) + "ms");
    }
}

结果已经很清楚了，十万长度的数组交换排序，temp交换的速度较快，异或交换的时间多了1/15
这在大数据量的情况下的很恐怖的！

所以在现代计算机中，我们推荐使用temp交换！