11 parse()-Methoden in Java mit Beispielen

Parsing im allgemeinsten Sinne ist das Extrahieren von benötigten Informationen aus Daten, meistens Textdaten. Was ist parse in Java? Es gibt viele Java-Klassen, die über die Methode parse() verfügen. Normalerweise erhält die parse()-Methode eine Zeichenkette als Eingabe, „extrahiert“ daraus die benötigten Informationen und wandelt sie in ein Objekt der aufrufenden Klasse um. Sie nimmt zum Beispiel eine Zeichenkette entgegen und gibt das Datum zurück, das in dieser Zeichenkette „verborgen“ ist. In diesem Beitrag werfen wir einen Blick auf die 10 nützlichen Varianten von parse().

0. parseInt()

Beginnen wir mit einer der beliebtesten parse()-Methoden, die nicht exakt parse(), sondern parseInt() heißt. Die Java-Methode parseInt() wird verwendet, um den primitiven Datentyp aus einer bestimmten Zeichenkette zu ermitteln. Mit anderen Worten: Sie wandelt eine Zeichenkette in eine Zahl um. parseInt() kann ein oder zwei Argumente haben. So sieht die Syntax von parseInt() aus:

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

Dabei ist s die Zeichenkette, die einen Dezimalwert mit Vorzeichen repräsentiert, und radix die Basis eines Zahlensystems. Beachte, dass es keinen standardmäßigen Basiswert gibt – du musst einen Wert zwischen 2 und 36 eingeben. Hier ist ein Beispiel. So führt man ein Parsing mit ParseInt() aus:

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

Die Ausgabe ist:

1. parse()-Methode von Period

Period ist eine Java-Klasse, mit der du eine Zeitspanne in Form von Jahren, Monaten und Tagen modellieren kannst, z. B. „3 Jahre, 5 Monate und 2 Tage“. Sie hat eine parse()-Methode, um einen Zeitraum aus einem Text zu gewinnen. Hier ist die Syntax von period parse():

public static Period parse(CharSequence text)

CharSequence ist ein Interface, das von Strings implementiert wird. Du kannst also Strings als Textelement in der parse()-Methode verwenden. Natürlich sollte der String das richtige Format haben, um ein Objekt der Klasse Period zurückzugeben. Dieses Format ist PnYnMnD. Dabei steht Y für „Jahr“, M für „Monat“, D für „Tag“. N ist eine Zahl, die dem jeweiligen Wert des Zeitraums entspricht.

• Die Methode hat einen Parameter – einen Textwert.
• parse() gibt einen Zeitraumwert zurück, bei dem der Wert eines Strings zu einem Parameter wird.
• Als Ausnahme kann period parse() die DateTimeParseException zurückgeben, wenn der String-Wert nicht der Struktur eines Zeitraums entspricht.

Hier ist ein Beispiel für die Verwendung von Period parse() in der Praxis:

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

Die Ausgabe ist:

2. parse()-Methode von SimpleDateFormat

SimpleDateFormat ist eine Klasse, die für die Formatierung und das Parsing von Datumsangaben in einer ortsabhängigen Weise verwendet wird. Die Methode SimpleDateFormat parse() zerlegt einen String in Datumsbestandteile und gibt einen Datumswwert im entsprechenden Format zurück. Die Methode beginnt mit dem Parsen der Zeichenkette an einem Index, der vom Entwickler festgelegt wird. Das ist die Syntax von SimpleDateFormat parse():

public Date parse(String the_text, ParsePosition position)

Die Methode hat zwei Parameter:

• Position: die Daten am Startindex, der immer der Objekttyp ParsePosition ist.
• the_text: definiert die Zeichenkette, die von der Methode geparst wird, und ist ein Wert vom Typ String.

Du kannst diese Methode auch ohne Positionsangabe verwenden. In diesem Fall beginnen die Daten mit dem Index Null. SimpleDateFormat parse() gibt ein Datum oder einen Nullwert zurück (für den Fall, dass die Zeichenkette aufgrund eines Fehlers nicht verarbeitet wurde). Hier ist ein Beispiel für die Implementierung von 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);
   }
}

