11 שיטות parse() ב-Java עם דוגמאות

ניתוח במובן הכללי ביותר שלו הוא חילוץ המידע הדרוש מפיסת נתונים כלשהי, לרוב נתונים טקסטואליים. מה זה ניתוח ב-Java? ישנן מחלקות Java רבות שיש להן את שיטת parse() . בדרך כלל השיטה parse() מקבלת מחרוזת כלשהי כקלט, "מחלצת" ממנה את המידע הדרוש וממירה אותו לאובייקט של המחלקה הקוראת. לדוגמה, הוא קיבל מחרוזת והחזיר את התאריך ש"הסתתר" במחרוזת הזו. בפוסט זה, אנו הולכים להסתכל על 10 הווריאציות השימושיות של parse() .

0. parseInt()

נתחיל מאחת משיטות parse() הפופולריות ביותר , כלומר לא בדיוק parse() , אלא parseInt() . שיטת Java parseInt () משמשת כדי לקבל את סוג הנתונים הפרימיטיביים ממחרוזת ספציפית. במילים אחרות הוא ממיר מחרוזת למספר. parseInt () יכול לכלול ארגומנט אחד או שניים. הנה התחביר של parseInt() :

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

כאשר s הוא המחרוזת המייצגת ערך עשרוני בסימן ורדיוס הבסיס של מערכת מספרית. זכור שאין ערך בסיס ברירת מחדל - עליך להזין אחד בטווח של 2 ו-36. הנה דוגמה. כיצד לנתח עם 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));

       }
   }

הפלט הוא:

1. שיטת period parse()

Period הוא מחלקה של Java למודל של כמות זמן במונחים של שנים, חודשים וימים כגון "3 שנים, 5 חודשים ויומיים". יש לו שיטת parse() להשגת נקודה מטקסט. הנה התחביר של period parse()

public static Period parse(CharSequence text)

CharSequence הוא ממשק, המיושם על ידי Strings. אז אתה יכול להשתמש ב-Strings כרכיב טקסט בשיטת parse() . בטוח שהמחרוזת צריכה להיות בפורמט מתאים כדי להחזיר אובייקט של מחלקה Period. פורמט זה הוא PnYnMnD . כאשר Y מייצג "שנה", M - עבור "חודש", D - עבור "יום". N הוא מספר המתאים לכל ערך תקופה.

• לשיטה יש פרמטר אחד - ערך טקסט.
• Parse() מחזיר ערך Period שבו הערך של מחרוזת הופך לפרמטר.
• כחריג, period parse() יכול להחזיר את DateTimeParseException אם ערך המחרוזת אינו עונה למבנה של תקופה.

הנה דוגמה לשימוש ב-Period parse() בהקשר של העולם האמיתי:

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

הפלט הוא:

שיטת 2.SimpleDateFormat Parse()

SimpleDateFormat היא מחלקה המשמשת לעיצוב וניתוח תאריכים באופן רגיש לאזור. השיטה SimpleDateFormat parse() מפרקת מחרוזת לאסימוני תאריך ומחזירה ערך Data בפורמט המתאים. השיטה מתחילה לנתח את המחרוזת באינדקס, שהוגדר על ידי מפתח. זהו התחביר של ה- SimpleDateFormat parse() :

public Date parse(String the_text, ParsePosition position)

לשיטה שני פרמטרים:

• מיקום: הנתונים באינדקס ההתחלתי שהוא תמיד סוג האובייקט ParsePosition.
• the_text: מגדיר את המחרוזת שהמתודה תנתח והיא ערך מסוג String.

אתה יכול להשתמש בשיטה זו ללא הצהרת עמדה. במקרה זה הנתונים מתחילים ממדד אפס. SimpleDateFormat parse() מחזירה תאריך או ערך null (במקרה שהמחרוזת לא עובדה עקב שגיאה). הנה דוגמה ליישום 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);
   }
}

