எடுத்துக்காட்டுகளுடன் ஜாவாவில் 11 பாகுபடுத்தும்() முறைகள்

அதன் பொதுவான அர்த்தத்தில் பாகுபடுத்துதல் என்பது சில தரவுகளிலிருந்து தேவையான தகவல்களைப் பிரித்தெடுப்பதாகும், பெரும்பாலும் உரைத் தரவு. ஜாவாவில் பாகுபடுத்துதல் என்றால் என்ன? பாகுபடுத்தும் () முறையைக் கொண்ட பல ஜாவா வகுப்புகள் உள்ளன . பொதுவாக பாகுபடுத்தும்() முறையானது சில சரங்களை உள்ளீடாகப் பெற்று, அதிலிருந்து தேவையான தகவலை "பிரித்தெடுத்து" அழைப்பு வகுப்பின் பொருளாக மாற்றுகிறது. எடுத்துக்காட்டாக, இது ஒரு சரத்தைப் பெற்றது மற்றும் இந்த சரத்தில் "மறைத்து" இருந்த தேதியை வழங்கியது. இந்த இடுகையில், பாகுபடுத்தலின் 10 பயனுள்ள மாறுபாடுகளைப் பார்க்கப் போகிறோம் .

0. parseInt()

மிகவும் பிரபலமான பாகுபடுத்தும் () முறைகளில் ஒன்றிலிருந்து தொடங்குவோம் , அது சரியாக பாகுபடுத்தாது() , ஆனால் parseInt() . Java parseInt () முறையானது ஒரு குறிப்பிட்ட சரத்திலிருந்து பழமையான தரவு வகையைப் பெற பயன்படுகிறது. வேறு வார்த்தைகளில் கூறுவதானால், இது ஒரு சரத்தை எண்ணாக மாற்றுகிறது. parseInt () ஒன்று அல்லது இரண்டு வாதங்களைக் கொண்டிருக்கலாம். parseInt() இன் தொடரியல் இங்கே :

static int parseInt(String s)
static int parseInt(String s, int radix)

s என்பது கையொப்பமிடப்பட்ட தசம மதிப்பைக் குறிக்கும் சரம் மற்றும் எண் அமைப்பின் அடிப்படையான ரேடிக்ஸ். இயல்புநிலை அடிப்படை மதிப்பு இல்லை என்பதை நினைவில் கொள்ளவும் - 2 மற்றும் 36 வரம்பிற்குள் ஒன்றை உள்ளிட வேண்டும். இதோ ஒரு உதாரணம். ParseInt() உடன் எவ்வாறு அலசுவது:

public class ParseInt0 {

       public static void main(String args[]){
           int x = Integer.parseInt("12");
           double c = Double.parseDouble("12");
           int b = Integer.parseInt("100",2);

           System.out.println(Integer.parseInt("12"));
           System.out.println(Double.parseDouble("12"));
           System.out.println(Integer.parseInt("100",2));
           System.out.println(Integer.parseInt("101", 8));
         
       }
   }

வெளியீடு:

1. பீரியட் பாகுஸ்() முறை

காலம் என்பது "3 ஆண்டுகள், 5 மாதங்கள் மற்றும் 2 நாட்கள்" போன்ற ஆண்டுகள், மாதங்கள் மற்றும் நாட்களின் அடிப்படையில் நேரத்தை மாதிரியாக்குவதற்கான ஒரு ஜாவா வகுப்பாகும். ஒரு உரையிலிருந்து ஒரு காலத்தைப் பெற இது ஒரு பாகுபடுத்தும் () முறையைக் கொண்டுள்ளது. இதோ கால பாகுபாட்டின் தொடரியல் ()

public static Period parse(CharSequence text)

CharSequence என்பது Strings மூலம் செயல்படுத்தப்படும் ஒரு இடைமுகமாகும். எனவே நீங்கள் parse() முறையில் Strings ஐ உரை உறுப்பாகப் பயன்படுத்தலாம் . நிச்சயமாக, பீரியட் வகுப்பின் பொருளைத் திருப்பித் தர, சரம் சரியான வடிவத்தில் இருக்க வேண்டும். இந்த வடிவம் PnYnMnD ஆகும் . Y என்பது "ஆண்டு", M - "மாதம்", D - "நாள்". N என்பது ஒவ்வொரு கால மதிப்புக்கும் தொடர்புடைய எண்.

• முறைக்கு ஒரு அளவுரு உள்ளது - ஒரு உரை மதிப்பு.
• சரத்தின் மதிப்பு ஒரு அளவுருவாக மாறும் கால மதிப்பை பார்ஸ்() வழங்குகிறது.
• விதிவிலக்காக, சரம் மதிப்பு ஒரு காலகட்டத்தின் கட்டமைப்பை பூர்த்தி செய்யவில்லை என்றால் , காலம் பாகுபடுத்தும்() DateTimeParseException ஐ வழங்கலாம்.

நிஜ உலக சூழலில் பீரியட் பார்ஸ்() ஐப் பயன்படுத்துவதற்கான ஒரு எடுத்துக்காட்டு இங்கே :

import java.time.Period;
public class ParseDemo1 {

   public static void main(String[] args)
   {
       //Here is the age String in format to  parse
       String age = "P17Y9M5D";

       // Converting strings into period value
       // using parse() method
       Period p = Period.parse(age);
       System.out.println("the age is: ");
       System.out.println(p.getYears() + " Years\n"
                          + p.getMonths() + " Months\n"
                          + p.getDays() + " Days\n");
   }
}
	} 
} 

வெளியீடு:

2.SimpleDateFormat பார்ஸ்() முறை

SimpleDateFormat என்பது லோகேல்-சென்சிட்டிவ் முறையில் தேதிகளை வடிவமைப்பதற்கும் பாகுபடுத்துவதற்கும் பயன்படுத்தப்படும் ஒரு வகுப்பாகும். SimpleDateFormat parse() முறை ஒரு சரத்தை தேதி டோக்கன்களாக உடைத்து, தொடர்புடைய வடிவத்தில் தரவு மதிப்பை வழங்குகிறது. டெவலப்பரால் வரையறுக்கப்பட்ட குறியீட்டில் சரத்தை பாகுபடுத்தும் முறை தொடங்குகிறது. இது SimpleDateFormat பாகுபாட்டின் தொடரியல் () :

public Date parse(String the_text, ParsePosition position)

முறை இரண்டு அளவுருக்கள் உள்ளன:

• நிலை: தொடக்கக் குறியீட்டில் உள்ள தரவு, இது எப்போதும் பார்ஸ்பொசிஷன் பொருள் வகையாகும்.
• the_text: முறை பாகுபடுத்தும் சரத்தை வரையறுக்கிறது மற்றும் இது ஒரு சரம் வகை மதிப்பாகும்.

நிலை அறிவிப்பு இல்லாமல் இந்த முறையைப் பயன்படுத்தலாம். இந்த வழக்கில் தரவு பூஜ்ஜிய குறியீட்டிலிருந்து தொடங்குகிறது. SimpleDateFormat parse() ஆனது ஒரு தேதி அல்லது பூஜ்ய மதிப்பை வழங்கும் (பிழை காரணமாக சரம் செயலாக்கப்படவில்லை என்றால்). SimpleDateFormat parse() செயல்படுத்தலுக்கான எடுத்துக்காட்டு இங்கே :

// Parsing strings into the Date format with two different patterns import java.text.ParseException;
import java.text.ParsePosition;
import java.text.SimpleDateFormat;
import java.util.Date;

public class ParseDemo2 {
   public static void main(String[] args) throws ParseException {
       SimpleDateFormat simpleDateFormat1 = new SimpleDateFormat("MM/dd/yyyy");
       SimpleDateFormat simpleDateFormat2 = new SimpleDateFormat("dd/MM/yyyy");
       //simpleDateFormat1.setLenient(false);
       Date date1 = simpleDateFormat1.parse("010/14/2020");
       System.out.println(date1);
       Date date2 = simpleDateFormat2.parse("14/10/2020");
       System.out.println(date2);
       ParsePosition p1 = new ParsePosition(18);
       ParsePosition p2 = new ParsePosition(19);
       ParsePosition p3 = new ParsePosition(5);

       String myString = "here is the date: 14/010/2020";
       Date date3 = simpleDateFormat2.parse(myString,p1);
       Date date4 = simpleDateFormat2.parse(myString,p2);
       Date date5 = simpleDateFormat2.parse(myString,p3);

       System.out.println(date3);
       System.out.println(date4);
       System.out.println(date5);
   }
}

வெளியீடு: 5வது இடத்தில் இருந்து தொடங்கும் தேதி முறை இல்லாததால் கடைசியானது பூஜ்யமானது. நீங்கள் தேதி5 = simpleDateFormat2.parse(myString) போன்ற நிலை இல்லாமல் தேதி5 ஐ அலச முயற்சித்தால் , நீங்கள் விதிவிலக்கு பெறுவீர்கள்:

3. LocalDate பாகுபடுத்தும்() முறை

LocalDate என்பது ஜாவா 8 இல் தோன்றிய ஒரு வகுப்பாகும், இது ஆண்டு-மாதம்-நாள் (நாள்-ஆண்டு, வாரம்-வாரம் மற்றும் வார-ஆண்டு ஆகியவற்றையும் அணுகலாம்). LocalDate என்பது நேரம் அல்லது நேர மண்டலத்தைக் குறிக்காது. LocalDate parse() முறை இரண்டு வகைகளைக் கொண்டுள்ளது. இரண்டும் ஒரு சரத்தை புதிய ஜாவா 8 தேதி API ஆக மாற்ற உதவுகின்றன — java.time.LocalDate .

பாகுபடுத்து(CharSequence text, DateTimeFormatter, formatter)

இந்த முறை LocalDate இன் நிகழ்வைப் பெற ஒரு குறிப்பிட்ட வடிவமைப்பைப் பயன்படுத்தி ஒரு சரத்தை அலசுகிறது. முறையின் தொடரியல் இங்கே:

public static LocalTime parse(CharSequence text,
                              DateTimeFormatter formatter)

முறைக்கு இரண்டு அளவுருக்கள் உள்ளன - பாகுபடுத்தப்படும் உரை மற்றும் ஒரு டெவலப்பர் பயன்படுத்தும் வடிவமைப்பு. திரும்பும் மதிப்பாக, இந்த முறை லோக்கல்டைம் ஆப்ஜெக்ட்டை வழங்குகிறது, அது உள்ளூர் நாள் நேரமாக அங்கீகரிக்கப்படும். உரை மதிப்பை பாகுபடுத்த முடியாவிட்டால், கணினி DayTimeParseException ஐ வீசுகிறது. இரண்டு அளவுருக்களுடன் LocalDate parse() ஐப் பயன்படுத்துவதற்கான குறியீட்டு உதாரணத்தைப் பார்ப்போம் :

import java.time.LocalDate;
import java.time.format.DateTimeFormatter;
public class ParserDemo3 {

   public static void main(String[]args) {

       DateTimeFormatter formatter = DateTimeFormatter.ofPattern("dd/MM/yyyy");
       String date = "14/10/2020";
       LocalDate localDate = LocalDate.parse(date, formatter);
       System.out.println("parsed local date: " + localDate);
       System.out.println("formatted local date: " + formatter.format(localDate));
   }
}

வெளியீடு: ஒரு அளவுருவுடன் LocalDate parse() முறையில் அடுத்த தொடரியல் உள்ளது:

public static LocalTime parse(CharSequence text)

இந்த முறைக்கு வடிவமைப்பைக் குறிப்பிடத் தேவையில்லை. டெவலப்பர் சரம் மதிப்புகளை அடைப்புக்குறிக்குள் உள்ளிட்ட பிறகு, கணினி தானாகவே DateTimeFormatter.ISO_LOCAL_DATE ஐப் பயன்படுத்தும். இந்த முறை ஒரு ஒற்றை அளவுருவைக் கொண்டுள்ளது - ஒரு CharSequence உரை. நீங்கள் சரம் மதிப்பை இங்கே பயன்படுத்தலாம். இது பூஜ்யமாக இல்லை மற்றும் வடிவமைப்பின் கட்டமைப்பை மதிக்கிறது என்பதை உறுதிப்படுத்தவும். சரத்தை அலசுவதற்கு வழி இல்லை என்றால், டெவலப்பர் DateTimeExceptionAlert ஐப் பெறுவார். LocalDate parse() பயன்பாட்டின் உதாரணம் இங்கே :

import java.time.*;
public class ParseDemo3 {
       public static void main(String[] args)
       {
           // let’s make a new LocalDate object
           LocalDate localDate = LocalDate.parse("2020-10-14");
           System.out.println("LocalDate : " + localDate);
       }
   }

வெளியீடு:

4. LocalDateTime parse() முறை

LocalDateTime என்பது தேதி-நேரப் பொருளாகும், இது ஆண்டு-மாதம்-நாள்-மணி-மணி-நிமிட-வினாடி என அடிக்கடி பார்க்கப்படும் தேதி நேரத்தைக் குறிக்கிறது. மேலும் டெவலப்பர்கள் பிற தேதி மற்றும் நேரப் புலங்களைப் பயன்படுத்தலாம் (நாள்-ஆண்டு, நாள்-வாரம் மற்றும் வாரம்-ஆண்டு). இந்த வர்க்கம் மாறாதது. நேரம் நானோ வினாடி துல்லியமாக குறிப்பிடப்படுகிறது. எடுத்துக்காட்டாக, "நவம்பர் 17, 2020 13:30.30.123456789" என்ற மதிப்பை LocalDateTimeல் சேமிக்கலாம். இந்த வகுப்பு நேர மண்டலத்தைப் பிரதிநிதித்துவப்படுத்துவது அல்ல. இது ஒரு நிலையான தேதி பிரதிநிதித்துவம் மற்றும் உள்ளூர் நேரம். LocalDateTime parse() முறை இரண்டு வகைகளில் குறிப்பிடப்படுகிறது:

• 2007-12-03T10:15:30 போன்ற உரை சரத்திலிருந்து லோக்கல்டேட் டைமின் நிகழ்வை நிலையான லோக்கல்டேட் டைம் பாகுபடுத்துதல்(சார்சீக்வென்ஸ் டெக்ஸ்ட்) வழங்குகிறது.
• நிலையான LocalDateTime அலசல் (CharSequence text, DateTimeFormatter formatter) ஒரு குறிப்பிட்ட வடிவமைப்பைப் பயன்படுத்தி ஒரு உரை சரத்திலிருந்து LocalDateTime இன் நிகழ்வை வழங்குகிறது.

LocalDateTime parse() முறையின் உதாரணம் இங்கே :

import java.time.*;
public class ParseDemo11 {
       public static void main(String[] args) {
           LocalDateTime localDateTime = LocalDateTime.parse("2020-11-17T19:34:50.63");
           System.out.println("LocalDateTime is: " + localDateTime);
       }
   }

வெளியீடு:

5. ZonedDateTime parse() முறை

