ఉదాహరణలతో జావాలో 11 పార్స్() పద్ధతులు

దాని అత్యంత సాధారణ అర్థంలో అన్వయించడం అనేది కొంత డేటా నుండి అవసరమైన సమాచారాన్ని సంగ్రహించడం, చాలా తరచుగా వచన డేటా. జావాలో పార్స్ అంటే ఏమిటి? పార్స్() పద్ధతిని కలిగి ఉన్న అనేక జావా తరగతులు ఉన్నాయి . సాధారణంగా పార్స్() పద్ధతి కొన్ని స్ట్రింగ్‌ను ఇన్‌పుట్‌గా స్వీకరిస్తుంది, దాని నుండి అవసరమైన సమాచారాన్ని "సంగ్రహిస్తుంది" మరియు దానిని కాలింగ్ క్లాస్ యొక్క వస్తువుగా మారుస్తుంది. ఉదాహరణకు, ఇది స్ట్రింగ్‌ను అందుకుంది మరియు ఈ స్ట్రింగ్‌లో "దాచుతున్న" తేదీని తిరిగి ఇచ్చింది. ఈ పోస్ట్‌లో, మేము పార్స్() యొక్క 10 ఉపయోగకరమైన వైవిధ్యాలను పరిశీలించబోతున్నాము .

0. 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 అనేది స్ట్రింగ్స్ ద్వారా అమలు చేయబడిన ఇంటర్‌ఫేస్. కాబట్టి మీరు పార్స్() పద్ధతిలో స్ట్రింగ్‌లను టెక్స్ట్ ఎలిమెంట్‌గా ఉపయోగించవచ్చు . పీరియడ్ క్లాస్ యొక్క వస్తువును తిరిగి ఇవ్వడానికి ఖచ్చితంగా స్ట్రింగ్ సరైన ఫార్మాట్‌లో ఉండాలి. ఈ ఫార్మాట్ PnYnMnD . Y అంటే "సంవత్సరం", M - "నెల", D - "రోజు". N అనేది ప్రతి వ్యవధి విలువకు అనుగుణంగా ఉండే సంఖ్య.

• పద్ధతికి ఒక పారామీటర్ ఉంది - ఒక టెక్స్ట్ విలువ.
• Parse() ఒక పీరియడ్ విలువను అందిస్తుంది, ఇక్కడ స్ట్రింగ్ విలువ పరామితి అవుతుంది.
• మినహాయింపుగా, స్ట్రింగ్ విలువ వ్యవధి యొక్క ఆకృతిని అందుకోకపోతే, వ్యవధి అన్వయం() 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 పార్స్() పద్ధతి ఒక స్ట్రింగ్‌ను తేదీ టోకెన్‌లుగా విభజించి, సంబంధిత ఆకృతిలో డేటా విలువను అందిస్తుంది. డెవలపర్ ద్వారా నిర్వచించబడిన సూచికలో స్ట్రింగ్‌ను అన్వయించడం పద్ధతి ప్రారంభమవుతుంది. ఇది SimpleDateFormat పార్స్() యొక్క వాక్యనిర్మాణం :

public Date parse(String the_text, ParsePosition position)

పద్ధతి రెండు పారామితులను కలిగి ఉంటుంది:

• స్థానం: ప్రారంభ సూచికలోని డేటా ఎల్లప్పుడూ పార్స్‌పొజిషన్ ఆబ్జెక్ట్ రకంగా ఉంటుంది.
• the_text: పద్ధతి అన్వయించే స్ట్రింగ్‌ను నిర్వచిస్తుంది మరియు ఇది స్ట్రింగ్ రకం విలువ.