הפלט הוא: האחרון הוא ריק מכיוון שאין דפוס תאריך החל מהמיקום החמישי. אגב, אם תנסה לנתח את ה-date5 ללא מיקום כגון Date date5 = simpleDateFormat2.parse(myString) , תקבל חריגה:

3. שיטת LocalDate parse()

LocalDate הוא מחלקה שהופיעה ב-Java 8 כדי לייצג תאריך כמו שנה-חודש-יום (ניתן לגשת גם ליום בשנה, ביום בשבוע ושבוע בשנה). LocalDate אינו מייצג זמן או אזור זמן. לשיטת LocalDate parse() יש שתי גרסאות. שניהם עוזרים להמיר מחרוזת ל-Java 8 date API חדש - java.time.LocalDate .

ניתוח (טקסט CharSequence, DateTimeFormatter, פורמט)

שיטה זו מנתחת מחרוזת באמצעות פורמט ספציפי כדי להשיג מופע של LocalDate. להלן התחביר של השיטה:

public static LocalTime parse(CharSequence text,
                              DateTimeFormatter formatter)

ישנם שני פרמטרים לשיטה - הטקסט שינתח והפורמט שהמפתח יחיל. כערך החזרה, השיטה מחזירה אובייקט LocalTime שיזוהה כשעון היום המקומי. אם ערך הטקסט לא הצליח לעבור ניתוח, המערכת זורקת את DayTimeParseException. בוא נקבל דוגמה של קוד לשימוש ב-LocalDate parse() עם שני פרמטרים:

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

הפלט הוא: לשיטת LocalDate parse() עם פרמטר אחד יש את התחביר הבא:

public static LocalTime parse(CharSequence text)

שיטה זו אינה דורשת ציון פורמט. לאחר שמפתח יזין את ערכי המחרוזת בסוגריים, המערכת תשתמש אוטומטית ב-DateTimeFormatter.ISO_LOCAL_DATE. לשיטה זו יש פרמטר בודד - טקסט CharSequence. אתה יכול להשתמש כאן בערך המחרוזת. ודא שהוא לא ריק ומכבד את המבנה של הפורמט. אם אין דרך לנתח מחרוזת, מפתח מקבל את התראת DateTimeExceptionAlert. הנה דוגמה ליישום 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);
       }
   }

הפלט הוא:

4. שיטת LocalDateTime parse()

LocalDateTime אובייקט תאריך-שעה המייצג תאריך-שעה הנצפה לעתים קרובות למדי כשנה-חודש-יום-שעה-דקה-שנייה. מפתחים יכולים גם להשתמש בשדות תאריך ושעה אחרים (יום בשנה, יום בשבוע ושבוע בשנה). מחלקה זו אינה ניתנת לשינוי. הזמן מיוצג לפי דיוק ננו-שניות. לדוגמה, אתה יכול לאחסן את הערך "17 בנובמבר 2020 בשעה 13:30.30.123456789" ב-LocalDateTime. מחלקה זו לא עוסקת בייצוג אזור זמן. זהו ייצוג סטנדרטי של תאריך בתוספת זמן מקומי. שיטת LocalDateTime parse() מיוצגת בשתי גרסאות:

• static LocalDateTime parse(CharSequence text) מחזיר מופע של LocalDateTime ממחרוזת טקסט כגון 2007-12-03T10:15:30.
• סטטי LocalDateTime parse(CharSequence text, DateTimeFormatter formatter) מחזיר מופע של LocalDateTime ממחרוזת טקסט באמצעות מעצב ספציפי.

הנה דוגמה לשיטת 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);
       }
   }

הפלט הוא:

5. שיטת ZonedDateTime parse()

