Java.lang.Integer ڪلاس

جاوا ڊيٽا جي قسمن کي مشروط طور تي ٻن بلاڪن ۾ ورهائي سگھجي ٿو: ابتدائي ۽ حوالو (ڪلاس). جاوا ۾ ڪيترائي پرائمري ڊيٽا جا قسم آھن، جھڙوڪ integers ( byte , short , int , long ) , floating point numbers ( float , double ) , logical data type ( boolean ) ۽ character data type ( char ). توهان شايد اڳ ۾ ئي ڄاڻو ٿا ته هر پرائمري ڊيٽا جي قسم جو پنهنجو لفافي ڪلاس آهي. ھڪڙو حوالو ڊيٽا جو قسم جيڪو "لفٽ" ڪري ٿو يا پنھنجي ابتدائي ننڍي ڀاء کي جاوا اعتراض ۾ ڦيرائي ٿو. Integer ان جي ابتدائي برو لاء int نالي هڪ ريپر ڪلاس آهي. انگريزيءَ ۾ Integer جو مطلب آهي پورو نمبر. اهي مثبت، منفي يا 0 ٿي سگهن ٿا. بدقسمتي سان، جاوا ۾ Integer جو مطلب ڪو پورو نمبر نه آهي. جاوا ۾ Integer ھڪڙو پورو نمبر آھي جيڪو 32 بٽ ۾ ٺھي ٿو. جيڪڏهن توهان هڪ وڏو نمبر چاهيو ٿا ته توهان جاوا لانگ نمبر استعمال ڪرڻ لاءِ ڀليڪار آهيو. انهن جي اختيار ۾ 64 بٽ آهن. جيڪڏهن توهان ڪافي بدقسمت آهيو ته ان کان به وڌيڪ وڏي تعداد جي ضرورت آهي Java توهان کي ڍڪيو آهي BigInteger سان .

Integer سان ڪم ڪرڻ

ريپر ڪلاس جي طور تي، Integer int سان ڪم ڪرڻ لاءِ مختلف طريقا مهيا ڪري ٿو ، ان سان گڏ int کي String ۽ String کي int ۾ تبديل ڪرڻ جا ڪيترائي طريقا . ڪلاس ۾ ٻه تعمير ڪندڙ آهن:

• public Integer(int i) ، جتي i شروعات ڪرڻ لاءِ هڪ ابتدائي قدر آهي. هي هڪ انٽيجر اعتراض ٺاهي ٿو جيڪو int قدر سان شروع ڪيو ويو آهي.

• عوامي انٽيجر (اسٽرنگ s) اڇلائي ٿو NumberFormatException . هتي s int قدر جي هڪ اسٽرنگ نمائندگي آهي . هي تعمير ڪندڙ هڪ Integer اعتراض ٺاهي ٿو جيڪو int value سان شروع ڪيو ويو هو اسٽرنگ نمائندگي طرفان مهيا ڪيل .

Integer اعتراض ٺاھڻ

اتي مختلف Integer اعتراض ٺاھڻ جا اختيار آھن. سڀ کان وڌيڪ عام طور تي استعمال ٿيل ھڪڙو ھڪڙو آسان آھي. هتي هڪ مثال آهي:

Integer myInteger = 5;

هن معاملي ۾ Integer variable جي شروعات، primitive int variable جي شروعات سان ملندڙ جلندڙ آهي . اهڙي طرح توهان هڪ Integer variable کي int جي قيمت سان شروع ڪري سگهو ٿا . هتي هڪ مثال آهي:

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

پيداوار هتي آهي: حقيقت ۾، هتي اسان خودڪار پيڪنگ جو مشاهدو ڪري سگهون ٿا. انهي سان گڏ اسان هڪ Integer آبجیکٹ ٺاهي سگهون ٿا جهڙوڪ ڪنهن به ٻين شين وانگر تعمير ڪندڙ ۽ نئون لفظ استعمال ڪندي:

Integer myInteger = new Integer(5);

توهان Integer variable سان ائين ڪري سگهو ٿا جيئن int سان (شامل ڪريو، گھٽايو، ضرب، تقسيم، واڌ، گهٽتائي). بهرحال، اهو ياد رکڻ ضروري آهي ته Integer هڪ حوالو ڊيٽا جو قسم آهي، ۽ هن قسم جو هڪ متغير null ٿي سگهي ٿو. انهي حالت ۾، اهو بهتر آهي ته اهڙي آپريشن کان بچڻ لاء.

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

هتي اسان هڪ استثنا حاصل ڪنداسين:

Integer class constants

Integer ڪلاس مختلف ثابتيون ۽ انٽيجرز سان ڪم ڪرڻ جا طريقا مهيا ڪري ٿو . هتي اهي آهن:

• SIZE جو مطلب آھي بٽس جو تعداد ٻن عددن واري نمبر سسٽم ۾ int قسم جي قبضي ۾

• BYTES ٻن عددي نمبر سسٽم ۾ بائيٽ جو تعداد آھي جيڪو قسم int جي قبضي ۾ آھي

• MAX_VALUE وڌ ۾ وڌ قدر آھي جنھن کي int قسم رکي سگھي ٿو

• MIN_VALUE گھٽ ۾ گھٽ قدر آھي جنھن کي int قسم رکي سگھي ٿو

• TYPE قسم int مان قسم جي ھڪڙي شئي کي واپس ڏئي ٿو

انٽيجر ڪلاس سڀ کان وڌيڪ مفيد طريقا

هاڻي اچو ته انٽيجر ڪلاس جي سڀ کان وڌيڪ استعمال ٿيندڙ طريقن تي هڪ نظر وجهون. انهن مان سڀ کان وڌيڪ مشهور، مان سمجهان ٿو، هڪ انگ کي String مان تبديل ڪرڻ جا طريقا ، يا ان جي برعڪس.

• static int parseInt(String s) ھي طريقو String کي int ۾ بدلائي ٿو . جيڪڏهن تبديلي ممڪن نه آهي، NumberFormatException اڇلايو ويندو.

• static int parseInt (String s, int radix) ھي طريقو پڻ s پيٽرولر کي int ۾ تبديل ڪري ٿو . ريڊيڪس پيٽرولر اشارو ڪري ٿو ته نمبر سسٽم s اصل ۾ لکيو ويو هو.

parseInt کان علاوه ، ڪيترن ئي مختلف قسمن ۾ پڻ تمام گهڻو ساڳيو قدرو طريقو آهي . بهرحال، valueOf جو نتيجو ٿيندو Integer ، ۽ parseInt ٿيندو int .

• static Integer valueOf(int i) ھڪ انٽيجر موٽائي ٿو جنھن جي قيمت i آھي ؛

• static Integer valueOf(String s) ڪم ڪري ٿو parseInt(String s) وانگر ، پر نتيجو ٿيندو Integer ، نه int ؛

• static Integer valueOf(String s, int radix) ساڳيو ڪم ڪري ٿو parseInt(String s, int radix) ، پر نتيجو هڪ Integer آهي ، هڪ int نه .

ڇا انٽيجر ڪلاس سان ڪو مسئلو آهي؟ ها، اتي آهي ...

