रैपर वर्ग विस्तार से

1. Integerवर्ग

Integerयह भी अच्छा है कि यह एक वर्ग है, जिसका अर्थ है कि इसमें क्षेत्र और विधियाँ हो सकती हैं। और, ज़ाहिर है, यह उनके पास है। उनमें से बहुत सारे - उनमें से दर्जनों। यहां हम सबसे बुनियादी पर विचार करेंगे।

वर्ग Integerमें दो फ़ील्ड होते हैं जिनमें प्रकार के अधिकतम और न्यूनतम संभव मान होते हैं int:

Integer.MAX_VALUE

Integer.MIN_VALUE

कभी-कभी आप intकिसी वेरिएबल को सबसे छोटा या सबसे बड़ा संभव मान निर्दिष्ट करना चाहते हैं। अपने कोड को समझने योग्य स्थिरांक के साथ अव्यवस्थित करने से बचने के लिए, आप इसे निम्नानुसार स्पष्ट रूप से लिख सकते हैं:

int min = Integer.MIN_VALUE;

min == 0x80000000

कक्षा Integerमें कुछ रोचक विधियाँ भी हैं। वे यहाँ हैं:

String Integer.toHexString(int)

String Integer.toBinaryString(int)

String Integer.toOctalString(int)

Integer Integer.valueOf(int i)

Integer Integer.parseInt(String)

आपने पहले स्थिर Integer.parseInt()विधि का सामना किया था। आइए याद करें कि यह कैसे काम करता है:

int name = Integer.parseInt(string);

यदि एक स्ट्रिंग जिसमें संख्या (केवल अंक) parseInt()विधि को पास की जाती है, तो यह स्ट्रिंग को पार्स करेगी और इसमें शामिल संख्या वापस कर देगी।

बाकी तरीके भी उपयोगी हैं। उदाहरण के लिए, उनमें से कुछ पास की गई संख्या को संख्या के बाइनरी, ऑक्टल या हेक्साडेसिमल प्रतिनिधित्व वाली स्ट्रिंग में परिवर्तित कर सकते हैं।

2. Doubleवर्ग

सामान्य तौर पर, Doubleवर्ग वर्ग के समान होता है Integer, केवल यह doubleएक के बजाय एक को लपेटता है int। इसके क्षेत्र और विधियाँ भी हैं जो हमारे लिए रूचिकर होंगी। उनमें से कुछ पर विचार करें:

कक्षा Doubleमें छह रोचक क्षेत्र हैं:

double Double.NEGATIVE_INFINITY

double Double.POSITIVE_INFINITY

int Double.MIN_EXPONENT

int Double.MAX_EXPONENT

double Double.MIN_VALUE

double Double.MAX_VALUE

अनंतता

यदि आप -1.0से विभाजित करते हैं 0.0, तो आपको नकारात्मक अनंतता मिलती है। यदि आप 1.0से विभाजित करते हैं 0.0, तो आपको सकारात्मक अनंतता मिलती है। न केवल आप a को doubleशून्य से विभाजित कर सकते हैं, बल्कि आप इसका उपयोग इन परिचालनों के परिणाम को संग्रहीत करने के लिए भी कर सकते हैं।

ए के प्रतिपादकdouble

प्रतिपादक को समझना आसान है। आंतरिक रूप से, एक डबल में एक मंटिसा और एक एक्सपोनेंट होता है। लेकिन यहाँ घातांक का मान नहीं है , बल्कि . इस प्रकार, यदि घातांक में वृद्धि होती है , तो संख्या का कुल मान दोगुना हो जाएगा।10x2x1

MIN_EXPONENT == -1024, जिसका अर्थ है , जो लगभग बराबर है2-102410-308

और हां, Doubleकक्षा में दिलचस्प तरीके हैं:

String Double.toHexString(double)

boolean Double.isInfinite(double)

boolean Double.isNaN(double)

Double Double.valueOf(double)

Double Double.parseDouble(String)

दिलचस्प बात यह है कि एक ऐसी isInfinite()विधि है जो trueपारित संख्या सकारात्मक या नकारात्मक अनंत होने पर वापस आती है।

विधि isNaN()समान है - यह जांचता है कि पारित संख्या है या नहीं NaN( नॉट-ए-नंबर , एक विशेष स्थिरांक जो एक अपरिभाषित मान इंगित करता है)।

3. Characterवर्ग

कक्षा Characterमुख्य रूप से इसकी बड़ी संख्या में स्थिर उपयोगिता विधियों के लिए दिलचस्प है जो आपको यह जांचने देती है कि वर्ण विभिन्न श्रेणियों से संबंधित हैं या नहीं।

उदाहरण

Character.isAlphabetic(int)

Character.isLetter(char)

Character.isDigit(char)

Character.isSpaceChar(char)

Character.isWhitespace(char)

Character.isLowerCase(char)

Character.isUpperCase(char)

Character.toLowerCase(char)

Character.toUpperCase(char)

इन विधियों की एक विशेषता यह है कि वे सभी ज्ञात वर्णों के साथ काम करते हैं: अरबी अंकों को अंक आदि के रूप में वर्गीकृत किया जाता है।

4. Booleanवर्ग

प्रकार Booleanवस्तुतः प्रकार के समान ही है boolean। मतभेद न्यूनतम हैं।

नीचे हम वर्ग का सरलीकृत संस्करण दिखाते हैं Boolean:

class Boolean
{
   public static final Boolean TRUE = new Boolean(true);
   public static final Boolean FALSE = new Boolean(false);

   private final boolean value;

   public Boolean(boolean value)
   {
      this.value = value;
   }

   public boolean booleanValue()
   {
      return value;
   }

   public static Boolean valueOf(boolean value)
   {
      return (value ? TRUE : FALSE);
   }
}

प्रकार Booleanमें दो स्थिरांक (दो फ़ील्ड) होते हैं:

Boolean.TRUE

true

Boolean.FALSE

false

आप उनके साथ उसी तरह काम कर सकते हैं जैसे आप booleanटाइप के साथ काम करते हैं:

if (Boolean.TRUE)
{
}

Boolean a = Boolean.TRUE;
boolean b = Boolean.TRUE;
boolean c = true;

Boolean a = Boolean.TRUE;
Boolean b = Boolean.TRUE;
if (a == b)

ऑटोबॉक्सिंग यहां बहुत अच्छा काम करती है। इसका मतलब है कि आप इस प्रकार का उपयोग उसी तरह से कर सकते हैं जैसे booleanप्रकार - देखने के लिए कोई नुकसान नहीं है।

Boolean a = true;
Boolean b = true;
Boolean c = false;
boolean d = a;

Boolean a = Boolean.valueOf(true);
Boolean b = Boolean.valueOf(true);
Boolean c = Boolean.valueOf(false);
boolean d = a.booleanValue();

booleanऔर यहाँ और प्रकारों की तुलना Boolean:

boolean a = true;
Boolean b = true; // b will be equal to Boolean.TRUE
Boolean c = true; // c will be equal to Boolean.TRUE

a == b; // true (compared by value)
a == c; // true (compared by value)
b == c; // true (compared by reference, but they point to the same object)

यदि आपको वास्तव में एक स्वतंत्र Booleanवस्तु की आवश्यकता है, तो आपको इसे स्पष्ट रूप से बनाना होगा:

boolean a = true;
Boolean b = new Boolean(true); // New Boolean object
Boolean c = true; // c will be equal to Boolean.TRUE

a == b; // true (compared by value)
a == c; // true (compared by value)
b == c; // false (compared by reference, and they point to different objects)

एक और उदाहरण, जहाँ हम Booleana के अंदर का उपयोग करेंगे if:

Boolean less = (2 < 3);
if (less)
{
   ...
}

यह संकलित होगा, लेकिन यह काम नहीं करेगा!

Boolean less = null;
if (less)
{
   ...
}

5. ऑटोबॉक्सिंग के दौरान कैशिंग मान

पूर्णांक आवरण प्रकार से संबंधित कुछ नुकसान हैं।

जैसा कि आप पहले से ही जानते हैं, यदि हम a intऔर an की तुलना करते हैं Integer, तो the को Integera में बदल दिया जाता है int:

int a = 5;
Integer b = 5;
if (a == b)
{
   ...
}

int a = 5;
Integer b = Integer.valueOf(5);
if (a == b.intValue())
{
   ...
}

यदि आप दो Integerवस्तुओं की एक दूसरे से तुलना करते हैं, तो वे intएस में परिवर्तित नहीं होते हैं:

Integer a = 500;
Integer b = 500;
int c = 500;

System.out.println(a == b); // Compared by reference
System.out.println(a == c);
System.out.println(b == c);

false
true
true

a == cऔर , लेकिन , क्योंकि जब हम तुलना करते हैं और हम संदर्भों की तुलना कर रहे होते हैं। जो अनिवार्य रूप से हम उम्मीद करेंगे।b == ca != bab

आश्चर्य

लेकिन अगर हम 500के साथ प्रतिस्थापित करते हैं 100, तो हमें एक पूरी तरह से अलग परिणाम मिलता है:

Integer a = 100;
Integer b = 100;
int c = 100;

System.out.println(a == b); // Compared by reference
System.out.println(a == c);
System.out.println(b == c);

true
true
true

यहां मुद्दा यह है कि ऑटोबॉक्सिंग के दौरान हमेशा एक नई Integerवस्तु वास्तव में नहीं बनाई जाती है । वस्तुओं को समावेशी -128के माध्यम से मूल्यों के लिए कैश किया जाता है ।127

वर्ग Integerमें एक छिपी हुई सरणी है जो वस्तुओं को संग्रहीत करती है: Integer(-128), Integer(-127), ... Integer(126),Integer(127)

यदि आप लिखते हैं Integer x = 128, तो ऑटोबॉक्सिंग प्रक्रिया एक नई वस्तु बनाती है, लेकिन यदि आप लिखते हैं Integer x = 127, तो ऑटोबॉक्सिंग प्रक्रिया मौजूदा ऑब्जेक्ट को कैश (सरणी से) से पुनर्प्राप्त करती है।

यदि आप नहीं चाहते कि Integerवस्तु कैश से आए, तो आपको इसे स्पष्ट रूप से लिखकर बनाना होगा:Integer x = new Integer(127);

सभी रैपर प्रकारों में ऐसा कैश होता है: Integer, Long, Byte, Short, Boolean. प्रकार के लिए Boolean, इसके TRUEऔर FALSEमान दोनों स्थिर हैं, इसलिए वे भी अनिवार्य रूप से कैश किए गए हैं।