11 metod parse() w Javie z przykładami

Opublikowano w grupie Poland
Parsowanie w najbardziej ogólnym sensie polega na wyodrębnianiu niezbędnych informacji z jakiegoś fragmentu danych, najczęściej tekstowych. Czym jest parsowanie w Javie? Istnieje wiele klas Javy, które posiadają metodę parse(). Zazwyczaj metoda parse() otrzymuje jakiś ciąg jako dane wejściowe, „wyodrębnia” z niego potrzebne informacje i przekształca go w obiekt klasy wywołującej. Na przykład otrzymuje ona ciąg znaków i zwraca datę, która się w ciągu „ukrywała”. W tym wpisie przyjrzymy się 10 przydatnym odmianom parse(). 11 metod parse() w Javie z przykładami - 1

0. parseInt()

Zacznijmy od jednej z najpopularniejszych metod parse(), którą nie jest parse() per se, ale parseInt(). Metoda Java parseInt () służy do uzyskania, przy pomocy swoistej ekstrakcji, prymitywnego typu danych z danego ciągu. Innymi słowy konwertuje ten ciąg na liczbę. parseInt () może przyjmować jeden lub dwa argumenty. Składnia metody parseInt() to:

static int parseInt(String s)
static int parseInt(String s, int radix)
Gdzie s to ciąg reprezentujący podpisaną wartość dziesiętną, a radix to podstawa systemu numerycznego. Lecz pamiętaj, że nie ma domyślnej wartości bazowej - należy wprowadzić wartość z zakresu od 2 do 36. Oto przykład. Jak parsować za pomocą 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));

       }
   }
Wyświetlone zostanie:
12 12.0 4 65

1. Metoda Period parse()

Period to klasa Java do służąca do modelowania ilości czasu w kategoriach lat, miesięcy i dni, np. „3 lata, 5 miesięcy i 2 dni”. Posiada metodę parse() umożliwiającą uzyskanie okresu z tekstu. Składnią metody period parse() jest:

public static Period parse(CharSequence text)
CharSequence to interfejs zaimplementowany przez klasę Strings. Można więc używać Strings do tworzenia elementów tekstowych w metodzie parse(). Ciąg powinien być w odpowiednim formacie, aby można było poprawnie zwrócić obiekt klasy Period. Jest to format PnYnMnD. Gdzie Y oznacza „rok”, M — „miesiąc”, D — „dzień”. N to liczba odpowiadająca każdej wartości danego okresu.
  • Metoda przyjmuje tylko jeden parametr — wartość tekstową.
  • Parse() zwraca wartość Period, gdzie wartość ciągu staje się parametrem.
  • Jako wyjątek, period parse() może zwrócić wyjątek DateTimeParseException, jeśli wartość ciągu nie odpowiada strukturze okresu.
Oto przykład użycia funkcji Period parse() w rzeczywistym kontekście:

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");
   }
}
	}
}
Wyświetlone zostanie:
wiek to: 17 lat 9 miesięcy 5 dni
11 metod parse() w Javie z przykładami - 2

2. Metoda SimpleDateFormat parse()

SimpleDateFormat jest klasą używaną do formatowania i analizowania dat z uwzględnieniem ustawień regionalnych. Metoda SimpleDateFormat parse() dzieli ciąg na tokeny daty i zwraca wartość Date w odpowiednim formacie. Metoda rozpoczyna analizowanie ciągu w indeksie zdefiniowanym przez programistę. Składnią metody SimpleDateFormat parse() jest:

public Date parse(String the_text, ParsePosition position)
Metoda posiada dwa parametry:
  • pozycja: dane w indeksie początkowym, który zawsze jest typem obiektu ParsePosition.
  • tekst: deklaruje ciąg, który metoda będzie analizować i jest wartością typu String.