تنهن ڪري جاوا ۾ انٽيجرز لاءِ ٻه قسم آهن (جيڪي 32 بٽ ۾ ٺهندا آهن) جاوا ۾: int ۽ Integer . انهن مان هر هڪ جي وضاحتن کي سمجهڻ لاءِ اسان کي JVM ميموري ماڊل بابت هيٺ ڏنل ڄاڻڻ جي ضرورت آهي: هر شي جيڪا توهان اعلان ڪيو آهي يا ته اسٽوريج ميموري ۾ محفوظ ڪئي وئي آهي (جي وي ايم اسٽيڪ مخصوص هر سلسلي لاءِ)، يا هيپ اسپيس. پرائمري قسمون ( int ، long ، float ، boolean ، double ، char ، byte ، وغيره) Stack ياداشت ۾ محفوظ ٿيل آهن. سڀئي شيون ۽ صفون Heap Space ۾ محفوظ ٿيل آھن. انهن شين جا حوالا ۽ طريقن لاءِ گهربل صفا اسٽيڪ ۾ محفوظ ٿيل آهن. سو. اسان کي پرواهه ڇو آهي؟ چڱو، توهان ڏسو، اسٽيڪ Heap (a con) کان ننڍو آهي، پر هيپ (هڪ پرو) جي ڀيٽ ۾ اسٽيڪ ۾ قدرن کي مختص ڪرڻ تمام تيز آهي. اچو ته شروعاتي قسم int سان شروع ڪريون . اهو لڳ ڀڳ 32 بٽ وٺي ٿو. اھو آھي 32/8 = 4 بائيٽ. ڇاڪاڻ ته اهو هڪ ابتدائي قسم آهي. هاڻي اچو ته انٽيجر تي غور ڪريون . اهو هڪ اعتراض آهي، اضافي مٿي ۽ ترتيب سان. مون ان جي سائيز کي ماپڻ لاءِ لائبريري جول استعمال ڪيو آهي:

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

۽ اهو 16 بائيٽ وٺي ويو: ڇا؟! اهو 4 ڀيرا وڌيڪ ياداشت آهي! پر اچو ته اتي نه رکون. جاوا ڊولپرز جي طور تي اسان عام طور تي هڪ انٽيجر استعمال ڪرڻ بند نه ڪندا آهيون. ڇا اسان واقعي چاهيون ٿا انهن مان تمام گهڻو استعمال ڪرڻ. هڪ تسلسل وانگر. مثال طور، هڪ صف ۾. يا هڪ فهرست. Arrays Heap ۾ محفوظ ٿيل آھن، جيئن فهرستون آھن. تنهن ڪري، مختص ڪرڻ ۾ لڳ ڀڳ ساڳئي وقت وٺڻ گهرجي. ساڄو؟ پر ڇا جيڪڏهن اسان کي وڌيڪ ميموري مختص ڪرڻ جي ضرورت آهي؟ اچو ته چيڪ ڪريون ته 1000 primitive int ويلز جي هڪ صف ڪيتري جاءِ وٺي ٿي:

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

۽ نتيجو آهي 4016 بائيٽ: ٺيڪ آهي، اهو قسم جو احساس آهي، هڪ واحد انٽ تي غور ڪندي 4 بائيٽ وٺندو آهي. 1000 Integers جي هڪ ArrayList<Integer> بابت ڇا ؟ اچو ته هڪ نظر رکون:

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

۽ نتيجو آهي 20040 بائيٽ (ٻيهر، 4 ڀيرا وڌيڪ!): تنهن ڪري، ArrayList<Integer> 4 ڀيرا وڌيڪ ميموري اسپيس وٺي ٿو. اهو سٺو ناهي. پر اڃا تائين، فهرستون آسان آهن ڇو ته اسان عناصر شامل ۽ حذف ڪري سگهون ٿا! اوه جاوا... توهان کي هر شي کي باڪس ڪرڻ جي ضرورت ڇو آهي؟! پر، مان وساري رهيو آهيان، جاوا عظيم آهي، ۽ ان جي عظمت کليل ذريعو لائبريرين جي گهڻائي ۾ آهي جنهن کي اسين استعمال ڪري سگهون ٿا! Trove4j انهن مان هڪ آهي. ان ۾ TIntArrayList آهي جنهن ۾ اندروني طور هڪ int[] ڊيٽا آهي. اچو ته ان جي ماپ جو اندازو لڳايو:

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

