ประเภทดั้งเดิมใน Java

1. รายการประเภทดั้งเดิม

Java มี 8 ประเภทดั้งเดิมพื้นฐาน พวกเขาเรียกว่า ดั้งเดิม เนื่องจากค่าของประเภทเหล่านี้ไม่ใช่วัตถุและถูกเก็บไว้ภายในตัวแปรโดยตรง

นี่คือตารางที่มีข้อมูลสั้น ๆ เกี่ยวกับประเภทเหล่านี้:

ตัวแปรโลคัลในเมธอดไม่มีค่าเริ่มต้น หากคุณไม่ได้กำหนดค่าให้กับตัวแปรดังกล่าว จะถือว่าตัวแปรเหล่านั้นไม่ได้กำหนดค่าเริ่มต้นและไม่สามารถใช้ได้

แต่ลองกลับมาที่ประเภทดั้งเดิมและดูให้ละเอียดยิ่งขึ้น

2. ประเภทจำนวนเต็ม

Java มีจำนวนเต็ม 4 ประเภท: byte, short, intและlong. โดยจะแตกต่างกันในขนาดและช่วงของค่าที่สามารถจัดเก็บได้

intพิมพ์

ที่ใช้กันมากที่สุดคือintประเภท ชื่อนี้มาจากคำว่าint eger (จำนวนเต็ม) จำนวนเต็มตามตัวอักษร (จำนวนเต็ม) ทั้งหมดในโค้ดคือints(หากไม่ได้ลงท้ายด้วยL, F, หรือD)

ตัวแปรประเภทนี้สามารถรับค่าจาก-2,147,483,648ถึง+2,147,483,647

ซึ่งเยอะและเพียงพอในแทบทุกโอกาส เกือบทุกฟังก์ชันที่คืนค่าตัวเลขจะส่งคืนค่าint.

ตัวอย่าง:

int n = "String".length();

String[] array = {"Tic", "Tac", "Toe"};
int n = array.length;

shortพิมพ์

ประเภทshortได้รับชื่อมาshort intจาก เรียกอีกอย่างว่าจำนวนเต็มสั้น ต่างจากintประเภทตรงที่มีความยาวเพียงสองไบต์และช่วงของค่าที่เป็นไปได้คือfrom -32,768ถึง+32,767

นั่นหมายความว่าคุณไม่สามารถเก็บหมายเลขหนึ่งล้านไว้ในนั้นได้ หรือ 50,000. นี่เป็นประเภทจำนวนเต็มที่ใช้บ่อยที่สุดใน Java แรงจูงใจหลักในการใช้งานคือการอนุรักษ์หน่วยความจำ

สมมติว่าคุณมีสถานการณ์ที่คุณรู้ล่วงหน้าว่าคุณจะต้องทำงานกับค่าที่ไม่เกิน 30,000 และจะมีค่าเหล่านี้หลายล้านค่า

ตัวอย่างเช่น สมมติว่าคุณกำลังเขียนแอปพลิเคชันที่ประมวลผลรูปภาพความละเอียดสูงพิเศษที่ใช้10บิตต่อสี และคุณมีล้านพิกเซลในรูปภาพของคุณ นี่คือสถานการณ์ที่การตัดสินใจใช้intหรือshortมีความสำคัญ

longพิมพ์

ประเภทนี้ได้ชื่อมาจากlong intและเรียกอีกอย่างว่าจำนวนเต็มยาว ซึ่งแตกต่างจากintประเภทคือมีค่ามากมายอย่างไม่น่าเชื่อ: จากถึง-9*1018+9*1018

ทำไมไม่เป็นประเภทจำนวนเต็มพื้นฐาน

เนื่องจาก Java ปรากฏขึ้นในช่วงกลางทศวรรษที่ 90 เมื่อคอมพิวเตอร์ส่วนใหญ่เป็นแบบ 32 บิต นั่นหมายความว่าโปรเซสเซอร์ทั้งหมดได้รับการปรับให้เหมาะสมสำหรับการทำงานกับตัวเลขที่ประกอบด้วย 32 บิต โปรเซสเซอร์สามารถทำงานกับจำนวนเต็ม 64 บิตได้ แต่การดำเนินการกับจำนวนเต็มนั้นช้ากว่า

เป็นผลให้โปรแกรมเมอร์ตัดสินใจอย่างสมเหตุสมผลที่จะสร้างintประเภทจำนวนเต็มมาตรฐาน และใช้longประเภทเมื่อจำเป็นจริงๆ เท่านั้น

byteพิมพ์

นี่เป็นประเภทจำนวนเต็มที่น้อยที่สุดใน Java แต่ยังห่างไกลจากประเภทที่ใช้น้อยที่สุด ชื่อของมันbyteยังเป็นคำสำหรับบล็อกหน่วยความจำแอดเดรสที่เล็กที่สุดใน Java

