11 parse()-metoder i Java med eksempler

Parsing i sin mest generelle forstand er utvinning av nødvendig informasjon fra en eller annen del av data, oftest tekstdata. Hva er parse i Java? Det er mange Java-klasser som har parse()- metoden. Vanligvis mottar parse() -metoden en streng som input, "trekker ut" den nødvendige informasjonen fra den og konverterer den til et objekt av den kallende klassen. For eksempel mottok den en streng og returnerte datoen som "gjemt seg" i denne strengen. I dette innlegget skal vi ta en titt på de 10 nyttige variantene av parse() .

0. parseInt()

La oss starte fra en av de mest populære parse()- metodene, det er ikke akkurat parse() , men parseInt() . Java parseInt () -metoden brukes til å hente den primitive datatypen fra en bestemt streng. Med andre ord konverterer den en streng til et tall. parseInt () kan ha ett eller to argumenter. Her er syntaksen til parseInt() :

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

Der s er strengen som representerer en fortegnet desimalverdi og radix grunnflaten til et numerisk system. Husk at det ikke er noen standard grunnverdi – du må angi en innenfor området 2 og 36. Her er et eksempel. Hvordan analysere med 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));
         
       }
   }

Utgangen er:

1. Periode parse()-metoden

Periode er en Java-klasse for å modellere en mengde tid i form av år, måneder og dager, for eksempel "3 år, 5 måneder og 2 dager". Den har en parse() -metode for å få et punktum fra en tekst. Her er syntaksen til periodeparse()

public static Period parse(CharSequence text)

CharSequence er et grensesnitt, implementert av Strings. Så du kan bruke Strings som et tekstelement i parse() -metoden. Klart at strengen skal være i riktig format for å returnere et objekt av Periode-klassen. Dette formatet er PnYnMnD . Der Y står for "år", M - for "måned", D - for "dag". N er et tall som tilsvarer hver periodeverdi.

• Metoden har én parameter - en tekstverdi.
• Parse() returnerer en periodeverdi der verdien til en streng blir en parameter.
• Som et unntak kan period parse() returnere DateTimeParseException hvis strengverdien ikke oppfyller strukturen til en periode.

Her er et eksempel på bruk av Period parse() i den virkelige konteksten:

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

Utgangen er:

2.SimpleDateFormat Parse()-metoden

SimpleDateFormat er en klasse som brukes til å formatere og analysere datoer på en stedssensitiv måte. SimpleDateFormat parse() -metoden bryter en streng ned i datotokens og returnerer en dataverdi i det tilsvarende formatet. Metoden starter å analysere strengen ved en indeks, definert av en utvikler. Dette er syntaksen til SimpleDateFormat-parse() :

public Date parse(String the_text, ParsePosition position)

Metoden har to parametere:

• Posisjon: dataene ved startindeksen som alltid er ParsePosition-objekttypen.
• the_text: definerer strengen som metoden vil analysere og er en strengtypeverdi.

Du kan bruke denne metoden uten posisjonserklæring. I dette tilfellet starter dataene fra nullindeks. SimpleDateFormat parse() returnerer en dato eller en nullverdi (i tilfelle strengen ikke ble behandlet på grunn av en feil). Her er et eksempel på SimpleDateFormat parse() -implementering:

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

Utgangen er: Den siste er null fordi det ikke er noe datomønster som starter fra 5. posisjon. Forresten, hvis du prøver å analysere date5 uten posisjon, for eksempel Date date5 = simpleDateFormat2.parse(myString) , får du et unntak:

3. LocalDate parse()-metoden

LocalDate er en klasse som dukket opp i Java 8 for å representere en dato som år-måned-dag (dag-i-år, dag-i-uke og uke-i-år, kan også nås). LocalDate representerer ikke en tid eller tidssone. LocalDate parse() -metoden har to varianter. Begge hjelper til med å konvertere en streng til en ny Java 8 date API — java.time.LocalDate .

parse(CharSequence-tekst, DateTimeFormatter, formatter)

Denne metoden analyserer en streng ved å bruke en bestemt formatering for å få en forekomst av LocalDate. Her er syntaksen til metoden:

public static LocalTime parse(CharSequence text,
                              DateTimeFormatter formatter)

Det er to parametere for metoden - teksten som vil bli analysert og formateringen en utvikler vil bruke. Som en returverdi returnerer metoden et LocalTime-objekt som vil bli gjenkjent som lokal dagtid. Hvis tekstverdien ikke kunne gå gjennom parsing, kaster systemet DayTimeParseException. La oss ha et kodeeksempel på bruk av LocalDate parse() med to parametere:

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

