11 parse() na pamamaraan sa Java na may Mga Halimbawa

Ang pag-parse sa pinaka-pangkalahatang kahulugan nito ay ang pagkuha ng kinakailangang impormasyon mula sa ilang piraso ng data, kadalasang textual na data. Ano ang parse sa Java? Maraming mga klase ng Java na mayroong parse() na pamamaraan. Karaniwan ang parse() na pamamaraan ay tumatanggap ng ilang string bilang input, "i-extract" ang kinakailangang impormasyon mula dito at i-convert ito sa isang bagay ng klase ng pagtawag. Halimbawa, nakatanggap ito ng string at ibinalik ang petsang "nagtatago" sa string na ito. Sa post na ito, titingnan natin ang 10 kapaki-pakinabang na variation ng parse() .

0. parseInt()

Magsimula tayo sa isa sa pinakasikat na parse() na pamamaraan, iyon ay hindi eksakto parse() , ngunit parseInt() . Ang Java parseInt () na pamamaraan ay ginagamit upang makuha ang primitive na uri ng data mula sa isang partikular na string. Sa madaling salita, pinapalitan nito ang isang string sa isang numero. parseInt () ay maaaring magkaroon ng isa o dalawang argumento. Narito ang syntax ng parseInt() :

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

Kung saan ang s ay ang string na kumakatawan sa isang nilagdaang decimal value at radix ang base ng isang numerical system. Tandaan na walang default na base value — kailangan mong maglagay ng isa sa loob ng hanay ng 2 at 36. Narito ang isang halimbawa. Paano mag-parse gamit ang 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));
         
       }
   }

Ang output ay:

1. Paraan ng period parse()

Ang panahon ay isang klase ng Java upang magmodelo ng dami ng oras sa mga tuntunin ng mga taon, buwan at araw gaya ng "3 taon, 5 buwan at 2 araw". Mayroon itong parse() na paraan upang makakuha ng tuldok mula sa isang teksto. Narito ang syntax ng period parse()

public static Period parse(CharSequence text)

Ang CharSequence ay isang Interface, na ipinatupad ng Strings. Kaya maaari mong gamitin ang Strings bilang isang elemento ng teksto sa parse() na pamamaraan. Tiyak na ang string ay dapat nasa wastong format upang maibalik ang isang bagay ng klase ng Panahon. Ang format na ito ay PnYnMnD . Kung saan ang Y ay nangangahulugang "taon", M - para sa "buwan", D - para sa "araw". Ang N ay isang numero na tumutugma sa bawat halaga ng panahon.

• Ang pamamaraan ay may isang parameter - isang halaga ng teksto.
• Ang Parse() ay nagbabalik ng Period value kung saan ang value ng isang string ay nagiging parameter.
• Bilang pagbubukod, maaaring ibalik ng period parse() ang DateTimeParseException kung ang halaga ng string ay hindi nakakatugon sa istruktura ng isang tuldok.

Narito ang isang halimbawa ng paggamit ng Period parse() sa real-world na konteksto:

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

Ang output ay:

2.SimpleDateFormat Parse() na paraan

Ang SimpleDateFormat ay isang klase na ginagamit para sa pag-format at pag-parse ng mga petsa sa paraang sensitibo sa lokal. Pinaghihiwa-hiwalay ng SimpleDateFormat parse() ang isang string sa mga token ng petsa at nagbabalik ng value ng Data sa kaukulang format. Ang pamamaraan ay nagsisimula sa pag-parse ng string sa isang index, na tinukoy ng isang developer. Ito ang syntax ng SimpleDateFormat parse() :

public Date parse(String the_text, ParsePosition position)

Ang pamamaraan ay may dalawang mga parameter:

• Posisyon: ang data sa panimulang index na palaging uri ng bagay na ParsePosition.
• the_text: tumutukoy sa string na ipapa-parse ng pamamaraan at isang halaga ng uri ng String.

Maaari mong gamitin ang paraang ito nang walang deklarasyon ng posisyon. Sa kasong ito ang data ay nagsisimula mula sa zero index. Ang SimpleDateFormat parse() ay nagbabalik ng isang petsa o isang null na halaga (kung sakaling ang string ay hindi naproseso dahil sa isang error). Narito ang isang halimbawa ng SimpleDateFormat parse() na pagpapatupad:

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