มีค่าที่ถูกต้องไม่มากนักสำหรับประเภทbyte: จาก-128ถึง +127แต่นั่นไม่ใช่จุดแข็งของมัน ประเภท นี้byteใช้บ่อยที่สุดเมื่อคุณต้องการเก็บข้อมูลหยดขนาดใหญ่ไว้ในหน่วยความจำ อาร์เรย์ของbytes เหมาะสำหรับจุดประสงค์นี้

สมมติว่าคุณต้องการคัดลอกไฟล์ที่ไหนสักแห่ง

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

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

byte[] buffer = new byte[1024*1024];
FileInputStream sourceFile = new FileInputStream("c:\\data.txt");
FileOutputStream destFile = new FileOutputStream("c:\\output.txt");
while (true)
{
   int size = sourceFile.read(buffer); // Read data from a file into a buffer
   destFile.write(buffer, 0, size); // Write data from the buffer to a file

   // Stop copying if the buffer is not full
   if (size < buffer.length) break;
}
sourceFile.close();
destFile.close();

3. ประเภทจริง

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

Java มีประเภทดั้งเดิมของทศนิยมสองประเภท: doubleและfloat.

ดังที่เราได้กล่าวไว้ก่อนหน้านี้ ประเภทเหล่านี้มีการจัดเรียงภายในที่เฉพาะเจาะจงมาก อันที่จริง ภายในตัวแปรแต่ละประเภทไม่ใช่ตัวเลขเดียว แต่มีสองตัว:

ตัวอย่างเช่น จำนวนทศนิยม987654.321สามารถแสดงเป็น จากนั้นในหน่วยความจำจะแสดงเป็นตัวเลขสองตัว( แมนทิสซาคือส่วนสำคัญของจำนวน) และ( เลขชี้กำลังคือกำลังของสิบ)0.987654321*1069876543216

floatพิมพ์

ชื่อของfloatประเภทมาจากหมายเลขจุดอิงทศนิยม ขนาดของประเภทนี้ค่อนข้างเล็ก — เพียง 4 ไบต์ (32 บิต) — แต่สามารถเก็บค่าได้ตั้งแต่ถึง มีการจัดสรร 24 บิตสำหรับแทนแมนทิสซา และ 8 บิตสำหรับเลขชี้กำลัง ประเภทนี้สามารถจัดเก็บได้เพียง 8 หลักที่มีนัยสำคัญ-3.4*10383.4*1038

วิธีการนี้ทำให้สามารถจัดเก็บตัวเลขที่มากกว่า a intในขณะที่ใช้ 4 ไบต์เท่าเดิม แต่เพื่อทำเช่นนั้น เราเสียสละความถูกต้อง เนื่องจากส่วนหนึ่งของหน่วยความจำจัดเก็บแมนทิสซา ตัวแปรเหล่านี้จึงจัดเก็บทศนิยมเพียง 6-7 ตำแหน่งเท่านั้น ในขณะที่ส่วนที่เหลือจะถูกละทิ้ง

ตัวอย่าง:

float a = (float) 123.456789;

float a = (float) 12345.9999;

float a = (float) -123.456789E-2;

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

doubleพิมพ์

ประเภทdoubleคือประเภทจุดลอยตัวมาตรฐาน ชื่อนี้มาจากเลขทศนิยมที่มีความแม่นยำสองเท่า ตัวอักษรจริงทั้งหมดเป็นdoubleค่าเริ่มต้น

ประเภทนี้ใช้หน่วยความจำสูงสุด 8 ไบต์ (64 บิต) และสามารถเก็บค่าได้ตั้งแต่ถึง สิ่งสำคัญที่ควรทราบคือมีการจัดสรร 53 บิตสำหรับแมนทิสซา ในขณะที่อีก 11 บิตที่เหลือมีไว้สำหรับเลขชี้กำลัง-1.7*103081.7*10308

สิ่งนี้ทำให้สามารถจัดเก็บตัวเลขสำคัญได้ 15-17 หลัก

ตัวอย่าง:

double a = 1234567890.1234567890;

double a = 1234567890.1234512345;

double a = 1234567890.1357913579;

ความแม่นยำนี้โดยเฉพาะอย่างยิ่งเมื่อเปรียบเทียบกับfloatประเภท เป็นตัวชี้ขาด: 99% ของการดำเนินการทั้งหมดด้วยจำนวนจริงดำเนินการโดยใช้doubleประเภท

11บิตถูกจัดสรรให้กับเลขยกกำลัง ซึ่งหมายความว่าคุณสามารถจัดเก็บยกกำลังสิบจาก-323ถึง+308(นั่นคือยกกำลังสองจาก-1024ถึง+1023) ประเภทdoubleสามารถจัดเก็บตัวเลขที่มีศูนย์หลายร้อยหลังจุดทศนิยมได้อย่างง่ายดาย:

double a = 2E-300 * 3E+302

4. อินฟินิตี้

