这是原始代码：
public static String reverseString(String s){
if(s == null) return "";
char[] rev = s.toCharArray();
int i = 0, j = s.length() - 1;
while(i < j) {
rev[i] ^= rev[j];
rev[j] ^= rev[i];
rev[i++] ^= rev[j--];
}
return String.valueOf(rev);
}
我的问题是，在这里交换字符值时，Xor是如何工作的，为什么需要使用rev[i++]^=rev[j--]？
这段代码等同于
rev[i] ^= rev[j];
rev[j] ^= rev[i];
rev[i] ^= rev[j];
i++; j--;
最后一部分只需要为下一个循环迭代增加i并减少j。
至于为什么x ^= y; y ^= x; x ^= y可以交换值，我不知道为什么，但你可以看到它对于1位值的所有四种可能性都有效：
start after x^=y after y^=x after x^=y
x y x y x y x y
0 0 0 0 0 0 0 0
0 1 1 1 1 0 1 0
1 0 1 0 1 1 0 1
1 1 0 1 0 1 1 1
因此，您可以看到在所有情况下，x 和 y 位被交换。当这些语句应用于较大的整数时，^ 运算符并行地作用于所有位，因此最终结果是每一对位都被交换，即整个值被交换。
A^B中，第ith位为1，这意味着A和B的第i位不同。这意味着其中一个是1，另一个是0。(A^B)^B时，如果B中的第i位是0，那么我们将得到1，因为1^0=1，这等于A中的第i位，而(A^B)^A=0，这是B中的第i位。B中的第i位为1且A中的第i位为0时，也会发生交换。A^B中的第i位为0时，相同的逻辑适用。您可以很容易地验证它。A^B时，您会得到另一个数字，因为每个相应位都会发生交换。a 和 b 的值。a = a ^ b
b = b ^ a
a = a ^ b
让我们分析一下交换操作的原理和过程。
为此，我们不直接交换变量的值，而是将它们存储在不同的变量中，这样我们就可以清楚地看到具体的操作过程。
a0 = a ^ b
b1 = b ^ a0
a1 = a0 ^ b1
使用 XOR 下面的性质简化方程。请参考XOR Properties@Wikipedia。
a ^ b == b ^ a) a ^ (b ^ c) == (a ^ b) ^ c) a ^ a == 0 0 ^ a == a
a0 = a ^ b // Equation #1
b1 = b ^ a0
a1 = a0 ^ b1
b1 = b ^ a0 // Equation #2
= b ^ (a ^ b) // Using Equation #1
= b ^ (b ^ a) // Property #1
= (b ^ b) ^ a // Property #2
= 0 ^ a // Property #3
= a // Property #4
a1 = a0 ^ b1
= a0 ^ (b ^ a0) // Using Equation #2
= (a ^ b) ^ (b ^ (a ^ b)) // Using Equation #1
= (b ^ a) ^ (b ^ (b ^ a)) // Using Property #1
= (b ^ a) ^ ((b ^ b) ^ a) // Using Property #2
= (b ^ a) ^ (0 ^ a) // Using Property #3
= (b ^ a) ^ a // Using Property #4
= b ^ (a ^ a) // Using Property #2
= b ^ 0 // Using Property #3
= b // Using Property #4
如您所见，b1 现在包含了 a 的原始值，而 a1 包含了 b 的原始值，即 b 和 a 的值被交换了。
总之，a^=b;b^=a;a^=b 只是一种惯用表达，其中并没有什么神奇的地方 :)
XOR 在操作数位不同时设置位，并在操作数位相同时重置位。
让我们通过一个例子来演示发生的转换。为此，假设我们将以下数字（以二进制形式）分配给变量。
a = 1 1 0 0
b = 1 0 1 0
步骤 #1: a = a ^ b // 创建掩码
a = 0 1 1 0
b = 1 0 1 0
假设a的新值是用于生成给定b的旧值或生成给定a的旧值的掩码。
步骤#2：b = b ^ a //使用掩码和b的原始值恢复a的原始值
a = 0 1 1 0
b = 1 1 0 0
由于b仍然被保留/未更改，我们可以使用掩码恢复a的原始值 - 这就是我们在此步骤中所做的。
第三步: a = a ^ b // 使用掩码和a的原始值恢复b的原始值
a = 1 0 1 0
b = 1 1 0 0
b中有了变量a的原始值，因此我们可以使用相同的掩码来恢复变量b的原始值。由于在这一步之后我们不再需要掩码，因此我们现在可以覆盖掉它。y == (x^y)^x == x^(y^x)，那么你就有了答案。a = a ^ b
b = b ^ a
a = a ^ b
现在重命名一个值以澄清正在发生的事情：
a_xor_b = a ^ b
b = b ^ a_xor_b // Now b is the original a because b^(a^b) == a!
a = a_xor_b ^ b // Now a is the original b because (a^b)^a == b!
现在请注意，如果a_xor_b与a是同一个变量，则代码可以正常工作。
也许首先考虑一种不同（但密切相关）的交换两个数字值 a 和 b 的方法会更容易：
a = a + b;
b = a - b;
a = -b + a;
这适用于纯任意精度数字和模N的整数（当它们变得太大或太小时会环绕的整数，就像在Java中一样）。
为了在数学上分析这个问题，我们应该每次值改变时分配一个新符号，以便=可以表示数学相等而不是赋值。然后，这只是基本代数问题。
a1 = a0 + b0
b2 = a1 - b0 = (a0 + b0) - b0 = a0
a2 = -b2 + a1 = -(a0) + (a0 + b0) = b0
a = a ^ b;
b = b ^ a;
a = a ^ b;
rev[i++]^=rev[j--]same with:rev[i]^=rev[j];i++;j++;it swaps one more time then incrementiandj- malioboro