Menghuraikan dalam erti kata yang paling umum ialah pengekstrakan maklumat yang diperlukan daripada beberapa data, selalunya data teks. Apakah parse dalam Java? Terdapat banyak kelas Java yang mempunyai kaedah parse() . Biasanya kaedah parse() menerima beberapa rentetan sebagai input, "mengekstrak" maklumat yang diperlukan daripadanya dan menukarnya menjadi objek kelas panggilan. Sebagai contoh, ia menerima rentetan dan mengembalikan tarikh yang "bersembunyi" dalam rentetan ini. Dalam siaran ini, kita akan melihat 10 variasi berguna parse() .

0. parseInt()

Mari kita mulakan dari salah satu kaedah parse() yang paling popular , itu bukan parse() , tetapi parseInt() . Kaedah Java parseInt () digunakan untuk mendapatkan jenis data primitif daripada rentetan tertentu. Dalam erti kata lain ia menukar rentetan kepada nombor. parseInt () boleh mempunyai satu atau dua argumen. Inilah sintaks parseInt() : 

static int parseInt(String s)
static int parseInt(String s, int radix)
Di mana s ialah rentetan yang mewakili nilai perpuluhan yang ditandatangani dan radix asas sistem berangka. Perlu diingat bahawa tiada nilai asas lalai — anda perlu memasukkan satu dalam julat 2 dan 36. Berikut ialah contohnya. Bagaimana untuk menghuraikan dengan 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));
         
       }
   }
Outputnya ialah:
12 12.0 4 65

1. Kaedah parse() tempoh

Tempoh ialah kelas Java untuk memodelkan kuantiti masa dari segi tahun, bulan dan hari seperti "3 tahun, 5 bulan dan 2 hari". Ia mempunyai kaedah parse() untuk mendapatkan noktah daripada teks. Berikut ialah sintaks period parse() 

public static Period parse(CharSequence text)
CharSequence ialah Antara Muka, dilaksanakan oleh Strings. Jadi anda boleh menggunakan Strings sebagai elemen teks dalam kaedah parse() . Pasti rentetan harus dalam format yang betul untuk mengembalikan objek kelas Period. Format ini ialah PnYnMnD . Di mana Y bermaksud “tahun”, M — untuk “bulan”, D — untuk “hari”. N ialah nombor yang sepadan dengan setiap nilai tempoh.
  • Kaedah ini mempunyai satu parameter — nilai teks.
  • Parse() mengembalikan nilai Period di mana nilai rentetan menjadi parameter.
  • Sebagai pengecualian, period parse() boleh mengembalikan DateTimeParseException jika nilai rentetan tidak memenuhi struktur tempoh.
Berikut ialah contoh menggunakan Period parse() dalam konteks dunia sebenar: 

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");
   }
}
	} 
}
Outputnya ialah:
umur ialah: 17 Tahun 9 Bulan 5 Hari

Kaedah 2.SimpleDateFormat Parse().

SimpleDateFormat ialah kelas yang digunakan untuk memformat dan menghuraikan tarikh dengan cara yang sensitif setempat. Kaedah SimpleDateFormat parse() memecahkan rentetan kepada token tarikh dan mengembalikan nilai Data dalam format yang sepadan. Kaedah ini mula menghuraikan rentetan pada indeks, yang ditakrifkan oleh pembangun. Ini ialah sintaks SimpleDateFormat parse() : 

public Date parse(String the_text, ParsePosition position)
Kaedah ini mempunyai dua parameter:
  • Kedudukan: data pada indeks permulaan yang sentiasa jenis objek ParsePosition.
  • the_text: mentakrifkan rentetan yang kaedah akan dihuraikan dan merupakan nilai jenis Rentetan.