Class ZonedDateTime என்பது நேர மண்டலத்துடன் ஒரு தேதி நேரத்தைக் குறிக்கிறது. இந்த வர்க்கம் மாறாதது. இது தேதி மற்றும் நேரப் புலங்களை நானோ வினாடிகளின் துல்லியமாகச் சேமிக்கிறது, மேலும் ஒரு நேர மண்டலம், தெளிவற்ற உள்ளூர் தேதி-நேரங்களைக் கையாளப் பயன்படும் மண்டலம். எனவே "அக்டோபர் 14, 2020 இல் 17:50.30.123456789 +02:00 மணிக்கு ஐரோப்பா/பாரிஸ் நேர மண்டலத்தில்" போன்ற மதிப்பை நீங்கள் வைத்திருக்க வேண்டும் என்றால், நீங்கள் ZonedDateTime ஐப் பயன்படுத்தலாம். உள்ளூர் நேர அடிப்படையிலான தரவைக் கையாள வகுப்பு பெரும்பாலும் பயன்படுத்தப்படுகிறது. ZondeDateTime parse() என்பது ISO-8061 அமைப்பில் சரத்தை டோக்கன்களாக உடைக்கும் ஒரு பாகுபடுத்தியாகும். பாகுபடுத்திய பிறகு நீங்கள் பெறும் மதிப்பின் எடுத்துக்காட்டு இங்கே: உயர் துல்லியமான தரவு தேவைப்படும் போதெல்லாம் இது பயன்படுத்தப்படுகிறது (எல்லாவற்றிற்கும் மேலாக, நீங்கள் பெறும் தரவு நானோ விநாடிகள் வரை துல்லியமாக இருக்கும்). உள்ளூர் நேர அடிப்படையிலான தரவைக் கையாள வகுப்பு பெரும்பாலும் பயன்படுத்தப்படுகிறது. சரம் மதிப்புகளை ZonedDateTime வகுப்பாக மாற்ற டெவலப்பர்கள் பயன்படுத்தும் ZonedDateTime பார்ஸ்() முறையின் பொதுவான தொடரியல் பற்றி பார்க்கலாம் .

public static ZonedDateTime parse(CharSequence text)

முறை பயன்படுத்தும் ஒரே அளவுரு ஒரு சரம் உரை. திரும்பும் மதிப்பாக, ZonedDateTime வடிவமைப்பில் ஒன்று அல்லது தொடர்ச்சியான பொருள்களைப் பெறுவீர்கள். பாகுபடுத்தும் போது பிழை ஏற்பட்டாலோ அல்லது அது சாத்தியமில்லாமல் இருந்தாலோ, தொடங்குவதற்கு, முறை DateTimeParseException ஐ வழங்கும். இரண்டு மாறிகள் கொண்ட பாகுபடுத்தும் () முறையும் உள்ளது .

public static ZonedDateTime parse(CharSequence text, DateFormatter formatter)

இந்த முறை ஒரு குறிப்பிட்ட வடிவமைப்பைப் பயன்படுத்தி ஒரு உரை மதிப்பிலிருந்து ZonedDateTime இன் நிகழ்வைப் பெறுகிறது. ஒரு அளவுருவுடன் கூடிய முறை, DateTimeFormatter.ISO_LOCAL_TIME வடிவமைப்பானது இயல்பாகப் பயன்படுத்தப்படுகிறது. ZonedDateTime பாகுபடுத்தலுக்கான பயன்பாட்டு வழக்கைப் பார்ப்போம்():

// An example program that uses
// ZonedDateTime.parse() method
  
import java.time.ZonedDateTime;
import java.time.format.DateTimeFormatter;

public class ParseDemo4 {
   public static void main(String[] args) {
       ZonedDateTime zonedDateTime = ZonedDateTime.parse("2020-10-15T10:15:30+01:00");
       System.out.println(zonedDateTime);

       DateTimeFormatter dateTimeFormatter = DateTimeFormatter.ISO_ZONED_DATE_TIME;
       String date = "2020-10-15T13:30:25+01:00";
       ZonedDateTime zoneDateTime1 = ZonedDateTime.parse(date, dateTimeFormatter);
       System.out.println(zoneDateTime1);
   }
}

வெளியீடு:

6. LocalTime parse() முறை

வகுப்பு லோக்கல்டைம் ஒரு நேரத்தைக் குறிக்கிறது, பெரும்பாலும் மணிநேரம்-நிமிடம்-வினாடியாகப் பார்க்கப்படுகிறது. ZonedDateTime போன்ற இந்த வகுப்பும் மாறாதது.நேரம் நானோ வினாடி துல்லியமாக குறிப்பிடப்படுகிறது. எடுத்துக்காட்டாக, "13:45.30.123456789" மதிப்பை லோக்கல் டைமில் சேமிக்கலாம். ஒன்று மற்றும் இரண்டு அளவுருக்களுடன் இரண்டு லோக்கல்டைம் பாகுபடுத்தும்() முறைகள் உள்ளன . இரண்டையும் பார்ப்போம்:

public static LocalTime parse(CharSequence text)

நீங்கள் பாகுபடுத்த விரும்பும் சரமான ஒரே ஒரு அளவுருவுடன் LocalTime parse() ஐப் பயன்படுத்தலாம் . இந்த வழக்கில், DateTimeFormatter.ISO_LOCAL_TIME வடிவமைப்பானது இயல்பாகப் பயன்படுத்தப்படும்.

Method with two parameters has the next syntax: 
public static LocalTime parse(CharSequence text,
                              DateTimeFormatter formatter)

இது ஒரு குறிப்பிட்ட வடிவமைப்பைப் பயன்படுத்தி ஒரு உரை மதிப்பிலிருந்து LocalTime இன் நிகழ்வைப் பெறுகிறது. இரண்டு முறைகளும் hh/mm/ss வடிவத்தில் LocalTime மதிப்பை வழங்கும். DateTimeParceException விழிப்பூட்டல்களைக் கவனியுங்கள். சரம் உரையின் வடிவம் LocalTime ஆப்ஜெக்ட்களுடன் ஒத்துப்போகவில்லை என்று அர்த்தம். தயாரிப்பில் LocalTime parse() ஐப் பயன்படுத்துவதற்கான எடுத்துக்காட்டு :

import java.time.*;
import java.time.format.*;
public class ParseDemo5 {

       public static void main(String[] args)
       {

           LocalTime localTime
                   = LocalTime.parse("10:25:30");

           // return the output value
           System.out.println("LocalTime : "
                              + localTime);

           // create a formater
           DateTimeFormatter formatter
                   = DateTimeFormatter.ISO_LOCAL_TIME;

           LocalTime localTime1
                   = LocalTime.parse("12:30:50");
           // parse a string to get a LocalTime object in return

           LocalTime.parse("12:30:50",
               formatter);
           // print the output
           System.out.println("LocalTime : "
                              + localTime1);
       }
   }

7. MessageFormat பார்ஸ்() முறை

MessageFormat வடிவமைப்பு வகுப்பை நீட்டிக்கிறது. வடிவமைப்பு என்பது லோக்கல்-சென்சிட்டிவ் தரவை (தேதிகள், செய்திகள் மற்றும் எண்கள்) வடிவமைப்பதற்கான ஒரு சுருக்க அடிப்படை வகுப்பாகும். MessageFormat சில பொருட்களைப் பெற்று அவற்றை வடிவமைக்கிறது. பின்னர் அது வடிவமைக்கப்பட்ட சரங்களை பொருத்தமான இடங்களில் அமைப்பில் செருகும். குறியீட்டு தொடக்கம் கொடுக்கப்பட்டால், ஒரு சர மதிப்பைப் பெற MessageFormat parse() பயன்படுகிறது. முறையின் பொதுவான தொடரியல் இங்கே:

public Object[] parse(String source, ParsePosition position)

மூலமானது பாகுபடுத்துவதற்கான சரம் மற்றும் நிலை என்பது பாகுபடுத்தலின் தொடக்கக் குறியீடாகும். MessageFormat parse() முறை வேலை செய்வதற்கான எடுத்துக்காட்டு இங்கே :

import java.text.MessageFormat;
import java.text.ParsePosition;

public class ParseDemo7 {
   public static void main(String[] args) {
    try {
           MessageFormat messageFormat = new MessageFormat("{1, number, #}, {0, number, #.#}, {2, number, #.##}");

           ParsePosition pos = new ParsePosition(3);
           Object[] hash = messageFormat.parse("12.101, 21.382, 35.121", pos);

           System.out.println("value after parsing: ");
           for (int i = 0; i < hash.length; i++)
               System.out.println(hash[i]);
       }
       catch (NullPointerException e) {
          System.out.println("\nNull");
          System.out.println("Exception thrown : " + e);
       } }
}