మీరు స్థానం ప్రకటన లేకుండా ఈ పద్ధతిని ఉపయోగించవచ్చు. ఈ సందర్భంలో డేటా సున్నా సూచిక నుండి ప్రారంభమవుతుంది. SimpleDateFormat పార్స్() తేదీ లేదా శూన్య విలువను అందిస్తుంది (ఒకవేళ స్ట్రింగ్ లోపం కారణంగా ప్రాసెస్ చేయబడకపోతే). SimpleDateFormat పార్స్() అమలు యొక్క ఉదాహరణ ఇక్కడ ఉంది :

// 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() పద్ధతిలో రెండు రకాలు ఉన్నాయి. ఈ రెండూ స్ట్రింగ్‌ను కొత్త Java 8 తేదీ APIగా మార్చడంలో సహాయపడతాయి — java.time.LocalDate .

అన్వయించు (చార్సీక్వెన్స్ టెక్స్ట్, డేట్ టైమ్ ఫార్మాటర్, ఫార్మాటర్)

ఈ పద్ధతి లోకల్‌డేట్ యొక్క ఉదాహరణను పొందడానికి నిర్దిష్ట ఫార్మాట్‌ని ఉపయోగించి స్ట్రింగ్‌ను అన్వయిస్తుంది. పద్ధతి యొక్క వాక్యనిర్మాణం ఇక్కడ ఉంది:

public static LocalTime parse(CharSequence text,
                              DateTimeFormatter formatter)

పద్ధతికి రెండు పారామితులు ఉన్నాయి - అన్వయించబడే వచనం మరియు డెవలపర్ వర్తించే ఫార్మాటర్. రిటర్న్ విలువగా, పద్ధతి స్థానిక పగటి సమయంగా గుర్తించబడే లోకల్ టైమ్ వస్తువును అందిస్తుంది. టెక్స్ట్ విలువ అన్వయించడం ద్వారా వెళ్ళలేకపోతే, సిస్టమ్ DayTimeParseExceptionని విసురుతుంది. లోకల్‌డేట్ పార్స్()ని రెండు పారామితులతో ఉపయోగించడం యొక్క కోడ్ ఉదాహరణను చూద్దాం :

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 పార్స్() పద్ధతి తదుపరి సింటాక్స్‌ను కలిగి ఉంటుంది:

public static LocalTime parse(CharSequence text)

ఈ పద్ధతికి ఫార్మాటర్‌ని పేర్కొనాల్సిన అవసరం లేదు. డెవలపర్ స్ట్రింగ్ విలువలను బ్రాకెట్‌లలోకి నమోదు చేసిన తర్వాత, సిస్టమ్ స్వయంచాలకంగా DateTimeFormatter.ISO_LOCAL_DATEని ఉపయోగిస్తుంది. ఈ పద్ధతికి ఒకే పరామితి ఉంది — చార్‌సీక్వెన్స్ టెక్స్ట్. మీరు ఇక్కడ స్ట్రింగ్ విలువను ఉపయోగించవచ్చు. ఇది శూన్యం కాదని మరియు ఫార్మాటర్ నిర్మాణాన్ని గౌరవిస్తుందని నిర్ధారించుకోండి. స్ట్రింగ్‌ను అన్వయించడానికి మార్గం లేకుంటే, డెవలపర్ 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 పార్స్() పద్ధతి

LocalDateTime తేదీ-సమయాన్ని సూచించే తేదీ-సమయం వస్తువు చాలా తరచుగా సంవత్సరం-నెల-రోజు-గంట-నిమిషం-సెకనుగా వీక్షించబడుతుంది. డెవలపర్‌లు ఇతర తేదీ మరియు సమయ ఫీల్డ్‌లను కూడా ఉపయోగించవచ్చు (రోజు-ఆఫ్-ఇయర్, డే-ఆఫ్-వీక్ మరియు వీక్-ఆఫ్-ఇయర్). ఈ తరగతి మార్పులేనిది. సమయం నానోసెకండ్ ఖచ్చితత్వంతో సూచించబడుతుంది. ఉదాహరణకు, మీరు "17 నవంబర్ 2020 13:30.30.123456789" విలువను LocalDateTimeలో నిల్వ చేయవచ్చు. ఈ తరగతి టైమ్-జోన్‌ని సూచించడం గురించి కాదు. ఇది ఒక ప్రామాణిక తేదీ ప్రాతినిధ్యం మరియు స్థానిక సమయం. LocalDateTime పార్స్() పద్ధతి రెండు రూపాంతరాలలో ప్రాతినిధ్యం వహిస్తుంది:

• స్టాటిక్ లోకల్‌డేట్ టైమ్ పార్స్(చార్‌సీక్వెన్స్ టెక్స్ట్) 2007-12-03T10:15:30 వంటి టెక్స్ట్ స్ట్రింగ్ నుండి LocalDateTime యొక్క ఉదాహరణను అందిస్తుంది.
• స్టాటిక్ లోకల్‌డేట్ టైమ్ పార్స్ (చార్‌సీక్వెన్స్ టెక్స్ట్, డేట్‌టైమ్ ఫార్మాటర్ ఫార్మాటర్) నిర్దిష్ట ఫార్మాటర్‌ని ఉపయోగించి టెక్స్ట్ స్ట్రింగ్ నుండి లోకల్‌డేట్ టైమ్ యొక్క ఉదాహరణను అందిస్తుంది.

ఇక్కడ LocalDateTime పార్స్() పద్ధతికి ఉదాహరణ :

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 పార్స్() పద్ధతి

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. లోకల్ టైమ్ పార్స్() పద్ధతి

క్లాస్ లోకల్ టైమ్ ఒక సమయాన్ని సూచిస్తుంది, తరచుగా గంట-నిమిషం-సెకనుగా వీక్షించబడుతుంది. ఈ తరగతి కూడా ZonedDateTime వంటి మార్పులేనిది. సమయం నానోసెకండ్ ఖచ్చితత్వానికి సూచించబడుతుంది. ఉదాహరణకు, "13:45.30.123456789" విలువను లోకల్‌టైమ్‌లో నిల్వ చేయవచ్చు. ఒకటి మరియు రెండు పారామితులతో రెండు లోకల్ టైమ్ పార్స్() పద్ధతులు ఉన్నాయి . రెండింటినీ పరిశీలిద్దాం:

public static LocalTime parse(CharSequence text)

మీరు అన్వయించాలనుకునే స్ట్రింగ్‌ను ఒకే ఒక పారామీటర్‌తో మీరు LocalTime పార్స్()ని ఉపయోగించవచ్చు . ఈ సందర్భంలో, DateTimeFormatter.ISO_LOCAL_TIME ఫార్మాటర్ డిఫాల్ట్‌గా ఉపయోగించబడుతుంది.

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

ఇది నిర్దిష్ట ఆకృతిని ఉపయోగించి వచన విలువ నుండి లోకల్ టైమ్ యొక్క ఉదాహరణను పొందుతుంది. రెండు పద్ధతులు స్థానిక సమయ విలువను hh/mm/ss ఆకృతిలో అందిస్తాయి. 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 పార్స్() ఉపయోగించబడుతుంది. పద్ధతి యొక్క సాధారణ వాక్యనిర్మాణం ఇక్కడ ఉంది:

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

మూలం అనేది అన్వయించడానికి స్ట్రింగ్ మరియు స్థానం అనేది పార్సింగ్ యొక్క ప్రారంభ సూచిక. ఇక్కడ MessageFormat పార్స్() పద్ధతి పని చేసే ఉదాహరణ :

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కి ప్రారంభించబడింది. లెవెల్ పార్స్() పద్ధతి టెక్స్ట్ విలువ నుండి అవసరమైన సమాచారాన్ని అన్వయిస్తుంది మరియు స్థాయి వస్తువును అందిస్తుంది. లెవెల్ పార్స్() పద్ధతి యొక్క సింటాక్స్ ఇక్కడ ఉంది :

public static Level parse(String name)