Metody można używać bez deklaracji pozycji. W tym przypadku dane zaczynają się od indeksu zerowego. SimpleDateFormat parse() zwraca datę lub wartość null (w przypadku, gdy ciąg nie został przetworzony z powodu błędu). Oto przykład implementacji funkcji 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);
   }
}
Wyświetlone zostanie:
Wed Oct 14 00:00:00 EEST 2020 Wed Oct 14 00:00:00 EEST 2020 Wed Oct 14 00:00:00 EEST 2020 Sun Oct 04 00:00:00 EEST 2020 null
Ostatnia z nich ma wartość null, ponieważ nie istnieje wzór daty zaczynający się od piątej pozycji. Przy okazji, jeśli spróbujesz przeanalizować date5 bez pozycji, np. Date date5 = simpleDateFormat2.parse(myString), otrzymasz wyjątek:
Exception in thread "main" java.text.ParseException: Unparseable date: "oto data: 14/010/2020" at java.base/java.text.DateFormat.parse(DateFormat.java:396) at ParseDemo2.main(ParseDemo2.java:22)

3. Metoda LocalDate parse()

LocalDate to klasa, która pojawiła się w Javie 8, aby reprezentować datę, taką jak rok-miesiąc-dzień (dostępne są również opcje dnia roku, dnia tygodnia i tygodnia roku). LocalDate nie reprezentuje czasu ani strefy czasowej. Metoda LocalDate parse() ma dwa warianty. Oba pomagają przekonwertować ciąg na nowy interfejs API daty w Javie 8 - java.time.LocalDate.

parse(CharSequence text, DateTimeFormatter, formatter)

Ta metoda analizuje ciąg przy użyciu określonego formattera, aby uzyskać instancję LocalDate. Oto składnia tej metody:

public static LocalTime parse(CharSequence text,
                              DateTimeFormatter formatter)
Metoda ma dwa parametry — tekst do przeanalizowania oraz formatter, który zastosuje programista. Jako wartość zwracaną metoda zwraca obiekt LocalTime rozpoznawany jako lokalny czas dzienny. Jeśli wartość tekstowa nie mogła zostać parsowana, system wyrzuca wyjątek DayTimeParseException. Prześledźmy przykład użycia funkcji LocalDate parse() z dwoma parametrami:

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));
   }
}
Wyświetlone zostanie:
parsowana data lokalna: 2020-10-14 sformatowana data lokalna: 14/10/2020
Metoda LocalDate parse() z jednym parametrem ma następującą składnię:

public static LocalTime parse(CharSequence text)
Ta metoda nie wymaga określenia formattera. Gdy programista wprowadzi wartości ciągu w nawiasach, system automatycznie użyje DateTimeFormatter.ISO_LOCAL_DATE. Ta metoda ma jeden parametr — tekst CharSequence. W tym miejscu można użyć wartości ciągu. Upewnij się, że nie ma on wartości null i jest zgodny ze strukturą formattera. Jeśli nie ma możliwości parsowania ciągu, programista otrzymuje wyjątek DateTimeExceptionAlert. Oto przykład aplikacji 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);
       }
   }
Wyświetlone zostanie:
LocalDate : 2020-10-14

4. Metoda LocalDateTime parse()

LocalDateTime obiekt czasu, który reprezentuje czas określony jako rok-miesiąc-dzień-godzina-minuta-sekunda. Programiści mogą również używać innych pól daty i czasu (dzień roku, dzień tygodnia i tydzień roku). Ta klasa jest niezmienna. Czas jest przedstawiany z dokładnością do nanosekundy. Na przykład możesz przechowywać wartość „17 listopada 2020 o 13:30.30.123456789” w LocalDateTime. W tej klasie nie chodzi o reprezentowanie strefy czasowej. Jest to raczej standardowe przedstawienie daty plus czasu lokalnego. Metoda LocalDateTime parse() występuje w dwóch wariantach:
  • static LocalDateTime parse(CharSequence text) zwraca instancję LocalDateTime z ciągu tekstowego, takiego jak 2007-12-03T10:15:30.
  • static LocalDateTime parse(CharSequence text, DateTimeFormatter formatter) zwraca instancję LocalDateTime z ciągu tekstowego przy użyciu określonego formattera.
Oto przykład użycia metody 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);
       }
   }
Wyświetlone zostanie:
LocalDateTime to: 2020-11-17T19:34:50.630

5. Metoda parse() ZonedDateTime

