Question

观察：

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

问题：

Java没有逻辑XOR运算符according to sun。我想定义一个。

方法定义：

作为一种方法，它只是定义如下：

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 确实有一个逻辑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);
        }
    }
}

输出：

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

Answer 2

不是x！= y？

Answer 3

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

错误。

Java已经

两个逻辑AND运算符：normal AND is＆amp;和短路AND是＆amp;＆amp;和
两个逻辑OR运算符：正常OR是|和短路OR是||。

XOR仅作为^存在，因为无法进行短路评估。

Answer 4

也许您误解了&和&&，|和||之间的区别快捷方式运算符&&和||的目的是第一个操作数的值可以确定结果，因此不需要计算第二个操作数。

如果第二个操作数会导致错误，则此功能尤其有用。 e.g。

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

然而，使用 XOR ，您总是必须评估第二个操作数以获得结果，因此唯一有意义的操作是^。

Answer 5

你可以写(a!=b)

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

Answer 6

那是因为运营商超载是他们特意故意忽略的。他们用字符串连接“欺骗”了一些，但除此之外，这种功能并不存在。

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

Answer 7

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

社区已经分为3年，1/3不需要它，1/3需要它，1/3不关心。

你可以使用unicode创建符号的方法名称...所以如果你有一个想要使用的符号，你可以做myVal = x。$（y）;其中$是符号而x不是原始的...但是在某些编辑器中这将是狡猾的并且是限制性的，因为你不能在原语上进行。

Answer 8

以下代码：

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

对于布尔操作数（您的情况），

!=和^的工作方式相同*，但整数操作数的方式不同。

_{*注意：

1.它们对boolean（基本类型）的工作方式相同，但不是Boolean（对象类型）操作数。由于Boolean（对象类型）值可以具有值null。当!=中的一个或两个操作数为false时，true将返回null或^，而NullPointerException将在此情况下抛出&。

虽然它们的工作方式相同，但它们的优先级不同，例如：与a & b != c & d一起使用时：a & (b != c) & d将被视为a & b ^ c & d，而(a & b) ^ (c & d)将被视为final PackageManager pm = getApplicationContext().getPackageManager();
ApplicationInfo ai;
try {
ai = pm.getApplicationInfo( "your_package_name", 0);
} catch (final NameNotFoundException e) {
ai = null;
}
final String applicationName = (String) (ai != null ? pm.getApplicationLabel(ai) : "(unknown)");
（offtopic：哎哟，C风格的优先表格很糟糕）。}

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

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

Answer 11

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

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

您的函数具有布尔输入，当在布尔值上使用按位XOR时，结果与您提供的代码相同。换句话说，在比较各个位（布尔值）或比较较大值的各个位时，按位XOR已经很有效。为了将其置于上下文中，就二进制值而言，任何非零值都为TRUE且只有ZERO为假。

因此，对于应用逻辑AND的XOR应用，您要么只使用一位二进制值（给出相同的结果和效率），要么必须将二进制值作为整体进行评估，而不是每位。换句话说，表达式（010 ^^ 110）= FALSE而不是（010 ^^ 110）= 100.这将从操作中删除大部分语义含义，并代表您不应该使用的逻辑测试。< / p>

Answer 12

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

Answer 13

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

Answer 14

我正在使用非常受欢迎的类“org.apache.commons.lang.BooleanUtils”

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

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

Answer 15

A和B必须是布尔值才能生成！=与xor相同，以便真值表看起来一样。你也可以使用！（A == B）lol。

Answer 16

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

pipe example

Answer 17

以下是一个例子：

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

    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

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

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

观察：

问题：

方法定义：

方法调用：

运营商使用：

问题：

18 个答案: