Java บูลีน

คำว่า "บูลีน" ในบริบทของภาษาจาวาสามารถใช้ในความหมายที่แตกต่างกัน แม้ว่าจะมีความเกี่ยวข้องกันมากก็ตาม มันอาจจะเป็น:

ประเภทดั้งเดิม บูลีนหรือ ตัวแปร บูลีนประเภทนี้
Java Boolean class หรือBoolean wrapper object
นิพจน์ บูลีนค่าบูลีน เงื่อนไขบางอย่าง
ตัวดำเนินการบูลีน Java

ในบทความนี้ เราจะกล่าวถึงตัวเลือกเหล่านี้ทั้งหมดและอธิบายว่าแนวคิดใดที่อยู่ภายใต้นิพจน์ บูลีน บูลีน Java - 1

บูลีนในความหมายทั่วไปคืออะไร

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

“หิมะขาวโพลน” “จระเข้บินได้” “2 + 2 = 4” “1 + 1 = 21”

ในขณะเดียวกัน "2" หรือ "snow" ไม่ใช่นิพจน์บูลีน

ชนิดข้อมูลดั้งเดิมบูลีน Java และตัวแปรบูลีน

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


boolean myBoolean; //boolean variable
myBoolean = false; 
boolean myBoolean1 = true; //another boolean variable

ที่นี่เรามี 2 ตัวแปรบูลีน ลองเขียนโปรแกรมขนาดเล็กด้วยตัวอย่างการใช้ ประเภท บูลีน :


//boolean variable example
public class BoolTest {

   public static void main(String[] args) {
       boolean myBoolean = false;
       System.out.println(myBoolean);
   }
}

โปรแกรมนี้พิมพ์ "เท็จ" ไปที่คอนโซล อย่างไรก็ตาม ตัวแปร บูลีนถูกตั้งค่าเป็นเท็จโดยค่าเริ่มต้น แต่ Java ไม่อนุญาตให้คุณทำงานกับตัวแปรโลคัลที่ไม่ได้กำหนดค่าเริ่มต้น

นิพจน์บูลีนในภาษาจาวา

นอกเหนือจากการเริ่มต้น ตัวแปร บูลีนให้เป็นจริงหรือเท็จอย่างชัดเจนแล้ว ชนิดข้อมูล บูลีนยังถูกใช้โดยปริยายในหลายแห่ง เช่นเดียวกับผลลัพธ์ของการบวกตัวเลขใด ๆ จะเป็นตัวเลข ผลลัพธ์ของการเปรียบเทียบใด ๆ จะเป็นจริงหรือเท็จ นั่นคือจะเป็นประเภทบูลีน ซึ่งหมายความว่า นอกเหนือจากการระบุค่าบูลีนโดยตรงผ่าน คำสั่งการกำหนดตัวแปร บูลีนแล้ว ค่าบูลีนเป็นผลมาจากการเปรียบเทียบต่างๆ เช่น5 > 2และใช้ในคำสั่งเงื่อนไขและคำสั่งวนซ้ำเป็นหลัก นี่คือตัวอย่างของการใช้ ประเภท บูลีน :


public class BoolTest {

   public static void main(String[] args) {
       boolean myBoolean = false;
       int a = 5;
       int b = 7;
       System.out.println(a < b);
       System.out.println(0 > 7);
       System.out.println(myBoolean == false);
   }
}

ผลลัพธ์คือ:

จริง เท็จ จริง

ในกรณีของa < bตัว ดำเนินการ <จะเปรียบเทียบนิพจน์ทางซ้ายกับนิพจน์ทางขวา เราแสดงผลการเปรียบเทียบบนหน้าจอ ตั้งแต่5 < 7 (คำสั่งเป็นจริง) ค่าจริงจะถูกพิมพ์ไปยังคอนโซล ในกรณีที่สอง เราจะแสดงการเปรียบเทียบโดยตรงระหว่างศูนย์กับเจ็ด และในกรณีที่สาม เราจะถามว่าค่าของตัวแปรmyBooleanเป็นเท็จหรือไม่ เนื่องจากเป็นกรณีนี้ เราจึงส่งออกค่าเป็นtrue ในการสร้าง นิพจน์ บูลีนใน Java เราสามารถใช้ตัวดำเนินการเปรียบเทียบใดๆ ก็ได้:

ตัวดำเนินการเปรียบเทียบ	ตัวดำเนินการจาวา	ตัวอย่างการดำเนินการ	ผลการดำเนินงาน
น้อย	<	ก < ข	เป็นจริงถ้าaน้อยกว่าbมิฉะนั้นจะเป็นเท็จ
มหานคร	>	ก > ข	จริงถ้าaมากกว่าbมิฉะนั้นเท็จ
น้อยกว่าหรือเท่ากับ	<=	ก <= ข	เป็นจริงถ้าaน้อยกว่าbหรือเท่ากัน มิฉะนั้นเป็นเท็จ
มากกว่าหรือเท่ากับ	>=	ก >= ข	จริงถ้าaมากกว่าหรือเท่ากับbมิฉะนั้นจะเป็นเท็จ
เท่ากัน	==	ก == ข	จริงถ้าaเท่ากับbมิฉะนั้นเท็จ
ไม่เท่ากับ	!=	ก != ข	จริงถ้าaไม่เท่ากับbมิฉะนั้นเท็จ

ในกรณีที่ใช้ค่าบูลีน

ค่าบูลีนและนิพจน์เงื่อนไขมักใช้ในเงื่อนไขของงบสาขา ตัวดำเนินการ ternary และลูป ในความเป็นจริง การใช้งานขึ้นอยู่กับการตรวจสอบนิพจน์บูลี น ตัวอย่างเช่น:


public class BoolTest2 {
       public static void main(String[] args) {
           int i = 0;
           while (i <= 10)
           {
               System.out.println(i);
               i++;
           }         
      }
}

โปรแกรมนี้พิมพ์ลำดับของจำนวนเต็มและเพิ่มขึ้นทีละหนึ่งตราบเท่าที่ตรงตามเงื่อนไขในวงเล็บหลังจากเครื่องหมาย while นั่นคือในขณะที่นิพจน์i <=10เป็นจริง

ตัวดำเนินการบูลีน Java การสร้างนิพจน์บูลีนด้วยตัวดำเนินการบูลีน

การดำเนินการทางตรรกะ (หรือบูลีน) ต่อไปนี้พร้อมใช้งานใน Java:

การปฏิเสธเชิงตรรกะก็ยังไม่ใช่หรือการผกผัน ใน Java แสดงด้วยสัญลักษณ์! ก่อนการแสดงออก
เชิงตรรกะ และ ยังเป็น AND หรือการร่วม แสดงด้วยสัญลักษณ์&ระหว่างสองนิพจน์ที่ใช้
ตรรกะหรือใน Java มันก็เป็น OR มันก็เป็น disjunction ใน Java แสดงด้วยสัญลักษณ์| ระหว่างสองนิพจน์
Exclusive หรือ XOR การแยกส่วนอย่างเข้มงวด ใน Java จะแสดงด้วยสัญลักษณ์^ระหว่างสองนิพจน์
ใน Java ตัวดำเนินการเชิงตรรกะรวมถึงเงื่อนไขหรือแสดงเป็น|| เช่น เดียวกับเงื่อนไขและ&&

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


a | b == true

ตัวดำเนินการบูลีน Java	ชื่อ	พิมพ์	คำอธิบาย	ตัวอย่าง
!	ตรรกะ "ไม่" (ปฏิเสธ)	คนเดียว	!xหมายถึง “ไม่ใช่ x” คืนค่าจริงหากxเป็นเท็จ คืนค่าเท็จหากxเป็นจริง	`boolean x = true;` แล้ว `// !x == false`
&	ตรรกะ "และ" (และการคูณเชิงตรรกะ)	ไบนารี่	(a & b )คืนค่า trueถ้าทั้งaและbเป็นจริง	`a = true; b = false;` แล้ว `a & b == false`
\|	ตรรกะ OR (การบวกเชิงตรรกะ)	ไบนารี่	(a \| b)คืนค่า trueถ้าaหรือbหรือทั้งคู่เป็นจริง	`a = true; b = false;` แล้ว
^	ตรรกะเอกสิทธิ์เฉพาะบุคคลหรือ (XOR)	ไบนารี่	(a ^ b)คืนค่า trueถ้ามีเพียงตัวถูกดำเนินการ (a หรือ b) ที่เป็นจริง ส่งคืนค่าเท็จถ้าaและbเป็นจริงหรือเท็จพร้อมกัน ในความเป็นจริง ถ้าaไม่เท่ากับbมันจะคืนค่าเป็นจริง	`a = true; b = false;` แล้ว `a ^ b == true`
&&	เงื่อนไข AND (ตัวย่อตรรกะ AND)	ไบนารี่	a && bมันเหมือนกับa & bแต่ถ้า a เป็นเท็จตัวดำเนินการจะส่งกลับเป็นเท็จโดยไม่ต้องตรวจสอบb
\|\|	เงื่อนไข OR (ตรรกะย่อ OR)	ไบนารี่	ก \|\| bเหมือนกับa \| bแต่ถ้าaเป็นจริงตัวดำเนินการจะส่งกลับค่าจริงโดยไม่ต้องตรวจสอบb

โปรดทราบว่าใน Java ตัวดำเนินการ& , | และ^ใช้กับจำนวนเต็มด้วย ในกรณีนี้ พวกมันทำงานแตกต่างกันเล็กน้อยและเรียกว่าตัวดำเนินการเชิงตรรกะระดับบิต (หรือระดับบิต) มาดูตัวอย่างและแสดงนิพจน์เชิงตรรกะหลายตัวที่ประกอบขึ้นโดยใช้ตัวดำเนินการเชิงตรรกะ


public class BoolTest2 {
   public static void main(String[] args) {
   int a = 5;
   int b = 7;
   boolean myBool1 = true;
   boolean myBool2 = false;
       System.out.println(myBool1&myBool2);
       System.out.println(myBool1|myBool2);
       System.out.println(!myBool1);
       System.out.println((a > b) & !myBool1 | myBool2);
   }
}

นี่คือผลลัพธ์:

เท็จ จริง เท็จ เท็จ

ในความเป็นจริง คุณสามารถสร้างโครงสร้างเชิงตรรกะที่ซับซ้อนมากได้โดยใช้ตัวดำเนินการเชิงตรรกะ ตัวอย่างเช่น

(a<!b)&(q+1 == 12)^(!a | c & b > 1 + b)|(q ^ a > !b)

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

ลำดับความสำคัญของการดำเนินการทางตรรกะ

ในวิชาคณิตศาสตร์ ในการเขียนโปรแกรม ตัวดำเนินการจะมีลำดับการดำเนินการเฉพาะหากเกิดขึ้นในนิพจน์เดียวกัน ตัวดำเนินการเอกฐานมีข้อได้เปรียบเหนือตัวดำเนินการไบนารี่ และการคูณ (แม้กระทั่งตรรกะ) เหนือการบวก ต่อไปนี้เป็นโอเปอเรเตอร์เชิงตรรกะที่อยู่ในรายการของหัวข้อที่สูงกว่า ลำดับความสำคัญก็จะยิ่งสูงขึ้น:

เครื่องห่อบูลีนของ Java

ใน Java แต่ละประเภทดั้งเดิมมี "บราเดอร์" ซึ่งเป็นคลาสของ wrapper ( Wrapper ) กระดาษห่อหุ้มเป็นชั้นพิเศษที่เก็บมูลค่าของสิ่งดั้งเดิมไว้ภายใน อย่างไรก็ตาม นี่คือคลาส ดังนั้นคุณจึงสามารถสร้างอินสแตนซ์ (วัตถุ) ของมันได้ วัตถุเหล่านี้เก็บค่าที่จำเป็นของวัตถุโบราณไว้ภายใน ในขณะที่วัตถุเหล่านั้นจะเป็นวัตถุจริง ประเภทดั้งเดิมของบูลีน Java มีคลาส Java Boolean (ที่มีตัวพิมพ์ใหญ่ B) วัตถุ Boolean Class ถูกสร้างขึ้นเหมือนกับสิ่งอื่นๆ:


Boolean b = new Boolean(false);

คลาส Java Boolean มีเมธอดที่เป็นประโยชน์ หนึ่งในสิ่งที่น่าสนใจที่สุดคือวิธีการ parseBoolean วิธีการ บูลีนแบบคงที่ parseBoolean (String s)แยกวิเคราะห์อาร์กิวเมนต์สตริงเป็นบูลีน บูลีนที่ส่งคืนแทนค่าจริงหากอาร์กิวเมนต์สตริงไม่เป็นโมฆะและมีค่าเท่ากับสตริง "จริง" โดยไม่สนใจตัวพิมพ์ มิฉะนั้นจะส่งกลับเป็น เท็จ

ตัวอย่างวิธีการ parseBoolean


public class BoolTest2 {

        public static void main(String[] args)
        {
            System.out.println(Boolean.parseBoolean("True"));
            System.out.println(Boolean.parseBoolean("TRuE"));
            System.out.println(Boolean.parseBoolean("False"));
            System.out.println(Boolean.parseBoolean("here"));

        }
    }

ผลลัพธ์คือ:

จริง จริง เท็จ เท็จ

เพื่อเสริมสิ่งที่คุณได้เรียนรู้ เราขอแนะนำให้คุณดูบทเรียนวิดีโอจากหลักสูตร Java ของเรา