Utgangen er: LocalDate parse()- metoden med én parameter har neste syntaks:

public static LocalTime parse(CharSequence text)

Denne metoden krever ikke å spesifisere en formatering. Etter at en utvikler har lagt inn strengverdiene i parentes, vil systemet automatisk bruke DateTimeFormatter.ISO_LOCAL_DATE. Denne metoden har en enkelt parameter - en CharSequence-tekst. Du kan bruke strengverdien her. Sørg for at den ikke er null og respekterer strukturen til formateringsprogrammet. Hvis det ikke er mulig å analysere en streng, får en utvikler DateTimeExceptionAlert. Her er et eksempel på LocalDate parse() -applikasjonen:

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

Utgangen er:

4. LocalDateTime parse()-metoden

LocalDateTime et dato-klokkeslett-objekt som representerer en dato-klokkeslett sett ganske ofte som år-måned-dag-time-minutt-sekund. Også utviklere kan bruke andre dato- og klokkeslettfelt (dag-i-år, dag-i-uke og uke-i-år). Denne klassen er uforanderlig. Tid er representert til nanosekunders presisjon. Du kan for eksempel lagre verdien "17. november 2020 kl. 13:30.30.123456789" i en LocalDateTime. Denne klassen handler ikke om å representere en tidssone. Det er snarere en standard datorepresentasjon pluss lokal tid. LocalDateTime parse() metode representert i to varianter:

• statisk LocalDateTime parse(CharSequence text) returnerer en forekomst av LocalDateTime fra en tekststreng som 2007-12-03T10:15:30.
• statisk LocalDateTime-parse(CharSequence-tekst, DateTimeFormatter-formater) returnerer en forekomst av LocalDateTime fra en tekststreng som bruker en bestemt formatter.

Her er et eksempel på LocalDateTime parse() -metoden:

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

Utgangen er:

5. ZonedDateTime parse() metode

Klasse ZonedDateTime representerer en dato-tid med en tidssone. Denne klassen er uforanderlig. Den lagrer dato- og tidsfelt med en presisjon på nanosekunder, og en tidssone, med en soneforskyvning som brukes til å håndtere tvetydige lokale dato-tider. Så hvis du trenger å beholde en verdi som "14. oktober 2020 kl. 17.50.30.123456789 +02:00 i tidssonen Europa/Paris", kan du bruke ZonedDateTime. Klassen brukes ofte til å manipulere lokale tidsbaserte data. ZondeDateTime parse() er en parser som bryter strengen ned i tokens i ISO-8061-systemet. Her er et eksempel på en verdi du får etter parsing: Den brukes når høypresisjonsdata er nødvendig (tross alt, dataene du får er nøyaktige opptil nanosekunder). Klassen brukes ofte til å manipulere lokale tidsbaserte data. La oss ta en titt på den generelle syntaksen til ZonedDateTime-parse() -metoden utviklere bruker for å konvertere strengverdier til ZonedDateTime-klassen.

public static ZonedDateTime parse(CharSequence text)

Den eneste parameteren metoden bruker er en strengtekst. Som en returverdi får du ett eller en rekke objekter i ZonedDateTime-formatet. Hvis det er en feil under parsing eller det er umulig, til å begynne med, returnerer metoden DateTimeParseException. Det er også en parse() -metode med to variabler.

public static ZonedDateTime parse(CharSequence text, DateFormatter formatter)

Denne metoden henter en forekomst av ZonedDateTime fra en tekstverdi ved å bruke en bestemt formatering. Metoden med én parameter, formateren DateTimeFormatter.ISO_LOCAL_TIME , brukes som standard. La oss ta en titt på brukstilfellet for 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);
   }
}

Utgangen er:

6. LocalTime parse()-metoden

Klasse LocalTime representerer en tid, ofte sett på som time-minutt-sekund. Denne klassen er også uforanderlig slik som ZonedDateTime.Time er representert med nanosekunders presisjon. For eksempel kan verdien "13:45.30.123456789" lagres i en LocalTime. Det er to LocalTime parse()- metoder, med én og to parametere. La oss ta en titt på begge:

public static LocalTime parse(CharSequence text)

Du kan bruke LocalTime parse() med bare én parameter, strengen du vil analysere. I dette tilfellet brukes formateren DateTimeFormatter.ISO_LOCAL_TIME som standard.

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

