रॅपरचे तपशीलवार वर्ग

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, फक्त तो a doubleऐवजी a गुंडाळतो 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तुम्हाला सकारात्मक अनंतता मिळेल. तुम्ही केवळ शून्याने भागाकार करू शकत नाही double, परंतु तुम्ही या ऑपरेशन्सचा परिणाम संग्रहित करण्यासाठी देखील वापरू शकता.

a चे घातांक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( Not-a-Number , एक विशेष स्थिरांक जो अपरिभाषित मूल्य दर्शवितो).

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 с = 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)

Booleanआणखी एक उदाहरण, जिथे आपण आतील एक वापरू if:

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

हे संकलित करेल, परंतु ते कार्य करणार नाही!

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

5. ऑटोबॉक्सिंग दरम्यान कॅशिंग मूल्ये

पूर्णांक रॅपर प्रकारांशी संबंधित काही तोटे आहेत.

तुम्हाला आधीच माहित आहे की, जर आपण an intआणि an ची तुलना केली तर Integer, चे Integerरूपांतर एका मध्ये होते int:

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

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

जर तुम्ही दोन Integerवस्तूंची एकमेकांशी तुलना केली तर ते ints मध्ये रूपांतरित होणार नाहीत:

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मूल्ये दोन्ही स्थिर आहेत, म्हणून ते देखील मूलत: कॅशे केलेले आहेत.