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:
12 12,0 4 65
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.
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:
åldern är: 17 år 9 månader 5 dagar
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.
// 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:
Ons 14 okt 00:00:00 EEST 2020 Ons 14 okt 00:00:00 EEST 2020 Ons 14 okt 00:00:00 EEST 2020 Sön 04 okt 00:00:00 EEST 2020 null
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:
Undantag i tråden "main" java.text.ParseException: Unparseable date: "här är datumet: 14/010/2020" på java.base/java.text.DateFormat.parse(DateFormat.java:396) på ParseDemo2.main (ParseDemo2.java:22)
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:
tolkat lokalt datum: 2020-10-14 formaterat lokalt datum: 14/10/2020
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:
Lokalt datum: 2020-10-14
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.
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:
LocalDateTime är: 2020-11-17T19:34:50.630
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:
2020-04-05T13:30:25+01:00 Europa/Rom
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:
2020-10-15T10:15:30+01:00 2020-10-15T13:30:25+01:00
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
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:
Nivå = FIN Nivå = FIN AV
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:
2020-10-14T10:37:30Z
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:
3,141592 3
GO TO FULL VERSION