8. நிலை பாகுபடுத்தும்() முறை

ஒரு புரோகிராமர் ஒரு லாகரைப் பயன்படுத்தி ஒரு செய்தியைப் பதிவு செய்யும்போது அது ஒரு குறிப்பிட்ட பதிவு மட்டத்தில் உள்நுழைந்திருக்கும். ஏழு உள்ளமைக்கப்பட்ட பதிவு நிலைகள் உள்ளன:

• கடுமையான
• எச்சரிக்கை
• தகவல்
• கட்டமைப்பு
• நன்றாக
• ஃபைனர்
• சிறந்த

மேலும் லாக்கிங்கை அணைக்கப் பயன்படுத்தப்படும் கூடுதல் நிலைகள் ஆஃப் மற்றும் அனைத்து செய்திகளையும் பதிவு செய்வதை இயக்குவதற்குப் பயன்படுத்தப்படும். பதிவு நிலை java.util.logging.Level வகுப்பால் குறிக்கப்படுகிறது . நிலை வகுப்பில் இந்த ஏழு நிலைகளில் ஒவ்வொன்றிற்கும் ஒரு மாறிலி உள்ளது. எனவே, லாகருக்கு ஒரு செய்தியைப் பதிவு செய்யும் போது, ​​ஆல் மற்றும் ஆஃப் உட்பட, இந்த மாறிலிகளில் ஒன்றைப் பயன்படுத்துகிறீர்கள். இந்த நிலைகள் அனைத்தும் சில முழு எண்களுக்கு துவக்கப்பட்டன. எடுத்துக்காட்டாக, FINE 500 க்கு துவக்கப்படுகிறது. Level parse() முறையானது ஒரு உரை மதிப்பிலிருந்து தேவையான தகவலைப் பாகுபடுத்தி, நிலைப் பொருளை வழங்கும். நிலை பாகுபடுத்தும்() முறையின் தொடரியல் இங்கே :

public static Level parse(String name)

ஒரு முறையின் அளவுரு என்பது டெவலப்பர் பாகுபடுத்த விரும்பும் சரத்தின் பெயராகும். இது மட்டத்தின் பெயராகவோ, அதன் துவக்கப் பெயராகவோ அல்லது வேறு முழு எண்ணாகவோ இருக்கலாம். பதிலுக்கு, ஒரு ப்ரோக்ராமர் ஒரு நிலை பெயர் மதிப்பைப் பெறுகிறார், இது ஆரம்ப சரத்தின் மதிப்பைப் பெறுகிறது. வாதத்தில் பாகுபடுத்த முடியாத குறியீடுகள் இருந்தால், முறையானது IllegalArgumentExceptionஐ தூக்கி எறியும். ஒரு சரத்தில் மதிப்புகள் இல்லை என்றால், டெவலப்பர் ஒரு NullPointerException ஐப் பெறுவார். லெவல் பார்ஸ்() செயல்படுத்தப்படுவதைக் காட்டும் குறியீட்டின் ஒரு பகுதி இங்கே உள்ளது .

import java.util.logging.Level;
public class ParseDemo6 {

   public static void main(String[] args)
   {
       Level level = Level.parse("500");
       System.out.println("Level = " + level.toString());

       Level level1 = Level.parse("FINE");
       System.out.println("Level = " + level1.toString());

       Level level2 = level.parse ("OFF");
       System.out.println(level2.toString());
   }
}

வெளியீடு:

9. உடனடி பாகுபடுத்தும்() முறை

உடனடி வகுப்பு மாதிரிகள் நேரக் கோட்டில் ஒரு உடனடி புள்ளி. உங்கள் பயன்பாட்டில் நிகழ்வு நேர முத்திரைகளைப் பதிவுசெய்ய இதைப் பயன்படுத்தலாம். உடனடி அலசல்() உரை மதிப்பிலிருந்து உடனடி மதிப்பைப் பெறுகிறது. சரம் பின்னர் UTC நேர மண்டல மதிப்பாக சேமிக்கப்படும். 2020-10-14T11:28:15.00Z போன்ற DateTimeFormatter.ISO_INSTANTஐ கணினி பயன்படுத்துகிறது. Instant parse() முறையின் தொடரியல் இங்கே :

