Создание «логического исключающего или» оператора в Java

Замечания:

У Java есть логический оператор AND.
У Java есть логический оператор ИЛИ.
У Java есть логический оператор НЕ.

Проблема:

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. С чего мне начать?

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

Вывод:

ложь ^ ложь = ложь
ложь ^ правда = правда
правда ^ ложь = правда
правда ^ правда = ложь

Разве это не х! = У?

У Java есть логический оператор AND.
У Java есть логический оператор ИЛИ.

Неправильно.

Ява имеет

• два логических оператора «И»: нормальное «И» - это «И» и короткое замыкание «И» - «&&», а также
• два логических оператора ИЛИ: нормальное ИЛИ есть | И короткое замыкание ИЛИ ||

XOR существует только как ^, потому что оценка короткого замыкания невозможна.

Возможно, вы неправильно поняли разницу между &и &&, |и || Цель операторов быстрого вызова &&и ||заключается в том, что значение первого операнда может определять результат, и поэтому второй операнд не нужно оценивать.

Это особенно полезно, если второй операнд приведет к ошибке. например

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

Однако с XOR вам всегда нужно вычислять второй операнд, чтобы получить результат, поэтому единственной значимой операцией является ^.

Вы можете просто написать (a!=b)

Это будет работать так же, как и a ^ b.

Это связано с тем, что перегрузка операторов - это то, что они специально не учитывают в языке. Они немного «обманывают» при конкатенации строк, но кроме этого, такой функциональности не существует.

(отказ от ответственности: я не работал с двумя последними основными выпусками Java, поэтому, если он появится сейчас, я буду очень удивлен)

Единственная перегрузка оператора в Java - это + для строк ( JLS 15.18.1 Оператор конкатенации строк + ).

Сообщество делится на 3 года, 1/3 не хочет, 1/3 хочет, а 1/3 не волнует.

Вы можете использовать юникод для создания имен методов, которые являются символами ... поэтому, если у вас есть символ, который вы хотите использовать, вы можете сделать myVal = x. $ (Y); где $ - символ, а x - не примитив ... но в некоторых редакторах это будет хитроумно и ограниченно, поскольку вы не можете сделать это на примитиве.

Следующий ваш код:

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. И !=вернется falseили trueкогда один или оба его операнда есть null, пока ^бросит NullPointerExceptionв этом случае.
2. Хотя они работают одинаково, они имеют различный приоритет, например, при использовании с &: a & b != c & dбудет обрабатываться как a & (b != c) & d, а a & b ^ c & dбудет обрабатываться как (a & b) ^ (c & d)(offtopic: ой, таблица приоритетов в стиле C отстой).</sub>

Вот XAR-метод var arg для Java ...

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

наслаждаться

Логический эксклюзив - или на Java называется !=. Вы также можете использовать, ^если хотите запутать своих друзей.

Вы можете использовать Xtend (Infix Operators и Operator Overloading), чтобы перегрузить операторы и «остаться» на Java

То, что вы просите, не имеет большого смысла. Если я не ошибаюсь, вы предлагаете использовать XOR для выполнения логических операций так же, как AND и OR. Ваш код на самом деле показывает, что я ссылаюсь на:

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

Ваша функция имеет логические входы, и при использовании побитового XOR для логических значений результат будет таким же, как и код, который вы предоставили. Другими словами, побитовый XOR уже эффективен при сравнении отдельных битов (логических значений) или при сравнении отдельных битов в больших значениях. Чтобы поместить это в контекст, в терминах двоичных значений любое ненулевое значение равно TRUE, и только ZERO - false.

Таким образом, для применения XOR таким же образом, как применяется логическое И, вы должны либо использовать только двоичные значения только с одним битом (давая тот же результат и эффективность), либо двоичное значение должно оцениваться как целое, а не на бит. Другими словами, выражение (010 ^^ 110) = FALSE вместо (010 ^^ 110) = 100. Это удалит большую часть семантического значения из операции и будет представлять собой логический тест, который вы все равно не должны использовать.

A и B должны быть логическими значениями, чтобы сделать! = Такими же, как xor, чтобы таблица истинности выглядела одинаково. Вы также можете использовать! (A == B) LOL.

Я использую очень популярный класс "org.apache.commons.lang.BooleanUtils"

Этот метод проверен многими пользователями и безопасен. Радоваться, веселиться. Использование:

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

Поскольку логический тип данных хранится как целое число, битовый оператор ^ функционирует как операция 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
            */
        }
    }

Вот пример:

Если задано 2 значения типа int, вернуть 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);
    }

вам нужно переключиться на Scala для реализации ваших собственных операторов

пример трубы