11 parse() methoden in Java met voorbeelden

Parseren in de meest algemene zin is het extraheren van de benodigde informatie uit een bepaald stuk gegevens, meestal tekstuele gegevens. Wat is parseren in Java? Er zijn veel Java-klassen die de methode parse() gebruiken . Gewoonlijk ontvangt de methode parse() een tekenreeks als invoer, "extraheert" de benodigde informatie daaruit en converteert deze naar een object van de aanroepende klasse. Het ontving bijvoorbeeld een tekenreeks en retourneerde de datum die "verstopt" was in deze tekenreeks. In dit bericht gaan we de 10 handige variaties van parse() bekijken .

0. parseInt()

Laten we beginnen met een van de meest populaire parse()- methoden, dat is niet precies parse() , maar parseInt() . De methode Java parseInt () wordt gebruikt om het primitieve gegevenstype uit een specifieke tekenreeks te halen. Met andere woorden, het converteert een string naar een getal. parseInt () kan een of twee argumenten hebben. Hier is de syntaxis van parseInt() :

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

Waarbij s de tekenreeks is die een decimale waarde met teken vertegenwoordigt en radix de basis van een numeriek systeem. Houd er rekening mee dat er geen standaard basiswaarde is — u moet er een invoeren tussen 2 en 36. Hier is een voorbeeld. Hoe te ontleden met 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));
         
       }
   }

De uitvoer is:

1. Periode parse() methode

Periode is een Java-klasse om een ​​hoeveelheid tijd te modelleren in termen van jaren, maanden en dagen, zoals "3 jaar, 5 maanden en 2 dagen". Het heeft een methode parse() om een ​​punt uit een tekst te halen. Hier is de syntaxis van period parse()

public static Period parse(CharSequence text)

CharSequence is een interface, geïmplementeerd door Strings. U kunt dus Strings gebruiken als een tekstelement in de parse() -methode. Zorg ervoor dat de tekenreeks de juiste indeling heeft om een ​​object van de Periode-klasse te retourneren. Dit formaat is PnYnMnD . Waar Y staat voor "jaar", M - voor "maand", D - voor "dag". N is een getal dat overeenkomt met elke periodewaarde.

• De methode heeft één parameter: een tekstwaarde.
• Parse() retourneert een Periode-waarde waarbij de waarde van een tekenreeks een parameter wordt.
• Als uitzondering kan period parse() de DateTimeParseException retourneren als de tekenreekswaarde niet voldoet aan de structuur van een periode.

Hier is een voorbeeld van het gebruik van Period parse() in de context van de echte wereld:

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

De uitvoer is:

2.SimpleDateFormat Parse()-methode

SimpleDateFormat is een klasse die wordt gebruikt voor het opmaken en ontleden van datums op een locale-gevoelige manier. De methode SimpleDateFormat parse() splitst een tekenreeks op in datumtokens en retourneert een Data-waarde in de overeenkomstige indeling. De methode begint met het ontleden van de string op een index, gedefinieerd door een ontwikkelaar. Dit is de syntax van de SimpleDateFormat parse() :

public Date parse(String the_text, ParsePosition position)

De methode heeft twee parameters:

• Positie: de gegevens bij de beginindex die altijd het objecttype ParsePosition is.
• the_text: definieert de string die de methode zal parseren en is een waarde van het type String.

U kunt deze methode gebruiken zonder positiedeclaratie. In dit geval beginnen de gegevens vanaf nul index. SimpleDateFormat parse() retourneert een datum of een null-waarde (voor het geval de tekenreeks niet is verwerkt vanwege een fout). Hier is een voorbeeld van de implementatie van 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);
   }
}

De uitvoer is: De laatste is null omdat er geen datumpatroon is vanaf de 5e positie. Trouwens, als je de date5 probeert te ontleden zonder positie zoals Date date5 = simpleDateFormat2.parse(myString) , krijg je een uitzondering:

3. LocalDate parse()-methode

LocalDate is een klasse die verscheen in Java 8 om een ​​datum weer te geven zoals jaar-maand-dag (dag-van-jaar, dag-van-week en week-van-jaar zijn ook toegankelijk). LocalDate vertegenwoordigt geen tijd of tijdzone. De methode LocalDate parse() heeft twee varianten. Beiden helpen bij het converteren van een string naar een nieuwe Java 8-datum-API - java.time.LocalDate .

ontleden (CharSequence-tekst, DateTimeFormatter, formatter)

Deze methode parseert een tekenreeks met behulp van een specifieke formatter om een ​​exemplaar van LocalDate te verkrijgen. Dit is de syntaxis van de methode:

public static LocalTime parse(CharSequence text,
                              DateTimeFormatter formatter)

Er zijn twee parameters voor de methode: de tekst die wordt geparseerd en de formatter die een ontwikkelaar zal toepassen. Als retourwaarde retourneert de methode een LocalTime-object dat wordt herkend als de lokale dagtijd. Als de tekstwaarde niet kan worden geparseerd, genereert het systeem de DayTimeParseException. Laten we een codevoorbeeld hebben van het gebruik van LocalDate parse() met twee parameters:

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

