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

Question

观察：

Java 有一个逻辑 AND 运算符。
Java 有一个逻辑 OR 运算符。
Java 有一个逻辑 NOT 运算符。

问题：

根据 sun的说法， Java 没有逻辑 XOR 运算符。我想定义一个。

方法定义：

作为一种方法，它简单地定义如下：

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

方法调用：

该方法的调用方式如下：

boolean myVal = logicalXOR(x, y);

运算符用法：

我宁愿有一个运算符，使用如下：

boolean myVal = x ^^ y;

问题：

我找不到任何关于如何在 Java 中定义新运算符的信息。我应该从哪里开始？

score 736 · Accepted Answer

Java确实有一个逻辑 XOR 运算符，它是^（如中a ^ b）。

除此之外，您不能在 Java 中定义新的运算符。

编辑：这是一个例子：

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);
        }
    }
}

输出：

假 ^ 假 = 假
假 ^ 真 = 真
真 ^ 假 = 真
真 ^ 真 = 假

score 323 · Accepted Answer

323

不是 x != y 吗？

于 2009-04-07T17:04:41.903 回答

score 76 · Accepted Answer

Java 有一个逻辑 AND 运算符。
Java 有一个逻辑 OR 运算符。

错误的。

Java有

两个逻辑 AND 运算符：普通 AND 是 &，短路 AND 是 &&，以及
两个逻辑或运算符：正常的 OR 是 | 短路或为||。

XOR 仅作为 ^ 存在，因为不可能进行短路评估。

score 34 · Accepted Answer

&可能你误解了and和的区别快捷操作符 and 的目的&&是|第一个操作数的值可以决定结果，所以第二个操作数不需要计算。||&&||

如果第二个操作数会导致错误，这将特别有用。例如

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

但是，对于XOR，您始终必须评估第二个操作数才能获得结果，因此唯一有意义的操作是^。

score 22 · Accepted Answer

22

你可以写(a!=b)

这与a ^ b.

于 2013-06-04T06:09:22.907 回答

score 9 · Accepted Answer

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

（免责声明：我没有使用过 java 的最后 2 个主要版本，所以如果它现在发布，我会感到非常惊讶）

score 8 · Accepted Answer

8

Java 中的逻辑异或称为!=. ^如果你想混淆你的朋友，你也可以使用。

于 2018-04-04T14:00:54.040 回答

score 7 · Accepted Answer

Java 中唯一的运算符重载是字符串上的 + （JLS 15.18.1 字符串连接运算符 +）。

社区多年来一直一分为三，1/3 不想要，1/3 想要，1/3 不在乎。

您可以使用 unicode 创建符号的方法名称...因此，如果您有要使用的符号，则可以执行 myVal = x.$(y); 其中 $ 是符号，而 x 不是原语......但这在某些编辑器中会很狡猾并且是有限的，因为你不能在原语上做到这一点。

score 7 · Accepted Answer

以下是您的代码：

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

是多余的。

为什么不写：

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

?

此外，正如 javashlook所说，已经有^运营商。

!=并且^对于布尔操作数（您的情况）相同*，但对于整数操作数则不同。

_{* 注意：

1. 它们对boolean（原始类型）操作数相同，但对Boolean（对象类型）操作数不同。As Boolean（对象类型）值可以具有 value null。当它的一个或两个操作数是时，!=将返回falseor ，而在这种情况下将抛出。
2. 虽然它们的工作方式相同，但它们具有不同的优先级，例如，当与:一起使用时，将被视为，而将被视为（offtopic：哎哟，C 风格的优先级表很烂）。truenull^NullPointerException
&a & b != c & da & (b != c) & da & b ^ c & d(a & b) ^ (c & d)}

score 6 · Accepted Answer

这是java的var arg XOR方法...

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

享受

score 2 · Accepted Answer

您可以使用Xtend（中缀运算符和运算符重载）来重载运算符并在 Java 上“停留”

score 2 · Accepted Answer

你所要求的没有多大意义。除非我不正确，否则您建议您要使用 XOR 以与 AND 和 OR 相同的方式执行逻辑运算。您提供的代码实际上显示了我所指的内容：

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

您的函数具有布尔输入，当对布尔值使用按位异或时，结果与您提供的代码相同。换句话说，在比较单个位（布尔值）或比较较大值中的单个位时，按位异或已经很有效。把它放到上下文中，就二进制值而言，任何非零值都是 TRUE，只有 ZERO 是 false。

因此，要以与应用逻辑 AND 相同的方式应用 XOR，您要么只使用只有一位的二进制值（给出相同的结果和效率），要么必须将二进制值作为一个整体而不是每个位进行评估。换句话说，表达式 (010 ^^ 110) = FALSE 而不是 (010 ^^ 110) = 100。这将删除操作中的大部分语义含义，并表示您无论如何都不应该使用的逻辑测试。

score 2 · Accepted Answer

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

此方法经过许多用户的测试并且安全。玩得开心。用法：

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

score 1 · Accepted Answer

A 和 B 必须是布尔值才能使 != 与 xor 相同，以便真值表看起来相同。您也可以使用 !(A==B) 大声笑。

score 1 · Accepted Answer

这是一个使用 XOR(^) 的例子，来自这个答案

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

score 0 · Accepted Answer

因为布尔数据类型像整数一样存储，如果与布尔值一起使用，位运算符 ^ 的功能类似于 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
            */
        }
    }

score 0 · Accepted Answer

这是一个例子：

给定 2 个 int 值，如果一个为负，一个为正，则返回 true。除非参数“negative”为真，否则只有当两者都为负时才返回真。

    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);
    }

score 0 · Accepted Answer

0

你需要切换到 Scala 来实现你自己的操作符

管道示例

于 2017-10-20T13:59:26.593 回答

score 0 · Accepted Answer

可以在 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;
}

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

观察：

问题：

方法定义：

方法调用：

运算符用法：

问题：

19 回答 19

Related

Reference