Kelas Java.lang.Integer

Jenis data Java boleh dibahagikan secara bersyarat kepada dua blok: primitif dan rujukan (kelas). Terdapat beberapa jenis data primitif dalam Java, seperti integer ( byte , short , int , long ), nombor titik terapung ( float , double ), jenis data logik ( boolean ) dan jenis data aksara ( char ). Anda mungkin sudah mengetahui bahawa setiap jenis data primitif mempunyai kelas pembalutnya sendiri. Jenis data rujukan yang "membungkus" atau menukar adik lelaki primitifnya dalam objek Java. Integer ialah kelas pembalut untuk bro primitifnya bernama int. Integer dalam bahasa Inggeris bermaksud nombor bulat. Mereka boleh menjadi positif, negatif atau 0. Malangnya, Integer dalam Java tidak bermaksud sebarang nombor bulat. Integer dalam java ialah nombor bulat yang muat dalam 32 bit. Jika anda mahukan nombor yang lebih besar anda dialu-alukan untuk menggunakan nombor Java Long . Mereka mempunyai 64 bit yang boleh digunakan. Jika anda tidak cukup bernasib baik untuk memerlukan Java nombor yang lebih besar telah anda dilindungi dengan BigInteger .

Bekerja dengan Integer

Sebagai kelas pembalut, Integer menyediakan pelbagai kaedah untuk bekerja dengan int , serta beberapa kaedah untuk menukar int kepada String dan String kepada int . Kelas ini mempunyai dua pembina:

• public Integer(int i) , di mana i ialah nilai primitif untuk dimulakan. Yang ini mencipta objek Integer yang dimulakan dengan nilai int .

• public Integer(String s) membuang NumberFormatException . Di sini s ialah perwakilan rentetan nilai int . Pembina ini mencipta objek Integer yang dimulakan dengan nilai int yang disediakan oleh perwakilan rentetan .

Penciptaan objek integer

Terdapat pilihan penciptaan objek Integer yang berbeza . Salah satu yang paling biasa digunakan adalah yang paling mudah. Berikut adalah contoh:

Integer myInteger = 5;

Inisialisasi pembolehubah Integer dalam kes ini adalah serupa dengan permulaan pembolehubah int primitif . Dengan cara ini anda boleh memulakan pembolehubah Integer dengan nilai int . Berikut adalah contoh:

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

Output di sini ialah: Malah, di sini kita boleh memerhatikan pembungkusan automatik. Juga kita boleh membuat objek Integer sama seperti objek lain menggunakan pembina dan kata kunci baharu :

Integer myInteger = new Integer(5);

Anda boleh lakukan dengan pembolehubah Integer sama seperti dengan int (tambah, tolak, darab, bahagi, kenaikan, pengurangan). Walau bagaimanapun, adalah penting untuk diingat bahawa Integer ialah jenis data rujukan, dan pembolehubah jenis ini boleh menjadi batal. Dalam kes ini, lebih baik untuk menahan diri daripada operasi sedemikian.

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

Di sini kita akan mendapat pengecualian:

Pemalar kelas integer

Kelas Integer menyediakan pelbagai pemalar dan kaedah untuk bekerja dengan integer. Di sini mereka:

• SIZE bermaksud bilangan bit dalam sistem nombor dua digit yang diduduki oleh jenis int

• BYTES ialah bilangan bait dalam sistem nombor dua digit yang diduduki oleh jenis int

• MAX_VALUE ialah nilai maksimum yang boleh disimpan oleh jenis int

• MIN_VALUE ialah nilai minimum yang boleh disimpan oleh jenis int

• TYPE mengembalikan objek jenis Kelas daripada jenis int

Kelas integer kaedah yang paling berguna

Sekarang mari kita lihat sekilas kaedah yang paling banyak digunakan dalam kelas Integer . Yang paling popular, saya rasa, adalah kaedah untuk menukar nombor daripada String , atau sebaliknya.

• static int parseInt(String s) kaedah ini menukar String kepada int . Jika penukaran tidak dapat dilakukan, NumberFormatException akan dibuang.

• static int parseInt(String s, int radix) kaedah ini juga menukar parameter s kepada int . Parameter radix menunjukkan sistem nombor s pada asalnya ditulis.

Selain parseInt , terdapat juga kaedah valueOf yang hampir sama dalam beberapa variasi. Walau bagaimanapun, hasil valueOf akan menjadi Integer , dan parseInt akan menjadi int .

• nilai Integer statikOf(int i) mengembalikan Integer yang nilainya ialah i ;

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

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

Adakah terdapat sebarang masalah dengan kelas Integer? Oh ya, ada…

