ரேப்பர் வகுப்புகள் விரிவாக

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வகுப்பு என்பது வகுப்பைப் போன்றது , இது ஒரு ஐ விட Integera ஐ மட்டுமே மறைக்கிறது . இது எங்களுக்கு ஆர்வமாக இருக்கும் துறைகள் மற்றும் முறைகளையும் கொண்டுள்ளது. அவற்றில் சிலவற்றைக் கவனியுங்கள்:doubleint

வகுப்பில் 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, ஆனால் இந்த செயல்பாடுகளின் முடிவை சேமிக்கவும் பயன்படுத்தலாம்.

ஒரு அடுக்கு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 с = 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. ஆட்டோ பாக்ஸிங்கின் போது கேச்சிங் மதிப்புகள்

முழு எண் ரேப்பர் வகைகளுடன் தொடர்புடைய சில ஆபத்துகள் உள்ளன.

உங்களுக்கு ஏற்கனவே தெரியும், நாம் ஒரு intமற்றும் ஒரு வை ஒப்பிட்டுப் பார்த்தால் 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மதிப்புகள் இரண்டும் மாறிலிகளாகும், எனவே அவைகள் அடிப்படையில் தற்காலிகமாக சேமிக்கப்படும்.