Die Ausgabe ist: Die letzte Zeile ist null, weil es kein Datumsmuster ab der 5. Position gibt. Übrigens, wenn du versuchst, date5 ohne Position zu parsen, z. B. Date date5 = simpleDateFormat2.parse(myString), erhältst du eine Ausnahme:

3. parse()-Methode von LocalDate

LocalDate ist eine Klasse, die in Java 8 eingeführt wurde, um ein Datum wie Jahr-Monat-Tag zu repräsentieren (auf Tag-des-Jahres, Tag-der-Woche und Woche-des-Jahres kann auch zugegriffen werden). LocalDate repräsentiert keine Zeit oder Zeitzone. Die Methode LocalDate parse() hat zwei Varianten. Beide helfen dabei, einen String in eine neue Java 8 Datums-API zu konvertieren – java.time.LocalDate.

parse(CharSequence text, DateTimeFormatter, formatter)

Diese Methode parst eine Zeichenkette mit einem bestimmten Formatter, um eine Instanz von LocalDate zu erhalten. Die Syntax der Methode lautet:

public static LocalTime parse(CharSequence text,
                              DateTimeFormatter formatter)

Es gibt zwei Parameter für die Methode: den Text, der geparst werden soll, und den Formatter, den ein Entwickler anwendet. Als Rückgabewert gibt die Methode ein LocalTime-Objekt zurück, das als lokale Tageszeit erkannt wird. Wenn der Textwert nicht geparst werden konnte, löst das System die DayTimeParseException aus. Hier ist ein Codebeispiel für die Verwendung von LocalDate parse() mit zwei Parametern:

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

Die Ausgabe ist: Die Methode LocalDate parse() mit einem Parameter hat die folgende Syntax:

public static LocalTime parse(CharSequence text)

Bei dieser Methode muss kein Formatter angegeben werden. Nachdem ein Entwickler die String-Werte in die Klammern eingegeben hat, verwendet das System automatisch DateTimeFormatter.ISO_LOCAL_DATE. Diese Methode hat einen einzigen Parameter: CharSequence text. Du kannst hier den String-Wert verwenden. Achte darauf, dass er nicht null ist und die Struktur des Formatters einhält. Wenn es keine Möglichkeit gibt, eine Zeichenkette zu parsen, erhält der Entwickler die DateTimeExceptionAlert. Hier ist ein Beispiel für die Anwendung von 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);
       }
   }

Die Ausgabe ist:

4. parse()-Methode von LocalDateTime

LocalDateTime ein Datum-Uhrzeit-Objekt, das Datum und Uhrzeit häufig als Jahr-Monat-Tag-Stunde-Minute-Sekunde darstellt. Entwickler können auch andere Datums- und Uhrzeitfelder verwenden (Tag des Jahres, Tag der Woche und Woche des Jahres). Diese Klasse ist unveränderlich. Die Uhrzeit wird auf eine Nanosekunde genau dargestellt. Du kannst zum Beispiel den Wert „17. November 2020 um 13:30.30.123456789“ in LocalDateTime speichern. In dieser Klasse geht es nicht um die Darstellung einer Zeitzone. Es handelt sich vielmehr um eine Standard-Datumsdarstellung plus lokaler Uhrzeit. Die Methode LocalDateTime parse() gibt es in zwei Varianten:

• static LocalDateTime parse(CharSequence text) gibt eine Instanz von LocalDateTime aus einer Textzeichenfolge wie 2007-12-03T10:15:30 zurück.

• static LocalDateTime parse(CharSequence text, DateTimeFormatter formatter) gibt eine Instanz von LocalDateTime aus einem Textstring unter Verwendung eines bestimmten Formatters zurück.

Hier ist ein Beispiel für die 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);
       }
   }

Die Ausgabe ist:

5. parse()-Methode von ZonedDateTime