Den henter en forekomst av LocalTime fra en tekstverdi ved å bruke en bestemt formatering. Begge metodene returnerer LocalTime-verdi i tt/mm/ss-formatet. Se opp for DateTimeParceException-varsler. De betyr at formatet på strengteksten ikke samsvarer med det for LocalTime-objekter. Her er et eksempel på bruk av LocalTime parse() i produksjon:

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()-metoden

MessageFormat utvider Format-klassen. Format er en abstrakt basisklasse for formatering av lokalitetssensitive data (datoer, meldinger og tall). MessageFormat henter noen objekter og formaterer dem. Deretter setter den inn de formaterte strengene i mønsteret på de riktige stedene. MessageFormat parse() brukes til å få en strengverdi hvis indeksen begynner. Her er den generelle syntaksen for metoden:

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

Der kilden er en streng som skal analyseres og posisjon er startindeksen for parsing. Her er et eksempel på hvordan MessageFormat parse() -metoden fungerer:

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()-metoden

Når en programmerer bruker en Logger til å logge en melding, logges den med et visst loggnivå. Det er syv innebygde loggnivåer:

• ALVORLIG
• ADVARSEL
• INFO
• KONFIG
• FINT
• FINERE
• FINESTE

Det er også flere nivåer AV som kan brukes til å slå av logging og ALT som kan brukes til å aktivere logging av alle meldinger. Loggnivået er representert av klassen java.util.logging.Level . Nivåklassen inneholder en konstant for hvert av disse syv nivåene. Så du bruker en av disse konstantene, inkludert Alle og AV mens du logger en melding til en logger. Også alle disse nivåene initialisert til noen heltall. For eksempel initialiseres FINE til 500. Level parse() -metoden analyserer nødvendig informasjon fra en tekstverdi og returnerer et Level-objekt. Her er syntaksen til level parse() -metoden:

public static Level parse(String name)

Parameteren til en metode er navnet på en streng en utvikler vil analysere. Det kan være et navn på nivået, dets initialiseringsnavn eller et annet heltall. Til gjengjeld får en programmerer en nivånavnverdi, som tilsvarer den for den første strengen. I tilfelle argumentet inneholder symboler som er umulige å analysere, vil systemet kaste IllegalArgumentException. Hvis en streng ikke inneholder noen verdier, får en utvikler et NullPointerException. Her er et stykke kode som viser implementeringen av 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());
   }
}

Utgangen er:

9. Instant parse()-metoden

Instant class modellerer et enkelt øyeblikkelig punkt på tidslinjen. Du kan bruke den til å ta opp tidsstempler for hendelser i appen din. Instant parse() henter en Instant-verdi fra en tekstverdi. Strengen vil senere bli lagret som en UTC-tidssoneverdi. Systemet bruker DateTimeFormatter.ISO_INSTANT som 2020-10-14T11:28:15.00Z. Her er en syntaks for Instant parse() -metoden:

public static Instant parse(CharSequence text)

For å analysere en streng og få et øyeblikk, må en utvikler sørge for at strengen inneholder litt tekst. I tilfelle den er null, får du et DateTimeException. Her er et eksempel på bruk av Instant parse i 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);
       }
   }

Utgangen er:

10. NumberFormat parse()-metoden

Klassen java.text.NumberFormat brukes til å formatere tall. NumberFormat parse() er en standardmetode for denne klassen. Parse () -metoden til NumberFormat-klassen konverterer en streng til et tall. Utviklere bruker den til å bryte en streng ned til komponentnumrene. Parsingen starter fra begynnelsen av strengen. Hvis du kaller setParseIntegerOnly (true) før du kaller parse () -metoden, som vist i følgende eksempel, blir bare heltallsdelen av tallet konvertert. Her er syntaksen til NumberFormat parse() :

public Number parse(String str)

Som en parameter aksepterer funksjonen strenger. En returverdi for parsingen er en numerisk verdi. Hvis en strengbegynnelse ikke kan analyseres, får du en ParseException-advarsel. For å se bruken av NumberFormat parse()- metoden, ta en titt på eksemplet nedenfor:

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

Utgangen er:

Konklusjon

Det er mange analyseringsmetoder utviklere kan bruke for å konvertere strenger til forskjellige datatyper. Selv om det kan virke kjedelig å huske dem, gir en slik rekke kommandoer utviklere mye fleksibilitet og presisjon. Sørg for å øve deg på å bruke dataparsing for å sikre at du husker syntaksen og ikke glemmer hvilke parametere som er avgjørende for hver metode.