Tworzenie „logicznego wyłącznego lub” operatora w Javie

Obserwacje:

Java ma logiczny operator AND.
Java ma logiczny operator OR.
Java ma logiczny operator NOT.

Problem:

Według Sun Java nie ma logicznego operatora XOR . Chciałbym zdefiniować jeden.

Definicja metody:

Jako metodę definiuje się go następująco:

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

Wywołanie metody:

Ta metoda jest wywoływana w następujący sposób:

boolean myVal = logicalXOR(x, y);

Wykorzystanie operatora:

Wolałbym mieć operatora używanego w następujący sposób:

boolean myVal = x ^^ y;

Pytanie:

Nie mogę nic znaleźć na temat definiowania nowego operatora w Javie. Od czego powinienem zacząć

Java ma logiczny operator XOR , jest ^ (jak w a ^ b).

Poza tym nie można definiować nowych operatorów w Javie.

Edycja: Oto przykład:

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

Wynik:

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

Czy to nie x! = Y?

Java ma logiczny operator AND.
Java ma logiczny operator OR.

Źle.

Java ma

• dwa logiczne operatory AND: normalny AND to & oraz zwarcie AND jest && i
• dwa logiczne operatory OR: normalne OR to | a zwarcie OR wynosi ||.

XOR istnieje tylko jako ^, ponieważ ocena zwarcia nie jest możliwa.

Być może zrozumiał różnicę między &i &&, |a || Zadaniem operatorów skrótów &&i ||jest to, że wartość pierwszego argumentu można określić rezultat, a więc drugi argument nie musi być ocenione.

Jest to szczególnie przydatne, jeśli drugi operand spowoduje błąd. na przykład

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

Jednak w przypadku XOR zawsze musisz ocenić drugi operand, aby uzyskać wynik, więc jedyną znaczącą operacją jest ^.

Możesz po prostu pisać (a!=b)

To działałoby tak samo jak a ^ b.

To dlatego, że przeciążanie operatorów jest czymś, co specjalnie pominęli z języka. „Oszukiwali” trochę poprzez łączenie łańcuchów, ale poza tym taka funkcjonalność nie istnieje.

(zrzeczenie się: Nie pracowałem z 2 ostatnimi ważnymi wydaniami Javy, więc jeśli będzie to teraz, będę bardzo zaskoczony)

Jedynym przeciążeniem operatora w Javie jest + na ciągach ( JLS 15.18.1 Operator konkatenacji ciągów + ).

Społeczność jest podzielona na 3 lata, 1/3 tego nie chce, 1/3 chce, a 1/3 nie obchodzi.

Możesz użyć Unicode do tworzenia nazw metod, które są symbolami ... więc jeśli masz symbol, którego chcesz użyć, możesz zrobić myVal = x. $ (Y); gdzie $ jest symbolem, a x nie jest prymitywne ... ale będzie to podejrzane w niektórych edytorach i jest ograniczone, ponieważ nie można tego zrobić na prymitywie.

Twój kod:

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

jest zbyteczny.

Dlaczego nie napisać:

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

?

Ponadto, jak powiedział javashlook , istnieje już ^operator.

!=i ^działają identycznie * dla operandów boolowskich (twój przypadek), ale inaczej dla operandów całkowitych.

<sub>* Uwagi:
1. Działają identycznie dla operandów boolean(typ pierwotny), ale nie działają Boolean(typ obiektu). Ponieważ Boolean(typ obiektu) wartości mogą mieć wartość null. I !=powróci falselub truegdy jeden lub oba operandy będą null, podczas gdy w tym przypadku ^rzuci NullPointerException.
2. Chociaż działają identycznie, mają różne pierwszeństwo, np. Gdy są używane z &: a & b != c & dbędą traktowane jako a & (b != c) & d, podczas gdy a & b ^ c & dbędą traktowane jako (a & b) ^ (c & d)(offtopic: ouch, tabela pierwszeństwa w stylu C jest do bani).</sub>

Oto metoda var arg XOR dla java ...

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

Cieszyć się

Nazywa się to logiczne wyłączne lub w Javie !=. Możesz także użyć, ^jeśli chcesz zmylić znajomych.

Możesz użyć Xtend (Infix Operators and Operator Overloading) do przeciążenia operatorów i „pozostania” na Javie

To, o co prosisz, nie miałoby większego sensu. O ile się nie mylę, sugerujesz, że chcesz używać XOR do wykonywania operacji logicznych w taki sam sposób, jak AND i OR. Podany kod pokazuje, o co mi chodzi:

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

Twoja funkcja ma dane logiczne, a gdy bitowa XOR jest używana na boolach, wynik jest taki sam, jak podany kod. Innymi słowy, bitowe XOR jest już wydajne podczas porównywania pojedynczych bitów (booleanów) lub porównywania pojedynczych bitów w większych wartościach. Aby umieścić to w kontekście, pod względem wartości binarnych każda niezerowa wartość ma wartość PRAWDA, a tylko ZERO jest fałszem.

Tak więc, aby XOR mógł być zastosowany w taki sam sposób, jak logiczny AND, albo użyłbyś tylko wartości binarnych z jednym bitem (dając ten sam wynik i wydajność), albo wartość binarna musiałaby być oceniana jako całość zamiast na bit. Innymi słowy, wyrażenie (010 ^^ 110) = FAŁSZ zamiast (010 ^^ 110) = 100. To usunie większość znaczenia semantycznego z operacji i reprezentuje logiczny test, którego i tak nie powinieneś używać.

A i B musiałyby być wartościami logicznymi, aby! = Taki sam jak xor, aby tablica prawdy wyglądała tak samo. Możesz także użyć! (A == B) lol.

Korzystam z bardzo popularnej klasy „org.apache.commons.lang.BooleanUtils”

Ta metoda jest testowana przez wielu użytkowników i bezpieczna. Baw się dobrze. Stosowanie:

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

Ponieważ typ danych logicznych jest przechowywany jak liczba całkowita, operator bitowy ^ działa jak operacja XOR, jeśli jest używany z wartościami logicznymi.

//©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
            */
        }
    }

Oto przykład:

Biorąc pod uwagę 2 wartości int, zwróć true, jeśli jedna jest ujemna, a druga dodatnia. Z wyjątkiem sytuacji, gdy parametr „przeczący” jest prawdziwy, zwróć wartość prawdy tylko wtedy, gdy oba są ujemne.

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

musisz przełączyć się na Scala, aby wdrożyć własnych operatorów

przykład rury