ตัวดำเนินการทางลัด“ or-assignment” (| =) ใน Java

ฉันมีการเปรียบเทียบที่ต้องทำใน Java มานานและฉันอยากรู้ว่าอย่างน้อยหนึ่งอย่างออกมาเป็นจริงหรือไม่ สตริงของการเปรียบเทียบเป็นเวลานานและยากที่จะอ่านดังนั้นฉันโพล่งขึ้นเพื่อให้สามารถอ่านและจะไปใช้ประกอบการทางลัดมากกว่า|=negativeValue = negativeValue || boolean

boolean negativeValue = false;
negativeValue |= (defaultStock < 0);
negativeValue |= (defaultWholesale < 0);
negativeValue |= (defaultRetail < 0);
negativeValue |= (defaultDelivery < 0);

ฉันคาดว่าnegativeValueจะเป็นจริงหากค่า <something> เริ่มต้นใด ๆ เป็นลบ ใช้ได้หรือไม่ มันจะทำตามที่ฉันคาดหวังหรือไม่? ฉันไม่เห็นมันกล่าวถึงบนไซต์ของ Sun หรือ stackoverflow แต่ดูเหมือนว่า Eclipse จะไม่มีปัญหากับมันและโค้ดจะคอมไพล์และรัน

ในทำนองเดียวกันถ้าฉันต้องการทำการตัดกันเชิงตรรกะหลาย ๆ จุดฉันสามารถใช้&=แทนได้&&หรือไม่?

|=เป็นผู้ประกอบการที่ได้รับมอบหมาย Punch ( JLS 15.26.2 ) สำหรับผู้ประกอบการตรรกะบูลีน|( JLS 15.22.2 ); เพื่อไม่ให้สับสนกับเงื่อนไขหรือ||( JLS 15.24 ) นอกจากนี้ยังมี&=และ^=สอดคล้องกับเวอร์ชันการกำหนดสารประกอบของตรรกะบูลีน&และ^ตามลำดับ

กล่าวอีกนัยหนึ่งสำหรับboolean b1, b2สองสิ่งนี้เทียบเท่ากัน:

 b1 |= b2;
 b1 = b1 | b2;

ความแตกต่างระหว่างตัวดำเนินการเชิงตรรกะ ( &และ|) เมื่อเทียบกับตัวดำเนินการตามเงื่อนไข ( &&และ||) คือตัวดำเนินการไม่ "shortcircuit"; หลังทำ นั่นคือ:

• &และประเมินตัวถูกดำเนินการทั้งสอง| เสมอ
• &&และ||ประเมินผลการดำเนินขวาเงื่อนไข ; ตัวถูกดำเนินการด้านขวาจะได้รับการประเมินก็ต่อเมื่อค่าของมันอาจส่งผลต่อผลลัพธ์ของการดำเนินการไบนารี นั่นหมายความว่าตัวถูกดำเนินการที่ถูกต้องไม่ได้รับการประเมินเมื่อ:
  • ตัวถูกดำเนินการด้านซ้ายของการ&&ประเมินเป็นfalse
    • (เพราะไม่ว่าตัวถูกดำเนินการที่ถูกต้องจะประเมินเป็นอย่างไรนิพจน์ทั้งหมดจะเป็นอย่างไรfalse)
  • ตัวถูกดำเนินการด้านซ้ายของการ||ประเมินเป็นtrue
    • (เพราะไม่ว่าตัวถูกดำเนินการที่ถูกต้องจะประเมินเป็นอย่างไรนิพจน์ทั้งหมดจะเป็นอย่างไรtrue)

ดังนั้นกลับไปที่คำถามเดิมของคุณใช่โครงสร้างนั้นถูกต้องและในขณะที่|=ไม่ใช่ทางลัดที่เทียบเท่ากัน=และ||มันจะคำนวณสิ่งที่คุณต้องการ เนื่องจากทางด้านขวามือของตัว|=ดำเนินการในการใช้งานของคุณเป็นการดำเนินการเปรียบเทียบจำนวนเต็มอย่างง่ายความจริงที่ว่าการ|ไม่ลัดวงจรจึงไม่มีนัยสำคัญ

มีหลายกรณีที่ต้องการการลัดวงจรหรือแม้กระทั่งจำเป็น แต่สถานการณ์ของคุณไม่ใช่หนึ่งในนั้น

มันเป็นโชคร้ายที่แตกต่างจากภาษาอื่น ๆ บาง, Java ไม่ได้และ&&= ||=สิ่งนี้ถูกกล่าวถึงในคำถามทำไม Java ไม่มีเวอร์ชันการกำหนดแบบผสมของตัวดำเนินการตามเงื่อนไขและและเงื่อนไขหรือ (&& =, || =) .

ไม่ใช่ตัวดำเนินการ "ทางลัด" (หรือการลัดวงจร) แบบที่ || และ && (ตามที่พวกเขาจะไม่ประเมิน RHS ถ้าพวกเขารู้อยู่แล้วว่าผลที่ได้ขึ้นอยู่กับ LHS) แต่มันจะทำสิ่งที่คุณต้องการในแง่ของการทำงาน