De uitvoer is: De methode LocalDate parse() met één parameter heeft de volgende syntaxis:

public static LocalTime parse(CharSequence text)

Voor deze methode hoeft u geen formatter op te geven. Nadat een ontwikkelaar de tekenreekswaarden tussen haakjes heeft ingevoerd, gebruikt het systeem automatisch de DateTimeFormatter.ISO_LOCAL_DATE. Deze methode heeft een enkele parameter: een CharSequence-tekst. U kunt hier de tekenreekswaarde gebruiken. Zorg ervoor dat het niet null is en de structuur van de formatter respecteert. Als er geen manier is om een ​​tekenreeks te ontleden, krijgt een ontwikkelaar de DateTimeExceptionAlert. Hier is een voorbeeld van de toepassing 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);
       }
   }

De uitvoer is:

4. LocalDateTime parse()-methode

LocalDateTime een datum-tijd-object dat een datum-tijd vertegenwoordigt die vrij vaak wordt gezien als jaar-maand-dag-uur-minuut-seconde. Ontwikkelaars kunnen ook andere datum- en tijdvelden gebruiken (dag van het jaar, dag van de week en week van het jaar). Deze klasse is onveranderlijk. Tijd wordt weergegeven tot op nanoseconde nauwkeurig. U kunt bijvoorbeeld de waarde "17 november 2020 om 13:30.30.123456789" opslaan in een LocalDateTime. Deze les gaat niet over het weergeven van een tijdzone. Het is eerder een standaard datumweergave plus lokale tijd. LocalDateTime parse()- methode weergegeven in twee varianten:

• statische LocalDateTime-parse (CharSequence-tekst) retourneert een instantie van LocalDateTime uit een tekenreeks zoals 2007-12-03T10:15:30.
• statische LocalDateTime-parse (CharSequence-tekst, DateTimeFormatter-formatter) retourneert een exemplaar van LocalDateTime uit een tekenreeks met behulp van een specifieke formatter.

Hier is een voorbeeld van de methode 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);
       }
   }

De uitvoer is:

5. ZonedDateTime parse()-methode

Klasse ZonedDateTime vertegenwoordigt een datum-tijd met een tijdzone. Deze klasse is onveranderlijk. Het slaat datum- en tijdvelden op met een precisie van nanoseconden, en een tijdzone, met een zone-offset die wordt gebruikt om dubbelzinnige lokale datum-tijden te verwerken. Dus als u een waarde wilt behouden zoals "14 oktober 2020 om 17:50.30.123456789 +02:00 in de tijdzone Europa/Parijs", kunt u ZonedDateTime gebruiken. De klasse wordt vaak gebruikt om lokale tijdgebaseerde gegevens te manipuleren. ZondeDateTime parse() is een parser die de string opsplitst in tokens in het ISO-8061-systeem. Hier is een voorbeeld van een waarde die u krijgt na het parseren: Het wordt gebruikt wanneer zeer nauwkeurige gegevens nodig zijn (de gegevens die u krijgt zijn immers nauwkeurig tot op nanoseconden). De klasse wordt vaak gebruikt om lokale tijdgebaseerde gegevens te manipuleren. Laten we eens kijken naar de algemene syntaxis van de ZonedDateTime-parse()- methode die ontwikkelaars gebruiken om tekenreekswaarden om te zetten in de klasse ZonedDateTime.

public static ZonedDateTime parse(CharSequence text)

De enige parameter die de methode gebruikt, is een tekenreekstekst. Als retourwaarde krijgt u een of een reeks objecten in de indeling ZonedDateTime. Als er een fout optreedt tijdens het parseren of als het om te beginnen onmogelijk is, retourneert de methode DateTimeParseException. Er is ook een methode parse() met twee variabelen.

public static ZonedDateTime parse(CharSequence text, DateFormatter formatter)

Deze methode verkrijgt een exemplaar van ZonedDateTime uit een tekstwaarde met behulp van een specifieke opmaak. De methode met één parameter, de formatter DateTimeFormatter.ISO_LOCAL_TIME wordt standaard gebruikt. Laten we eens kijken naar de use case voor 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);
   }
}

De uitvoer is:

6. LocalTime parse()-methode

Class LocalTime vertegenwoordigt een tijd, vaak gezien als uur-minuut-seconde. Deze klasse is ook onveranderlijk, zoals ZonedDateTime.Time wordt weergegeven tot op nanoseconde nauwkeurig. De waarde "13:45.30.123456789" kan bijvoorbeeld worden opgeslagen in een LocalTime. Er zijn twee LocalTime parse()- methoden, met één en twee parameters. Laten we beide eens bekijken:

public static LocalTime parse(CharSequence text)

U kunt LocalTime parse() gebruiken met slechts één parameter, de string die u wilt parseren. In dit geval wordt standaard de formatter DateTimeFormatter.ISO_LOCAL_TIME gebruikt.

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

