บทความ
เริ่ม
เริ่มเรียนรู้
JavaRush /จาวาบล็อก /Random-TH /คู่มือคลาส Java Integer
Зепп Бранниган
ระดับ

คู่มือคลาส Java Integer

เผยแพร่ในกลุ่ม
ในบทความนี้เราจะพูดถึงคลาส Integer ลองพิจารณาคำถามเหล่านี้:
  • คลาส wrapper คืออะไร
  • การบรรจุอัตโนมัติ/การเปิดบรรจุภัณฑ์ดั้งเดิม
  • การดำเนินการของคลาส Integer วิธีการ และค่าคงที่
การสอนคลาส Java Integer - 1

คลาส Wrapper ประเภทดั้งเดิม

ดังที่คุณทราบ Java มีประเภทข้อมูลหลายประเภท ซึ่งสามารถแบ่งออกเป็นสองช่วงตึก:
  • ดั้งเดิม;
  • อ้างอิง.
มีข้อมูลพื้นฐานหลายประเภทใน Java:
  • จำนวนเต็ม - ไบต์, สั้น, int, ยาว;
  • ตัวเลขทศนิยม (จริง) - ลอย, สองเท่า;
  • ชนิดข้อมูลเชิงตรรกะ - บูลีน;
  • ชนิดข้อมูลอักขระ - อักขระ
ข้อมูลพื้นฐานแต่ละประเภทมีคลาส wrapper ของตัวเอง ชนิดข้อมูลอ้างอิงที่ล้อมน้องชายคนเล็กดั้งเดิมไว้ในอ็อบเจ็กต์ Java ด้านล่างนี้คือประเภทข้อมูลดั้งเดิมและคลาส wrapper ที่เกี่ยวข้อง:
ประเภทดั้งเดิม คลาสเครื่องห่อ
ไบต์ ไบต์
สั้น สั้น
ภายใน จำนวนเต็ม
ยาว ยาว
ลอย ลอย
สองเท่า สองเท่า
บูลีน บูลีน
ถ่าน อักขระ
ในทางปฏิบัติแล้ว primitives และคลาส wrapper มีอะไรที่เหมือนกันหลายอย่าง การดำเนินการส่วนใหญ่จะดำเนินการเหมือนกัน อย่างไรก็ตาม คลาส wrapper มีลักษณะเฉพาะจำนวนหนึ่งที่ไม่มีลักษณะเฉพาะของคลาสพื้นฐาน ประการแรก มีคลาสต่างๆ: เมื่อทำงานกับคลาส wrapper เราจะทำงานกับอ็อบเจ็กต์ ประการที่สอง (ทุกสิ่งที่ตามมาจากจุดที่หนึ่ง) วัตถุเหล่านี้อาจเป็นโมฆะได้ ประการที่สาม คลาส wrapper จัดเตรียมค่าคงที่และวิธีการต่างๆ ที่ช่วยให้ทำงานกับประเภทข้อมูลใดประเภทหนึ่งได้ง่ายขึ้น ในบทความนี้ เราจะมาดูการทำงานกับคลาส Integer โดยละเอียดยิ่งขึ้น

จำนวนเต็ม _

คลาส 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 พวกเขาสามารถเป็น:
Java-университет
พับ 

Integer a = 6;
Integer b = 2;
Integer c = a + b;
System.out.println(c); // 8
ลบ 

Integer a = 6;
Integer b = 2;
Integer c = a - b;
System.out.println(c); // 4
คูณ 

Integer a = 6;
Integer b = 2;
Integer c = a * b;
System.out.println(c); // 12
แบ่ง 

Integer a = 6;
Integer b = 2;
Integer c = a / b;
System.out.println(c); // 3
เพิ่มขึ้น 

Integer a = 6;
a++;
++a;
System.out.println(a); // 8
ลดลง 

Integer a = 6;
a--;
--a;
System.out.println(a); // 4
อย่างไรก็ตาม ทั้งหมดนี้ คุณต้องระมัดระวังและจำไว้ว่า Integer เป็นประเภทข้อมูลอ้างอิง และตัวแปรประเภทนี้อาจเป็นค่าว่างได้ ในกรณีนี้ (หากตัวแปรเป็นโมฆะ) จะเป็นการดีกว่าถ้าละเว้นการดำเนินการทางคณิตศาสตร์ (และตัวแปรอื่นๆ ที่ค่าว่างไม่เป็นลางไม่ดี) นี่คือตัวอย่าง: 
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)
วิธีการนี้จะแปลง String เป็น int มาสาธิตวิธีการทำงานของวิธีนี้กัน: 
int i = Integer.parseInt("10");
System.out.println(i); // 10
หากไม่สามารถแปลงได้ เช่น เราส่งคำไปยังวิธี parseInt แล้ว NumberFormatException จะถูกส่งออกไป วิธีการ parseInt(String s) มีพี่น้องที่โอเวอร์โหลด: 
  • 
static int parseInt(String s, int radix)
วิธีการนี้จะแปลงพารามิเตอร์ s เป็น int พารามิเตอร์ Radix ระบุว่าระบบตัวเลขใดที่เขียนตัวเลขใน s ซึ่งต้องแปลงเป็น int ตัวอย่างด้านล่าง: 
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 รวมถึงค่าคงที่บางตัวด้วย พวกเขายกตัวอย่างการแปลงตัวเลขจากระบบตัวเลขหนึ่งไปอีกระบบหนึ่ง

การบ้าน

  1. ศึกษาว่ามีวิธีอื่นของคลาส Integer ใดบ้าง (คุณสามารถศึกษาได้จากเว็บไซต์พร้อมเอกสารอย่างเป็นทางการ ) เขียนความคิดเห็นว่าวิธีใดที่คุณได้ศึกษา (ไม่รวมวิธีที่ให้ไว้ในบทความ) มีประโยชน์มากที่สุดในความคิดเห็นของคุณ ( จะถูกใช้บ่อยที่สุด) พร้อมทั้งให้เหตุผลประกอบความคิดเห็นของคุณด้วย

    ป.ล. ที่นี่ไม่มีคำตอบที่ถูกต้อง แต่กิจกรรมนี้จะช่วยให้คุณเรียนชั้นเรียนได้ดีขึ้น

  2. แก้ไขปัญหาง่ายๆ เล็กๆ น้อยๆ เพื่อรวมวัสดุเข้าด้วยกัน

    เรามีตัวเลขสองตัว:

    1100001001 - ในระบบเลขฐานสอง
    33332 - ในระบบเลขควินารี

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

  3. แปลงค่าจำนวนเต็มที่เป็นไปได้สูงสุดให้เป็นระบบเลขฐานแปดและแสดงจำนวนหลักในตัวเลขผลลัพธ์ (นับตัวเลขโดยทางโปรแกรม)

ความคิดเห็น
TO VIEW ALL COMMENTS OR TO MAKE A COMMENT,
GO TO FULL VERSION