ข้อมูลจำเพาะหมายเลข L (ยาว) ของ Java

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

มีข้อกำหนดตัวเลขอื่น ๆ เช่นสั้นไบต์ลอยคู่หรือไม่? ดูเหมือนว่าสิ่งเหล่านี้จะดีที่จะมีเพราะ (ฉันถือว่า) ถ้าคุณสามารถระบุหมายเลขที่คุณกำลังพิมพ์เป็นตัวย่อ java ก็ไม่ต้องแคสต์ - นั่นเป็นข้อสันนิษฐานโปรดแก้ไขฉันถ้าฉันผิด . ปกติฉันจะค้นหาคำถามนี้ด้วยตัวเอง แต่ฉันไม่รู้ว่าข้อกำหนดตัวเลขประเภทนี้เรียกว่าอะไร

มีคำต่อท้ายเฉพาะสำหรับlong(เช่น39832L) float(เช่น2.4f) และdouble(เช่น-7.832d)

หากไม่มีคำต่อท้ายและเป็นประเภทอินทิกรัล (เช่น5623) จะถือว่าเป็นintไฟล์. ถ้าไม่ใช่ประเภทอินทิกรัล (เช่น3.14159) จะถือว่าเป็นกdouble.

ในกรณีอื่น ๆ ( byte, short, char) คุณต้องโยนเป็นไม่มีคำต่อท้ายที่เฉพาะเจาะจง

ข้อมูลจำเพาะ Java ช่วยให้ทั้งบนและล่างต่อท้ายกรณี แต่รุ่นกรณีบนสำหรับlongs เป็นที่ต้องการเป็นกรณีบนLน้อยง่ายต่อการสับสนกับเลขกว่ากรณีที่ต่ำกว่า1l

ดูรายละเอียดเกี่ยวกับเลือดในส่วน JLS 3.10 (ดูคำจำกัดความของIntegerTypeSuffix)

ฉันหวังว่าคุณจะไม่สนใจเรื่องสัมผัสเล็กน้อย แต่คิดว่าคุณอาจสนใจที่จะรู้ว่านอกจากF(สำหรับลอย) D(สำหรับคู่) และL(นาน) แล้วยังมีการเสนอให้เพิ่มคำต่อท้ายสำหรับbyteและshort- YและSตามลำดับ . สิ่งนี้จะขจัดความจำเป็นในการส่งเป็นไบต์เมื่อใช้ไวยากรณ์แบบอักษรสำหรับอาร์เรย์ไบต์ (หรือแบบสั้น) อ้างถึงตัวอย่างจากข้อเสนอ:

ประโยชน์ที่สำคัญ: เหตุใดแพลตฟอร์มจึงดีกว่าหากมีการนำข้อเสนอมาใช้

รหัส cruddy เช่น

 byte[] stuff = { 0x00, 0x7F, (byte)0x80,  (byte)0xFF};

สามารถเข้ารหัสเป็นไฟล์

 byte[] ufum7 = { 0x00y, 0x7Fy, 0x80y, 0xFFy };

Joe Darcy ดูแล Project Coin สำหรับ Java 7 และบล็อกของเขาเป็นวิธีง่ายๆในการติดตามข้อเสนอเหล่านี้

โดยค่าเริ่มต้นประเภทข้อมูลไพรเมตอินทิกรัลใด ๆ (ไบต์สั้น int ยาว) จะถือว่าเป็นประเภทintโดยคอมไพเลอร์ java สำหรับไบต์และสั้นตราบเท่าที่ค่าที่กำหนดให้อยู่ในช่วงไม่มีปัญหาและไม่จำเป็นต้องมีส่วนต่อท้าย หากค่าที่กำหนดให้กับไบต์และสั้นเกินช่วงจำเป็นต้องมีการแคสต์ประเภทที่ชัดเจน

เช่น:

byte b = 130; // CE: range is exceeding.

เพื่อเอาชนะการหล่อประเภทนี้

byte b = (byte)130; //valid, but chances of losing data is there.

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

Long l = 2147483647; //which is max value of int

ในกรณีนี้ไม่จำเป็นต้องมีคำต่อท้ายเช่น L / l โดยค่าเริ่มต้น 2147483647 ถือว่าคอมไพเลอร์ java คือประเภท int การหล่อประเภทภายในทำโดยคอมไพเลอร์และ int เลื่อนระดับเป็นประเภทยาวโดยอัตโนมัติ

Long l = 2147483648; //CE: value is treated as int but out of range 

ที่นี่เราต้องใส่คำต่อท้ายเป็น L เพื่อให้ถือว่า 2147483648 ลิเทอรัลเป็นแบบยาวโดยคอมไพเลอร์ java

ในที่สุด

Long l = 2147483648L;// works fine.

สิ่งเหล่านี้เป็นตัวอักษรและอธิบายไว้ในส่วนที่ 3.10ของข้อกำหนดภาษา Java

ดูเหมือนว่าสิ่งเหล่านี้จะดีที่จะมีเพราะ (ฉันถือว่า) ถ้าคุณสามารถระบุหมายเลขที่คุณกำลังพิมพ์เป็นตัวย่อ java ก็ไม่ต้องแคสต์

เนื่องจากการแยกวิเคราะห์ตัวอักษรเกิดขึ้นในเวลาคอมไพล์จึงไม่เกี่ยวข้องอย่างยิ่งในเรื่องประสิทธิภาพ เหตุผลเดียวที่มีshortและbyteคำต่อท้ายจะดีก็คือทำให้โค้ดมีขนาดกะทัดรัดมากขึ้น

เพื่อให้เข้าใจว่าเหตุใดจึงจำเป็นต้องแยกความแตกต่างระหว่างintและlongตัวอักษรให้พิจารณา:

long l = -1 >>> 1;

เทียบกับ

int a = -1;
long l = a >>> 1;

lตอนนี้เป็นคุณอย่างถูกต้องคาดว่าจะได้ทั้งเศษรหัสให้ค่าเดียวกันกับตัวแปร โดยไม่สามารถแยกแยะintและตามlongตัวอักษรได้การตีความหมายถึง-1 >>> 1อะไร?

-1L >>> 1 // ?

หรือ

(int)-1 >>> 1 // ?

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

นี้ไม่ได้เกิดขึ้นbyte, shortและcharเพราะพวกเขามีการส่งเสริมเสมอก่อนที่จะดำเนินการทางคณิตศาสตร์และค่าที่เหมาะสม เนื้อหาควรเป็นคำต่อท้ายประเภทจำนวนเต็มเพื่อใช้ในการพูดนิพจน์การเริ่มต้นอาร์เรย์ แต่ไม่มี floatใช้คำต่อท้ายfและdouble d. ตัวอักษรอื่น ๆ nullมีชนิดที่ชัดเจนกับการมีชนิดพิเศษสำหรับ