డెవలపర్ అన్వయించాలనుకునే స్ట్రింగ్ పేరు పద్ధతి యొక్క పరామితి. ఇది స్థాయి పేరు, దాని ప్రారంభ పేరు లేదా ఇతర పూర్ణాంకం కావచ్చు. ప్రతిగా, ప్రోగ్రామర్ ప్రారంభ స్ట్రింగ్‌కు అనుగుణంగా స్థాయి పేరు విలువను పొందుతాడు. ఆర్గ్యుమెంట్‌లో అన్వయించడం సాధ్యం కాని చిహ్నాలు ఉన్నట్లయితే, సిస్టమ్ చట్టవిరుద్ధమైన వాదన మినహాయింపును విసిరివేస్తుంది. స్ట్రింగ్ విలువలను కలిగి ఉండకపోతే, డెవలపర్ 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ని ఉపయోగిస్తుంది. తక్షణ అన్వయం() పద్ధతి యొక్క సింటాక్స్ ఇక్కడ ఉంది :

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. నంబర్ ఫార్మాట్ పార్స్() పద్ధతి

java.text.NumberFormat తరగతి సంఖ్యలను ఫార్మాట్ చేయడానికి ఉపయోగించబడుతుంది. NumberFormat parse() అనేది ఈ తరగతి యొక్క డిఫాల్ట్ పద్ధతి. నంబర్‌ఫార్మాట్ క్లాస్ యొక్క పార్స్ () పద్ధతి ఒక స్ట్రింగ్‌ను సంఖ్యగా మారుస్తుంది. డెవలపర్‌లు స్ట్రింగ్‌ను దాని కాంపోనెంట్ నంబర్‌లకు విచ్ఛిన్నం చేయడానికి దీనిని ఉపయోగిస్తారు. పార్సింగ్ స్ట్రింగ్ ప్రారంభం నుండి ప్రారంభమవుతుంది. కింది ఉదాహరణలో చూపిన విధంగా, పార్స్ () పద్ధతికి కాల్ చేయడానికి ముందు మీరు setParseIntegerOnly (true) కి కాల్ చేస్తే, సంఖ్య యొక్క పూర్ణాంకం భాగం మాత్రమే మార్చబడుతుంది. NumberFormat పార్స్() యొక్క వాక్యనిర్మాణం ఇక్కడ ఉంది :

public Number parse(String str)

పారామీటర్‌గా, ఫంక్షన్ స్ట్రింగ్‌లను అంగీకరిస్తుంది. పార్సింగ్ యొక్క రిటర్న్ విలువ సంఖ్యా విలువ. స్ట్రింగ్ ప్రారంభాన్ని అన్వయించలేకపోతే, మీరు ParseException హెచ్చరికను పొందుతారు. NumberFormat పార్స్() పద్ధతి యొక్క అనువర్తనాన్ని చూడటానికి , దిగువ ఉదాహరణను పరిశీలించండి:

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"));
       }
   }

అవుట్‌పుట్:

ముగింపు

స్ట్రింగ్‌లను వివిధ డేటా రకాలుగా మార్చడానికి డెవలపర్‌లు ఉపయోగించే అనేక పార్సింగ్ పద్ధతులు ఉన్నాయి. వాటిని గుర్తుంచుకోవడం చాలా శ్రమతో కూడుకున్నదిగా అనిపించినప్పటికీ, ఇటువంటి వివిధ ఆదేశాలు డెవలపర్‌లకు చాలా సౌలభ్యాన్ని మరియు ఖచ్చితత్వాన్ని ఇస్తాయి. మీరు వాక్యనిర్మాణాన్ని గుర్తుంచుకున్నారని మరియు ప్రతి పద్ధతికి ఏ పారామితులు అవసరం అని మరచిపోలేరని నిర్ధారించుకోవడానికి డేటా పార్సింగ్‌ని ఉపయోగించడం సాధన చేయాలని నిర్ధారించుకోండి.