11 parse()-metoder i Java med exempel

Att analysera i sin mest allmänna mening är att extrahera den nödvändiga informationen från någon del av data, oftast textdata. Vad är parse i Java? Det finns många Java-klasser som har metoden parse() . Vanligtvis tar metoden parse() emot en sträng som indata, "extraherar" den nödvändiga informationen från den och konverterar den till ett objekt av den anropande klassen. Till exempel fick den en sträng och returnerade datumet som "gömde sig" i denna sträng. I det här inlägget ska vi ta en titt på de 10 användbara varianterna av parse() .

0. parseInt()

Låt oss utgå från en av de mest populära parse()- metoderna, det vill säga inte exakt parse() , utan parseInt() . Metoden Java parseInt () används för att hämta den primitiva datatypen från en specifik sträng. Med andra ord konverterar den en sträng till ett tal. parseInt () kan ha ett eller två argument. Här är syntaxen för parseInt() :

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

Där s är strängen som representerar ett decimalvärde med tecken och radix basen för ett numeriskt system. Tänk på att det inte finns något standardbasvärde – du måste ange ett inom intervallet 2 och 36. Här är ett exempel. Hur man tolkar 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));
         
       }
   }

Utgången är:

1. Period parse()-metoden

Period är en Java-klass för att modellera en mängd tid i termer av år, månader och dagar som "3 år, 5 månader och 2 dagar". Den har en parse() -metod för att få en punkt från en text. Här är syntaxen för period parse()

public static Period parse(CharSequence text)

CharSequence är ett gränssnitt, implementerat av Strings. Så du kan använda Strings som ett textelement i metoden parse() . Säkert ska strängen vara i rätt format för att returnera ett objekt av klassen Period. Detta format är PnYnMnD . Där Y står för "år", M - för "månad", D - för "dag". N är ett tal som motsvarar varje periodvärde.

• Metoden har en parameter — ett textvärde.
• Parse() returnerar ett periodvärde där värdet på en sträng blir en parameter.
• Som ett undantag kan period parse() returnera DateTimeParseException om strängvärdet inte uppfyller strukturen för en period.

Här är ett exempel på hur man använder Period parse() i verkliga sammanhang:

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

Utgången är:

2.SimpleDateFormat Parse()-metoden

SimpleDateFormat är en klass som används för att formatera och analysera datum på ett språkkänsligt sätt. Metoden SimpleDateFormat parse() bryter ner en sträng i datumtokens och returnerar ett datavärde i motsvarande format. Metoden börjar analysera strängen vid ett index, definierat av en utvecklare. Detta är syntaxen för SimpleDateFormat parse() :

public Date parse(String the_text, ParsePosition position)

Metoden har två parametrar:

• Position: data vid startindex som alltid är objekttypen ParsePosition.
• the_text: definierar strängen som metoden kommer att analysera och är ett strängtypvärde.

Du kan använda den här metoden utan positionsdeklaration. I detta fall börjar data från nollindex. SimpleDateFormat parse() returnerar ett datum eller ett nollvärde (om strängen inte bearbetades på grund av ett fel). Här är ett exempel 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);
   }
}

Utgången är: Den sista är null eftersom det inte finns något datummönster som börjar från den 5:e positionen. Förresten, om du försöker analysera date5 utan position som Date date5 = simpleDateFormat2.parse(myString) , får du ett undantag:

3. LocalDate parse() metod

LocalDate är en klass som dök upp i Java 8 för att representera ett datum som år-månad-dag (dag-på-år, veckodag och vecka-i-år, kan också nås). LocalDate representerar inte en tid eller tidszon. LocalDate parse() -metoden har två varianter. Båda hjälper till att konvertera en sträng till ett nytt Java 8 date API — java.time.LocalDate .

parse(CharSequence text, DateTimeFormatter, formatter)

Denna metod analyserar en sträng med en specifik formatterare för att få en instans av LocalDate. Här är syntaxen för metoden:

public static LocalTime parse(CharSequence text,
                              DateTimeFormatter formatter)

Det finns två parametrar för metoden - texten som kommer att tolkas och formatet som en utvecklare kommer att använda. Som ett returvärde returnerar metoden ett LocalTime-objekt som kommer att kännas igen som lokal dagtid. Om textvärdet inte kunde gå igenom parsning, kastar systemet DayTimeParseException. Låt oss ta ett kodexempel på hur du använder LocalDate parse() med två parametrar:

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