Anda boleh menggunakan kaedah ini tanpa pengisytiharan kedudukan. Dalam kes ini, data bermula dari indeks sifar. SimpleDateFormat parse() mengembalikan tarikh atau nilai nol (sekiranya rentetan tidak diproses kerana ralat). Berikut ialah contoh pelaksanaan 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);
   }
}
Outputnya ialah:
Rab 14 Okt 00:00:00 EEST 2020 Rab 14 Okt 00:00:00 EEST 2020 Rab 14 Okt 00:00:00 EEST 2020 Ahad 04 Okt 00:00:00 EEST 2020 null
Yang terakhir adalah batal kerana tiada corak tarikh bermula dari kedudukan ke-5. Dengan cara ini jika anda cuba menghuraikan date5 tanpa kedudukan seperti Date date5 = simpleDateFormat2.parse(myString) , anda akan mendapat pengecualian:
Pengecualian dalam utas "utama" java.text.ParseException: Tarikh tidak boleh dihuraikan: "di sini ialah tarikh: 14/010/2020" di java.base/java.text.DateFormat.parse(DateFormat.java:396) di ParseDemo2.main (ParseDemo2.java:22)

3. Kaedah parse() LocalDate

LocalDate ialah kelas yang muncul dalam Java 8 untuk mewakili tarikh seperti tahun-bulan-hari (hari-dalam-tahun, hari-dalam-minggu dan minggu-dalam-tahun, juga boleh diakses). LocalDate tidak mewakili masa atau zon waktu. Kaedah LocalDate parse() mempunyai dua varian. Kedua-duanya membantu menukar rentetan kepada API tarikh Java 8 baharu — java.time.LocalDate .

parse(Teks CharSequence, DateTimeFormatter, pemformat)

Kaedah ini menghuraikan rentetan menggunakan pemformat khusus untuk mendapatkan contoh LocalDate. Berikut ialah sintaks kaedah: 

public static LocalTime parse(CharSequence text,
                              DateTimeFormatter formatter)
Terdapat dua parameter untuk kaedah — teks yang akan dihuraikan dan pemformat yang akan digunakan oleh pembangun. Sebagai nilai pulangan, kaedah mengembalikan objek LocalTime yang akan diiktiraf sebagai waktu siang tempatan. Jika nilai teks tidak dapat melalui penghuraian, sistem membuang DayTimeParseException. Mari kita dapatkan contoh kod menggunakan LocalDate parse() dengan dua parameter: 

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));
   }
}
Outputnya ialah:
tarikh tempatan yang dihuraikan: tarikh tempatan terformat 2020-10-14: 14/10/2020
Kaedah LocalDate parse() dengan satu parameter mempunyai sintaks seterusnya: 

public static LocalTime parse(CharSequence text)
Kaedah ini tidak memerlukan penetapan pemformat. Selepas pembangun memasukkan nilai rentetan ke dalam kurungan, sistem akan secara automatik menggunakan DateTimeFormatter.ISO_LOCAL_DATE. Kaedah ini mempunyai satu parameter — teks CharSequence. Anda boleh menggunakan di sini nilai rentetan. Pastikan ia tidak batal dan menghormati struktur pemformat. Jika tiada cara untuk menghuraikan rentetan, pembangun mendapat DateTimeExceptionAlert. Berikut ialah contoh aplikasi 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);
       }
   }
Outputnya ialah:
Tarikh Tempatan : 2020-10-14

4. Kaedah parse() LocalDateTime

LocalDateTime objek tarikh-masa yang mewakili tarikh-masa dilihat dengan kerap sebagai tahun-bulan-hari-jam-minit-saat. Pembangun juga boleh menggunakan medan tarikh dan masa lain (hari-dalam-tahun, hari-dalam-minggu dan minggu-dalam-tahun). Kelas ini tidak berubah. Masa diwakili kepada ketepatan nanosaat. Sebagai contoh, anda boleh menyimpan nilai "17 November 2020 pada 13:30.30.123456789" dalam LocalDateTime. Kelas ini bukan tentang mewakili zon waktu. Ia lebih merupakan perwakilan tarikh standard ditambah waktu tempatan. Kaedah LocalDateTime parse() diwakili dalam dua varian:
  • static LocalDateTime parse(CharSequence text) mengembalikan contoh LocalDateTime daripada rentetan teks seperti 2007-12-03T10:15:30.
  • parse LocalDateTime statik (teks CharSequence, pemformat DateTimeFormatter) mengembalikan contoh LocalDateTime daripada rentetan teks menggunakan pemformat tertentu.
Berikut ialah contoh kaedah 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);
       }
   }
Outputnya ialah:
LocalDateTime ialah: 2020-11-17T19:34:50.630

5. Kaedah parse() ZonedDateTime

