Создание логического исключающего ИЛИ в 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);
        }
    }
}

Выход:

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

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

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

Неправильный.

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 все равно.

Вы можете использовать Unicode для создания имен методов, которые являются символами ... поэтому, если у вас есть символ, который вы хотите использовать, вы можете сделать 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) (оффтоп: ой, таблица приоритетов в стиле C - отстой).</sub>

Вот метод var arg XOR для java ...

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

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

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

Для перегрузки операторов и 'остаться' на Яве

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

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

Ваша функция имеет логические входы, и когда побитовое XOR используется с логическими значениями, результат будет таким же, как и в коде, который вы предоставили. Другими словами, побитовое исключающее ИЛИ уже эффективно при сравнении отдельных битов (логических значений) или сравнении отдельных битов с большими значениями. Чтобы поместить это в контекст, с точки зрения двоичных значений любое ненулевое значение является ИСТИННЫМ, и только НОЛЬ является ложным.

Таким образом, чтобы 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 (^) из этого ответа

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

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

пример трубы

Может быть достигнуто с помощью потокового API в java 8 и выше.

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