- คลาส wrapper คืออะไร
- การบรรจุอัตโนมัติ/การเปิดบรรจุภัณฑ์ดั้งเดิม
- การดำเนินการของคลาส Integer วิธีการ และค่าคงที่
คลาส Wrapper ประเภทดั้งเดิม
ดังที่คุณทราบ Java มีประเภทข้อมูลหลายประเภท ซึ่งสามารถแบ่งออกเป็นสองช่วงตึก:- ดั้งเดิม;
- อ้างอิง.
- จำนวนเต็ม - ไบต์, สั้น, int, ยาว;
- ตัวเลขทศนิยม (จริง) - ลอย, สองเท่า;
- ชนิดข้อมูลเชิงตรรกะ - บูลีน;
- ชนิดข้อมูลอักขระ - อักขระ
ประเภทดั้งเดิม | คลาสเครื่องห่อ |
---|---|
ไบต์ | ไบต์ |
สั้น | สั้น |
ภายใน | จำนวนเต็ม |
ยาว | ยาว |
ลอย | ลอย |
สองเท่า | สองเท่า |
บูลีน | บูลีน |
ถ่าน | อักขระ |
จำนวนเต็ม _
คลาส Integer เป็นคลาส wrapper ของประเภทดั้งเดิม int คลาสนี้มีฟิลด์ประเภท int เพียงฟิลด์เดียว ในฐานะที่เป็นคลาส wrapper Integer จัดเตรียมวิธีการต่างๆ สำหรับการทำงานกับ int รวมถึงวิธีการต่างๆ ในการแปลง int เป็น String และ String เป็น int ด้านล่างนี้เราจะดูตัวอย่างต่างๆ ของการทำงานร่วมกับชั้นเรียน เริ่มต้นด้วยการสร้างสรรค์ ตัวเลือกการสร้างที่ใช้บ่อยที่สุด (และง่ายที่สุด) คือ:
Integer a = 3;
นั่นคือ การเริ่มต้นของตัวแปร Integer ในกรณีนี้จะคล้ายกับการเริ่มต้นของตัวแปร int นอกจากนี้ ตัวแปร Integer สามารถเริ่มต้นได้ด้วยค่าของตัวแปร int:
int i = 5;
Integer x = i;
System.out.println(x); // 5
ในกรณีข้างต้น การบรรจุอัตโนมัติจะเกิดขึ้นโดยปริยาย เราจะพูดถึงเรื่องนี้เพิ่มเติมด้านล่าง นอกเหนือจากตัวเลือกการเริ่มต้นที่ระบุไว้ข้างต้นแล้ว ตัวแปรจำนวนเต็มยังสามารถสร้างได้เหมือนกับออบเจ็กต์อื่นๆ โดยใช้ตัวสร้างและคีย์เวิร์ดใหม่:
Integer x = new Integer(25);
System.out.println(x);
อย่างไรก็ตาม ใช้เวลาในการเขียนนานกว่าและอ่านนานกว่า ดังนั้นตัวเลือกนี้จึงพบบ่อยน้อยที่สุด คุณสามารถทำทุกอย่างด้วยตัวแปร Integer ซึ่งคุณสามารถทำได้ด้วยตัวแปร int พวกเขาสามารถเป็น:
พับ |
|
ลบ |
|
คูณ |
|
แบ่ง |
|
เพิ่มขึ้น |
|
ลดลง |
|
Integer a = null;
Integer b = a + 1; // Здесь мы упадем с "Exception in thread "main" java.lang.NullPointerException"
System.out.println(b);
การดำเนินการเปรียบเทียบส่วนใหญ่ดำเนินการในลักษณะเดียวกับในประเภทดั้งเดิม int:
Integer a = 1;
Integer b = 2;
System.out.println(a > b);
System.out.println(a >= b);
System.out.println(a < b);
System.out.println(a <= b);
เอาท์พุท:
false
false
true
true
การดำเนินการเปรียบเทียบตัวแปรจำนวนเต็มสองตัวมีความโดดเด่น และประเด็นก็คือ Integer เป็นประเภทข้อมูลอ้างอิง และตัวแปรของมันจะเก็บการอ้างอิงถึงค่า ไม่ใช่ค่าของตัวเอง (วัตถุ) การแสดงข้อเท็จจริงนี้สามารถสังเกตได้เมื่อดำเนินการส่วนโค้ดต่อไปนี้:
Integer a = 1;
Integer b = 1;
Integer c = new Integer(1);
System.out.println(a == b); // true
System.out.println(a == c); // false
ผลลัพธ์ของความเท่าเทียมกันครั้งแรกจะเป็นจริง และผลลัพธ์ที่สองจะเป็นเท็จ สิ่งนี้เกิดขึ้นเพราะในกรณีแรกเราเปรียบเทียบตัวแปรสองตัว (“a” และ “b”) ที่เก็บการอ้างอิงไปยังวัตถุเดียวกัน และในกรณีที่สอง เราจะเปรียบเทียบตัวแปรสองตัวที่อ้างถึงวัตถุสองชิ้นที่แตกต่างกัน (เมื่อสร้างตัวแปร “c” เราจะสร้างวัตถุใหม่) ขอยกตัวอย่างที่น่าสนใจอีกตัวอย่างหนึ่ง:
Integer a = 1;
Integer b = 1;
Integer x = 2020;
Integer y = 2020;
System.out.println(a == b); // true
System.out.println(x == y); // false
ดังที่เราเห็น ผลลัพธ์ของการเปรียบเทียบครั้งแรกเป็นจริง และผลลัพธ์ของการเปรียบเทียบครั้งที่สองเป็นเท็จ มันคือทั้งหมดที่เกี่ยวกับการแคช จำนวนเต็มทั้งหมดในช่วงตั้งแต่ -128 ถึง 127 รวม (ค่าเหล่านี้สามารถปรับแต่งได้) จะถูกแคชไว้ ดังนั้นเมื่อเราสร้างตัวแปรใหม่และกำหนดค่าจำนวนเต็มระหว่าง -128 ถึง 127 ให้กับมัน เราไม่ได้สร้างอ็อบเจ็กต์ใหม่ แต่เป็นการกำหนดตัวแปรให้อ้างอิงกับอ็อบเจ็กต์ที่สร้างไว้แล้วในแคช เมื่อรู้ข้อเท็จจริงนี้แล้ว ตัวอย่างข้างต้นก็ดูไม่ลึกลับนัก ตัวแปร a และ b อ้างถึงวัตถุเดียวกัน - วัตถุจากแคช และในระหว่างการเริ่มต้นตัวแปร x และ y เราได้สร้างออบเจ็กต์ใหม่ในแต่ละครั้ง และตัวแปรเหล่านี้จะจัดเก็บการอ้างอิงไปยังออบเจ็กต์ต่างๆ และดังที่คุณทราบ ตัวดำเนินการ == จะเปรียบเทียบค่าของตัวแปร และค่าของตัวแปรอ้างอิงจะเป็นข้อมูลอ้างอิง หากต้องการตรวจสอบความเท่าเทียมกันระหว่างตัวแปร Integer สองตัวอย่างแม่นยำ คุณต้องใช้วิธีเท่ากับ (ไม่ว่าจะฟังดูเล็กน้อยแค่ไหนก็ตาม) ลองเขียนตัวอย่างด้านบนนี้ใหม่:
Integer a = 1;
Integer b = 1;
Integer x = 2020;
Integer y = 2020;
System.out.println(a.equals(b)); // true
System.out.println(x.equals(y)); // true
การใส่กล่องอัตโนมัติและการแกะกล่องจำนวนเต็ม
การบรรจุและแกะอัตโนมัติคืออะไร? เมื่อสร้างตัวแปร Integer ใหม่ เราใช้โครงสร้างต่อไปนี้:Integer a = 2020;
ด้วยวิธีนี้เราจึงสร้างออบเจ็กต์ใหม่โดยไม่ต้องใช้ตัวดำเนินการคีย์ใหม่ สิ่งนี้เป็นไปได้ด้วยกลไกการบรรจุอัตโนมัติของประเภทดั้งเดิม int กระบวนการย้อนกลับเกิดขึ้นเมื่อกำหนดตัวแปร int ดั้งเดิมให้กับค่าของตัวแปรอ้างอิงจำนวนเต็ม:
Integer a = 2020;
int x = a;
ในกรณีนี้ ดูเหมือนว่าเราจะกำหนดการอ้างอิง (กล่าวคือ การอ้างอิงถึงวัตถุคือค่าของตัวแปร “a”) ให้กับตัวแปรดั้งเดิม แต่ในความเป็นจริงแล้ว ต้องขอบคุณกลไกการแตกไฟล์อัตโนมัติ ค่า 2020 จึงถูกเขียนลงในตัวแปร “x” การแพ็ค/แกะไฟล์อัตโนมัติเป็นปรากฏการณ์ที่พบบ่อยมากใน Java บ่อยครั้งมันเกิดขึ้นเอง บางครั้งถึงแม้โปรแกรมเมอร์จะไม่รู้ก็ตาม แต่คุณยังต้องรู้เกี่ยวกับปรากฏการณ์นี้ เรามีบทความที่น่าสนใจในหัวข้อนี้ บน Javarush
ค่าคงที่คลาสจำนวนเต็ม
คลาส Integer จัดเตรียมค่าคงที่และวิธีการต่างๆ สำหรับการทำงานกับจำนวนเต็ม ในส่วนนี้เราจะมาดูบางส่วนในทางปฏิบัติโดยละเอียดยิ่งขึ้น เริ่มจากค่าคงที่กันก่อน ตารางด้านล่างแสดงค่าคงที่ของคลาสทั้งหมด:คอสตันตา | คำอธิบาย |
---|---|
ขนาด | จำนวนบิตในระบบตัวเลขสองหลักที่ถูกครอบครองโดยประเภท int |
ไบต์ | จำนวนไบต์ในระบบตัวเลขสองหลักที่ถูกครอบครองโดยประเภท int |
MAX_VALUE | ค่าสูงสุดที่ประเภท int สามารถเก็บได้ |
MIN_VALUE | ค่าต่ำสุดที่ประเภท int สามารถเก็บได้ |
พิมพ์ | ส่งกลับวัตถุประเภท Class จากประเภท int |
public static void main(String[] args) {
System.out.println(Integer.SIZE);
System.out.println(Integer.BYTES);
System.out.println(Integer.MAX_VALUE);
System.out.println(Integer.MIN_VALUE);
System.out.println(Integer.TYPE);
}
เป็นผลให้เราได้รับผลลัพธ์ดังต่อไปนี้:
32
4
2147483647
-2147483648
int
วิธีการของคลาสจำนวนเต็ม
ตอนนี้เรามาดูวิธีการที่ใช้มากที่สุดของคลาส Integer กันดีกว่า ดังนั้นวิธี "บนสุด" จะนำโดยวิธีการแปลงตัวเลขจากสตริงหรือแปลงสตริงจากตัวเลข เริ่มต้นด้วยการแปลงสตริงเป็นตัวเลข วิธีการ parseIntใช้เพื่อวัตถุประสงค์เหล่านี้ลายเซ็นอยู่ด้านล่าง:-
static int parseInt(String s)
int i = Integer.parseInt("10");
System.out.println(i); // 10
หากไม่สามารถแปลงได้ เช่น เราส่งคำไปยังวิธี parseInt แล้ว NumberFormatException จะถูกส่งออกไป วิธีการ parseInt(String s) มีพี่น้องที่โอเวอร์โหลด:
-
static int parseInt(String s, int radix)
System.out.println(Integer.parseInt("0011", 2)); // 3
System.out.println(Integer.parseInt("10", 8)); // 8
System.out.println(Integer.parseInt("F", 16)); // 15
วิธีการ parseInt ส่งกลับชนิดข้อมูลดั้งเดิม int วิธีการเหล่านี้มีอะนาล็อก - วิธีvalueOf รูปแบบบางส่วนของวิธีนี้เพียงเรียก parseInt ภายใน ความแตกต่างจาก parseInt คือผลลัพธ์ของ valueOf จะเป็นจำนวนเต็ม ไม่ใช่ int ลองพิจารณาตัวเลือกทั้งหมดด้านล่างสำหรับวิธีนี้และตัวอย่างวิธีการทำงาน:
- ค่าจำนวนเต็มคงที่ (int i) - ส่งกลับจำนวนเต็มที่มีค่าเป็น i;
- ค่าจำนวนเต็มคงที่ (สตริง s) - คล้ายกับ parseInt (สตริง s) แต่ผลลัพธ์จะเป็นจำนวนเต็ม
- ค่าจำนวนเต็มคงที่ (String s, int radix) - คล้ายกับ parseInt(String s, int radix) แต่ผลลัพธ์จะเป็น Integer
int a = 5;
Integer x = Integer.valueOf(a);
Integer y = Integer.valueOf("20");
Integer z = Integer.valueOf("20", 8);
System.out.println(x); // 5
System.out.println(y); // 20
System.out.println(z); // 16
เราดูวิธีการที่ช่วยให้คุณแปลง String เป็น int/Integer กระบวนการย้อนกลับทำได้โดยใช้ วิธี toString คุณสามารถเรียกใช้เมธอด toString บนอ็อบเจ็กต์ Integer ใดก็ได้ และรับการแสดงสตริง:
Integer x = 5;
System.out.println(x.toString()); // 5
อย่างไรก็ตาม เนื่องจากความจริงที่ว่าเมธอด toString มักถูกเรียกโดยปริยายบนอ็อบเจ็กต์ (เช่น เมื่อส่งอ็อบเจ็กต์ไปยังคอนโซลเพื่อพิมพ์) นักพัฒนาจึงไม่ค่อยได้ใช้วิธีนี้อย่างชัดเจน นอกจากนี้ยังมีวิธีการคงที่ toString ซึ่งรับพารามิเตอร์ int และแปลงเป็นการแสดงสตริง ตัวอย่างเช่น:
System.out.println(Integer.toString(5)); // 5
อย่างไรก็ตาม เช่นเดียวกับวิธี toString ที่ไม่คงที่ การใช้วิธีคงที่นั้นหาได้ยาก สิ่งที่น่าสนใจกว่าคือวิธีการแบบคงที่ toString ซึ่งรับพารามิเตอร์จำนวนเต็ม 2 ตัว:
- สตริงคงที่ toString(int i, int radix) - จะแปลง i เป็นการแสดงสตริงในระบบตัวเลข Radix
System.out.println(Integer.toString(5, 2)); // 101
คลาส Integer มีหลายวิธีในการค้นหาค่าสูงสุด/ต่ำสุดของตัวเลขสองตัว:
- static int max(int a, int b) จะส่งคืนค่าที่ใหญ่ที่สุดในบรรดาตัวแปรที่ส่งผ่าน
- static int min(int a, int b) จะส่งกลับค่าที่น้อยที่สุดในบรรดาตัวแปรที่ส่งผ่าน
int x = 4;
int y = 40;
System.out.println(Integer.max(x,y)); // 40
System.out.println(Integer.min(x,y)); // 4
บทสรุป
ในบทความนี้เรามาดูคลาส Integer เราคุยกันว่านี่คือคลาสประเภทไหนและคลาส wrapper คืออะไร เรามองชั้นเรียนจากมุมมองเชิงปฏิบัติ เราดูตัวอย่างการดำเนินการทางคณิตศาสตร์ รวมถึงการดำเนินการเปรียบเทียบ เราได้ดูความซับซ้อนของการเปรียบเทียบตัวแปรจำนวนเต็มสองตัว และตรวจสอบแนวคิดของออบเจ็กต์ที่แคชไว้ นอกจากนี้เรายังกล่าวถึงปรากฏการณ์ของการบรรจุ/แกะประเภทข้อมูลดั้งเดิมโดยอัตโนมัติ นอกจากนี้ เรายังดูวิธีการบางอย่างของคลาส Integer รวมถึงค่าคงที่บางตัวด้วย พวกเขายกตัวอย่างการแปลงตัวเลขจากระบบตัวเลขหนึ่งไปอีกระบบหนึ่งการบ้าน
-
ศึกษาว่ามีวิธีอื่นของคลาส Integer ใดบ้าง (คุณสามารถศึกษาได้จากเว็บไซต์พร้อมเอกสารอย่างเป็นทางการ ) เขียนความคิดเห็นว่าวิธีใดที่คุณได้ศึกษา (ไม่รวมวิธีที่ให้ไว้ในบทความ) มีประโยชน์มากที่สุดในความคิดเห็นของคุณ ( จะถูกใช้บ่อยที่สุด) พร้อมทั้งให้เหตุผลประกอบความคิดเห็นของคุณด้วย
ป.ล. ที่นี่ไม่มีคำตอบที่ถูกต้อง แต่กิจกรรมนี้จะช่วยให้คุณเรียนชั้นเรียนได้ดีขึ้น
-
แก้ไขปัญหาง่ายๆ เล็กๆ น้อยๆ เพื่อรวมวัสดุเข้าด้วยกัน
เรามีตัวเลขสองตัว:
1100001001 - ในระบบเลขฐานสอง
33332 - ในระบบเลขควินารีจำเป็นต้องใช้เฉพาะวิธีการของคลาส Integer เพื่อกำหนดค่าสูงสุดระหว่างตัวเลขที่กำหนดสองตัว จากนั้นจึงแสดงความแตกต่างระหว่างค่าสูงสุดและค่าต่ำสุดในระบบตัวเลขแบบไตรภาค
-
แปลงค่าจำนวนเต็มที่เป็นไปได้สูงสุดให้เป็นระบบเลขฐานแปดและแสดงจำนวนหลักในตัวเลขผลลัพธ์ (นับตัวเลขโดยทางโปรแกรม)
GO TO FULL VERSION