Pengenalan Primitif Java

1. Gambaran keseluruhan

Bahasa Pengaturcaraan Java mempunyai lapan jenis data primitif.

Dalam artikel ini, kita akan mengingat semula apa yang primitif dan mengatasinya.

2. Jenis Data Primitif

Lapan primitif yang ditentukan dalam Java adalah int , byte , pendek , panjang , float , double , boolean , dan char - yang tidak dianggap objek dan mewakili nilai mentah.

Mereka disimpan terus di tumpukan (lihat artikel ini untuk maklumat lebih lanjut mengenai pengurusan memori di Java)

Mari kita lihat ukuran penyimpanan, nilai lalai, dan contoh cara menggunakan setiap jenis.

Mari mulakan dengan rujukan ringkas:

Jenis	Saiz (bit)	Minimum	Maksimum	Contohnya
bait	8	-27	27–1	bait b = 100;
pendek	16	-215	215–1	pendek s = 30_000;
int	32	-231	231–1	int i = 100_000_000;
lama	64	-263	263–1	panjang l = 100_000_000_000_000;
terapung	32	-2-149	(2-2-23) · 2127	apungan f = 1.456f;
berganda	64	-2-1074	(2-2-52) · 21023	berganda f = 1.456789012345678;
char	16	0	216–1	char c = 'c';
boolean	1	-	-	boolean b = benar;

2.1. int

Jenis data primitif pertama yang akan kita bahas adalah int . Juga dikenali sebagai bilangan bulat, jenis int mempunyai pelbagai nilai nombor bukan pecahan.

Secara khusus, Java menyimpannya dengan memori 32 bit . Dengan kata lain, ia dapat mewakili nilai dari -2,147,483,648 (-231) hingga 2,147,483,647 (231-1).

Di Java 8, dapat menyimpan nilai bilangan bulat yang tidak ditandatangani hingga 4,294,967,295 (232-1) dengan menggunakan fungsi pembantu khas baru.

Kita hanya boleh menyatakan int hanya:

int x = 424_242; int y;

Nilai lalai dari int yang dinyatakan tanpa tugasan adalah 0.

Sekiranya pemboleh ubah didefinisikan dalam satu kaedah, kita mesti memberikan nilai sebelum kita dapat menggunakannya.

Kami dapat melakukan semua operasi aritmetik standard di int s. Ketahuilah bahawa nilai perpuluhan akan dipotong ketika melakukan ini pada bilangan bulat.

2.2. bait

byte adalah jenis data primitif yang serupa dengan int , kecuali hanya memerlukan 8 bit memori . Oleh itu, mengapa kita memanggilnya bait. Kerana saiz memori sangat kecil, byte hanya dapat menahan nilai dari -128 (-27) hingga 127 (27 - 1).

Kami boleh membuat bait :

byte b = 100; byte empty;

Nilai bait lalai juga 0.

2.3. pendek

Singgahan seterusnya dalam senarai jenis data primitif kami di Java adalah pendek .

Sekiranya kita mahu menjimatkan memori dan bait terlalu kecil, kita boleh menggunakan jenis di antara kedua-duanya: pendek .

Pada memori 16 bit, ia adalah separuh ukuran int dan dua kali ukuran bait . Julat nilai yang mungkin ialah -32,768 (-215) hingga 32,767 (215 - 1).

pendek dinyatakan seperti ini:

short s = 202_020; short s;

Sama seperti jenis lain, nilai lalai adalah 0. Kita juga boleh menggunakan semua aritmetik standard di dalamnya.

2.4. lama

Jenis data primitif terakhir kami yang berkaitan dengan bilangan bulat panjang .

lama adalah kakak int . Ia disimpan dalam 64 bit memori sehingga dapat menyimpan sekumpulan nilai yang lebih besar.

Nilai kemungkinan panjang adalah antara -9,223,372,036,854,775,808 (-263) hingga 9,223,372,036,854,775,807 (263 - 1).

Kita hanya boleh menyatakan satu:

long l = 1_234_567_890; long l;

