Java.lang.Integer کلاس

جاوا ڈیٹا کی اقسام کو مشروط طور پر دو بلاکس میں تقسیم کیا جا سکتا ہے: قدیم اور حوالہ (کلاسز)۔ جاوا میں ڈیٹا کی متعدد اقسام ہیں، جیسے انٹیجرز ( بائٹ ، شارٹ ، انٹ ، لانگ )، فلوٹنگ پوائنٹ نمبرز ( فلوٹ ، ڈبل )، منطقی ڈیٹا ٹائپ ( بولین ) اور کریکٹر ڈیٹا ٹائپ ( چار )۔ آپ شاید پہلے ہی جان چکے ہوں گے کہ ہر قدیم ڈیٹا کی قسم کی اپنی ریپر کلاس ہوتی ہے۔ ایک حوالہ ڈیٹا کی قسم جو اپنے قدیم چھوٹے بھائی کو جاوا آبجیکٹ میں "لپٹتی" یا بدل دیتی ہے۔ انٹیجر اپنے قدیم بھائی کے لیے ایک ریپر کلاس ہے جس کا نام int ہے۔ انگریزی میں انٹیجر کا مطلب مکمل نمبر ہے۔ وہ مثبت، منفی یا 0 ہو سکتے ہیں۔ بدقسمتی سے، جاوا میں انٹیجر کا مطلب کوئی مکمل نمبر نہیں ہے۔ جاوا میں انٹیجر ایک مکمل نمبر ہے جو 32 بٹس میں فٹ بیٹھتا ہے۔ اگر آپ بڑی تعداد چاہتے ہیں تو آپ جاوا لانگ نمبر استعمال کرنے کے لیے خوش آمدید ہیں۔ ان کے اختیار میں 64 بٹس ہیں۔ اگر آپ اتنے بدقسمت ہیں کہ اس سے بھی بڑی تعداد کی ضرورت ہے تو Java نے آپ کو BigInteger کے ساتھ کور کیا ہے ۔

انٹیجر کے ساتھ کام کرنا

ریپر کلاس کے طور پر، Integer int کے ساتھ کام کرنے کے مختلف طریقے فراہم کرتا ہے ، نیز int کو String اور String کو int میں تبدیل کرنے کے کئی طریقے ۔ کلاس میں دو کنسٹرکٹرز ہیں:

• public Integer(int i) ، جہاں i شروع کرنے کے لیے ایک قدیم قدر ہے۔ یہ ایک انٹیجر آبجیکٹ بناتا ہے جو int ویلیو کے ساتھ شروع کیا جاتا ہے۔

• عوامی عدد (اسٹرنگ s) NumberFormatException کو پھینک دیتا ہے ۔ یہاں s int ویلیو کی سٹرنگ کی نمائندگی ہے ۔ یہ کنسٹرکٹر ایک انٹیجر آبجیکٹ بناتا ہے جو سٹرنگ کی نمائندگی کے ذریعہ فراہم کردہ int ویلیو کے ساتھ شروع کیا گیا تھا۔

انٹیجر آبجیکٹ کی تخلیق

انٹیجر آبجیکٹ بنانے کے مختلف اختیارات ہیں ۔ سب سے زیادہ عام استعمال میں سے ایک سب سے آسان ہے. یہاں ایک مثال ہے:

Integer myInteger = 5;

اس معاملے میں انٹیجر متغیر کی ابتداء قدیم int متغیر کی ابتداء کی طرح ہے ۔ ویسے آپ انٹیجر متغیر کو int کی قدر کے ساتھ شروع کر سکتے ہیں ۔ یہاں ایک مثال ہے:

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

آؤٹ پٹ یہاں ہے: درحقیقت، یہاں ہم آٹو پیکنگ کا مشاہدہ کر سکتے ہیں۔ اس کے علاوہ ہم کنسٹرکٹر اور نئے مطلوبہ الفاظ کا استعمال کرتے ہوئے کسی بھی دوسری اشیاء کی طرح ایک انٹیجر آبجیکٹ بنا سکتے ہیں :

Integer myInteger = new Integer(5);

آپ انٹیجر متغیر کے ساتھ وہی کر سکتے ہیں جیسا کہ int کے ساتھ (اضافہ، گھٹاؤ، ضرب، تقسیم، اضافہ، کمی)۔ تاہم، یہ یاد رکھنا ضروری ہے کہ Integer ایک حوالہ ڈیٹا کی قسم ہے، اور اس قسم کا ایک متغیر کالعدم ہو سکتا ہے۔ اس صورت میں، اس طرح کی کارروائیوں سے باز رہنا بہتر ہے.

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

یہاں ہمیں ایک استثناء ملے گا:

انٹیجر کلاس مستقل

انٹیجر کلاس انٹیجرز کے ساتھ کام کرنے کے لیے مختلف مستقل اور طریقے فراہم کرتی ہے۔ وہ یہاں ہیں:

• 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 طریقہ بھی ہے ۔ تاہم، 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 میموری ماڈل کے بارے میں درج ذیل کو جاننے کی ضرورت ہے: آپ جو کچھ بھی اعلان کرتے ہیں وہ یا تو Stack Memory (ہر تھریڈ کے لیے مخصوص JVM Stack)، یا Heap Space میں محفوظ ہے۔ قدیم قسمیں ( int , long , float , boolean , double , char , byte , etc ) Stack میموری میں محفوظ ہیں۔ تمام آبجیکٹ اور ارے ہیپ اسپیس میں محفوظ ہیں۔ ان اشیاء کے حوالہ جات اور طریقوں کے لیے درکار صفیں Stack میں محفوظ ہیں۔ تو ہم کیوں پرواہ کرتے ہیں؟ ٹھیک ہے، آپ نے دیکھا، Stack Heap (a con) سے چھوٹا ہے، لیکن اسٹیک میں قدریں مختص کرنا ہیپ (ایک پرو) کے مقابلے میں بہت تیز ہے۔ آئیے ایک قدیم قسم کے ساتھ شروع کرتے ہیں int ۔ یہ بالکل 32 بٹس لیتا ہے۔ یہ 32/8=4 بائٹس ہے۔ کیونکہ یہ ایک قدیم قسم ہے۔ اب، آئیے انٹیجر پر غور کریں ۔ یہ ایک آبجیکٹ ہے، جس میں اضافی اوور ہیڈ اور صف بندی ہوتی ہے۔ میں نے اس کے سائز کی پیمائش کرنے کے لیے لائبریری jol کا استعمال کیا ہے۔

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

اور یہ 16 بائٹس لینے کے لئے نکلا: کیا؟! یہ 4 گنا زیادہ میموری ہے! لیکن ہمیں وہاں نہیں رکنے دو۔ جاوا ڈویلپرز کے طور پر ہم عام طور پر ایک عدد عدد کا استعمال بند نہیں کرتے۔ ہم واقعی میں ان میں سے بہت سے استعمال کرنا چاہتے ہیں۔ جیسے ایک تسلسل میں۔ مثال کے طور پر، ایک صف میں۔ یا ایک فہرست۔ صفوں کو ہیپ میں محفوظ کیا جاتا ہے، جیسا کہ فہرستیں ہیں۔ لہذا، مختص کرنے میں تقریباً اتنا ہی وقت لگنا چاہیے۔ ٹھیک ہے؟ لیکن اگر ہمیں مزید میموری مختص کرنے کی ضرورت ہو تو کیا ہوگا؟ آئیے چیک کرتے ہیں کہ 1000 قدیم 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 بائٹس ہے: ٹھیک ہے، اس طرح کی سمجھ میں آتا ہے، ایک int پر غور 4 بائٹس لیتا ہے. 1000 انٹیجرز کی 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 گنا کم جگہ لیتی ہیں۔ اور اس میں انٹیجر مثالیں شامل نہیں ہیں ۔ صرف int s. ہم جاوا دیو واقعی میموری کی پرواہ کرتے ہیں… لیکن ہمیں کارکردگی کا بھی خیال ہے۔ ایک معمولی نام 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;
}

نتائج: لہٰذا، اوسطاً، مختص، اور پرائمیٹو انٹس کا مجموعہ باکسڈ انٹیجرز کے مقابلے میں دو گنا سے زیادہ تیز ہے۔ اب، آئیے تخلیق کی کارکردگی کا موازنہ کریں اور مجموعہ کے مجموعے (یا 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 کے کچھ دلچسپ جامد طریقے ہیں ، جن کے بارے میں مجھے ختم کرنے سے پہلے بات کرنی چاہیے۔ public static Integer getInteger(String nm, int val) وہ نہیں کرتا جو کوئی سوچ سکتا ہے، لیکن سسٹم پراپرٹی کی ایک عددی قدر بازیافت کرتا ہے۔ یہ پراپرٹی سیٹ نہ ہونے کی صورت میں Val ڈیفالٹ ہے۔ عوامی جامد String toBinaryString(int i) نمبر کی بائنری نمائندگی کے ساتھ سٹرنگ لوٹاتا ہے ۔ بیسڈ-16 ( toHexString ) اور بیسڈ-8 ( toOctalString ) کی بازیافت کے طریقے ہیں۔ اسٹرنگ کو int میں پارس کرنے کا ایک طریقہ ہے ۔ یہاں تک کہ اگر سٹرنگ غیر 10 ریڈکس پر مبنی نمائندگی ہو۔ یہاں کچھ مثالیں ہیں: Integer.parseInt("-FF", 16) -255 واپس کرتا ہے Integer.parseInt("+42", 10) 42 Integer.parseInt("1100110", 2) 102 لوٹاتا ہے۔