उदाहरणांसह Java मध्ये 11 parse() पद्धती

त्याच्या सर्वात सामान्य अर्थाने पार्सिंग म्हणजे डेटाच्या काही भागातून आवश्यक माहिती काढणे, बहुतेक वेळा मजकूर डेटा. Java मध्ये पार्स म्हणजे काय? अनेक जावा वर्ग आहेत ज्यात parse() पद्धत आहे. सहसा parse() पद्धत इनपुट म्हणून काही स्ट्रिंग प्राप्त करते, त्यातून आवश्यक माहिती "अर्क" करते आणि कॉलिंग क्लासच्या ऑब्जेक्टमध्ये रूपांतरित करते. उदाहरणार्थ, त्याला एक स्ट्रिंग मिळाली आणि या स्ट्रिंगमध्ये "लपत" असलेली तारीख परत केली. या पोस्टमध्ये, आम्ही parse() च्या 10 उपयुक्त फरकांवर एक नजर टाकणार आहोत .

0. पार्सइंट()

चला सर्वात लोकप्रिय parse() पद्धतींपैकी एकापासून सुरुवात करूया , ती parse() नाही तर 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 हा एक इंटरफेस आहे, जो स्ट्रिंग्सद्वारे लागू केला जातो. म्हणून तुम्ही parse() पद्धतीत मजकूर घटक म्हणून Strings वापरू शकता . पीरियड क्लासचा ऑब्जेक्ट परत करण्यासाठी स्ट्रिंग योग्य फॉरमॅटमध्ये असावी. हे स्वरूप PnYnMnD आहे . जिथे Y म्हणजे “वर्ष”, M — “महिना” साठी, D — “दिवस” साठी. N ही प्रत्येक कालावधीच्या मूल्याशी संबंधित संख्या आहे.

• पद्धतीमध्ये एक पॅरामीटर आहे - मजकूर मूल्य.
• पार्स() एक पीरियड व्हॅल्यू देते जेथे स्ट्रिंगचे मूल्य पॅरामीटर बनते.
• अपवाद म्हणून, जर स्ट्रिंग व्हॅल्यू पीरियडच्या संरचनेशी जुळत नसेल तर, period 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 parse() पद्धत तारीख टोकनमध्ये स्ट्रिंग मोडते आणि संबंधित फॉरमॅटमध्ये डेटा मूल्य परत करते. पद्धत विकासकाने परिभाषित केलेल्या निर्देशांकावर स्ट्रिंग पार्स करणे सुरू करते. हे SimpleDateFormat parse() चे वाक्यरचना आहे :

public Date parse(String the_text, ParsePosition position)

पद्धतीमध्ये दोन पॅरामीटर्स आहेत:

• स्थान: सुरुवातीच्या निर्देशांकातील डेटा जो नेहमी ParsePosition ऑब्जेक्ट प्रकार असतो.
• 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 व्या स्थानापासून सुरू होणारी तारीख पॅटर्न नाही. तसे, जर तुम्ही date5 चे स्थानाशिवाय जसे की Date date5 = simpleDateFormat2.parse(myString) पार्स करण्याचा प्रयत्न केला तर तुम्हाला अपवाद मिळेल:

3. LocalDate parse() पद्धत

LocalDate हा एक वर्ग आहे जो Java 8 मध्ये वर्ष-महिना-दिवस (वर्ष-दिवस, आठवड्याचा-दिवस आणि वर्ष-ऑफ-वर्ष, देखील प्रवेश केला जाऊ शकतो) सारख्या तारखेचे प्रतिनिधित्व करण्यासाठी दिसला. LocalDate वेळ किंवा टाइम-झोन दर्शवत नाही. LocalDate parse() पद्धतीचे दोन प्रकार आहेत. ते दोन्ही स्ट्रिंगला नवीन Java 8 date API — java.time.LocalDate मध्ये रूपांतरित करण्यास मदत करतात .

पार्स (CharSequence मजकूर, DateTime Formatter, Formatter)

ही पद्धत LocalDate चे उदाहरण मिळवण्यासाठी विशिष्ट स्वरूपाचा वापर करून स्ट्रिंग पार्स करते. या पद्धतीचे वाक्यरचना येथे आहे:

public static LocalTime parse(CharSequence text,
                              DateTimeFormatter formatter)

पद्धतीसाठी दोन पॅरामीटर्स आहेत — जो मजकूर पार्स केला जाईल आणि डेव्हलपर लागू होणारा फॉरमॅटर. रिटर्न व्हॅल्यू म्‍हणून, पद्धत लोकलटाइम ऑब्‍जेक्‍ट रिटर्न करते जिला स्‍थानिक दिवस-वेळ म्‍हणून ओळखले जाईल. जर मजकूर मूल्य पार्सिंगद्वारे जाऊ शकले नाही, तर सिस्टम डेटाइमपार्सेएक्सेप्शन टाकते. दोन पॅरामीटर्ससह 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 parse() पद्धत दोन प्रकारांमध्ये दर्शविली जाते:

• स्टॅटिक LocalDateTime पार्स(CharSequence text) 2007-12-03T10:15:30 सारख्या मजकूर स्ट्रिंगमधून LocalDateTime चे उदाहरण देते.
• स्टॅटिक LocalDateTime पार्स (CharSequence मजकूर, 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() पद्धत

वर्ग ZonedDateTime टाइम-झोनसह तारीख-वेळ दर्शवते. हा वर्ग अपरिवर्तनीय आहे. हे अस्पष्ट स्थानिक तारीख-वेळा हाताळण्यासाठी वापरल्या जाणार्‍या झोन ऑफसेटसह नॅनोसेकंदांच्या अचूकतेसाठी तारीख आणि वेळ फील्ड आणि टाइम झोन संचयित करते. त्यामुळे तुम्हाला "14 ऑक्टोबर 2020 रोजी 17:50.30.123456789 +02:00 युरोप/पॅरिस टाइम-झोनमध्ये" असे मूल्य ठेवायचे असल्यास तुम्ही ZonedDateTime वापरू शकता. वर्गाचा वापर अनेकदा स्थानिक वेळ-आधारित डेटा हाताळण्यासाठी केला जातो. ZondeDateTime parse() हा एक पार्सर आहे जो ISO-8061 सिस्टीममधील स्ट्रिंगला टोकनमध्ये मोडतो. विश्लेषण केल्यानंतर तुम्हाला मिळणाऱ्या मूल्याचे येथे उदाहरण आहे: जेव्हा जेव्हा उच्च-परिशुद्धता डेटा आवश्यक असतो तेव्हा त्याचा वापर केला जातो (अखेर, आपल्याला मिळणारा डेटा नॅनोसेकंदपर्यंत अचूक असतो). वर्गाचा वापर अनेकदा स्थानिक वेळ-आधारित डेटा हाताळण्यासाठी केला जातो. ZonedDateTime parse() मेथड डेव्हलपर स्ट्रिंग व्हॅल्यूज ZonedDateTime क्लासमध्ये रूपांतरित करण्यासाठी वापरतात त्या सामान्य वाक्यरचनाकडे एक नजर टाकूया .

public static ZonedDateTime parse(CharSequence text)

पद्धत वापरते फक्त पॅरामीटर एक स्ट्रिंग मजकूर आहे. रिटर्न व्हॅल्यू म्‍हणून, तुम्‍हाला ZonedDateTime फॉरमॅटमध्‍ये एक किंवा अनेक ऑब्जेक्ट्स मिळतील. पार्सिंग करताना त्रुटी आढळल्यास किंवा ते अशक्य असल्यास, सुरूवातीस, पद्धत DateTimeParseException परत करते. तसेच दोन व्हेरिएबल्ससह parse() पद्धत आहे .

public static ZonedDateTime parse(CharSequence text, DateFormatter formatter)

ही पद्धत विशिष्ट फॉरमॅटर वापरून मजकूर मूल्यावरून ZonedDateTime चे उदाहरण मिळवते. एक पॅरामीटर असलेली पद्धत, DateTimeFormatter.ISO_LOCAL_TIME हे फॉरमॅटर बाय डीफॉल्ट वापरले जाते. ZonedDateTime parse() साठी वापर केस पाहू या:

// 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() पद्धत

वर्ग LocalTime वेळ दर्शवतो, अनेकदा तास-मिनिट-सेकंद म्हणून पाहिले जाते. हा वर्ग देखील अपरिवर्तनीय आहे जसे की ZonedDateTime. वेळ नॅनोसेकंद अचूकतेमध्ये दर्शविला जातो. उदाहरणार्थ, "13:45.30.123456789" मूल्य LocalTime मध्ये संग्रहित केले जाऊ शकते. एक आणि दोन पॅरामीटर्ससह दोन LocalTime parse() पद्धती आहेत . चला दोन्हीकडे एक नजर टाकूया:

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 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 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 मिळते. येथे कोडचा एक भाग आहे जो Level parse() ची अंमलबजावणी दर्शवितो .

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. झटपट पार्स() पद्धत

झटपट वर्ग टाइम-लाइनवर एकच तात्काळ बिंदू मॉडेल करते. तुम्ही तुमच्या अॅपमध्ये इव्हेंट टाइमस्टॅम्प रेकॉर्ड करण्यासाठी ते वापरू शकता. Instant parse() मजकूर मूल्यातून झटपट मूल्य मिळवते. स्ट्रिंग नंतर UTC टाइम झोन मूल्य म्हणून संग्रहित केली जाईल. सिस्टम DateTimeFormatter.ISO_INSTANT वापरते जसे की 2020-10-14T11:28:15.00Z. येथे झटपट पार्स() पद्धतीचा एक वाक्यरचना आहे:

public static Instant parse(CharSequence text)

स्ट्रिंग पार्स करण्यासाठी आणि झटपट मिळवण्यासाठी, डेव्हलपरला स्ट्रिंगमध्ये काही मजकूर असल्याची खात्री करणे आवश्यक आहे. जर ते शून्य असेल, तर तुम्हाला DateTimeException मिळेल. Java मध्ये इन्स्टंट पार्स वापरण्याचे येथे एक उदाहरण आहे :

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() पद्धत

java.text.NumberFormat वर्ग क्रमांक फॉरमॅट करण्यासाठी वापरला जातो. NumberFormat parse() ही या वर्गाची डिफॉल्ट पद्धत आहे. NumberFormat वर्गाची पार्स () पद्धत स्ट्रिंगला संख्येत रूपांतरित करते. डेव्हलपर त्याचा वापर स्ट्रिंगला त्याच्या घटक क्रमांकांमध्ये मोडण्यासाठी करतात. पार्सिंग स्ट्रिंगच्या सुरुवातीपासून सुरू होते. जर तुम्ही खालील उदाहरणात दाखवल्याप्रमाणे parse() मेथडला कॉल करण्यापूर्वी setParseIntegerOnly (true) कॉल केला , तर नंबरचा फक्त पूर्णांक भाग रूपांतरित केला जातो. येथे NumberFormat parse() चे वाक्यरचना आहे :

public Number parse(String str)

पॅरामीटर म्हणून, फंक्शन स्ट्रिंग्स स्वीकारते. पार्सिंगचे रिटर्न व्हॅल्यू हे संख्यात्मक मूल्य आहे. जर एखाद्या स्ट्रिंगची सुरुवात पार्स केली जाऊ शकत नसेल, तर तुम्हाला ParseException चेतावणी मिळेल. 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"));
       }
   }

आउटपुट आहे:

निष्कर्ष

स्ट्रिंग्सचे विविध डेटा प्रकारांमध्ये रूपांतर करण्यासाठी विकसक अनेक पार्सिंग पद्धती वापरू शकतात. जरी ते लक्षात ठेवणे कंटाळवाणे वाटत असले तरी, अशा प्रकारच्या विविध आदेश विकासकांना भरपूर लवचिकता आणि अचूकता देतात. तुम्हाला वाक्यरचना आठवत आहे आणि प्रत्येक पद्धतीसाठी कोणते मापदंड आवश्यक आहेत हे विसरू नका याची खात्री करण्यासाठी डेटा पार्सिंग वापरण्याचा सराव करा.