Die Klasse ZonedDateTime stellt Datum und Uhrzeit mit einer Zeitzone dar. Diese Klasse ist unveränderlich. Sie speichert Datums- und Zeitfelder mit einer Genauigkeit von Nanosekunden und eine Zeitzone, wobei ein Zonen-Offset verwendet wird, um mehrdeutige lokale Daten und Uhrzeiten zu behandeln. Wenn du also einen Wert wie „14. Oktober 2020 um 17:50.30.123456789 +02:00 in der Zeitzone Europa/Paris“ verwenden willst, kannst du ZonedDateTime verwenden. Die Klasse wird oft verwendet, um auf der lokalen Uhrzeit basierende Daten zu manipulieren. ZondeDateTime parse() ist ein Parser, der die Zeichenkette in Token im ISO-8061-System zerlegt. Hier ist ein Beispiel für einen Wert, den du nach dem Parsen erhältst: Sie wird immer dann eingesetzt, wenn hochpräzise Daten benötigt werden (schließlich sind die Daten, die du erhältst, bis auf Nanosekunden genau). Die Klasse wird oft verwendet, um auf der lokalen Uhrzeit basierende Daten zu manipulieren. Werfen wir einen Blick auf die allgemeine Syntax der Methode ZonedDateTime parse(), mit der Entwickler String-Werte in die ZonedDateTime-Klasse umwandeln.

public static ZonedDateTime parse(CharSequence text)

Der einzige Parameter, den die Methode verwendet, ist ein String text. Als Rückgabewert erhältst du ein oder eine Reihe von Objekten im ZonedDateTime-Format. Wenn beim Parsen ein Fehler auftritt oder es zunächst nicht möglich ist, gibt die Methode eine DateTimeParseException zurück. Außerdem gibt es eine parse()-Methode mit zwei Variablen.

public static ZonedDateTime parse(CharSequence text, DateFormatter formatter)

Diese Methode erhält eine Instanz von ZonedDateTime aus einem text-Wert unter Verwendung eines bestimmten Formatters. Die Methode mit einem Parameter, dem Formatter DateTimeFormatter.ISO_LOCAL_TIME, wird standardmäßig verwendet. Werfen wir einen Blick auf den Anwendungsfall für 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);
   }
}

Die Ausgabe ist:

6. parse()-Methode von LocalTime

Die Klasse LocalTime stellt eine Uhrzeit dar, die oft als Stunde-Minute-Sekunde angegeben wird. Diese Klasse ist ebenso unveränderlich wie ZonedDateTime. Die Uhrzeit wird auf Nanosekunden genau dargestellt. Zum Beispiel kann der Wert „13:45.30.123456789“ in LocalTime gespeichert werden. Es gibt zwei LocalTime parse()-Methoden, mit einem und zwei Parametern. Schauen wir uns beide an:

public static LocalTime parse(CharSequence text)

Du kannst LocalTime parse() mit nur einem Parameter verwenden, nämlich der Zeichenkette, die du parsen willst. In diesem Fall wird standardmäßig der Formatter DateTimeFormatter.ISO_LOCAL_TIME verwendet.

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

Sie holt eine Instanz von LocalTime aus einem text-Wert mit einem bestimmten Formatter. Die beiden Methoden geben den LocalTime-Wert im Format hh/mm/ss zurück. Achte auf DateTimeParceException-Meldungen. Sie bedeuten, dass das Format des Strings text nicht mit dem von LocalTime-Objekten übereinstimmt. Hier ist ein praktisches Beispiel für die Verwendung von 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. parse()-Methode von MessageFormat

MessageFormat erweitert die Klasse Format. Format ist eine abstrakte Basisklasse für die Formatierung von ortsabhängigen Daten (Datum, Nachrichten und Zahlen). MessageFormat übernimmt Objekte und formatiert sie. Dann fügt es die formatierten Strings an den entsprechenden Stellen in das Muster ein. MessageFormat parse() wird verwendet, um einen String-Wert zu erhalten, wenn der Startindex übergeben wird. Hier ist die allgemeine Syntax der Methode:

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

Dabei ist source der zu parsende String und position der Startindex des Parsens. Hier ist ein Beispiel, wie die Methode MessageFormat parse() funktioniert:

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. parse()-Methode von Level

Wenn ein Programmierer einen Logger verwendet, um eine Meldung zu protokollieren, wird sie mit einem bestimmten Log-Level protokolliert. Es gibt sieben integrierte Log-Levels:

• SEVERE
• WARNING
• INFO
• CONFIG
• FINE
• FINER
• FINEST

Außerdem gibt es die Levels OFF, um die Protokollierung auszuschalten, und ALL, um die Protokollierung aller Meldungen zu aktivieren. Der Log-Level wird durch die Klasse java.util.logging.Level dargestellt. Die Klasse Level enthält eine Konstante für jeden dieser sieben Levels. Du verwendest also eine dieser Konstanten, einschließlich „All“ und „OFF“, wenn du eine Nachricht in einen Logger einträgst. Außerdem werden alle diese Levels mit einer ganzen Zahl initialisiert. Zum Beispiel wird FINE auf 500 initialisiert. Die Methode Level parse() parst eine benötigte Information aus einem Textwert und gibt ein Level-Objekt zurück. Hier ist die Syntax der Methode Level parse():

public static Level parse(String name)

Der Parameter der Methode ist der Name eines Strings, den der Entwickler parsen möchte. Das kann der Name des Levels, sein Initialisierungsname oder eine andere Ganzzahl sein. Im Gegenzug erhält der Programmierer einen Wert für den Level-Namen, der dem der ursprünglichen Zeichenkette entspricht. Wenn das Argument Zeichen enthält, die nicht geparst werden können, löst das System die IllegalArgumentException aus. Wenn ein String keine Werte enthält, erhält der Entwickler eine NullPointerException. Hier ist ein Stück Code, das die Implementierung von Level parse() zeigt.

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

Die Ausgabe ist:

9. parse()-Methode von Instant

Die Klasse Instant modelliert einen einzelnen momentanen Punkt auf der Zeitachse. Du kannst sie für die Aufzeichnung von Ereignis-Zeitstempeln in deiner App verwenden. Instant parse() ruft einen Instant-Wert aus einem Textwert ab. Der String wird später als UTC-Zeitzonenwert gespeichert. Das System verwendet DateTimeFormatter.ISO_INSTANT wie 2020-10-14T11:28:15.00Z. Hier ist die Syntax der Methode Instant parse():

public static Instant parse(CharSequence text)

Um eine Zeichenkette zu analysieren und einen Moment zu erhalten, muss ein Entwickler sicherstellen, dass die Zeichenkette einen Text enthält. Wenn er null ist, erhältst du eine DateTimeException. Hier ist ein Beispiel für die Verwendung von 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);
       }
   }

Die Ausgabe ist:

10. parse()-Methode von NumberFormat

Die Klasse java.text.NumberFormat wird verwendet, um Zahlen zu formatieren. NumberFormat parse() ist eine Standardmethode dieser Klasse. Die Methode parse() der Klasse NumberFormat wandelt eine Zeichenkette in eine Zahl um. Entwickler benutzen sie, um eine Zeichenkette in ihre Bestandteile zu zerlegen. Das Parsen beginnt am Anfang des Strings. Wenn du setParseIntegerOnly (true) aufrufst, bevor du die Methode parse () aufrufst, wie im folgenden Beispiel gezeigt, wird nur der ganzzahlige Teil der Zahl umgewandelt. Hier ist die Syntax von NumberFormat parse():

public Number parse(String str)

Als Parameter akzeptiert die Funktion Strings. Der Rückgabewert des Parsens ist ein numerischer Wert. Wenn ein String-Anfang nicht geparst werden kann, erhältst du eine ParseException-Meldung. Für die Anwendung der Methode NumberFormat parse() schau dir das folgende Beispiel an:

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

Die Ausgabe ist:

Fazit

Es gibt eine Menge Parsing-Methoden, mit denen Entwickler Strings in verschiedene Datentypen umwandeln können. Auch wenn es mühsam erscheinen mag, sich diese Befehle zu merken, bietet eine solche Vielfalt an Befehlen Entwicklern eine Menge Flexibilität und Präzision. Übe unbedingt das Parsen von Daten, damit du dir die Syntax merkst und nicht vergisst, welche Parameter für jede Methode wichtig sind.