Klasa ZonedDateTime reprezentuje czas z określoną strefą czasową. Ta klasa jest niezmienna. Przechowuje pola daty i czasu z dokładnością do nanosekund oraz strefę czasową i mechanizmami do kalibracji używanymi przy pracy z niejednoznacznymi lokalnymi czasami. Jeśli więc chcesz zachować wartość taką jak "14 października 2020 o godzinie 17:50.30.123456789 +02:00 w strefie czasowej Europa/Paryż", możesz użyć ZonedDateTime. Klasa ta jest często używana do manipulowania danymi lokalnymi opartymi na czasie. ZondeDateTime parse() to parser, który w systemie ISO-8061 dzieli ciąg na tokeny. Oto przykład wartości, którą otrzymasz po przetworzeniu danych:
2020-04-05T13:30:25+01:00 Europe/Rome
Stosuje się ją wszędzie tam, gdzie potrzebne są dane o wysokiej precyzji (w końcu otrzymane dane są dokładne do nanosekund). Klasa ta jest często używana do manipulowania danymi lokalnymi opartymi na czasie. Przyjrzyjmy się ogólnej składni metody ZonedDateTime parse() używanej przez programistów do konwersji wartości ciągów na klasę ZonedDateTime.

public static ZonedDateTime parse(CharSequence text)
Jedynym parametrem, którego używa metoda, jest tekst w postaci ciągu. Jako wartość zwracaną otrzymasz jeden lub serię obiektów w formacie ZonedDateTime. Jeśli podczas parsowania wystąpi błąd lub nie jest to możliwe, na początek metoda zwraca wyjątek DateTimeParseException. Istnieje również metoda parse() z dwiema zmiennymi.

public static ZonedDateTime parse(CharSequence text, DateFormatter formatter)
Ta metoda uzyskuje instancję ZonedDateTime z wartości tekstowej przy użyciu określonego formattera. Domyślnie używana jest metoda z jednym parametrem, formaterem DateTimeFormatter.ISO_LOCAL_TIME. Rzućmy okiem na przypadek użycia 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);
   }
}
Wyświetlone zostanie:
2020-10-15T10:15:30+01:00 2020-10-15T13:30:25+01:00

6. Metoda parse() LocalTime

Klasa LocalTime reprezentuje czas, często określany jako godzina-minuta-sekunda. Klasa ta jest również niezmienna jak ZonedDateTime. Czas jest reprezentowany z dokładnością do nanosekundy. Na przykład wartość "13:45.30.123456789" może być przechowywana w LocalTime. Istnieją dwie metody LocalTime parse() z jednym i dwoma parametrami. Przyjrzyjmy się obydwu:

public static LocalTime parse(CharSequence text)
Możesz użyć LocalTime parse() z tylko jednym parametrem, ciągiem, który chcesz parsować. W takim przypadku domyślnie używany jest formatter DateTimeFormatter.ISO_LOCAL_TIME.

Method with two parameters has the next syntax:
public static LocalTime parse(CharSequence text,
                              DateTimeFormatter formatter)
Uzyskuje instancję funkcji LocalTime z wartości tekstowej przy użyciu określonego formattera. Obie metody zwracają wartość LocalTime w formacie gg/mm/ss. Należy uważać na alerty DateTimeParceException. Oznaczają, że format tekstu ciągu nie odpowiada formatowi obiektów LocalTime. Oto przykład użycia LocalTime parse() w produkcji:

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. Metoda Parse() MessageFormat

MessageFormat rozszerza klasę Format. Format to abstrakcyjna klasa bazowa do formatowania danych wrażliwych na ustawienia regionalne (daty, wiadomości i liczby). MessageFormat pobiera określone obiekty i je formatuje. Następnie wstawia sformatowane ciągi do wzorca w odpowiednich miejscach. MessageFormat parse() służy do pobrania wartości ciągu, jeśli podany jest początek indeksu. Oto ogólna składnia tej metody:

public Object[] parse(String source, ParsePosition position)
Gdzie źródło jest ciągiem do parsowania, a pozycja jest indeksem początkowym parsowania. Oto przykład działania metody 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. Metoda Level parse()