Class ZonedDateTime מייצג תאריך-שעה עם אזור זמן. מחלקה זו אינה ניתנת לשינוי. הוא מאחסן שדות תאריך ושעה בדיוק של ננו-שניות, ואזור זמן, עם היסט אזור המשמש לטיפול בשעות תאריך-שעות מקומיות מעורפלות. אז אם אתה צריך לשמור ערך כגון "14 באוקטובר 2020 בשעה 17:50.30.123456789 +02:00 באזור הזמן של אירופה/פריז", אתה יכול להשתמש ב- ZonedDateTime. המחלקה משמשת לעתים קרובות כדי לתפעל נתונים מבוססי זמן מקומיים. ZondeDateTime parse() הוא מנתח שמפרק את המחרוזת לאסימונים במערכת ISO-8061. הנה דוגמה לערך שתקבל לאחר ניתוח: הוא משמש בכל פעם שיש צורך בנתונים בעלי דיוק גבוה (אחרי הכל, הנתונים שאתה מקבל הם מדויקים עד ננו-שניות). המחלקה משמשת לעתים קרובות כדי לתפעל נתונים מבוססי זמן מקומיים. בואו נסתכל על התחביר הכללי של שיטת ה-Parse() ZonedDateTime שמפתחים משתמשים כדי להמיר ערכי מחרוזת למחלקה ZonedDateTime.

public static ZonedDateTime parse(CharSequence text)

הפרמטר היחיד שהשיטה משתמשת בו הוא טקסט מחרוזת. כערך החזרה, תקבל אחד או סדרה של אובייקטים בפורמט ZonedDateTime. אם יש שגיאה במהלך הניתוח או שזה בלתי אפשרי, מלכתחילה, השיטה מחזירה DateTimeParseException. כמו כן, יש שיטת parse() עם שני משתנים.

public static ZonedDateTime parse(CharSequence text, DateFormatter formatter)

שיטה זו משיגה מופע של ZonedDateTime מערך טקסט באמצעות מעצב ספציפי. השיטה עם פרמטר אחד, הפורמט DateTimeFormatter.ISO_LOCAL_TIME משמשת כברירת מחדל. בואו נסתכל על מקרה השימוש של 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);
   }
}

הפלט הוא:

6. שיטת LocalTime parse()

Class LocalTime מייצג זמן, הנראה לרוב כשעה-דקה-שנייה. מחלקה זו גם ניתנת לשינוי, כגון ZonedDateTime.Time מיוצג לפי דיוק ננו-שניות. לדוגמה, ניתן לאחסן את הערך "13:45.30.123456789" ב-LocalTime. ישנן שתי שיטות LocalTime parse() עם פרמטר אחד ושני. בואו נסתכל על שניהם:

public static LocalTime parse(CharSequence text)

אתה יכול להשתמש ב-LocalTime parse() עם פרמטר אחד בלבד, המחרוזת שברצונך לנתח. במקרה זה, הפורמט DateTimeFormatter.ISO_LOCAL_TIME משמש כברירת מחדל.

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

הוא משיג מופע של LocalTime מערך טקסט באמצעות עיצוב ספציפי. שתי השיטות מחזירות ערך LocalTime בפורמט hh/mm/ss. היזהרו מהתראות DateTimeParceException. המשמעות היא שהפורמט של טקסט המחרוזת אינו תואם את זה של אובייקטי LocalTime. הנה דוגמה לשימוש ב- 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. שיטת MessageFormat Parse()

MessageFormat מרחיב את המחלקה Format. פורמט הוא מחלקת בסיס מופשטת לעיצוב נתונים רגישים לאזור (תאריכים, הודעות ומספרים). MessageFormat מקבל כמה אובייקטים ומעצב אותם. לאחר מכן הוא מכניס את המחרוזות המעוצבות לתבנית במקומות המתאימים. ה- MessageFormat parse() משמש כדי לקבל ערך מחרוזת אם נתון לתחילת האינדקס. להלן התחביר הכללי של השיטה:

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

כאשר המקור הוא מחרוזת לניתוח ומיקום הוא האינדקס ההתחלתי של הניתוח. הנה דוגמה לשיטת 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. השיטה Level parse()

כאשר מתכנת משתמש ב-Logger כדי לרשום הודעה, הוא נרשם ברמת יומן מסוימת. ישנן שבע רמות יומן מובנות:

• חָמוּר
• אַזהָרָה
• מידע
• CONFIG
• בסדר גמור
• FINER
• הכי טוב

כמו כן, ישנן רמות נוספות OFF שניתן להשתמש בהן כדי לכבות את הרישום ו-ALL שניתן להשתמש בהן כדי לאפשר רישום של כל ההודעות. רמת היומן מיוצגת על ידי המחלקה java.util.logging.Level . מחלקה ברמה מכילה קבוע עבור כל אחת משבע הרמות הללו. אז אתה משתמש באחד מהקבועים האלה, כולל הכל ו-OFF בזמן רישום הודעה ל-logger. כמו כן, כל הרמות הללו אוחלו לכמה מספרים שלמים. לדוגמה FINE מאותחל ל-500. השיטה Level parse() מנתחת מידע הדרוש מערך טקסט ומחזירה אובייקט Level. הנה התחביר של שיטת level parse() :

public static Level parse(String name)

הפרמטר של שיטה הוא שם של מחרוזת שמפתח רוצה לנתח. זה יכול להיות שם של הרמה, השם המאתחל שלה או מספר שלם אחר. בתמורה, מתכנת מקבל ערך שם Level, המתאים לזה של המחרוזת הראשונית. במקרה שהארגומנט מכיל סמלים שאי אפשר לנתח, המערכת תזרוק את IllegalArgumentException. אם מחרוזת אינה מכילה ערכים, מפתח מקבל NullPointerException. הנה קטע קוד שמראה את היישום של 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());
   }
}

הפלט הוא:

9. שיטת parse() מיידי

מחלקה מיידית מדגמנת נקודה מיידית אחת על ציר הזמן. אתה יכול להשתמש בו להקלטת חותמות זמן של אירועים באפליקציה שלך. Instant parse() מקבל ערך מיידי מערך טקסט. המחרוזת תישמר מאוחר יותר כערך אזור זמן UTC. המערכת משתמשת ב-DateTimeFormatter.ISO_INSTANT כגון 2020-10-14T11:28:15.00Z. הנה תחביר של שיטת Instant parse() :

public static Instant parse(CharSequence text)

כדי לנתח מחרוזת ולקבל מיידיות, מפתח צריך לוודא שהמחרוזת מכילה טקסט כלשהו. במקרה שהוא ריק, תקבל DateTimeException. הנה דוגמה לשימוש בניתוח מיידי ב-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);
       }
   }

הפלט הוא:

10. שיטת NumberFormat parse()

המחלקה java.text.NumberFormat משמשת לעיצוב מספרים. NumberFormat parse() היא שיטת ברירת מחדל של מחלקה זו. שיטת הניתוח () של המחלקה NumberFormat ממירה מחרוזת למספר. מפתחים משתמשים בו כדי לפרק מחרוזת למספרי הרכיבים שלה. הניתוח מתחיל מתחילת המחרוזת. אם אתה קורא ל-setParseIntegerOnly (true) לפני הקריאה לשיטת ה- parse () , כפי שמוצג בדוגמה הבאה, אז רק החלק השלם של המספר יומר. הנה התחביר של NumberFormat parse() :

public Number parse(String str)

כפרמטר, הפונקציה מקבלת מחרוזות. ערך החזרה של הניתוח הוא ערך מספרי. אם לא ניתן לנתח מחרוזת התחלה, תקבל אזהרת ParseException. כדי לראות את היישום של שיטת NumberFormat parse() תסתכל על הדוגמה שלהלן:

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

הפלט הוא:

סיכום

יש הרבה שיטות ניתוח שמפתחים יכולים להשתמש כדי להמיר מחרוזות לסוגי נתונים שונים. למרות שהזכירתם עשויה להיראות מייגעת, מגוון כזה של פקודות מעניק למפתחים הרבה גמישות ודיוק. הקפד לתרגל שימוש בניתוח נתונים כדי לוודא שאתה זוכר את התחביר ולא תשכח אילו פרמטרים חיוניים לכל שיטה.