ตัวเลขทศนิยมมีคุณสมบัติที่น่าสนใจอีกอย่างหนึ่ง: พวกมันสามารถเก็บค่าพิเศษที่แสดงถึงความไม่สิ้นสุดได้ และคุณสามารถแทนค่าอนันต์ที่เป็นบวกและค่าอนันต์ที่เป็นลบได้

ตัวอย่าง:

System.out.println( 100.0 / 0.0 );

Infinity

System.out.println( -100.0 / 0.0 );

-Infinity

double a = 1d / 0d;
double b = a * 10;
double c = b - 100;

a == Infinity
b == Infinity
c == Infinity

ถ้าอินฟินิตี้คูณด้วยตัวเลข คุณจะได้อินฟินิตี้ ถ้าคุณบวกเลขเข้าไป คุณจะได้ค่าอนันต์ สะดวกสุด ๆ

ไม่ใช่ตัวเลข ( NaN)

การดำเนินการใด ๆ ที่เกี่ยวข้องกับอินฟินิตี้ให้ผลอินฟินิตี้ ส่วนใหญ่ แต่ไม่ใช่ทั้งหมด

ตัวเลขทศนิยมสามารถเก็บค่าพิเศษอื่นNaN: ย่อมาจากN ot a N umber (ไม่ใช่ตัวเลข)

ในทางคณิตศาสตร์ ถ้าคุณหารอนันต์ด้วยอนันต์ ผลลัพธ์ที่ได้จะไม่ได้นิยาม

แต่ใน Java หากคุณหารอนันต์ด้วยอนันต์ ผลลัพธ์ที่ได้NaNคือ

ตัวอย่าง:

System.out.println(0.0 / 0.0);

NaN

double infinity = 1d / 0d;
System.out.println(infinity / infinity);

NaN

double a = 0.0 / 0.0;
double b = a * 10;
double c = b - 100;
double d = a + infinity;

a == NaN
b == NaN
c == NaN
d == NaN

การดำเนินการใด ๆ ที่มีผลNaNตอบแทนNaN

5. charประเภท

ในบรรดาประเภทดั้งเดิมของJavachar เราสมควรได้รับความสนใจเป็นพิเศษ: ประเภท ชื่อของมันมาจากคำว่าchar acterและประเภทนั้นใช้เพื่อเก็บอักขระ

ตัวอักษรเป็นสิ่งที่ทำมาจากสตริงใช่ไหม? สตริงเป็นอาร์เรย์ของอักขระ

แต่ที่น่าสนใจยิ่งกว่าคือความจริงที่ว่าcharประเภทนั้นเป็นประเภทตัวเลข ด้วย ! มันเป็นประเภทวัตถุประสงค์สองทางเพื่อที่จะพูด

ความจริงก็คือcharประเภทไม่ได้ตัวอักษร แต่จะเก็บรหัสอักขระจากการเข้ารหัส Unicode อักขระแต่ละตัวสอดคล้องกับตัวเลข: รหัสตัวเลขของอักขระ

ตัวแปร แต่ละตัวcharใช้สองไบต์ในหน่วยความจำ (เหมือนกับshortประเภท) แต่แตกต่างจากประเภทshortประเภทcharจำนวนเต็มไม่ได้ลงนามและสามารถเก็บค่าจาก0ถึง65,535

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

ยูนิโค้ด

Unicodeเป็นตารางพิเศษ (การเข้ารหัส) ที่มีอักขระทั้งหมดในโลก และอักขระแต่ละตัวมีหมายเลขของตัวเอง มีลักษณะประมาณนี้:

มีหลายวิธีในการกำหนดค่าให้กับcharตัวแปร

char a = 'A';

char a = 65;

char a = 0x41;

char a = 0x0041;

char a = '\u0041';

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

และอย่างที่เราบอกไปแล้วว่าchartype เป็นประเภทจำนวนเต็มด้วย ดังนั้นคุณสามารถเขียนได้ดังนี้:

char a = 'A';
a++;
System.out.println(a);

ร่วมงานกับcharส

แต่ละตัวcharจะเป็นตัวเลข (รหัสอักขระ) ก่อน จากนั้นจึงตามด้วยอักขระ หากคุณทราบรหัสอักขระ คุณสามารถรับอักขระนั้นในโปรแกรมของคุณได้เสมอ ตัวอย่าง:

char c = (char) 1128;
System.out.println(c);

Ѩ

รหัสมาตรฐาน

นี่คือรหัสอักขระที่เป็นที่รู้จักมากที่สุด:

6. booleanประเภท

และประเภทดั้งเดิมสุดท้ายbooleanคือ

อย่างที่คุณทราบแล้วว่าสามารถรับได้เพียงสองค่าเท่านั้น: trueและfalse

และด้วยเหตุนี้คุณจึงรู้ทุกสิ่งที่ควรรู้เกี่ยวกับประเภทนี้