Het verkrijgt een exemplaar van LocalTime uit een tekstwaarde met behulp van een specifieke formatter. Beide methoden retourneren de LocalTime-waarde in de notatie hh/mm/ss. Pas op voor DateTimeParceException-waarschuwingen. Ze betekenen dat het formaat van de tekenreekstekst niet overeenkomt met dat van LocalTime-objecten. Hier is een voorbeeld van het gebruik van LocalTime parse() in productie:

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

MessageFormat breidt de klasse Format uit. Format is een abstracte basisklasse voor het formatteren van locale-gevoelige gegevens (datums, berichten en getallen). MessageFormat haalt enkele objecten op en formatteert ze. Vervolgens voegt het de geformatteerde strings op de juiste plaatsen in het patroon in. De MessageFormat parse() wordt gebruikt om een ​​tekenreekswaarde te krijgen als het indexbegin wordt gegeven. Dit is de algemene syntaxis van de methode:

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

Waar source een string is die moet worden geparseerd en position de startindex van het parseren is. Hier is een voorbeeld van de werking van de methode 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. Level parse()-methode

Wanneer een programmeur een Logger gebruikt om een ​​bericht te loggen, wordt het gelogd met een bepaald logniveau. Er zijn zeven ingebouwde logboekniveaus:

• STRENG
• WAARSCHUWING
• INFO
• CONFIG
• PRIMA
• FIJNER
• BESTE

Er zijn ook extra niveaus UIT die kunnen worden gebruikt om het loggen uit te schakelen en ALLE die kunnen worden gebruikt om het loggen van alle berichten mogelijk te maken. Het logboekniveau wordt weergegeven door de klasse java.util.logging.Level . Niveauklasse bevat een constante voor elk van deze zeven niveaus. U gebruikt dus een van deze constanten, inclusief Alles en UIT, terwijl u een bericht naar een Logger logt. Ook zijn al deze niveaus geïnitialiseerd op enkele gehele getallen. FINE wordt bijvoorbeeld geïnitialiseerd op 500. De methode Level parse() ontleedt de benodigde informatie uit een tekstwaarde en retourneert een Level-object. Dit is de syntaxis van de methode level parse() :

public static Level parse(String name)

De parameter van een methode is de naam van een string die een ontwikkelaar wil ontleden. Het kan een naam van het niveau zijn, de initialisatienaam of een ander geheel getal. In ruil daarvoor krijgt een programmeur een Level-naamwaarde, die overeenkomt met die van de initiële string. Als het argument symbolen bevat die niet kunnen worden geparseerd, genereert het systeem de IllegalArgumentException. Als een tekenreeks geen waarden bevat, krijgt een ontwikkelaar een NullPointerException. Hier is een stuk code dat de implementatie van Level parse() laat zien .

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

De uitvoer is:

9. Instant parse()-methode

Instant class modelleert een enkel ogenblikkelijk punt op de tijdlijn. U kunt het gebruiken voor het opnemen van tijdstempels van gebeurtenissen in uw app. Instant parse() haalt een Instant-waarde uit een tekstwaarde. De tekenreeks wordt later opgeslagen als een UTC-tijdzonewaarde. Het systeem gebruikt DateTimeFormatter.ISO_INSTANT zoals 2020-10-14T11:28:15.00Z. Hier is een syntaxis van de methode Instant parse() :

public static Instant parse(CharSequence text)

Om een ​​string te ontleden en een instant te krijgen, moet een ontwikkelaar ervoor zorgen dat de string wat tekst bevat. Als het null is, krijg je een DateTimeException. Hier is een voorbeeld van het gebruik van Instant parse in 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);
       }
   }

De uitvoer is:

10. NumberFormat parse()-methode

De klasse java.text.NumberFormat wordt gebruikt om getallen op te maken. NumberFormat parse() is een standaardmethode van deze klasse. De methode parse() van de klasse NumberFormat converteert een tekenreeks naar een getal. Ontwikkelaars gebruiken het om een ​​string op te splitsen in de componentnummers. Het parseren begint vanaf het begin van de string. Als u setParseIntegerOnly (true) aanroept voordat u de methode parse() aanroept , zoals in het volgende voorbeeld wordt getoond, wordt alleen het gehele deel van het getal geconverteerd. Hier is de syntaxis van NumberFormat parse() :

public Number parse(String str)

Als parameter accepteert de functie tekenreeksen. Een geretourneerde waarde van de parsering is een numerieke waarde. Als het begin van een tekenreeks niet kan worden geparseerd, krijgt u een ParseException-waarschuwing. Bekijk het onderstaande voorbeeld om de toepassing van de methode NumberFormat parse() te zien:

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

De uitvoer is:

Conclusie

Er zijn veel analysemethoden die ontwikkelaars kunnen gebruiken om tekenreeksen om te zetten in verschillende gegevenstypen. Hoewel het misschien vervelend lijkt om ze te onthouden, biedt zo'n verscheidenheid aan commando's ontwikkelaars veel flexibiliteit en precisie. Zorg ervoor dat u oefent met het parseren van gegevens om ervoor te zorgen dat u de syntaxis onthoudt en niet vergeet welke parameters essentieel zijn voor elke methode.