วิธีแปลง long เป็น int ใน Java

ในบทความนี้ เราจะอธิบายวิธีการแปลงlongเป็นintใน Java และเขียนตัวอย่างโค้ด เนื่องจากlongเป็นประเภทข้อมูลที่ใหญ่กว่าintเราจึงควรใช้การหล่อประเภทสำหรับการแปลงดังกล่าว อย่างที่คุณทราบอยู่แล้วว่าทั้งlongและintใน Java เป็นประเภทข้อมูลดั้งเดิม นั่นหมายความว่าพวกมันไม่ใช่คลาสอ็อบเจกต์ อ็อบเจกต์และอาร์เรย์ทั้งหมดถูกจัดเก็บไว้ใน Heap Space ในขณะที่ประเภทดั้งเดิม เช่นintและlongจะถูกจัดเก็บไว้ในหน่วยความจำ Stack ยาวและintค่อนข้างคล้ายกัน จำนวนเต็มหมายถึงจำนวนเต็มที่สามารถเป็นบวก ลบ หรือศูนย์ได้ ยาวทั้งคู่และintเป็นประเภทจำนวนเต็ม ดังนั้นจึงเข้ากันได้ ปัญหาคือ ประเภท ยาวมีตั้งแต่ -263 ถึง 263 – 1 หรือ -9223372036854775808 ถึง 9223372036854775807 นั่นคือ โปรแกรม Java จัดสรร 64 บิตสำหรับประเภทยาว ในเวลาเดียวกัน ประเภท intครอบครอง 32 บิต ซึ่งคุณสามารถใส่ตัวเลขได้ตั้งแต่ -231 до 231 - 1 หรือซึ่งเท่ากันตั้งแต่ -2147483648 ถึง 2147483647 ซึ่งหมายความว่าประเภท int จำนวนเท่าใดก็ได้สามารถใส่ลงในประเภทยาว ใน Java เมื่อทำงานกับ primitives การแปลงจากประเภทที่แคบลงเป็นประเภทที่กว้างขึ้นจะเป็นไปโดยอัตโนมัติ อีกประการหนึ่งเรียกว่าการขยับขยาย

int myInt= 18;
long myLong= 16000;
       myLong = myInt;

ที่นี่เรากำลังกำหนดintให้กับตัวแปรแบบยาว ทุกอย่างเป็นไปอย่างราบรื่น ในช่วงที่กว้างขึ้น ขนาดเล็กลงอย่างเงียบๆ และเราไม่เสียอะไรเลยนอกจากพื้นที่หน่วยความจำ อย่างไรก็ตาม เมื่อเราประกาศตัวแปรประเภทlongและกำหนดค่าของมัน จะเป็นการดีกว่าถ้ากำหนดตัวอักษรlให้กับตัวแปร ซึ่งจะมีประโยชน์เมื่อเราทำงานกับตัวเลขที่อยู่นอกช่วง int

long myVeryLong = 10000000000l;

การแปลง Java ยาวเป็น int

ตอนนี้กลับมาที่ภารกิจหลักของบทความนี้ — การแปลง Java เป็นint ปัญหาคือของที่ใหญ่กว่าไม่เหมาะกับของที่เล็กกว่าเสมอไป ในที่นี้เราไม่สามารถใส่ "เล็กลง" ลงใน "ใหญ่ขึ้น" โดยอัตโนมัติใน Java ได้ หากเราพยายามทำตามตัวอย่างที่แล้ว แต่กลับกัน:

//example without typecasting…nice trying! 
public static void main(String[] args) {

int myInt= 18;
long myLong= 16000;
       myInt = myLong;
}

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

public class longToInt {

   public static void main(String[] args) {

       int myInt = 18;
       long myLong = 16000;
       long myVeryLong = 2147483648l;//l in the end means ‘long’ 
       long myVeryLong = 10000000000l;

       myInt = (int) myLong;
       System.out.println(myInt);
       myInt = (int) oneMoreLong;
       System.out.println(myInt);
       myInt = (int) myVeryLong;
       System.out.println(myInt);
   }
}

เราได้แจ้งให้คอมไพเลอร์ทราบว่าเราต้องการใส่ ค่า longลงใน ตัวแปร intและเราต้องรับผิดชอบต่อผลของการตัดสินใจนี้ คอมไพเลอร์เห็นการบ่งชี้ที่ชัดเจนของประเภทที่แคบกว่า ดำเนินการแปลง เป็นผลให้เราได้รับผลลัพธ์: 16,000 เป็นสิ่งที่เราคาดว่าจะเห็นแน่นอน แต่ทำไมต้องลบใน -2147483648 และ 1410065408 นี้หมายความว่าอย่างไร ความจริงก็คือตัวเลขดังกล่าวถูกเก็บไว้ใน ตัวแปร แบบยาวซึ่งใช้เวลา 64 บิตอย่างที่เราจำได้ เรากำลังพยายามใส่ตัวเลขเหล่านี้ลงใน ตัวแปร intที่เก็บได้เพียง 32 บิต ตามกฎแล้ว 32 เซลล์เหล่านี้จะมีเลขศูนย์และเซลล์จาก 32 บิตแรกของจำนวนยาวและส่วนที่เหลือจะถูกละทิ้งไป ดังนั้นหากจำนวนเดิมไม่พอดีกับ 32 บิต บิตที่ไม่เหมาะสมจะถูกละทิ้งไป นั่นเป็นเหตุผลที่เรามีหมายเลขที่ถูกต้องเพียง 16000 เนื่องจากใช้เวลาน้อยกว่า 32 บิต

การแปลง Java 8 ยาวเป็น int

ใน Java 8 คลาส Mathมีเมธอดใหม่ที่จะแปลงlongเป็นint นี่คือ:

Math.toIntExact(value);

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

public class intToLong {

   public static void main(String[] args) {

       int myInt = 18;
       long myLong = 16000;
       long oneMoreLong = 2147483648l;
       long myVeryLong = 10000000000l;
      
       System.out.println(Math.toIntExact(myLong));
       int y = Math.toIntExact(oneMoreLong);
       System.out.println(oneMoreLong);
       System.out.println(Math.toIntExact(myVeryLong));
   }
}

ผลลัพธ์คือ: ดังนั้น โปรแกรมจึงพิมพ์เฉพาะหมายเลข 16000 ที่แปลงอย่างถูกต้อง และเมื่อพยายามดันหมายเลขที่อยู่นอกช่วง 2147483648l เข้าไปในintเมธอดดังกล่าวก็มีข้อยกเว้น ดังนั้นเราจึงไม่มีปัญหาของบิตที่ถูกละทิ้ง เช่นในกรณีของการแปลง จาวาคลาสสิก แบบยาวเป็นint