Pengantar Primitif Java

1. Ikhtisar

Bahasa Pemrograman Java memiliki delapan tipe data primitif.

Dalam artikel ini, kita akan mengingat apa itu primitif dan membahasnya.

2. Tipe Data Primitif

Delapan primitif yang didefinisikan di Java adalah int , byte , short , long , float , double , boolean , dan char - itu tidak dianggap sebagai objek dan mewakili nilai mentah.

Mereka disimpan langsung di stack (lihat artikel ini untuk informasi selengkapnya tentang manajemen memori di Java).

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

Mari kita mulai dengan referensi cepat:

Tipe Ukuran (bit) Minimum Maksimum Contoh
byte 8 -27 27– 1 byte b = 100;
pendek 16 -215 215– 1 pendek s = 30_000;
int 32 -231 231– 1 int i = 100_000_000;
panjang 64 -263 263– 1 panjang l = 100_000_000_000_000;
mengapung 32 -2-149 (2-2-23) · 2127 float f = 1.456f;
dua kali lipat 64 -2-1074 (2-2-52) · 21023 ganda f = 1,456789012345678;
arang 16 0 216– 1 char c = 'c';
boolean 1 - - boolean b = true;

2.1. int

Tipe data primitif pertama yang akan kita bahas adalah int . Juga dikenal sebagai integer, tipe int menyimpan berbagai nilai bilangan non-pecahan.

Secara khusus, Java menyimpannya menggunakan memori 32 bit . Dengan kata lain dapat merepresentasikan nilai dari -2.147.483.648 (-231) hingga 2.147.483.647 (231-1).

Di Java 8, dimungkinkan untuk menyimpan nilai integer unsigned hingga 4.294.967.295 (232-1) dengan menggunakan fungsi helper khusus baru.

Kita cukup mendeklarasikan int :

int x = 424_242; int y;

Nilai default dari int yang dideklarasikan tanpa penugasan adalah 0.

Jika variabel didefinisikan dalam sebuah metode, kita harus memberikan nilai sebelum kita dapat menggunakannya.

Kita dapat melakukan semua operasi aritmatika standar pada int s. Ketahuilah bahwa nilai desimal akan dipotong saat melakukan ini pada bilangan bulat.

2.2. byte

byte adalah tipe data primitif yang mirip dengan int , kecuali hanya membutuhkan 8 bit memori . Jadi, mengapa kami menyebutnya byte. Karena ukuran memori sangat kecil, byte hanya dapat menampung nilai dari -128 (-27) hingga 127 (27 - 1).

Kita bisa membuat byte :

byte b = 100; byte empty;

Nilai default byte juga 0.

2.3. pendek

Perhentian berikutnya dalam daftar tipe data primitif kami di Java adalah singkat .

Jika kita ingin menghemat memory dan byte terlalu kecil, kita bisa menggunakan tipe halfway diantara keduanya: short .

Pada memori 16 bit, ukurannya setengah dari int dan dua kali ukuran byte . Kisaran nilai yang memungkinkan adalah -32.768 (-215) hingga 32.767 (215 - 1).

pendek dinyatakan seperti ini:

short s = 202_020; short s;

Juga mirip dengan tipe lainnya, nilai defaultnya adalah 0. Kita juga bisa menggunakan semua aritmatika standar.

2.4. panjang

Tipe data primitif terakhir kami yang terkait dengan bilangan bulat adalah panjang .

long adalah kakak dari int . Ini disimpan dalam 64 bit memori sehingga dapat menampung set kemungkinan nilai yang lebih besar secara signifikan.

Nilai yang mungkin dari sebuah long adalah antara -9.223.372.036.854.775.808 (-263) hingga 9.223.372.036.854.775.807 (263 - 1).

Kami hanya dapat menyatakan satu:

long l = 1_234_567_890; long l;

Seperti tipe integer lainnya, defaultnya juga 0. Kita bisa menggunakan semua aritmatika pada long yang bekerja pada int .

2.5. mengapung

Kami mewakili bilangan pecahan dasar di Jawa menggunakan tipe float . Ini adalah angka desimal presisi tunggal. Artinya jika kita melewati enam koma desimal, angka ini menjadi kurang tepat dan lebih merupakan perkiraan.

Dalam kebanyakan kasus, kami tidak peduli dengan kehilangan presisi. Tetapi, jika kalkulasi kita membutuhkan ketelitian absolut (mis., Operasi keuangan, pendaratan di bulan, dll.), Kita perlu menggunakan tipe khusus yang dirancang untuk pekerjaan ini. Untuk informasi lebih lanjut, lihat Desimal Besar 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).

Untungnya, Java dapat melakukan konversi ini untuk kita secara otomatis. Kami menyebut proses ini Autoboxing . Berikut ini contohnya:

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

3. Kesimpulan

Dalam tutorial ini, kita telah membahas delapan tipe data primitif yang didukung di Java.

Ini adalah blok bangunan yang digunakan oleh sebagian besar, tidak semua program Java di luar sana - jadi sangat penting untuk memahami cara kerjanya.