Kelas ZonedDateTime mewakili tarikh-masa dengan zon masa. Kelas ini tidak berubah. Ia menyimpan medan tarikh dan masa kepada ketepatan nanosaat, dan zon masa, dengan zon mengimbangi digunakan untuk mengendalikan masa tarikh tempatan yang samar-samar. Jadi, jika anda perlu menyimpan nilai seperti "14hb Oktober 2020 pada 17:50.30.123456789 +02:00 di zon waktu Eropah/Paris" anda boleh menggunakan ZonedDateTime. Kelas sering digunakan untuk memanipulasi data berasaskan masa tempatan. ZondeDateTime parse() ialah parser yang memecahkan rentetan menjadi token dalam sistem ISO-8061. Berikut ialah contoh nilai yang anda akan dapat selepas menghuraikan:
05-04-2020T13:30:25+01:00 Eropah/Rom
Ia digunakan apabila data berketepatan tinggi diperlukan (lagipun, data yang anda perolehi adalah tepat sehingga nanosaat). Kelas sering digunakan untuk memanipulasi data berasaskan masa tempatan. Mari kita lihat sintaks umum kaedah ZonedDateTime parse() yang digunakan oleh pembangun untuk menukar nilai rentetan ke dalam kelas ZonedDateTime. 

public static ZonedDateTime parse(CharSequence text)
Satu-satunya parameter yang digunakan kaedah ialah teks rentetan. Sebagai nilai pulangan, anda akan mendapat satu atau satu siri objek dalam format ZonedDateTime. Jika terdapat ralat semasa menghuraikan atau mustahil, sebagai permulaan, kaedah mengembalikan DateTimeParseException. Juga terdapat kaedah parse() dengan dua pembolehubah. 

public static ZonedDateTime parse(CharSequence text, DateFormatter formatter)
Kaedah ini memperoleh contoh ZonedDateTime daripada nilai teks menggunakan pemformat tertentu. Kaedah dengan satu parameter, pemformat DateTimeFormatter.ISO_LOCAL_TIME digunakan secara lalai. Mari kita lihat kes penggunaan untuk 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);
   }
}
Outputnya ialah:
15-10-2020T10:15:30+01:00 15-10-2020T13:30:25+01:00

6. Kaedah parse() LocalTime

Class LocalTime mewakili masa, selalunya dilihat sebagai jam-minit-saat. Kelas ini juga tidak boleh diubah seperti ZonedDateTime.Time diwakili kepada ketepatan nanosaat. Sebagai contoh, nilai "13:45.30.123456789" boleh disimpan dalam LocalTime. Terdapat dua kaedah parse() LocalTime , dengan satu dan dua parameter. Mari kita lihat kedua-duanya: 

public static LocalTime parse(CharSequence text)
Anda boleh menggunakan LocalTime parse() dengan hanya satu parameter, rentetan yang ingin anda huraikan. Dalam kes ini, pemformat DateTimeFormatter.ISO_LOCAL_TIME digunakan secara lalai. 

Method with two parameters has the next syntax: 
public static LocalTime parse(CharSequence text,
                              DateTimeFormatter formatter)
Ia Mendapatkan contoh LocalTime daripada nilai teks menggunakan pemformat tertentu. Kedua-dua kaedah mengembalikan nilai LocalTime dalam format hh/mm/ss. Berhati-hati dengan makluman DateTimeParceException. Ini bermakna bahawa format teks rentetan tidak sepadan dengan objek LocalTime. Berikut ialah contoh penggunaan LocalTime parse() dalam pengeluaran: 

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

MessageFormat memanjangkan kelas Format. Format ialah kelas asas abstrak untuk memformat data sensitif setempat (tarikh, mesej dan nombor). MessageFormat mendapatkan beberapa objek dan memformatkannya. Kemudian ia memasukkan rentetan yang diformat ke dalam corak di tempat yang sesuai. Parse MessageFormat () digunakan untuk mendapatkan nilai rentetan jika diberi permulaan indeks. Berikut ialah sintaks umum kaedah: 

public Object[] parse(String source, ParsePosition position)
Di mana sumber ialah rentetan untuk dihuraikan dan kedudukan ialah indeks permulaan penghuraian. Berikut ialah contoh kaedah parse() MessageFormat yang berfungsi: 

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. Kaedah parse() tahap

