Створення оператора "логічний ексклюзив" або "Java"

Спостереження:

У Java є логічний оператор І.
У 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);
        }
    }
}

Вихід:

false ^ false = хибно
false ^ true = правда
true ^ false = правда
true ^ true = хибно

Хіба це не х! = У?

У Java є логічний оператор І.
У Java є логічний оператор АБО.

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

Java має

• два логічних оператора AND: нормальний AND є &, а коротке замикання AND - &&, і
• два логічні оператори АБО: нормальне АБО є | а коротке замикання АБО ||.

XOR існує лише як ^, оскільки оцінка короткого замикання неможлива.

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

Це особливо корисно, якщо другий операнд призведе до помилки. напр

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

Однак з XOR завжди потрібно оцінювати другий операнд, щоб отримати результат, тому єдиною значущою операцією є ^.

Можна просто написати (a!=b)

Це буде працювати так само, як і a ^ b.

Це тому, що перевантаження операторів - це те, що вони спеціально лишилися поза мовою. Вони трохи "обдурили" стрункову конкатенацію, але поза цим такої функціональності не існує.

(відмова від відповідальності: я не працював з останніми двома основними випусками Java, тому, якщо це вже зараз, я буду дуже здивований)

Єдиний оператор, який перевантажує Java, є + на Strings ( JLS 15.18.1 String Concatenation Operator + ).

Спільнота поділяється на 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)(offtopic: ouch, стійка таблиці пріоритетів у стилі 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 називається !=. Ви також можете використовувати, ^якщо хочете заплутати своїх друзів.

Ви можете використовувати Xtend (оператори інфікування та перевантаження оператора) для перевантаження операторів та «перебування» на Java

Те, про що ви просите, не мало б великого сенсу. Якщо я невірний, ви пропонуєте використовувати XOR для виконання логічних операцій так само, як і AND і OR. Наданий код насправді показує, на що я звертаюсь:

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

У вашій функції є булеві входи, і коли бітовий XOR використовується на булевих результатах, результат такий же, як і код, який ви вказали. Іншими словами, побітовий XOR вже ефективний при порівнянні окремих бітів (булевих) або порівнянні окремих бітів у більших значеннях. Щоб поставити це в контекст, з точки зору бінарних значень будь-яке ненульове значення є ПРАВИЛЬНИМ, і лише ZERO - хибним.

Отже, щоб XOR застосовувався так само, як застосовується логічний AND, ви використовуєте лише бінарні значення лише з одним бітом (даючи однаковий результат та ефективність), або двійкове значення має оцінюватися як ціле, а не за біт. Іншими словами, вираз (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, поверніть істинне, якщо одне є негативним, а одне - позитивним. За винятком випадків, коли параметр "негативний" є істинним, повертайте істинне, лише якщо обидва є негативними.

    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 для впровадження власних операторів

приклад труби