Jadi terdapat dua jenis untuk integer (yang sesuai dengan 32 bit) dalam Java: int dan Integer . Untuk memahami spesifik setiap satu daripadanya, kita perlu mengetahui perkara berikut tentang model memori JVM: semua yang anda isytiharkan disimpan sama ada dalam Memori Tindanan (khusus Timbunan JVM untuk setiap Benang) atau Ruang Timbunan. Jenis primitif ( int , long , float , boolean , double , char , byte , dll) disimpan dalam memori Stack. Semua Objek dan tatasusunan disimpan dalam Heap Space. Rujukan kepada objek dan tatasusunan yang diperlukan untuk kaedah ini disimpan dalam Stack. Jadi. Kenapa kita peduli? Nah, anda lihat, Stack lebih kecil daripada Heap (a con), tetapi ia adalah lebih cepat untuk memperuntukkan nilai dalam Stack, berbanding dalam Heap (pro). Mari kita mulakan dengan jenis primitif int . Ia mengambil masa tepat 32 bit. Itu 32/8=4 bait. Kerana ia adalah jenis primitif. Sekarang, mari kita pertimbangkan Integer . Ia adalah objek, dengan overhed dan penjajaran tambahan. Saya telah menggunakan jol perpustakaan untuk mengukur saiznya:

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

dan ternyata mengambil 16 bait: Apa?! Itu 4 kali ganda lebih ingatan! Tetapi janganlah kita berhenti di situ sahaja. Sebagai pembangun Java, kami biasanya tidak berhenti menggunakan satu integer. Apa yang kita mahukan ialah menggunakan banyak daripadanya. Seperti dalam urutan. Sebagai contoh, dalam tatasusunan. Atau Senarai. Tatasusunan disimpan dalam Heap, seperti Senarai. Jadi, peruntukan harus mengambil masa yang lebih kurang sama. Betul ke? Tetapi bagaimana jika kita perlu memperuntukkan lebih banyak ingatan? Mari kita semak berapa banyak ruang yang diperlukan oleh tatasusunan 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 ialah 4016 bait: OK, itu agak masuk akal, memandangkan satu int memerlukan 4 bait. Bagaimana pula dengan ArrayList<Integer> daripada 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 ialah 20040 bait (sekali lagi, 4 kali lebih banyak!): Jadi, ArrayList<Integer> mengambil 4 kali lebih banyak ruang memori. Itu tidak bagus. Namun begitu, Senarai lebih mudah kerana kami boleh menambah dan memadam elemen! Oh Java... Kenapa awak perlu kotak segala-galanya?! Tetapi, saya terlupa, Java adalah hebat, dan kehebatannya terletak pada banyaknya perpustakaan sumber terbuka yang boleh kita gunakan! Trove4j adalah salah satu daripadanya. Ia mempunyai TIntArrayList yang secara dalaman mempunyai data int[] . Mari kita ukur saiznya:

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 ialah 4040 bait (hampir sama dengan int[] !): Jadi, pada akhirnya, kita boleh mempunyai yang terbaik dari kedua-dua dunia! Senarai integer yang mengambil 4 kali lebih sedikit ruang. Dan ini tidak melibatkan kejadian Integer . Hanya int s. Kami pembangun Java sangat mementingkan ingatan... Tetapi kami juga mengambil berat tentang prestasi. Terdapat perpustakaan penanda aras mikro yang indah dengan nama sederhana jmh yang membolehkan kami mengukur prestasi kod. Mula-mula mari kita bandingkan prestasi pengiraan jumlah dua integer rawak, berkotak atau tidak: Konfigurasi untuk jmh adalah seperti 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

Penanda aras:

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;
}

Keputusan: Jadi, secara purata, peruntukan dan jumlah int primitif adalah lebih daripada dua kali lebih pantas daripada Integer berkotak. Sekarang, mari kita bandingkan prestasi penciptaan dan pengiraan jumlah koleksi (atau tatasusunan 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]

Keputusan: tatasusunan primitif adalah lebih daripada 4 kali lebih pantas daripada tatasusunan nilai kotak ( Integer s); hampir enam kali lebih pantas daripada ArrayList nilai kotak ( Integer s); dan dua kali lebih cepat daripada TIntArrayList (yang sebenarnya menghiasi pelbagai int primitif). Oleh itu, jika anda memerlukan struktur data untuk menyimpan koleksi nilai integer, dan saiznya tidak akan berubah, gunakan int [] ; jika saiznya akan berubah — anda mungkin mahu menggunakan perpustakaan tove4j dengan TIntArrayList . Dan inilah penghujung esei saya di mana saya menerangkan keburukan menggunakan jenis Integer . Terdapat beberapa kaedah statik Integer yang menarik , yang harus saya bincangkan sebelum saya selesai. public static Integer getInteger(String nm, int val) tidak melakukan apa yang mungkin difikirkan, tetapi mendapatkan nilai Integer bagi sifat sistem. Val ialah lalai sekiranya sifat ini tidak ditetapkan. String statik awam kepadaBinaryString(int i) mengembalikan String dengan perwakilan binari nombor. Terdapat kaedah untuk mendapatkan semula perwakilan berasaskan-16 ( toHexString ) dan berasaskan-8 ( toOctalString ). Terdapat kaedah untuk menghuraikan String menjadi int . Walaupun rentetan itu ialah perwakilan berasaskan radix bukan 10. Berikut ialah beberapa contoh: Integer.parseInt("-FF", 16) returns -255 Integer.parseInt("+42", 10) returns 42 Integer.parseInt("1100110", 2) returns 102