首页 文章

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

提问于
浏览 次
244

观察：

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中定义新运算符的内容 . 我应该从哪里开始？

java operators xor

17 回答

  • 624

    Java does have a logical XOR operator ，它是^（如 a ^ b ） .

    除此之外，您无法在Java中定义新的运算符 .

    Edit: 这是一个例子：

    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
    回复于
  • 71

    不是x！= y？

    回复于
  • 7

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

    错误 .

    Java有

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

    • 两个逻辑OR运算符：正常OR是|和短路OR是|| .

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

    回复于
  • 6

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

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

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

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

    回复于
  • 0

    你可以写 (a!=b)

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

    回复于
  • 20

    这是因为运算符重载是他们特意故意忽略的语言 . 他们用字符串连接“欺骗”了一点，但除此之外，这种功能并不存在 .

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

    回复于
  • 2

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

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

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

    回复于
  • 1

    以下代码：

    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 . 它们对布尔（基本类型）的工作方式相同，但不是布尔（对象类型）操作数 . 由于布尔值（对象类型）值可以为null . 并且！=当其一个或两个操作数为空时将返回false或true，而^在这种情况下将抛出NullPointerException . 虽然它们的工作方式相同，但它们具有不同的优先权，例如：与＆一起使用时：a＆b！= c＆d将被视为＆（b！= c）＆d，而a＆b ^ c＆d将被视为（a＆b）^（c＆d ）（offtopic：哎哟，C风格的优先表很糟糕） .

    回复于
  • 2

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

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

    请享用

    回复于
  • 0

    您可以使用Xtend (Infix Operators and Operator Overloading)在Java上重载运算符和'stay'

    回复于
  • 0

    你要求的东西没有多大意义 . 除非我不正确，否则你建议你使用XOR来执行逻辑运算，方法与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.这将从操作中删除大部分语义含义，并表示您不应该使用的逻辑测试 .

    回复于
  • 28

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

    回复于
  • 1

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

    这种方法经过许多用户的测试和安全 . 玩得开心 . 用法：

    boolean result =BooleanUtils.xor(new boolean[]{true,false});
    回复于
  • 7

    逻辑异或 - 在Java中叫 != . 如果你想让你的朋友感到困惑，你也可以使用 ^ .

    回复于
  • 280

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

    这是一个例子：

    给定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);
    }
    回复于
  • 8

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

    pipe example

    回复于

相关问题