การสร้างโอเปอเรเตอร์“ ตรรกะพิเศษหรือ” ใน Java

ข้อสังเกต:

Java มีตัวดำเนินการตรรกะและ AND
Java มีตัวดำเนินการ OR เชิงตรรกะ
Java มีตัวดำเนินการ NOT แบบโลจิคัล

ปัญหา:

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
false ^ true = true
จริง ^ false = จริง
true ^ true = false

มันไม่ใช่ x! = y?

Java มีตัวดำเนินการตรรกะและ AND
Java มีตัวดำเนินการ OR เชิงตรรกะ

ไม่ถูกต้อง.

Java ได้

• ตรรกะและตัวดำเนินการสองตัว: ปกติและคือ & และลัดวงจรและคือ &&, และ
• ตัวดำเนินการตรรกะสองตัวหรือ OR: ปกติ OR คือ | และลัดวงจรหรือคือ ||

XOR มีเพียงเป็น ^ เท่านั้นเนื่องจากไม่สามารถประเมินการลัดวงจรได้

บางทีคุณอาจจะเข้าใจผิดความแตกต่างระหว่าง&และ&&, |และ|| วัตถุประสงค์ของผู้ประกอบการทางลัด&&และ||เป็นว่าค่าของตัวถูกดำเนินการครั้งแรกที่สามารถตรวจสอบผลและเพื่อให้ตัวถูกดำเนินการที่สองไม่ต้องมีการประเมิน

สิ่งนี้มีประโยชน์อย่างยิ่งหากตัวถูกดำเนินการตัวที่สองส่งผลให้เกิดข้อผิดพลาด เช่น

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

อย่างไรก็ตามกับแฮคเกอร์ที่คุณมักจะมีการประเมินผลการดำเนินที่สองที่จะได้รับผลเพื่อให้การดำเนินการเพียง ^แต่มีความหมายคือ

คุณสามารถเขียนได้ (a!=b)

a ^ bนี้จะทำงานเช่นเดียวกับวิธีที่เป็น

นั่นเป็นเพราะผู้ปฏิบัติงานเกินกำลังเป็นสิ่งที่พวกเขาออกจากภาษาโดยเฉพาะอย่างจงใจ พวกเขา "โกง" เล็กน้อยด้วยการเรียงสตริง แต่ยิ่งไปกว่านั้นฟังก์ชั่นดังกล่าวไม่มีอยู่จริง

(ข้อจำกัดความรับผิดชอบ: ฉันไม่ได้ทำงานร่วมกับจาวารุ่นใหญ่ 2 ตัวล่าสุดดังนั้นหากในตอนนี้ฉันจะแปลกใจมาก)

โอเปอเรเตอร์ที่โอเวอร์โหลดใน Java เท่านั้นคือ + on 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;
}

สนุก

!=แต่เพียงผู้เดียวหรือตรรกะในชวาเรียกว่า คุณสามารถใช้^หากคุณต้องการทำให้เพื่อนสับสน

คุณสามารถใช้Xtend (Infix Operators และ Operator Overloading)เพื่อทำ overload operator และ 'stay' บน Java

สิ่งที่คุณถามจะไม่สมเหตุสมผล นอกจากว่าฉันผิดคุณแนะนำให้คุณใช้ XOR เพื่อดำเนินการทางตรรกะเช่นเดียวกับ AND และ OR รหัสที่คุณให้มาแสดงสิ่งที่ฉันขอให้:

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

ฟังก์ชั่นของคุณมีอินพุตบูลีนและเมื่อใช้ค่าบิต XOR บนบูลีนผลลัพธ์จะเหมือนกับรหัสที่คุณให้ กล่าวอีกนัยหนึ่ง Bitwise XOR นั้นมีประสิทธิภาพอยู่แล้วเมื่อทำการเปรียบเทียบแต่ละบิต (booleans) หรือเปรียบเทียบแต่ละบิตในค่าที่มากขึ้น เมื่อต้องการใส่สิ่งนี้ลงในบริบทในแง่ของค่าไบนารีค่าที่ไม่เป็นศูนย์ใด ๆ คือ TRUE และ ZERO เท่านั้นที่เป็นเท็จ

ดังนั้นสำหรับ XOR ที่จะใช้วิธีเดียวกับ Logical 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
            */
        }
    }

นี่คือตัวอย่าง:

รับค่า int 2 ค่าส่งคืนจริงถ้ามีค่าเป็นลบและอีกค่าหนึ่งเป็นค่าบวก ยกเว้นถ้าพารามิเตอร์ "ลบ" เป็นจริงจากนั้นส่งคืนจริงเฉพาะในกรณีที่ทั้งสองเป็นลบ

    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 เพื่อดำเนินการกับผู้ให้บริการของคุณเอง

ตัวอย่างท่อ