Seperti jenis integer lain, lalai juga 0. Kita boleh menggunakan semua aritmetik dengan panjang yang berfungsi pada int .

2.5. terapung

Kami mewakili nombor pecahan asas di Jawa menggunakan jenis pelampung . Ini adalah nombor perpuluhan ketepatan tunggal. Yang bermaksud jika kita melepasi enam titik perpuluhan, angka ini menjadi kurang tepat dan lebih banyak anggaran.

Dalam kebanyakan kes, kami tidak peduli dengan kehilangan ketepatan. Tetapi, jika pengiraan kita memerlukan ketepatan mutlak (iaitu operasi kewangan, mendarat di bulan, dan lain-lain) kita perlu menggunakan jenis khusus yang dirancang untuk kerja ini. Untuk maklumat lebih lanjut, lihat Big Java Decimal kelas Java.

This type is stored in 32 bits of memory just like int. However, because of the floating decimal point its range is much different. It can represent both positive and negative numbers. The smallest decimal is 1.40239846 x 10-45, and the largest value is 3.40282347 x 1038.

We declare floats the same as any other type:

float f = 3.145f; float f;

And the default value is 0.0 instead of 0. Also, notice we add the f designation to the end of the literal number to define a float. Otherwise, Java will throw an error because the default type of a decimal value is double.

We can also perform all standard arithmetic operations on floats. However, it's important to note that we perform floating point arithmetic very differently than integer arithmetic.

2.6. double

Next, we look at double – its name comes from the fact that it's a double-precision decimal number.

It's stored in 64 bits of memory. Which means it represents a much larger range of possible numbers than float.

Although, it does suffer from the same precision limitation as float does. The range is 4.9406564584124654 x 10-324 to 1.7976931348623157 x 10308. That range can also be positive or negative.

Declaring double is the same as other numeric types:

double d = 3.13457599923384753929348D; double d;

The default value is also 0.0 as it is with float.Similar to float, we attach the letter D to designate the literal as a double.

2.7. boolean

The simplest primitive data type is boolean. It can contain only two values: true or false. It stores its value in a single bit.

However, for convenience, Java pads the value and stores it in a single byte.

Declare boolean like this:

boolean b = true; boolean b;

Declaring it without a value defaults to false. boolean is the cornerstone of controlling our programs flow. We can use boolean operators on them (i.e., and, or, etc.).

2.8. char

The final primitive data type to look at is char.

Also called a character, char is a 16-bit integer representing a Unicode-encoded character. Its range is from 0 to 65,535. Which in Unicode represents ‘\u0000' to ‘\uffff'.

For a list of all possible Unicode values check out sites like Unicode Table.

Let's now declare a char:

char c = 'a'; char c = 65; char c;

When defining our variables, we can use any character literal, and they will get automatically transformed into their Unicode encoding for us. A characters default value is ‘/u0000'.

2.9. Overflow

The primitive data types have size limits. But what happens if we try to store a value that's larger than the maximum value?

We run into a situation called overflow.

When an integer overflows, it rolls over to the minimum value and begins counting up from there.

Floating point number overflow by returning Infinity. When they underflow, they return 0.0.

Here's an example:

int i = Integer.MAX_VALUE; int j = i + 1; // j will roll over to -2_147_483_648 double d = Double.MAX_VALUE; double o = d + 1; // o will be Infinity

Underflow is the same issue except if we store a value smaller than the minimum value.

2.10. Autoboxing

Each primitive data type also has a full Java class implementation that can wrap it. For instance, the Integer class can wrap an int. There is sometimes a need to convert from the primitive type to its object wrapper (e.g., using them with generics).

Nasib baik, Java dapat melakukan penukaran ini untuk kami secara automatik. Kami memanggil proses ini sebagai Autoboxing . Berikut adalah contoh:

Character c = 'c'; Integer i = 1;

3. Kesimpulannya

Dalam tutorial ini, kami telah membahas lapan jenis data primitif yang disokong di Java.

Ini adalah blok bangunan yang digunakan oleh kebanyakan, bukan semua program Java di luar sana - jadi perlu difahami bagaimana ia berfungsi.