public static Instant parse(CharSequence text)

ஒரு சரத்தை அலசி உடனடியாகப் பெற, டெவலப்பர் சரத்தில் ஏதேனும் உரை உள்ளதா என்பதை உறுதிப்படுத்த வேண்டும். அது பூஜ்யமாக இருந்தால், நீங்கள் DateTimeExceptionஐப் பெறுவீர்கள். ஜாவாவில் உடனடி பாகுபடுத்தலைப் பயன்படுத்துவதற்கான எடுத்துக்காட்டு இங்கே :

import java.time.Instant;

public class ParseDemo8 {
       public static void main(String[] args) {

           Instant instant = Instant.parse("2020-10-14T10:37:30.00Z");
           System.out.println(instant);
       }
   }

வெளியீடு:

10. NumberFormat parse() method

எண்களை வடிவமைக்க java.text.NumberFormat வகுப்பு பயன்படுத்தப்படுகிறது. NumberFormat parse() என்பது இந்த வகுப்பின் இயல்புநிலை முறையாகும். NumberFormat வகுப்பின் பாகுபடுத்தும் () முறை ஒரு சரத்தை எண்ணாக மாற்றுகிறது. ஒரு சரத்தை அதன் கூறு எண்களுக்கு உடைக்க டெவலப்பர்கள் இதைப் பயன்படுத்துகின்றனர். பாகுபடுத்துதல் சரத்தின் தொடக்கத்தில் இருந்து தொடங்குகிறது. பின்வரும் எடுத்துக்காட்டில் காட்டப்பட்டுள்ளபடி, பாகுபடுத்தும் () முறையை அழைப்பதற்கு முன் setParseIntegerOnly (true) என அழைத்தால் , எண்ணின் முழு எண் பகுதி மட்டுமே மாற்றப்படும். NumberFormat parse() இன் தொடரியல் இங்கே :

public Number parse(String str)

ஒரு அளவுருவாக, செயல்பாடு சரங்களை ஏற்றுக்கொள்கிறது. பாகுபடுத்தலின் வருவாய் மதிப்பு என்பது ஒரு எண் மதிப்பாகும். ஒரு சரத்தின் தொடக்கத்தை பாகுபடுத்த முடியாவிட்டால், பார்ஸ்எக்ஸப்ஷன் எச்சரிக்கையைப் பெறுவீர்கள். NumberFormat parse() முறையின் பயன்பாட்டைப் பார்க்க , கீழே உள்ள எடுத்துக்காட்டைப் பாருங்கள்:

import java.text.NumberFormat;
import java.text.ParseException;

public class ParseDemo9 {

       public static void main(String[] args) throws ParseException {
           NumberFormat numberFormat = NumberFormat.getInstance();
           System.out.println(numberFormat.parse("3,141592"));
           numberFormat.setParseIntegerOnly(true);
           System.out.println(numberFormat.parse("3,141592"));
       }
   }

வெளியீடு:

முடிவுரை

சரங்களை பல்வேறு தரவு வகைகளாக மாற்ற டெவலப்பர்கள் பயன்படுத்தக்கூடிய பல பாகுபடுத்தும் முறைகள் உள்ளன. அவற்றை நினைவில் கொள்வது கடினமானதாகத் தோன்றினாலும், இதுபோன்ற பல்வேறு கட்டளைகள் டெவலப்பர்களுக்கு நிறைய நெகிழ்வுத்தன்மையையும் துல்லியத்தையும் தருகின்றன. ஒவ்வொரு முறைக்கும் எந்த அளவுருக்கள் அவசியம் என்பதை மறந்துவிடாமல் தொடரியலை நீங்கள் நினைவில் வைத்திருக்கிறீர்கள் என்பதை உறுதிப்படுத்த தரவு பாகுபடுத்தலைப் பயன்படுத்துவதை உறுதிசெய்யவும்.