在 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 中定义新运算符的任何信息。 我应该从哪里开始？

Answer 1

Java确实有一个逻辑异或运算符，它是^ （如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);
        }
    }
}

输出：

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

Answer 2

不是 x != y 吗？

Answer 3

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

错误的。

Java有

• 两个逻辑 AND 运算符：正常 AND 是 & 和短路 AND 是 &&，和
• 两个逻辑 OR 运算符：正常 OR 是 | 和短路 OR 是 || 。

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

Answer 4

也许你误解了&和&&之间的区别， | 和|| 快捷操作符&&和||的用途是第一个操作数的值可以确定结果，因此不需要评估第二个操作数。

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

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

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

Answer 5

你可以写(a!=b)

这与a ^ b工作方式相同。

Answer 6

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

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

Answer 7

以下是您的代码：

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所说，已经有^运算符。

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

<sub>* 备注：
1. 它们对boolean （原始类型）操作数相同，但对于Boolean （对象类型）操作数则不同。 由于Boolean （对象类型）值可以具有值null 。 当一个或两个操作数为null ， !=将返回false或true ，而^在这种情况下将抛出NullPointerException 。
2. 尽管它们的工作方式相同，但它们具有不同的优先级，例如与&使用时： a & b != c & d将被视为a & (b != c) & d ，而a & b ^ c & d将被视为被视为(a & b) ^ (c & d) （题外话：哎哟，C 风格的优先表很烂）。</sub>

Answer 8

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

社区多年来一直被分成3个，1/3不想要，1/3想要，1/3不在乎。

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

Answer 9

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

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

享受

Answer 10

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

Answer 11

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

Answer 12

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

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

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

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

Answer 13

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

Answer 14

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

这种方法已经过很多用户的测试并且是安全的。 玩得开心。 用法：

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

Answer 15

这是使用 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

Answer 16

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

Answer 17

下面是一个例子：

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

Answer 18

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

管道示例

Answer 19

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