ตามตัวอย่างของความแตกต่างรหัสนี้จะใช้ได้ถ้าtextเป็นโมฆะ:

boolean nullOrEmpty = text == null || text.equals("")

ในขณะที่สิ่งนี้จะไม่:

boolean nullOrEmpty = false;
nullOrEmpty |= text == null;
nullOrEmpty |= text.equals(""); // Throws exception if text is null

(เห็นได้ชัดว่าคุณสามารถทำได้"".equals(text)สำหรับกรณีนั้น - ฉันแค่พยายามแสดงหลักการ)

คุณสามารถมีคำสั่งเดียว แสดงในหลายบรรทัดซึ่งอ่านได้เกือบจะเหมือนกับโค้ดตัวอย่างของคุณมีความจำเป็นน้อยลงเท่านั้น:

boolean negativeValue
    = defaultStock < 0 
    | defaultWholesale < 0
    | defaultRetail < 0
    | defaultDelivery < 0;

สำหรับนิพจน์ที่ง่ายที่สุดการใช้|อาจเร็วกว่า||เนื่องจากแม้ว่าจะหลีกเลี่ยงการเปรียบเทียบ แต่ก็หมายถึงการใช้สาขาโดยปริยายและอาจมีราคาแพงกว่าหลายเท่า

แม้ว่ามันอาจจะมากเกินไปสำหรับปัญหาของคุณ แต่ห้องสมุดGuavaมีไวยากรณ์ที่ดีกับPredicates และทำการประเมินการลัดวงจรของหรือ / และPredicates

โดยพื้นฐานแล้วการเปรียบเทียบจะกลายเป็นวัตถุบรรจุลงในคอลเลกชั่นจากนั้นจึงวนซ้ำ สำหรับหรือเพรดิเคต Hit จริงแรกจะกลับมาจากการวนซ้ำและในทางกลับกันสำหรับและ

หากเป็นเรื่องเกี่ยวกับความสามารถในการอ่านฉันมีแนวคิดในการแยกข้อมูลที่ทดสอบจากตรรกะการทดสอบ ตัวอย่างโค้ด:

// declare data
DataType [] dataToTest = new DataType[] {
    defaultStock,
    defaultWholesale,
    defaultRetail,
    defaultDelivery
}

// define logic
boolean checkIfAnyNegative(DataType [] data) {
    boolean negativeValue = false;
    int i = 0;
    while (!negativeValue && i < data.length) {
        negativeValue = data[i++] < 0;
    }
    return negativeValue;
}

โค้ดดูละเอียดและอธิบายได้มากขึ้น คุณสามารถสร้างอาร์เรย์ในการเรียกใช้เมธอดได้เช่นนี้:

checkIfAnyNegative(new DataType[] {
    defaultStock,
    defaultWholesale,
    defaultRetail,
    defaultDelivery
});

อ่านได้ง่ายกว่า 'สตริงเปรียบเทียบ' และยังมีข้อได้เปรียบด้านประสิทธิภาพของการลัดวงจร (โดยเสียค่าใช้จ่ายในการจัดสรรอาร์เรย์และการเรียกใช้เมธอด)

แก้ไข: สามารถอ่านได้ง่ายขึ้นโดยใช้พารามิเตอร์ varargs:

ลายเซ็นวิธีจะเป็น:

boolean checkIfAnyNegative(DataType ... data)

และการโทรอาจมีลักษณะดังนี้:

checkIfAnyNegative( defaultStock, defaultWholesale, defaultRetail, defaultDelivery );

เป็นกระทู้เก่า แต่เพื่อให้มุมมองที่แตกต่างสำหรับผู้เริ่มต้นฉันขอยกตัวอย่าง

+=ผมคิดว่าส่วนใหญ่กรณีการใช้งานทั่วไปสำหรับผู้ประกอบการสารคล้ายจะเป็น ฉันแน่ใจว่าเราทุกคนเขียนสิ่งนี้:

int a = 10;   // a = 10
a += 5;   // a = 15

จุดนี้คืออะไร? ประเด็นคือหลีกเลี่ยงการสร้างสำเร็จรูปและกำจัดรหัสซ้ำ

ดังนั้นบรรทัดถัดไปจะb1เหมือนกันทุกประการโดยหลีกเลี่ยงการพิมพ์ตัวแปรซ้ำสองครั้งในบรรทัดเดียวกัน

b1 |= b2;

List<Integer> params = Arrays.asList (defaultStock, defaultWholesale, 
                                       defaultRetail, defaultDelivery);
int minParam = Collections.min (params);
negativeValue = minParam < 0;

|| บูลีนตรรกะหรือ
| บิตหรือ

| = bitwise รวม OR และตัวดำเนินการกำหนด

สาเหตุที่ | = ไม่ shortcircit เป็นเพราะมันทำแบบบิตหรือไม่ใช่ตรรกะหรือ กล่าวคือ:

C | = 2 เหมือนกับ C = C | 2

บทช่วยสอนสำหรับตัวดำเนินการ java