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)
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));
}
}
12 12,0 4 65
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)
- 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.
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 leeftijd is: 17 Jaar 9 Maanden 5 Dagen
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)
- 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.
// 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);
}
}
Wo Okt 14 00:00:00 EEST 2020 Wo Okt 14 00:00:00 EEST 2020 Wo Okt 14 00:00:00 EEST 2020 Zo Okt 04 00:00:00 EEST 2020 null
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:
Uitzondering in thread "main" java.text.ParseException: Unparseable date: "hier is de datum: 14/010/2020" op java.base/java.text.DateFormat.parse(DateFormat.java:396) op ParseDemo2.main (ParseDemo2.java:22)
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)
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));
}
}
geparseerde lokale datum: 2020-10-14 geformatteerde lokale datum: 14/10/2020
De methode LocalDate parse() met één parameter heeft de volgende syntaxis:
public static LocalTime parse(CharSequence text)
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);
}
}
Lokale datum: 2020-10-14
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.
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);
}
}
LocalDateTime is: 2020-11-17T19:34:50.630
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:
2020-04-05T13:30:25+01:00 Europa/Rome
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)
public static ZonedDateTime parse(CharSequence text, DateFormatter formatter)
// 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);
}
}
2020-10-15T10:15:30+01:00 2020-10-15T13:30:25+01:00
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)
Method with two parameters has the next syntax:
public static LocalTime parse(CharSequence text,
DateTimeFormatter formatter)
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)
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
public static Level parse(String name)
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());
}
}
Niveau = FIJN Niveau = FIJN UIT
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)
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);
}
}
2020-10-14T10:37:30Z
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)
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"));
}
}
3.141592 3
GO TO FULL VERSION