ฉันเป็นคำตอบที่เพิ่มขึ้นเล็กน้อย (เนื่องจากจนถึงตอนนี้พวกเขามุ่งเน้นไปที่คำศัพท์ "ของตัวเอง" / ประดิษฐ์โดยมุ่งเน้นที่การเขียนโปรแกรมภาษาเฉพาะแทนที่จะดูแลภาพใหญ่กว่าเบื้องหลังการสร้างภาษาโปรแกรมโดยทั่วไปคือเมื่อสิ่งต่าง ๆ เช่นข้อควรพิจารณาเกี่ยวกับประเภทความปลอดภัยและความจำทำให้เกิดความแตกต่าง):
int ไม่ใช่บูลีน
พิจารณา
boolean bar = true;
System.out.printf("Bar is %b\n", bar);
System.out.printf("Bar is %d\n", (bar)?1:0);
int baz = 1;
System.out.printf("Baz is %d\n", baz);
System.out.printf("Baz is %b\n", baz);
กับเอาท์พุท
Bar is true
Bar is 1
Baz is 1
Baz is true
รหัส Java ในบรรทัดที่ 3 (bar)?1:0แสดงให้เห็นว่าบาร์ ( บูล ) ไม่สามารถแปลงโดยปริยาย (หล่อ) เป็นint ฉันกำลังนำเรื่องนี้ขึ้นมาเพื่อไม่แสดงให้เห็นถึงรายละเอียดของการดำเนินการที่อยู่เบื้องหลัง JVM แต่เพื่อชี้ให้เห็นว่าในแง่ของการพิจารณาในระดับต่ำ (เป็นขนาดหน่วยความจำ) หนึ่งจะต้องชอบค่ามากกว่าความปลอดภัย โดยเฉพาะอย่างยิ่งถ้าความปลอดภัยประเภทนั้นไม่ได้ใช้อย่างแท้จริง / อย่างเต็มที่ในประเภทบูลีนซึ่งการตรวจสอบจะทำในรูปแบบของ
ถ้า value \ in {0,1} แล้วส่งไปยังประเภทบูลีนมิฉะนั้นจะเกิดข้อยกเว้น
ทั้งหมดเพียงระบุว่า {0,1} <{-2 ^ 31, .. , 2 ^ 31 -1} ดูเหมือนว่า overkill ใช่ไหม? ความปลอดภัยของประเภทนั้นมีความสำคัญอย่างแท้จริงในประเภทที่ผู้ใช้กำหนดไม่ใช่การคัดเลือกแบบดั้งเดิม (แม้ว่าจะรวมอยู่ในครั้งแรก)
ไบต์ไม่ใช่ชนิดหรือบิต
โปรดทราบว่าในหน่วยความจำตัวแปรของคุณจากช่วง {0,1} จะยังคงครอบครองอย่างน้อยหนึ่งไบต์หรือคำ (xbits ขึ้นอยู่กับขนาดของการลงทะเบียน) เว้นแต่ได้รับการดูแลเป็นพิเศษ (เช่นบรรจุไว้ในหน่วยความจำ - 8 "boolean" บิตเป็น 1 ไบต์ - ไปมา)
โดยการเลือกประเภทความปลอดภัย (เช่นในการใส่ / ห่อค่าลงในกล่องชนิดพิเศษ) บนการบรรจุแบบพิเศษ (เช่นการใช้บิตกะหรือเลขคณิต) ผู้ใช้เลือกที่จะเขียนโค้ดน้อยลงเพื่อเพิ่มหน่วยความจำมากขึ้น (ในอีกด้านหนึ่งสามารถกำหนดประเภทผู้ใช้ที่กำหนดเองซึ่งจะช่วยให้การแปลงทั้งหมดไม่คุ้มค่ากว่าบูลีน)
คำหลักกับประเภท
สุดท้ายคำถามของคุณเกี่ยวกับการเปรียบเทียบคำหลักเมื่อเทียบกับประเภท ผมเชื่อว่ามันเป็นสิ่งสำคัญที่จะอธิบายว่าทำไมหรือวิธีการว่าคุณจะได้รับประสิทธิภาพการทำงานโดยใช้ / เลือกคำหลัก ( "เครื่องหมาย" เป็นดั้งเดิม ) มากกว่าประเภท (เรียนที่ผู้ใช้กำหนดปกติคอมโพสิตใช้คำอีกชั้น ) หรืออีกนัยหนึ่ง
boolean foo = true;
เมื่อเทียบกับ
Boolean foo = true;
"สิ่ง" แรก (ประเภท) ไม่สามารถขยายได้ (คลาสย่อย) และไม่ได้โดยไม่มีเหตุผล คำศัพท์ Java อย่างมีประสิทธิภาพของคลาสดั้งเดิมและ คลาสการตัดคำสามารถแปลเป็นค่าอินไลน์ (ตัวย่อหรือค่าคงที่ที่ถูกแทนที่โดยตรงโดยคอมไพเลอร์เมื่อใดก็ตามที่เป็นไปได้ที่จะอนุมานการแทนค่าหรือถ้าไม่ -
การเพิ่มประสิทธิภาพสามารถทำได้เนื่องจากเรื่องเล็กน้อย:
"การดำเนินการแคสต์ Runtime น้อยลง => ความเร็วมากขึ้น"
นั่นคือเหตุผลที่เมื่อทำการอนุมานประเภทจริงมันอาจ (ยัง) สิ้นสุดในการอินสแตนซ์ของคลาสการตัดคำด้วยข้อมูลชนิดทั้งหมดหากจำเป็น
ดังนั้นความแตกต่างระหว่างบูลีนและบูลีนจึงอยู่ในการรวบรวมและรันไทม์ (ค่อนข้างไกล แต่เกือบจะเหมือนกับinstanceofกับgetClass () )
ในที่สุดการ Autoboxing ช้ากว่าระบบพื้นฐาน
สังเกตความจริงที่ว่า Java สามารถทำการautoboxingเป็นเพียง "น้ำตาลทราย" มันไม่ได้เพิ่มความเร็วอะไรเลยเพียงแค่ให้คุณเขียนโค้ดน้อยลง แค่นั้นแหละ. ยังคงดำเนินการส่งและตัดคำในคอนเทนเนอร์ข้อมูลชนิด สำหรับเหตุผลด้านประสิทธิภาพให้เลือกเครื่องคิดเลขซึ่งจะข้ามการทำความสะอาดพิเศษของการสร้างอินสแตนซ์ของชั้นเรียนพร้อมกับข้อมูลประเภทเพื่อใช้ความปลอดภัยของประเภท การขาดความปลอดภัยประเภทคือราคาที่คุณจ่ายเพื่อให้ได้ประสิทธิภาพ สำหรับรหัสที่มีความปลอดภัยประเภทนิพจน์ที่มีค่าบูลีน (เมื่อคุณเขียนน้อยลงและรหัสโดยนัย ) จะมีความสำคัญเช่นสำหรับ if-then-else flow control