Utgången är: LocalDate parse() -metoden med en parameter har nästa syntax:

public static LocalTime parse(CharSequence text)

Den här metoden kräver inte att du anger en formatterare. Efter att en utvecklare har skrivit in strängvärdena inom parentes, kommer systemet automatiskt att använda DateTimeFormatter.ISO_LOCAL_DATE. Denna metod har en enda parameter — en CharSequence-text. Du kan använda strängvärdet här. Se till att den inte är null och respekterar formaterarens struktur. Om det inte finns något sätt att analysera en sträng får en utvecklare DateTimeExceptionAlert. Här är ett exempel på LocalDate parse() -applikation:

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

Utgången är:

4. LocalDateTime parse() metod

LocalDateTime ett datum-tid-objekt som representerar en datum-tid som visas ganska ofta som år-månad-dag-timme-minut-sekund. Även utvecklare kan använda andra datum- och tidsfält (dag på året, veckodag och veckovis). Denna klass är oföränderlig. Tiden representeras med nanosekunders precision. Du kan till exempel lagra värdet "17 november 2020 kl. 13:30.30.123456789" i en LocalDateTime. Den här klassen handlar inte om att representera en tidszon. Det är snarare en standarddatumrepresentation plus lokal tid. LocalDateTime parse() metod representerad i två varianter:

• statisk LocalDateTime parse(CharSequence text) returnerar en instans av LocalDateTime från en textsträng som 2007-12-03T10:15:30.
• statisk LocalDateTime parse(CharSequence text, DateTimeFormatter formatter) returnerar en instans av LocalDateTime från en textsträng som använder en specifik formatterare.

Här är ett exempel 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);
       }
   }

Utgången är:

5. ZonedDateTime parse() metod

Klass ZonedDateTime representerar en datum-tid med en tidszon. Denna klass är oföränderlig. Den lagrar datum- och tidsfält med en precision av nanosekunder, och en tidszon, med en zonförskjutning som används för att hantera tvetydiga lokala datum-tider. Så om du behöver behålla ett värde som "14 oktober 2020 kl. 17:50.30.123456789 +02:00 i Europa/Paris tidszon" kan du använda ZonedDateTime. Klassen används ofta för att manipulera lokal tidsbaserad data. ZondeDateTime parse() är en parser som bryter ner strängen i tokens i ISO-8061-systemet. Här är ett exempel på ett värde du får efter analys: Den används närhelst högprecisionsdata behövs (trots allt är data du får exakt upp till nanosekunder). Klassen används ofta för att manipulera lokal tidsbaserad data. Låt oss ta en titt på den allmänna syntaxen för ZonedDateTime-parse() -metoden som utvecklare använder för att konvertera strängvärden till ZonedDateTime-klassen.

public static ZonedDateTime parse(CharSequence text)

Den enda parametern som metoden använder är en strängtext. Som ett returvärde får du ett eller en serie objekt i formatet ZonedDateTime. Om det finns ett fel under analysen eller om det är omöjligt, returnerar metoden till att börja med DateTimeParseException. Det finns också en parse() -metod med två variabler.

public static ZonedDateTime parse(CharSequence text, DateFormatter formatter)

Den här metoden hämtar en instans av ZonedDateTime från ett textvärde med en specifik formatterare. Metoden med en parameter, formateraren DateTimeFormatter.ISO_LOCAL_TIME används som standard. Låt oss ta en titt på användningsfallet 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);
   }
}

Utgången är:

6. LocalTime parse() metod

Klass LocalTime representerar en tid, ofta sedd som timme-minut-sekund. Denna klass är också oföränderlig som ZonedDateTime.Time representeras med nanosekunders precision. Till exempel kan värdet "13:45.30.123456789" lagras i en LocalTime. Det finns två LocalTime parse()- metoder, med en och två parametrar. Låt oss ta en titt på båda:

public static LocalTime parse(CharSequence text)

Du kan använda LocalTime parse() med endast en parameter, strängen du vill analysera. I det här fallet används formateraren DateTimeFormatter.ISO_LOCAL_TIME som standard.

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

