Java'da "mantıksal özel" veya "operatör" oluşturma

Gözlemler:

Java'nın mantıksal bir AND operatörü vardır.
Java'nın mantıksal bir VEYA işleci vardır.
Java'nın mantıksal bir NOT işleci vardır.

Sorun:

Güneşe göre Java'nın mantıksal bir XOR operatörü yoktur . Bir tanesini tanımlamak istiyorum.

Yöntem Tanımı:

Bir yöntem olarak basitçe aşağıdaki gibi tanımlanır:

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

Yöntem Çağrısı:

Bu yöntem şu şekilde çağrılır:

boolean myVal = logicalXOR(x, y);

Operatör Kullanımı:

Daha çok, aşağıdaki gibi kullanılan bir operatör olmasını tercih ederim:

boolean myVal = x ^^ y;

Soru:

Java'da yeni bir operatör tanımlama konusunda nasıl bir şey bulamıyorum. Nereden başlamalıyım?

Java mantıksal bir XOR operatörüne sahiptir , ^ (olduğu gibi a ^ b).

Bunun dışında Java'da yeni işleçler tanımlayamazsınız.

Düzenleme: İşte bir örnek:

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

Çıktı:

false ^ false = false
false ^ true = true
true ^ false = true
true ^ true = yanlış

X! = Y değil mi?

Java'nın mantıksal bir AND operatörü vardır.
Java'nın mantıksal bir VEYA işleci vardır.

Yanlış.

Java

• iki mantıksal AND operatörü: normal AND & & kısa devre AND &&, ve
• iki mantıksal OR operatörü: normal OR | ve kısa devre VEYA ||

XOR sadece ^ olarak mevcuttur, çünkü kısa devre değerlendirmesi mümkün değildir.

Belki arasındaki farkı yanlış &ve &&, |ve || kısayol operatörleri amacı &&ve|| ikinci işlenen değerlendirilecek gerekmez böylece ilk görenin değeri sonucunu belirlemek ve olmasıdır.

Bu, özellikle ikinci işlenenin hataya neden olması durumunda kullanışlıdır. Örneğin

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

Ancak XOR ile , sonucu elde etmek için her zaman ikinci işleneni değerlendirmeniz gerekir, böylece tek anlamlı işlem olur ^.

Sadece yazabilirsin (a!=b)

Bu, aynı şekilde çalışır a ^ b.

Çünkü operatör aşırı yüklenmesi, özellikle dilden kasıtlı olarak bıraktıkları bir şeydir. Dize birleştirme ile biraz "aldattılar", ancak bunun ötesinde, böyle bir işlevsellik mevcut değildir.

(feragatname: Java'nın son 2 büyük sürümünde çalışmadım, bu yüzden şimdi varsa, çok şaşıracağım)

Java'da aşırı yükleme yapan tek operatör Dizelerdeki + ( JLS 15.18.1 Dize Birleştirme İşleci + ).

Topluluk yıllardır 3'e bölünmüş, 1/3 istemiyor, 1/3 istiyor ve 1/3 umursamıyor.

Sembol olan yöntem adları oluşturmak için unicode kullanabilirsiniz ... bu nedenle kullanmak istediğiniz bir sembolünüz varsa myVal = x. $ (Y); burada $ sembol ve x ilkel değil ... ama bazı editörlerde tehlikeli olacak ve ilkel üzerinde yapamayacağınız için sınırlayıcı olacak.

Aşağıdaki kod:

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

gereksizdir.

Neden yazmıyorsunuz:

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

?

Ayrıca, javashlook'un dediği gibi , zaten var^ operatör var.

!= ve ^ boolean işlenenler (durumunuz) için aynı şekilde *, ancak tamsayı işlenenler için farklı şekilde çalışın.

<sub>* Notlar:
1. boolean(ilkel tip) için aynı şekilde çalışırlar , ancakBoolean (nesne tipi) işlenenler için . Olarak Boolean(nesne türü) değerleri değere sahip olabilir null. Ve !=dönecek falseya trueda işlenenlerinden biri veya her ikisi de olduğunda null, bu durumda ^atılacaktır NullPointerException.
Bunlar aynı şekilde çalışacaktır, ancak kullanıldığında 2., bunlar örneğin farklı önceliğe sahiptir &: a & b != c & dolarak kabul edilecek a & (b != c) & dise, a & b ^ c & dolarak kabul edilecektir (a & b) ^ (c & d)(: AH, C gibi bir öncelik tablosu emmek offtopic).</sub>

Java için var arg XOR yöntemi İşte ...

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

Zevk almak

Mantıksal münhasır- veya Java'da çağrılır !=. ^Arkadaşlarınızı karıştırmak istiyorsanız da kullanabilirsiniz .

Sen kullanabilirsiniz xtend (telkin Operatörleri ve operatörler) aşırı yük operatörleri ve Java üzerinde 'kalmak' için

Sorduğun şey pek mantıklı değil. Yanlış olmadıkça, Mantıksal işlemleri AND ve VEYA gibi yapmak için XOR kullanmanızı öneririz. Sağladığınız kod aslında neye başvurduğumu gösteriyor:

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

İşlevinizin boole girişleri vardır ve boolelarda bit olarak XOR kullanıldığında sonuç sağladığınız kodla aynı olur. Başka bir deyişle, bitsel XOR, tek tek bitleri (booleans) karşılaştırırken veya tek tek bitleri daha büyük değerlerle karşılaştırırken zaten etkilidir. Bunu bağlama koymak için, ikili değerler açısından sıfır olmayan herhangi bir değer DOĞRU ve yalnızca SIFIR yanlıştır.

Bu nedenle XOR'un Mantıksal AND'in uygulandığı şekilde uygulanması için, yalnızca bir bitli (aynı sonucu ve verimliliği veren) ikili değerleri kullanırsınız veya ikili değerin bit yerine bir bütün olarak değerlendirilmesi gerekir. Başka bir deyişle, (010 ^^ 110) = 100 yerine (010 ^^ 110) = FALSE ifadesi. Bu, anlamsal anlamın çoğunu işlemden kaldıracak ve yine de kullanmamanız gereken mantıksal bir testi temsil edecektir.

A ve B, doğruluk tablosunun aynı görünmesi için! = Xor ile aynı olması için boole değerleri olmalıdır. ! (A == B) lol da kullanabilirsiniz.

Çok popüler sınıfı kullanıyorum "org.apache.commons.lang.BooleanUtils"

Bu yöntem birçok kullanıcı tarafından test edilmiştir ve güvenlidir. İyi eğlenceler. Kullanımı:

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

Boole veri türü bir tamsayı gibi saklandığından, bit operatörü ^ boole değerleriyle birlikte kullanılırsa XOR işlemi gibi işlev görür.

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

İşte bir örnek:

2 int değeri verildiğinde, biri negatifse diğeri pozitifse true değerini döndürün. "Negatif" parametresi doğru değilse, yalnızca her ikisi de negatifse true değerini döndürün.

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

kendi operatörlerinizi uygulamak için Scala'ya geçmeniz gerekecek

boru örneği