۽ نتيجو آهي 4040 بائيٽ (تقريبا ساڳيا صرف int[] !): تنهن ڪري، آخر ۾، اسان ٻنهي جهانن جو بهترين حاصل ڪري سگهون ٿا! انٽيجرز جي فهرست جيڪي 4 ڀيرا گھٽ جاء وٺن ٿيون. ۽ ان ۾ Integer مثال شامل نه آهي . صرف int s. اسان جاوا devs حقيقت ۾ يادگيري جي پرواهه ڪندا آهيون... پر اسان ڪارڪردگي جو به خيال رکون ٿا. هتي هڪ شاندار مائڪرو بينچ مارڪنگ لائبريري آهي هڪ معمولي نالي سان jmh جيڪا اسان کي ڪوڊ جي ڪارڪردگي کي ماپڻ جي اجازت ڏئي ٿي. پهرين اچو ته ٻن بي ترتيب انٽيجرز جي رقم جي حساب سان ڪارڪردگي جو مقابلو ڪريون، باڪس ٿيل، يا نه: jmh لاءِ ترتيب هن ريت آهي:

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

معيار جا نشان:

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

نتيجا: تنهن ڪري، سراسري طور، مختص، ۽ primitive ints جو مجموعو باڪس ٿيل Integers جي ڀيٽ ۾ ٻه ڀيرا وڌيڪ تيز آهي. ھاڻي اچو ته ٺاھڻ جي ڪارڪردگيءَ جو مقابلو ڪريون ۽ مجموعن جي مجموعن جي حساب سان (يا 1000 ints of Integers جي صفن):

@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]

نتيجا: primitives array دٻيل قدرن جي صف کان 4 ڀيرا وڌيڪ تيز آھي ( Integer s)؛ باڪس ٿيل قدرن جي ArrayList کان لڳ ڀڳ ڇهه ڀيرا تيز ( Integer s)؛ ۽ TIntArrayList جي ڀيٽ ۾ ٻه ڀيرا تيز (جيڪو اصل ۾ پرائمري انٽس جي هڪ صف کي سجائي ٿو). ان ڪري، جيڪڏھن توھان کي ضرورت آھي ڊيٽا جي جوڙجڪ لاءِ انٽيجر ويلز جو مجموعو ذخيرو ڪرڻ لاءِ، ۽ ان جو سائز تبديل ٿيڻ وارو نه آھي، استعمال ڪريو int [] ؛ جيڪڏهن سائيز تبديل ٿيڻ واري آهي - توهان شايد استعمال ڪرڻ چاهيو ٿا tove4j لائبريري سان TIntArrayList . ۽ هتي اچي ٿو منهنجي مقالي جي پڇاڙي جتي آئون انٽيجر قسم جي استعمال جي نقصانن کي بيان ڪريان ٿو. Integer جا ڪي دلچسپ جامد طريقا آهن ، جن کي ختم ڪرڻ کان اڳ مون کي ڳالهائڻ گهرجي. عوامي جامد انٽيجر getInteger (String nm، int val) اهو نٿو ڪري جيڪو ڪو سوچي سگھي ٿو، پر سسٽم جي ملڪيت جي انٽيجر قدر حاصل ڪري ٿو. Val ڊفالٽ آهي صورت ۾ هي ملڪيت مقرر نه آهي. عوامي جامد اسٽرنگ toBinaryString(int i) هڪ عدد جي بائنري نمائندگي سان هڪ اسٽرنگ واپس ڪري ٿو. بيسڊ-16 ( toHexString ) ۽ بيسڊ-8 ( toOctalString ) نمائندگي جي ٻيهر حاصل ڪرڻ جا طريقا آھن. ھڪڙو طريقو آھي ھڪڙي String کي int ۾ پارس ڪرڻ جو . جيتوڻيڪ تار هڪ غير 10 ريڊڪس تي ٻڌل نمائندگي آهي. هتي ڪجھ مثال آهن: Integer.parseInt("-FF"، 16) موٽائي ٿو -255 Integer.parseInt("+42", 10) 42 Integer.parseInt("1100110"، 2) 102 موٽائي ٿو