Ang output ay: Ang huli ay null dahil walang pattern ng petsa simula sa ika-5 posisyon. Sa pamamagitan ng paraan kung susubukan mong i-parse ang date5 nang walang posisyon tulad ng Date date5 = simpleDateFormat2.parse(myString) , makakakuha ka ng exception:

3. LocalDate parse() na pamamaraan

Ang LocalDate ay isang klase na lumitaw sa Java 8 upang kumatawan sa isang petsa tulad ng taon-buwan-araw (araw-ng-taon, araw-ng-linggo at linggo-ng-taon, ay maaari ding ma-access). Ang LocalDate ay hindi kumakatawan sa isang oras o time-zone. Ang pamamaraang LocalDate parse() ay may dalawang variant. Pareho silang tumutulong sa pag-convert ng string sa isang bagong Java 8 date API — java.time.LocalDate .

parse(CharSequence text, DateTimeFormatter, formatter)

Ang pamamaraang ito ay nag-parse ng isang string gamit ang isang partikular na formatter upang makakuha ng isang halimbawa ng LocalDate. Narito ang syntax ng pamamaraan:

public static LocalTime parse(CharSequence text,
                              DateTimeFormatter formatter)

Mayroong dalawang parameter para sa pamamaraan — ang text na ipapa-parse at ang formatter na ilalapat ng developer. Bilang isang return value, ang pamamaraan ay nagbabalik ng isang LocalTime object na makikilala bilang lokal na araw-oras. Kung ang halaga ng teksto ay hindi dumaan sa pag-parse, itatapon ng system ang DayTimeParseException. Magkaroon tayo ng halimbawa ng code ng paggamit ng LocalDate parse() na may dalawang parameter:

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

Ang output ay: LocalDate parse() method na may isang parameter ay may susunod na syntax:

public static LocalTime parse(CharSequence text)

Ang pamamaraang ito ay hindi nangangailangan ng pagtukoy ng isang formatter. Pagkatapos ipasok ng developer ang mga string value sa mga bracket, awtomatikong gagamitin ng system ang DateTimeFormatter.ISO_LOCAL_DATE. Ang pamamaraang ito ay may iisang parameter — isang CharSequence text. Maaari mong gamitin dito ang halaga ng string. Tiyaking hindi ito null at iginagalang ang istraktura ng formatter. Kung walang paraan para mag-parse ng string, makukuha ng developer ang DateTimeExceptionAlert. Narito ang isang halimbawa ng LocalDate parse() application:

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

Ang output ay:

4. LocalDateTime parse() na pamamaraan

LocalDateTime isang date-time object na kumakatawan sa isang petsa-oras na madalas na tinitingnan bilang taon-buwan-araw-oras-minuto-segundo. Maaari ding gumamit ang mga developer ng iba pang mga field ng petsa at oras (araw-ng-taon, araw-ng-linggo at linggo-ng-taon). Ang klase na ito ay hindi nababago. Ang oras ay kinakatawan sa nanosecond precision. Halimbawa, maaari mong iimbak ang value na "Nobyembre 17, 2020 sa 13:30.30.123456789" sa isang LocalDateTime. Ang klase na ito ay hindi tungkol sa kumakatawan sa isang time-zone. Ito ay isang karaniwang representasyon ng petsa kasama ang lokal na oras. LocalDateTime parse() method na kinakatawan sa dalawang variant:

• static LocalDateTime parse(CharSequence text) ay nagbabalik ng isang instance ng LocalDateTime mula sa isang text string gaya ng 2007-12-03T10:15:30.
• static LocalDateTime parse(CharSequence text, DateTimeFormatter formatter) ay nagbabalik ng isang instance ng LocalDateTime mula sa isang text string gamit ang isang partikular na formatter.

Narito ang isang halimbawa ng LocalDateTime parse() na pamamaraan:

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

Ang output ay:

5. ZonedDateTime parse() method

