แผนภูมิเปรียบเทียบ
| พื้นฐานสำหรับการเปรียบเทียบ | & | && |
|---|---|---|
| ผู้ประกอบการ | มันเป็น "ผู้ประกอบการ Bitwise" | มันเป็น "ผู้ประกอบการตรรกะ" |
| การประเมินผล | มันประเมินทั้งด้านซ้ายและด้านขวาของนิพจน์ | มันประเมินเฉพาะด้านซ้ายของนิพจน์เท่านั้น |
| ทำงานบน | มันทำงานบน "ประเภทข้อมูลบูลีน" เช่นเดียวกับทำงานบน "บิต" | มันทำงานเฉพาะใน "ประเภทข้อมูลบูลีน" |
| ใช้ | ใช้เพื่อตรวจสอบสภาพโลจิคัลและใช้เพื่อปกปิดบิตบางอย่างเช่นบิตพาริตี้ | ใช้เพื่อตรวจสอบสภาพตรรกะเท่านั้น |
คำจำกัดความของ & (Bitwise AND)
ตัวดำเนินการ '&' นี้ใช้เป็นทั้งตัวดำเนินการแบบตรรกะ (&) และตัวดำเนินการระดับบิต มันทำงานบนบูลีนเช่นเดียวกับข้อมูลไบนารี เมื่อ & โอเปอเรเตอร์ถูกใช้เป็นโลจิคัล & โอเปอเรเตอร์จะส่งผลให้ "จริง" ถ้าทั้งสองด้านของนิพจน์ของการประเมินผลเป็นจริงมิฉะนั้นจะส่งคืน "เท็จ" จะช่วยให้คอมไพเลอร์ประเมินทั้งสองด้านของการแสดงออก นั่นคือแม้ว่าด้านซ้ายของนิพจน์จะให้ผลลัพธ์เป็นเท็จ แต่จะประเมินทางด้านขวาของนิพจน์
ให้เราเข้าใจสิ่งนี้ด้วยตัวอย่าง
int a = 4, b = 5; system.out.println ((a == 6) & (b ++ == 6)); system.out.println ("b =" + b); // output false b = 5 ที่นี่ในการประเมินด้านซ้ายของนิพจน์ (a == 6) จะส่งผลให้เป็นเท็จจากนั้นผู้ประกอบการ & ประเมินด้านขวาของการแสดงออก (b ++ == 6) เป็นผลให้ค่าของการเพิ่มขึ้นข
เมื่อ '&' ใช้เป็น "ตัวดำเนินการระดับบิต" อันดับแรกจะแปลงทั้งตัวถูกดำเนินการเป็นรูปแบบไบนารีแล้วดำเนินการโดยใช้ตัวดำเนินการโดยใช้ & ตัวดำเนินการทีละบิต หลังจากการดำเนินการผลลัพธ์ที่ได้รับอยู่ในรูปแบบไบนารีซึ่งจะถูกแปลงเป็นทศนิยม บิตใด ๆ ที่เป็น 0 ในตัวถูกดำเนินการตัวใดตัวหนึ่งให้ผลลัพธ์เป็น 0 หากบิตทั้งสองตัวถูกดำเนินการเป็น 1 แล้วบิตผลลัพธ์คือ 1 บิตและตัวดำเนินการถูกควบคุมโดยตารางความจริงเดียวกับตรรกะ & ตัวดำเนินการ
ให้เราเห็นการทำงานระดับบิตของ & โอเปอเรเตอร์
int a; a = 3 & 4; // 011 & 100 = 000 system.out.println ("a =" + a); // เอาท์พุท a = 0 ที่นี่ค่าทศนิยม 3 และ 4 จะถูกแปลงเป็นรูปแบบไบนารีในตอนแรกจากนั้นตัวดำเนินการ & bitwise จะดำเนินการ & ดำเนินการกับพวกเขาแบบทีละบิต ผลลัพธ์ที่ได้คือรูปแบบไบนารีซึ่งจะถูกแปลงเป็นรูปแบบทศนิยมอีกครั้ง
คำจำกัดความของ && (ลัดวงจรและ)
ตัวดำเนินการ && นี้ทำงานเป็นตัวดำเนินการเชิงตรรกะโดยสิ้นเชิง มันทำงานเฉพาะในประเภทข้อมูลบูลีน มันเรียกว่าผู้ประกอบการลัดวงจร เนื่องจากมันตรวจสอบเฉพาะด้านซ้ายของนิพจน์เท่านั้น หากด้านซ้ายของนิพจน์ส่งผลให้เป็นเท็จแสดงว่าไม่ต้องกังวลกับการประเมินด้านขวาของนิพจน์
ให้เราเข้าใจการทำงานของผู้ประกอบการ && ด้วยตัวอย่าง
int a = 4, b = 5; system.out.println ((a == 6) && (b ++ == 6)); system.out.println ("b =" + b); // output false b = 4 นี่คือเงื่อนไข (a == 6) เป็นเท็จผู้ประกอบการ && ไม่ได้ประเมินการแสดงออก (b ++ == 6) ดังนั้นผลลัพธ์ของค่า b จะไม่เพิ่มขึ้น
ความแตกต่างที่สำคัญระหว่าง & และ &&
- & โอเปอเรเตอร์เป็นตรรกะและโอเปอเรเตอร์ขณะที่มันทำงานกับทั้งบูลีนและข้อมูลไบนารี่ในขณะที่ & & โอเปอเรเตอร์เป็นเพียงผู้ประกอบการเชิงตรรกะ
- ผู้ประกอบการ & ประเมินทั้งสองด้านของการแสดงออกเพื่อให้ได้ผลลัพธ์สุดท้ายในขณะที่ & & ผู้ดำเนินการประเมินเพียงด้านซ้ายของการแสดงออก & ถ้าเปลี่ยนเป็นเท็จมันไม่ได้ประเมินด้านขวาของการแสดงออก
บันทึก:
ในขณะที่ประเมินประเภทข้อมูลบูลีนตัวดำเนินการทั้งสองจะให้ผลลัพธ์เป็น "จริง" เฉพาะถ้าทั้งสองตัวถูกดำเนินการเป็นจริงมิฉะนั้นจะส่งคืน "เท็จ"
สรุป:
ตัวดำเนินการ & และ && ทั้งสองถูกใช้เพื่อประเมินเงื่อนไขบูลีนในขณะที่ตัวดำเนินการ & จะใช้สำหรับการดำเนินการระดับบิต เมื่อเราต้องการประเมินทั้งสองด้านของนิพจน์ตัวดำเนินการ & จะใช้อย่างอื่นเราสามารถใช้ตัวดำเนินการ && ได้