Apabila pengaturcara menggunakan Logger untuk log mesej ia dilog dengan tahap log tertentu. Terdapat tujuh tahap log terbina dalam:
  • TERUK
  • AMARAN
  • INFO
  • KONFIG
  • BAIK
  • LEBIH HALUS
  • TERBAIK
Terdapat juga tahap tambahan OFF yang boleh digunakan untuk mematikan pengelogan dan SEMUA yang boleh digunakan untuk membolehkan pengelogan semua mesej. Tahap log diwakili oleh kelas java.util.logging.Level . Kelas tahap mengandungi pemalar untuk setiap tujuh tahap ini. Jadi anda menggunakan salah satu pemalar ini, termasuk Semua dan MATI semasa log mesej ke Logger. Juga semua peringkat ini dimulakan kepada beberapa integer. Contohnya FINE dimulakan kepada 500. Kaedah parse() Tahap menghuraikan maklumat yang diperlukan daripada nilai teks dan mengembalikan objek Tahap. Berikut ialah sintaks kaedah parse() tahap : 

public static Level parse(String name)
Parameter kaedah ialah nama rentetan yang ingin dihuraikan oleh pembangun. Ia boleh menjadi nama tahap, nama permulaannya atau beberapa integer lain. Sebagai balasan, pengaturcara mendapat nilai nama Tahap, sepadan dengan rentetan awal. Sekiranya hujah mengandungi simbol yang mustahil untuk dihuraikan, sistem akan membuang IllegalArgumentException. Jika rentetan tidak mengandungi nilai, pembangun mendapat NullPointerException. Berikut ialah sekeping kod yang menunjukkan pelaksanaan 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());
   }
}
Outputnya ialah:
Tahap = Tahap HALUS = DENDA MATI

9. Kaedah parse() segera

Kelas segera memodelkan satu titik serta-merta pada garis masa. Anda boleh menggunakannya untuk merakam cap masa acara dalam apl anda. Instant parse() memperoleh nilai Segera daripada nilai teks. Rentetan itu kemudiannya akan disimpan sebagai Nilai Zon Waktu UTC. Sistem menggunakan DateTimeFormatter.ISO_INSTANT seperti 2020-10-14T11:28:15.00Z. Berikut ialah sintaks kaedah parse() Segera : 

public static Instant parse(CharSequence text)
Untuk menghuraikan rentetan dan mendapatkan segera, pembangun perlu memastikan rentetan mengandungi beberapa teks. Sekiranya ia batal, anda akan mendapat DateTimeException. Berikut ialah contoh menggunakan Parse Segera dalam 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);
       }
   }
Outputnya ialah:
14-10-2020T10:37:30Z

10. Kaedah parse() NumberFormat

Kelas java.text.NumberFormat digunakan untuk memformat nombor. NumberFormat parse() ialah kaedah lalai kelas ini. Kaedah parse () kelas NumberFormat menukar rentetan kepada nombor. Pembangun menggunakannya untuk memecahkan rentetan kepada nombor komponennya. Penghuraian bermula dari permulaan rentetan. Jika anda memanggil setParseIntegerOnly (true) sebelum memanggil kaedah parse () , seperti yang ditunjukkan dalam contoh berikut, maka hanya bahagian integer nombor itu ditukar. Berikut ialah sintaks NumberFormat parse() : 

public Number parse(String str)
Sebagai parameter, fungsi menerima rentetan. Nilai pulangan penghuraian ialah nilai berangka. Jika rentetan permulaan tidak boleh dihuraikan, anda akan mendapat amaran ParseException. Untuk melihat penggunaan kaedah NumberFormat parse() , lihat contoh di bawah: 

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"));
       }
   }
Outputnya ialah:
3.141592 3

Kesimpulan

Terdapat banyak kaedah penghuraian yang boleh digunakan oleh pembangun untuk menukar rentetan kepada pelbagai jenis data. Walaupun mengingatinya mungkin kelihatan membosankan, pelbagai arahan sedemikian memberikan pembangun banyak kelonggaran dan ketepatan. Pastikan anda berlatih menggunakan penghuraian data untuk memastikan anda mengingati sintaks dan tidak akan melupakan parameter yang penting untuk setiap kaedah.