Den erhåller en instans av LocalTime från ett textvärde med en specifik formatterare. Båda metoderna returnerar LocalTime-värdet i formatet hh/mm/ss. Se upp för DateTimeParceException-varningar. De betyder att formatet på strängtexten inte motsvarar det för LocalTime-objekt. Här är ett exempel på hur du använder LocalTime parse() i produktionen:

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

MessageFormat utökar klassen Format. Format är en abstrakt basklass för formatering av lokalitetskänsliga data (datum, meddelanden och siffror). MessageFormat hämtar några objekt och formaterar dem. Sedan infogar den de formaterade strängarna i mönstret på lämpliga platser. MessageFormat parse() används för att få ett strängvärde om indexet börjar. Här är den allmänna syntaxen för metoden:

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

Där source är en sträng att analysera och position är startindexet för analysen. Här är ett exempel på hur MessageFormat parse() -metoden fungerar:

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

När en programmerare använder en Logger för att logga ett meddelande loggas den med en viss loggnivå. Det finns sju inbyggda loggnivåer:

• SVÅR
• VARNING
• INFO
• KONFIG
• BRA
• FINARE
• FINASTE

Det finns också ytterligare nivåer AV som kan användas för att stänga av loggning och ALLA som kan användas för att aktivera loggning av alla meddelanden. Loggnivån representeras av klassen java.util.logging.Level . Nivåklass innehåller en konstant för var och en av dessa sju nivåer. Så du använder en av dessa konstanter, inklusive Alla och AV medan du loggar ett meddelande till en Logger. Även alla dessa nivåer initierades till några heltal. Till exempel initieras FINE till 500. Metoden Level parse() analyserar en information som behövs från ett textvärde och returnerar ett Level-objekt. Här är syntaxen för metoden level parse() :

public static Level parse(String name)

Parametern för en metod är namnet på en sträng som en utvecklare vill analysera. Det kan vara ett namn på nivån, dess initialiserande namn eller något annat heltal. I gengäld får en programmerare ett nivånamnvärde, motsvarande det för den initiala strängen. Om argumentet innehåller symboler som är omöjliga att tolka, kommer systemet att kasta IllegalArgumentException. Om en sträng inte innehåller några värden får en utvecklare ett NullPointerException. Här är en bit kod som visar 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());
   }
}

Utgången är:

9. Instant parse() metod

Instant class modellerar en enda momentan punkt på tidslinjen. Du kan använda den för att spela in händelsetidsstämplar i din app. Instant parse() erhåller ett Instant-värde från ett textvärde. Strängen kommer senare att lagras som ett UTC-tidszonvärde. Systemet använder DateTimeFormatter.ISO_INSTANT som 2020-10-14T11:28:15.00Z. Här är en syntax för metoden Instant parse() :

public static Instant parse(CharSequence text)

För att analysera en sträng och få ett ögonblick måste en utvecklare se till att strängen innehåller lite text. Om den är null får du ett DateTimeException. Här är ett exempel på hur du använder 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);
       }
   }

Utgången är:

10. NumberFormat parse() metod

Klassen java.text.NumberFormat används för att formatera tal. NumberFormat parse() är en standardmetod för denna klass. Metoden parse () för klassen NumberFormat konverterar en sträng till ett tal. Utvecklare använder den för att bryta ner en sträng till dess komponentnummer. Analysen börjar från början av strängen. Om du anropar setParseIntegerOnly (true) innan du anropar parse () -metoden, som visas i följande exempel, konverteras endast heltalsdelen av talet. Här är syntaxen för NumberFormat parse() :

public Number parse(String str)

Som en parameter accepterar funktionen strängar. Ett returvärde för analysen är ett numeriskt värde. Om en sträng som börjar inte kan analyseras, får du en ParseException-varning. För att se tillämpningen av NumberFormat parse() -metoden, ta en titt på exemplet nedan:

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

Utgången är:

Slutsats

Det finns många analysmetoder som utvecklare kan använda för att konvertera strängar till olika datatyper. Även om det kan verka tråkigt att komma ihåg dem, ger en sådan mängd kommandon utvecklare mycket flexibilitet och precision. Se till att öva på att använda dataanalys för att se till att du kommer ihåg syntaxen och kommer inte att glömma vilka parametrar som är viktiga för varje metod.