异或的运算法则
　a⊕b = （¬a ∧ b） ∨ （a ∧¬b）

如果a、b两个值不相同，则异或结果为1。

如果a、b两个值相同，异或结果为0。
按位异或的3个特点：
（1） 0异或任何数= 任何数
（2） 1异或任何数 = 任何数取反
（3） 任何数异或自己=把自己置0、
按位异或的常见用途：
实现两个值的交换，而不必使用临时变量
例如：交换两个整数 a=10100001，b=00000110的值，可通过下列语句实现：
a = a^b； 　　//a=10100111
b = b^a； 　　//b=10100001
a = a^b； 　　//a=00000110
快速判断两个值是否相等
a ^ b == 0

文章摘要：
1、按位异或，可以简单理解成：不进位加法。即：1+1=0；0+0=0；1+0 =1；
2、任何数和自己异或结果为零。
3、按位异或自反性。两次运算操作，可以将最后的结果还原。
4、任何数和0做异或值不变，和1异或结果为原操作数取反。
5、交换律。不使用中间变量，交换两个数。
一、按位异或具有自反性。即：对同一个数据，进行两次按位异或操作，等于数据本身。
int displayOptions = 0x1100;
int flag = 0x1001;
int result = displayOptions ^ flag;
System.out.println(Integer.toHexString(displayOptions)
+ " ^ " + Integer.toHexString(flag)
+ " = " + Integer.toHexString(result));
//第一次运算：1100 ^ 1001 = 0101
result = result ^ flag;
System.out.println(Integer.toHexString(displayOptions)
+ " ^ " + Integer.toHexString(flag)
+ " = " + Integer.toHexString(result));
// 第二次运算：0101 ^ 1001 = 1100(displayOptions)
//我们还可以直接使用如下的代码直接进行测试：
System.out.println(Integer.toHexString(displayOptions ^ flag ^ flag));
二、应用案例
场景：
大房子中有很多关闭的电灯，随机操作电灯开关，实时显示房间中电灯的状态，并允许一键关闭所有电灯。【只允许使用按位异或】
分析：
1、连续两次操作电灯开关，电灯将处于操作前状态。
2、关闭所有开关。任何数和自己异或结果为零。
实现：
1、定义“大房子”类。
lightFlags 标识房间全部电灯实时状态。
封装电灯操作方法以及一键关闭所有电灯的方法。
/**
* 1、按位运算操作应用。
* 2、走廊灯、厕所灯、厨房灯、主卧灯、次卧灯分别对应一个字段位
* 走廊灯=0000 0001
* 厕所灯=0000 0010
* 厨房灯=0000 0100
* 主卧灯=0000 1000
* 次卧灯=0001 0000
* @author DrodYoung
*/
static class 大房子{
private static final int 走廊灯 = (1 << 0); // 1{0000 0001}
private static final int 厕所灯 = (1 << 1); // 2{0000 0001}
private static final int 厨房灯 = (1 << 2); // 4{0000 0001}
private static final int 主卧灯 = (1 << 3); // 8{0000 0001}
private static final int 次卧灯 = (1 << 4); //16{0000 0001}
private static final int LIGHT_MASK = 走廊灯|
厕所灯|
厨房灯|
主卧灯|
次卧灯;
//lightFlags = 电灯状态标记字段。
private int lightFlags = 0;
private void 操作电灯开关(int flag){
lightFlags ^= flag;
}
//任何数和自己异或结果为零。
private void 让所有的灯关闭(){
操作电灯开关(lightFlags);
}
@Override
public String toString() {
return "房子中电灯状况：\n"
+"走廊灯="+(((lightFlags&走廊灯)!=0)?"开":"关")+"\n"
+"厕所灯="+(((lightFlags&厕所灯)!=0)?"开":"关")+"\n"
+"厨房灯="+(((lightFlags&厨房灯)!=0)?"开":"关")+"\n"
+"主卧灯="+(((lightFlags&主卧灯)!=0)?"开":"关")+"\n"
+"次卧灯="+(((lightFlags&次卧灯)!=0)?"开":"关")+"\n";
}
}
2、测试：
//1、初始化大房子对象
大房子 hourse = new 大房子();
System.out.println(hourse);
//2、操作厨房灯开关
hourse.操作电灯开关(大房子.厨房灯);
System.out.println(hourse);//厨房灯为【开】
//3、再次操作厨房灯开关
hourse.操作电灯开关(大房子.厨房灯);
System.out.println(hourse);//厨房灯为【关】
//4、依次操作主卧灯、次卧灯、走廊灯开关
hourse.操作电灯开关(大房子.主卧灯);
hourse.操作电灯开关(大房子.次卧灯);
hourse.操作电灯开关(大房子.走廊灯);
//5、一键关闭所有灯
hourse.让所有的灯关闭();
System.out.println(hourse);
三、总结：
妙用按位异或，可以让代码更加简洁、高效。本例演示了按位异或的自反性，异或还有其他妙用，我们可以总结如下：
1、按位异或，可以简单理解成：不进位加法。即：1+1=0；0+0=0；1+0 =1；
2、任何数和自己异或结果为零。
3、任何数和0做异或值不变，和1异或结果为原操作数取反。
4、交换律。不使用中间变量，交换两个数。
a=a^b;
b=a^b;
a=a^b;

