Kelas Java.lang.Integer

Tipe data Java secara kondisional dapat dibagi menjadi dua blok: primitif dan referensi (kelas). Ada beberapa tipe data primitif di Java, seperti integer ( byte , short , int , long ), angka floating point ( float , double ), tipe data logis ( boolean ) dan tipe data karakter ( char ). Anda mungkin sudah mengetahui bahwa setiap tipe data primitif memiliki kelas pembungkusnya sendiri. Tipe data referensi yang "membungkus" atau mengubah adik primitifnya menjadi objek Java. Integer adalah kelas pembungkus untuk bro primitifnya yang bernama int. Integer dalam bahasa Inggris berarti bilangan bulat. Bisa positif, negatif, atau 0. Sayangnya, Integer di Java tidak berarti bilangan bulat apa pun. Integer di java adalah bilangan bulat yang muat dalam 32 bit. Jika Anda menginginkan angka yang lebih besar, Anda dipersilakan menggunakan nomor Java Long . Mereka memiliki 64 bit yang dapat mereka gunakan. Jika Anda kurang beruntung dan membutuhkan jumlah yang lebih besar, Java siap membantu Anda dengan BigInteger .

Bekerja dengan Integer

Sebagai kelas pembungkus, Integer menyediakan berbagai metode untuk bekerja dengan int , serta sejumlah metode untuk mengonversi int menjadi String dan String menjadi int . Kelas memiliki dua konstruktor:

• public Integer(int i) , di mana i adalah nilai primitif untuk diinisialisasi. Yang ini membuat objek Integer yang diinisialisasi dengan nilai int .

• public Integer(String s) melempar NumberFormatException . Di sini s adalah representasi string dari nilai int . Konstruktor ini membuat objek Integer yang diinisialisasi dengan nilai int yang disediakan oleh representasi string .

Pembuatan objek bilangan bulat

Ada beberapa opsi pembuatan objek Integer yang berbeda . Salah satu yang paling umum digunakan adalah yang paling mudah. Berikut ini contohnya:

Integer myInteger = 5;

Inisialisasi variabel Integer dalam hal ini mirip dengan inisialisasi variabel int primitif . Omong-omong, Anda dapat menginisialisasi variabel Integer dengan nilai int . Berikut ini contohnya:

int myInt = 5;
Integer myInteger = myInt;
System.out.println(myInteger);

Outputnya di sini adalah: Faktanya, di sini kita bisa mengamati auto-packing. Kita juga dapat membuat objek Integer sama seperti objek lainnya menggunakan konstruktor dan kata kunci new :

Integer myInteger = new Integer(5);

Anda dapat melakukan hal yang sama dengan variabel Integer seperti pada int (menambah, mengurangi, mengalikan, membagi, menambah, mengurangi). Namun, penting untuk diingat bahwa Integer adalah tipe data referensi, dan variabel tipe ini bisa berupa null. Dalam hal ini, lebih baik menahan diri dari operasi tersebut.

Integer myInteger1  = null;
Integer myInteger2 = myInteger1 + 5;

Di sini kita akan mendapatkan pengecualian:

Konstanta kelas bilangan bulat

Kelas Integer menyediakan berbagai konstanta dan metode untuk bekerja dengan bilangan bulat. Di sini mereka:

• SIZE berarti jumlah bit dalam sistem bilangan dua digit yang ditempati oleh tipe int

• BYTES adalah jumlah byte dalam sistem bilangan dua digit yang ditempati oleh tipe int

• MAX_VALUE adalah nilai maksimum yang dapat ditampung oleh tipe int

• MIN_VALUE adalah nilai minimum yang dapat ditampung oleh tipe int

• TYPE mengembalikan objek bertipe Kelas dari tipe int

Metode kelas integer yang paling berguna

Sekarang mari kita lihat sekilas metode kelas Integer yang paling sering digunakan . Saya kira yang paling populer adalah metode untuk mengonversi angka dari String , atau sebaliknya.

• static int parseInt(String s) metode ini mengubah String menjadi int . Jika konversi tidak memungkinkan, NumberFormatException akan dilempar.

• static int parseInt(String s, int radix) metode ini juga mengubah parameter s menjadi int . Parameter radix menunjukkan sistem bilangan s yang pertama kali ditulis.

