在Java中创建“逻辑异或”运算符

确实有逻辑XOR运算符 ,它是 ^ a ^ b ).

这里有一个例子:

public static void main(String[] args) {
    boolean[] all = { false, true };
    for (boolean a : all) {
        for (boolean b: all) {
            boolean c = a ^ b;
            System.out.println(a + " ^ " + b + " = " + c);
        }
    }
}

输出:

false ^ false = false
false ^ true = true
true ^ false = true
true ^ true = false

是不是x!y

Java有一个逻辑OR运算符。

• 两个逻辑AND运算符:正常的AND是&短路and为&&,以及
• 两个逻辑OR运算符:正常OR为|,短路OR为||。

& 和 && , | 和 || 快捷运算符的用途 && 和 第一个操作数的值可以决定结果,因此不需要计算第二个操作数。

如果第二个操作数会导致错误,这尤其有用。 例如

if (set == null || set.isEmpty())
// or
if (list != null && list.size() > 0)

然而,随着 ^ .

你可以写 (a!=b)

a ^ b .

在Java中,逻辑互斥或被称为 != ^ 如果你想迷惑你的朋友。

以下是您的代码:

public static boolean logicalXOR(boolean x, boolean y) {
    return ( ( x || y ) && ! ( x && y ) );
}

是多余的。

public static boolean logicalXOR(boolean x, boolean y) {
    return x != y;
}

?

said ,已经有了 ^ 操作员。

!= 和 ^ 对布尔操作数(您的情况)的工作方式相同,但对整数操作数的工作方式不同。

_{*备注:
1.他们的工作方式完全一样 boolean (原始类型),但不是 Boolean 布尔 (对象类型)值可以有值 null .还有 会回来的 false 或 true 当其一个或两个操作数为 空值 ,而 ^ 将投掷 NullPointerException 在这种情况下。
2.虽然它们的工作原理相同,但优先级不同,例如与 & : a & b != c & d 将被视为 a & (b != c) & d ,而 a & b ^ c & d 将被视为 (a & b) ^ (c & d)}

这是因为运算符重载是他们故意在语言中遗漏的东西。他们用字符串连接“欺骗”了一点,但除此之外,这种功能并不存在。

(免责声明:我没有使用过java的最后两个主要版本,所以如果现在有,我会非常惊讶)

Java中唯一重载的运算符是字符串上的+( JLS 15.18.1 String Concatenation Operator + ).

社区多年来一直分为3个部分,1/3不想要,1/3想要,1/3不在乎。

您可以使用unicode创建作为符号的方法名。..所以如果你有一个你想使用的符号,你可以做myVal=x.$(y);其中$是符号,x不是基元。..但在某些编辑器中,这将是不可靠的,并且是有限制的,因为你不能在基元上做到这一点。

public static boolean XOR(boolean... args) {
  boolean r = false;
  for (boolean b : args) {
    r = r ^ b;
  }
  return r;
}

您可以使用 Xtend (Infix Operators and Operator Overloading) 重载运算符并“留在”Java上

你的要求没有多大意义。除非我错了,否则你是在建议你想使用XOR来执行逻辑运算,就像AND和OR一样。你提供的代码实际上显示了我所引用的内容:

public static boolean logicalXOR(boolean x, boolean y) {
    return ( ( x || y ) && ! ( x && y ) );
}

你的函数有布尔输入,当对布尔值使用位XOR时,结果与你提供的代码相同。换句话说,在比较单个比特(布尔值)或比较较大值的单个比特时,逐位XOR已经很有效。从上下文来看,就二进制值而言,任何非零值都是TRUE,只有zero是false。

我正在使用非常流行的类“org.apache.commons.lang.BooleanUtils”

这种方法经过许多用户的测试,是安全的。玩得高兴。

boolean result =BooleanUtils.xor(new boolean[]{true,false});

这是一个使用XOR(^)的例子,由此 answer

byte[] array_1 = new byte[] { 1, 0, 1, 0, 1, 1 };
byte[] array_2 = new byte[] { 1, 0, 0, 1, 0, 1 };

byte[] array_3 = new byte[6];

int i = 0;
for (byte b : array_1)
    array_3[i] = b ^ array_2[i++];

输出

0 0 1 1 1 0

因为布尔数据类型的存储方式类似于整数,所以如果与布尔值一起使用,位运算符^的功能类似于XOR运算。

//©Mfpl - XOR_Test.java

    public class XOR_Test {
        public static void main (String args[]) {
            boolean a,b;

            a=false; b=false;
            System.out.println("a=false; b=false;  ->  " + (a^b));

            a=false; b=true;
            System.out.println("a=false; b=true;  ->  " + (a^b));

            a=true;  b=false;
            System.out.println("a=true;  b=false;  ->  " + (a^b));

            a=true; b=true;
            System.out.println("a=true; b=true;  ->  " + (a^b));

            /*  output of this program:
                    a=false; b=false;  ->  false
                    a=false; b=true;  ->  true
                    a=true;  b=false;  ->  true
                    a=true; b=true;  ->  false
            */
        }
    }

这里有一个例子:

    public boolean posNeg(int a, int b, boolean negative) {
      if(!negative){
        return (a>0 && b<0)^(b>0 && a<0);
      }
      else return (a<0 && b<0);
    }

您需要切换到Scala来实现自己的运算符

pipe example

可以在java 8及更高版本中使用流API实现

public static boolean logicalXOR(boolean x, boolean y) {  // can modify to take [] or list of bools
    return Stream.of(x, y)  // modify as per method params
        .filter(bool -> bool)
        .count() == 1;
}