Gdy programista używa Loggera do logowania komunikatu, jest on logowany z określonym poziomem logowania. Dostępnych jest siedem wbudowanych poziomów logowania:
  • SEVERE
  • WARNING
  • INFO
  • CONFIG
  • FINE
  • FINER
  • FINEST
Dostępne są także dodatkowe poziomy: OFF, który daje możliwość wyłączenia logowania oraz ALL, który umożliwia logowanie wszystkich komunikatów. Poziom logowania jest reprezentowany przez klasę java.util.logging.Level. Klasa Level zawiera stałą dla każdego z tych siedmiu poziomów. W związku z tym podczas rejestrowania komunikatu w rejestratorze używasz jednej z tych stałych, w tym All i OFF. Również wszystkie te poziomy są inicjowane do niektórych liczb całkowitych. Na przykład wartość parametru FINE jest inicjowana na 500. Metoda Level parse() przetwarza potrzebne informacje z wartości tekstowej i zwraca obiekt Level. Oto składnia metody level parse():

public static Level parse(String name)
Parametrem metody jest nazwa ciągu, który programista chce parsować. Może to być nazwa poziomu, jego nazwa inicjująca lub inna liczba całkowita. W zamian programista otrzymuje wartość nazwy Level, odpowiadającą wartości początkowego ciągu. Jeśli argument zawiera symbole, których nie można parsować, system wyrzuci wyjątek IllegalArgumentException. Jeśli ciąg nie zawiera wartości, programista otrzymuje wyjątek NullPointerException. Oto fragment kodu, który pokazuje implementację 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());
   }
}
Wyświetlone zostanie:
Level = FINE Level = FINE OFF

9. Metoda Instant parse()

Klasa Instant modeluje pojedynczy punkt chwilowy na linii czasu. Możesz jej używać do rejestrowania sygnatur czasowych wydarzeń w swojej aplikacji. Instant parse() uzyskuje wartość Instant z wartości tekstowej. Ciąg ten zostanie później zapisany jako wartość strefy czasowej UTC. System używa formattera DateTimeFormatter.ISO_INSTANT, na przykład 2020-10-14T11:28:15.00Z. Oto składnia metody Instant parse():

public static Instant parse(CharSequence text)
Aby parsować ciąg i uzyskać natychmiastową odpowiedź, programista musi się upewnić, że ciąg ten zawiera jakiś tekst. Jeśli ma wartość null, zostanie wyświetlony wyjątek DateTimeException. Oto przykład użycia Instant parse w Javie:

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);
       }
   }
Wyświetlone zostanie:
2020-10-14T10:37:30Z

10. Metoda numberFormat parse()

Klasa java.text.NumberFormat służy do formatowania liczb. NumberFormat parse() jest domyślną metodą tej klasy. Metoda parse () klasy NumberFormat konwertuje ciąg na liczbę. Programiści używają jej do rozbicia ciągu na jego składowe liczby. Parsowanie rozpoczyna się od początku ciągu. Jeśli wywołasz setParseIntegerOnly (true) przed wywołaniem metody parse (), jak pokazano w poniższym przykładzie, to tylko część całkowita liczby zostanie przekonwertowana. Oto składnia NumberFormat parse():

public Number parse(String str)
Jako parametr funkcja przyjmuje ciągi. Zwracana wartość parsowania jest wartością liczbową. Jeśli nie można przeanalizować początku ciągu, otrzymasz ostrzeżenie ParseException. Zastosowanie metody NumberFormat parse() można zauważyć na poniższym przykładzie:

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"));
       }
   }
Wyświetlone zostanie:
3.141592 3

Wniosek

Istnieje wiele metod parsowania, których programiści mogą używać do konwersji ciągów na różne typy danych. Chociaż ich zapamiętywanie może wydawać się uciążliwe, taka różnorodność poleceń zapewnia programistom dużą elastyczność i precyzję. Przećwicz używanie parsowania danych, aby mieć pewność, że pamiętasz składnię i nie zapomnisz, które parametry są niezbędne dla każdej z metod.
Komentarze
TO VIEW ALL COMMENTS OR TO MAKE A COMMENT,
GO TO FULL VERSION