Selain parseInt , ada juga metode valueOf yang sangat mirip dalam beberapa variasi. Namun, hasil dari valueOf akan menjadi Integer , dan parseInt akan menjadi int .

• static Integer valueOf(int i) mengembalikan Integer yang nilainya i ;

• static Integer valueOf(String s) berfungsi seperti parseInt(String s) , tetapi hasilnya adalah Integer , bukan int ;

• static Integer valueOf(String s, int radix) berfungsi sama seperti parseInt(String s, int radix) , tetapi hasilnya adalah Integer , bukan int .

Apakah ada masalah dengan kelas Integer? Oh ya, ada…

Jadi ada dua tipe integer (yang muat dalam 32 bit) di Java: int dan Integer . Untuk memahami secara spesifik masing-masingnya, kita perlu mengetahui hal berikut tentang model memori JVM: semua yang Anda deklarasikan disimpan di Stack Memory (JVM Stack khusus untuk setiap Thread), atau Heap Space. Tipe primitif ( int , long , float , boolean , double , char , byte , dll) disimpan dalam memori Stack. Semua Objek dan array disimpan di Heap Space. Referensi ke objek dan array yang diperlukan untuk metode ini disimpan di Stack. Jadi. Mengapa kami peduli? Begini, Stack lebih kecil dari Heap (penipu), tetapi mengalokasikan nilai di Stack jauh lebih cepat daripada di Heap (pro). Mari kita mulai dengan tipe primitif int . Dibutuhkan tepat 32 bit. Itu 32/8=4 byte. Karena ini adalah tipe primitif. Sekarang, mari kita pertimbangkan Integer . Itu adalah sebuah objek, dengan overhead dan keberpihakan ekstra. Saya telah menggunakan perpustakaan jol untuk mengukur ukurannya:

public static void main(String[] args) {
 	System.out.println(ClassLayout.parseInstance(Integer.valueOf(1)).toPrintable());
}

dan ternyata memakan 16 byte: Apa?! Itu memori 4 kali lebih banyak! Tapi janganlah kita berhenti di situ. Sebagai pengembang Java, kami biasanya tidak berhenti menggunakan satu bilangan bulat. Yang sebenarnya kami inginkan adalah menggunakan banyak dari mereka. Seperti secara berurutan. Misalnya saja dalam sebuah array. Atau Daftar. Array disimpan di Heap, seperti halnya Daftar. Jadi, alokasinya akan memakan waktu yang kira-kira sama. Benar? Namun bagaimana jika kita perlu mengalokasikan lebih banyak memori? Mari kita periksa berapa banyak ruang yang dibutuhkan oleh array dengan 1000 nilai int primitif :

public static void main(String[] args) {
    	int[] array = new int[1000];
    	for (int i = 0; i < 1000; i++) array[i] = i;                System.out.println(ClassLayout.parseInstance(array).toPrintable());
}

Dan hasilnya adalah 4016 byte: Oke, itu masuk akal, mengingat satu int membutuhkan 4 byte. Bagaimana dengan ArrayList<Integer> dari 1000 Integer ? Mari kita lihat:

public static void main(String[] args) {
	List<Integer> list = new ArrayList<>(1000);
	for (int i = 0; i < 1000; i++) list.add(i);
      System.out.println(GraphLayout.parseInstance(list).toFootprint());
}

Dan hasilnya adalah 20040 byte (sekali lagi, 4 kali lebih banyak!): Jadi, ArrayList<Integer> memakan ruang memori 4 kali lebih banyak. Itu tidak baik. Tapi tetap saja, Daftar lebih mudah karena kita bisa menambah dan menghapus elemen! Oh Java… Kenapa harus mengemas semuanya?! Tapi, saya lupa, Java itu hebat, dan kehebatannya terletak pada banyaknya perpustakaan sumber terbuka yang bisa kita gunakan! Trove4j adalah salah satunya. Ia memiliki TIntArrayList yang secara internal memiliki data int[] . Mari kita ukur ukurannya:

public static void main(String[] args) {
	TIntList list = new TIntArrayList(1000);
	for (int i = 0; i < 1000; i++) list.add(i);
	System.out.println(GraphLayout.parseInstance(list).toFootprint());
}