Ang Class ZonedDateTime ay kumakatawan sa isang petsa-oras na may time-zone. Ang klase na ito ay hindi nababago. Nag-iimbak ito ng mga field ng petsa at oras sa isang katumpakan ng nanoseconds, at isang time zone, na may isang zone offset na ginagamit upang pangasiwaan ang hindi maliwanag na lokal na mga oras ng petsa. Kaya kung kailangan mong panatilihin ang isang halaga tulad ng "Oktubre 14, 2020 sa 17:50.30.123456789 +02:00 sa Europe/Paris time-zone" maaari mong gamitin ang ZonedDateTime. Ang klase ay kadalasang ginagamit upang manipulahin ang lokal na data na nakabatay sa oras. Ang ZondeDateTime parse() ay isang parser na hinahati ang string sa mga token sa ISO-8061 system. Narito ang isang halimbawa ng isang halaga na makukuha mo pagkatapos ng pag-parse: Ginagamit ito sa tuwing kailangan ang high-precision na data (pagkatapos ng lahat, ang data na nakukuha mo ay tumpak hanggang sa nanoseconds). Ang klase ay kadalasang ginagamit upang manipulahin ang lokal na data na nakabatay sa oras. Tingnan natin ang pangkalahatang syntax ng ZonedDateTime parse() method na ginagamit ng mga developer para i-convert ang mga string value sa ZonedDateTime class.

public static ZonedDateTime parse(CharSequence text)

Ang tanging parameter na ginagamit ng pamamaraan ay isang string na teksto. Bilang isang return value, makakakuha ka ng isa o isang serye ng mga object sa ZonedDateTime na format. Kung mayroong isang error sa panahon ng pag-parse o imposible, sa simula, ang pamamaraan ay nagbabalik ng DateTimeParseException. Mayroon ding paraan ng parse() na may dalawang variable.

public static ZonedDateTime parse(CharSequence text, DateFormatter formatter)

Ang pamamaraang ito ay nakakakuha ng isang instance ng ZonedDateTime mula sa isang text value gamit ang isang partikular na formatter. Ang pamamaraan na may isang parameter, ang formatter na DateTimeFormatter.ISO_LOCAL_TIME ay ginagamit bilang default. Tingnan natin ang kaso ng paggamit para sa 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);
   }
}

Ang output ay:

6. LocalTime parse() na pamamaraan

Kinakatawan ng Class LocalTime ang isang oras, kadalasang tinitingnan bilang oras-minuto-segundo. Ang klase na ito ay hindi rin nababago gaya ng ZonedDateTime.Time ay kinakatawan sa nanosecond precision. Halimbawa, ang value na "13:45.30.123456789" ay maaaring iimbak sa isang LocalTime. Mayroong dalawang LocalTime parse() na pamamaraan, na may isa at dalawang parameter. Tingnan natin ang pareho:

public static LocalTime parse(CharSequence text)

Maaari mong gamitin ang LocalTime parse() na may isang parameter lamang, ang string na gusto mong i-parse. Sa kasong ito, ang formatter na DateTimeFormatter.ISO_LOCAL_TIME ay ginagamit bilang default.

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

Ito ay nakakakuha ng isang halimbawa ng LocalTime mula sa isang halaga ng teksto gamit ang isang partikular na formatter. Ang parehong mga pamamaraan ay nagbabalik ng halaga ng LocalTime sa hh/mm/ss na format. Mag-ingat sa mga alerto sa DateTimeParceException. Ang ibig nilang sabihin ay ang format ng string text ay hindi tumutugma sa LocalTime objects. Narito ang isang halimbawa ng paggamit ng LocalTime parse() sa produksyon:

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 Parse() na pamamaraan

Pinapalawak ng MessageFormat ang klase ng Format. Ang format ay isang abstract base class para sa pag-format ng locale-sensitive na data (mga petsa, mensahe, at numero). Nakakakuha ang MessageFormat ng ilang bagay at pino-format ang mga ito. Pagkatapos ay ipinapasok nito ang mga na-format na string sa pattern sa naaangkop na mga lugar. Ang MessageFormat parse() ay ginagamit upang makakuha ng string value kung bibigyan ng simula ang index. Narito ang pangkalahatang syntax ng pamamaraan:

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

Kung saan ang pinagmulan ay isang string upang i-parse at ang posisyon ay ang panimulang index ng pag-parse. Narito ang isang halimbawa ng MessageFormat parse() method na gumagana:

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. Level parse() na paraan

Kapag ang isang programmer ay gumagamit ng isang Logger upang mag-log ng isang mensahe ito ay naka-log na may isang tiyak na antas ng log. Mayroong pitong built-in na antas ng log:

• MALALA
• BABALA
• IMPORMASYON
• CONFIG
• AYOS
• MAS MABUTI
• PINAKAMABUTI

Mayroon ding mga karagdagang antas ng OFF na maaaring magamit upang i-off ang pag-log at LAHAT na maaaring magamit upang paganahin ang pag-log ng lahat ng mga mensahe. Ang antas ng log ay kinakatawan ng klase na java.util.logging.Level . Ang antas ng klase ay naglalaman ng pare-pareho para sa bawat pitong antas na ito. Kaya gumamit ka ng isa sa mga constant na ito, kasama ang Lahat at OFF habang nagla-log ng mensahe sa isang Logger. Gayundin ang lahat ng mga antas na ito ay sinimulan sa ilang mga integer. Halimbawa, ang FINE ay sinisimulan sa 500. Ang Level parse() na paraan ay nag-parse ng impormasyong kailangan mula sa isang text value at nagbabalik ng Level object. Narito ang syntax ng level parse() na pamamaraan:

public static Level parse(String name)

Ang parameter ng isang paraan ay ang pangalan ng isang string na gustong i-parse ng developer. Ito ay maaaring pangalan ng antas, pangalan ng pagsisimula nito o iba pang integer. Bilang kapalit, ang isang programmer ay nakakakuha ng halaga ng pangalan ng Antas, na naaayon sa unang string. Kung sakaling ang argumento ay naglalaman ng mga simbolo na imposibleng ma-parse, itatapon ng system ang IllegalArgumentException. Kung walang mga value ang isang string, makakakuha ang isang developer ng NullPointerException. Narito ang isang piraso ng code na nagpapakita ng pagpapatupad ng 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());
   }
}

Ang output ay:

9. Instant parse() na pamamaraan

Ang instant class ay nagmomodelo ng isang instant na punto sa time-line. Magagamit mo ito para sa pag-record ng mga timestamp ng kaganapan sa iyong app. Ang Instant parse() ay nakakakuha ng Instant na value mula sa isang text value. Ang string ay maiimbak sa ibang pagkakataon bilang isang UTC Time Zone Value. Gumagamit ang system ng DateTimeFormatter.ISO_INSTANT gaya ng 2020-10-14T11:28:15.00Z. Narito ang isang syntax ng Instant parse() na pamamaraan:

public static Instant parse(CharSequence text)

Para mag-parse ng string at makakuha ng instant, kailangang tiyakin ng developer na naglalaman ng ilang text ang string. Kung sakaling ito ay null, makakakuha ka ng DateTimeException. Narito ang isang halimbawa ng paggamit ng Instant parse sa 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);
       }
   }

Ang output ay:

10. NumberFormat parse() method

Ang klase ng java.text.NumberFormat ay ginagamit upang i-format ang mga numero. NumberFormat parse() ay isang default na paraan ng klase na ito. Ang parse () na paraan ng klase ng NumberFormat ay nagko-convert ng string sa isang numero. Ginagamit ito ng mga developer para masira ang isang string hanggang sa mga component number nito. Ang pag-parse ay nagsisimula sa simula ng string. Kung tatawagan mo ang setParseIntegerOnly (true) bago tawagan ang parse () na paraan, tulad ng ipinapakita sa sumusunod na halimbawa, kung gayon ang integer na bahagi lamang ng numero ang nako-convert. Narito ang syntax ng NumberFormat parse() :

public Number parse(String str)

Bilang isang parameter, ang function ay tumatanggap ng mga string. Ang isang return value ng parsing ay isang numeric value. Kung hindi ma-parse ang simula ng string, makakakuha ka ng babala ng ParseException. Upang makita ang aplikasyon ng paraan ng NumberFormat parse() , tingnan ang halimbawa sa ibaba:

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

Ang output ay:

Konklusyon

Mayroong maraming mga paraan ng pag-parse na magagamit ng mga developer upang i-convert ang mga string sa iba't ibang uri ng data. Bagama't ang pag-alala sa mga ito ay maaaring mukhang nakakapagod, ang ganitong iba't ibang mga utos ay nagbibigay sa mga developer ng maraming flexibility at katumpakan. Tiyaking magsanay gamit ang pag-parse ng data upang matiyak na naaalala mo ang syntax at hindi malilimutan kung aling mga parameter ang mahalaga para sa bawat pamamaraan.