最近在看一些加密函数,其中总涉及到一些位运算,尤其是^(按位异或),经过多方查找资料,对^的理解深入,分享资料留作纪念！
/*
手册资料：
位运算符
位运算符允许对整型数中指定的位进行置位。如果左右参数都是字符串，则位运算符将操作字符的 ASCII 值
$a ^ $b Xor (按位异或) 将把 $a 和 $b 中不同的位设为 1
*/
^(按位异或)的运算实例
#数字之间位运算
echo 12 ^ 9;      // 输出为 '5'
#字符串之间位运算
echo "12" ^ "9"; // 输出退格字符(ascii 8)
// ('1' (ascii 49)) ^ ('9' (ascii 57)) = #8
echo "hallo" ^ "hello";    // 输出 ascii 值 #0 #4 #0 #0 #0
// 'a' ^ 'e' = #4
echo 2 ^ "3"; // 输出 1
// 2 ^ ((int)"3") == 1
echo "2" ^ 3; // 输出 1
// ((int)"2") ^ 3 == 1
分析：在定义中我们可以知道,位运算符允许对“整型”中指定的位进行置位.但是也不仅仅只是支持“整数”,还支持字符串,不过如果左右参数都是字符串,则位运算符将操作“字符的 ASCII 值”,也就是如果是字符串,将转变成字符相应的ASCII 然后再进行操作.
#对与字符串操作,根据上面分析，原理总结如下：
$aa= 'a'^'b';
$bb= chr(ord('a')^ord('b'));
var_dump($aa);
var_dump($bb);
#以上两种写法结果是一样的

转自：
参与运算的两个值，如果两个相应bit位相同，则结果为0，否则为1。
即：
0^0 = 0，
1^0 = 1，
0^1 = 1，
1^1 = 0
例如：10100001^00010001=10110000
按位异或的3个特点:
(1) 0^0=0,0^1=1  0异或任何数＝任何数
(2) 1^0=1,1^1=0  1异或任何数－任何数取反
(3)              任何数异或自己＝把自己置0
按位异或的几个常见用途:
(1) 使某些特定的位翻转
例如对数10100001的第2位和第3位翻转，则可以将该数与00000110进行按位异或运算。
10100001^00000110 = 10100111
(2) 实现两个值的交换，而不必使用临时变量。
例如交换两个整数a=10100001，b=00000110的值，可通过下列语句实现：
a = a^b； //a=10100111
b = b^a； //b=10100001
a = a^b； //a=00000110
(3) 在汇编语言中经常用于将变量置零：
xor   a，a
(4) 快速判断两个值是否相等
举例1: 判断两个整数a，b是否相等，则可通过下列语句实现：
return ((a ^ b) == 0)
举例2: Linux中最初的ipv6_addr_equal()函数的实现如下:
static inline int ipv6_addr_equal(const struct in6_addr *a1, const struct in6_addr *a2)
{
return (a1->s6_addr32[0] == a2->s6_addr32[0] &&
a1->s6_addr32[1] == a2->s6_addr32[1] &&
a1->s6_addr32[2] == a2->s6_addr32[2] &&
a1->s6_addr32[3] == a2->s6_addr32[3]);
}
可以利用按位异或实现快速比较, 最新的实现已经修改为:
static inline int ipv6_addr_equal(const struct in6_addr *a1, const struct in6_addr *a2)
{
return (((a1->s6_addr32[0] ^ a2->s6_addr32[0]) |
(a1->s6_addr32[1] ^ a2->s6_addr32[1]) |
(a1->s6_addr32[2] ^ a2->s6_addr32[2]) |
(a1->s6_addr32[3] ^ a2->s6_addr32[3])) == 0);
}
-----------------------------------------------------------------------------------
经典的运用：现在有一万(1-10000)的个数，从中拿掉一个数，问怎么才能找出拿掉的数？
设 最初的数组是 A，
拿掉 x 之后的数组是 B，
A 和 B 两个数组共 19999 个数，全部用来做异或，结果就是去掉的那个数 x。
(注：设 A = {a1, a2, a3, .... a10000}， 则 array_xor(A) = a1 ^ a2 ^ a3 ^ ... ^ a10000 )