Dan hasilnya adalah 4040 byte (hampir sama dengan int[] !): Jadi, pada akhirnya, kita bisa mendapatkan yang terbaik dari kedua hal tersebut! Daftar bilangan bulat yang memakan ruang 4 kali lebih sedikit. Dan ini tidak melibatkan instance Integer . Hanya ke dalam s. Kami para pengembang Java sangat peduli dengan memori… Tapi kami juga peduli dengan kinerja. Ada perpustakaan microbenchmarking yang bagus dengan nama sederhana jmh yang memungkinkan kita mengukur kinerja kode. Pertama mari kita bandingkan performa penghitungan penjumlahan dua bilangan bulat acak, kotak, atau tidak: Konfigurasi jmh adalah sebagai berikut:

benchmark {
	configurations {
    	main {
        	warmups = 5 // number of warmup iterations
        	iterations = 50 // number of iterations
        	iterationTime = 500 // time in seconds per iteration
        	iterationTimeUnit = "ns" // time unit for iterationTime

Tolok ukurnya:

private static final Random random = new Random();

@Benchmark
public int testPrimitiveIntegersSum() {
	int a = random.nextInt();
	int b = random.nextInt();
	return a + b;
}

@Benchmark
public Integer testBoxedIntegersSum() {
	Integer a = random.nextInt();
	Integer b = random.nextInt();
	return a + b;
}

Hasil: Jadi, rata-rata, alokasi dan jumlah int primitif dua kali lebih cepat dibandingkan Integer dalam kotak. Sekarang, mari kita bandingkan kinerja pembuatan dan perhitungan jumlah koleksi (atau array 1000 int Integer):

@Benchmark
public int testPrimitiveArray() {
	int[] array = new int[1000];
	for (int i = 0; i < 1000; i++) array[i] = i;
	int sum = 0;
	for (int x : array) sum += x;
	return sum;
}
11933.545 ops/s [Average]


@Benchmark
public int testBoxesArray() {
	Integer[] array = new Integer[1000];
	for (int i = 0; i < 1000; i++) array[i] = i;
	int sum = 0;
	for (int x : array) sum += x;
	return sum;
}
2733.312 ops/s [Average]


@Benchmark
public int testList() {
	List<Integer> list = new ArrayList<>(1000);
	for (int i = 0; i < 1000; i++) list.add(i);
	int sum = 0;
	for (int x : list) sum += x;
	return sum;
}
2086.379 ops/s [Average]


@Benchmark
public int testTroveIntList() {
	TIntList list = new TIntArrayList(1000);
	for (int i = 0; i < 1000; i++) list.add(i);
	int sum = 0;
	for (int i = 0; i < 1000; i++) sum += list.get(i);
	return sum;
}
5727.979 ops/s [Average]

Hasilnya: array primitif lebih dari 4 kali lebih cepat daripada array nilai dalam kotak ( Integer s); hampir enam kali lebih cepat dari ArrayList nilai kotak ( Integer s); dan dua kali lebih cepat dari TIntArrayList (yang sebenarnya menghiasi array int primitif). Oleh karena itu, jika Anda memerlukan struktur data untuk menyimpan kumpulan nilai integer, dan ukurannya tidak akan berubah, gunakan int [] ; jika ukurannya akan berubah — Anda mungkin ingin menggunakan perpustakaan tove4j dengan TIntArrayList . Dan inilah akhir esai saya dimana saya menjelaskan kerugian menggunakan tipe Integer . Ada beberapa metode statis Integer yang menarik , yang harus saya bicarakan sebelum saya menyelesaikannya. public static Integer getInteger(String nm, int val) tidak melakukan apa yang dipikirkan orang, tetapi mengambil nilai Integer dari properti sistem. Val adalah default jika properti ini tidak disetel. public static String toBinaryString(int i) mengembalikan sebuah String dengan representasi biner dari sebuah angka. Ada metode untuk mengambil representasi berbasis-16 ( toHexString ) dan berbasis-8 ( toOctalString ). Ada metode untuk mengurai String menjadi int . Meskipun string tersebut adalah representasi berbasis non-10 radix. Berikut beberapa contohnya: Integer.parseInt("-FF", 16) mengembalikan -255 Integer.parseInt("+42", 10) mengembalikan 42 Integer.parseInt("1100110", 2) mengembalikan 102