streamalism.org

1. סקירה כללית

בעת המרת Java חוּט אל א לְהַכפִּיל, בדרך כלל נשתמש ב- Double.parseDouble (ערך מחרוזת) שיטה. שיטה זו מאפשרת לנו להמיר a חוּט ייצוג של נתון לְהַכפִּיל - למשל, "2.0" - לפרימיטיבי לְהַכפִּיל ערך.

כמו ברוב שיחות השיטה, כדאי להימנע מלהעביר א ריק התייחסות, אשר ככל הנראה תביא ל- NullPointerException בזמן ריצה.

במדריך זה נבדוק מספר דרכים בהן אנו יכולים לבדוק ריק לפני הפעלת Double.parseDouble. נתחיל בבחינת פתרונות באמצעות Java הליבה לפני שנבדוק כמה ספריות חיצוניות.

2. למה לבדוק

ראשית, בואו נבין מה קורה אם לא נבדוק ריק ערכים בעת ניתוח Sטרינג. נתחיל בהעברת ריק חוּט:

double blankString = Double.parseDouble ("");

כאשר אנו מריצים את הקוד הזה, הוא יזרוק א java.lang.NumberFormatException:

חריג בשרשור "ראשי" java.lang.NumberFormatException: ריק מחרוזת בשמש.misc.FloatingDecimal.readJavaFormatString (FloatingDecimal.java:1842) ב- sun.misc.FloatingDecimal.parseDouble (FloatingDecimal.java:110) ב- java.lang.Double .parseDouble (Double.java:538) ...

בואו נשקול לעבור א ריק התייחסות:

כפול nullString = Double.parseDouble (null);

באופן לא מפתיע, א java.lang.NullPointerException יושלך הפעם:

חריג בשרשור "ראשי" java.lang.NullPointerException ב- sun.misc.FloatingDecimal.readJavaFormatString (FloatingDecimal.java:1838) ב sun.misc.FloatingDecimal.parseDouble (FloatingDecimal.java:110) ב- java.lang.Double.parseDouble ( Double.java:538) ...

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

3. כיצד לבדוק עם ליבת Java

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

3.1. באמצעות וניל ג'אווה

נתחיל בהגדרת שיטה פשוטה שתבדוק אם הערך שאנו מעבירים הוא ריק או ריק חוּט:

parse static double parseStringToDouble (ערך מחרוזת) 

כפי שאנו רואים, אם הערך שאנו מנסים לנתח הוא ריק או לרוקן שיטה זו לא מחזירה מספר. אחרת, אנו קוראים את Double.parseDouble שיטה.

אנו יכולים לקחת דוגמה זו צעד קדימה ולהציע אפשרות לספק ברירת מחדל מוגדרת מראש:

פרטית כפולה סטטית parseStringToDouble (ערך מחרוזת, ערך כפול default) ערך החזרה == null 

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

assertThat (parseStringToDouble ("1", 2.0d). isEqualTo (1.0d); assertThat (parseStringToDouble (null, 1.0d)). isEqualTo (1.0d); assertThat (parseStringToDouble ("", 1.0d)). isEqualTo (1.0d);

3.2. באמצעות אופציונאלי

עכשיו בואו נסתכל על פיתרון אחר עם ה- שימוש ב אופציונאלי:

פרטית סטטית פרטית אופציונלית parseStringToOptionalDouble (ערך מחרוזת) value.isEmpty ()? Optional.empty (): Optional.of (Double.valueOf (value)); 

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

parseStringToOptionalDouble ("2"). isPresent ()

אנו יכולים גם להחזיר ערך ברירת מחדל באמצעות ה- אחרת שיטה של אופציונאלי:

parseStringToOptionalDouble ("1.0"). orElse (2.0d) parseStringToOptionalDouble (null) .orElse (2.0d) parseStringToOptionalDouble (""). orElse (2.0d)

4. ספריות חיצוניות

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

4.1. גויאבה של גוגל

הפיתרון החיצוני הראשון שעליו נבחן הוא גוגל גויאבה, אשר זמין ב- Maven Central:

 com.google.guava גויאבה 28.2-jre 

אנחנו יכולים פשוט להשתמש ב- Doubles.tryParse שיטה:

Doubles.tryParse (MoreObjects.firstNonNull ("1.0", "2.0")) Doubles.tryParse (MoreObjects.firstNonNull (null, "2.0"))

בדוגמה זו אנו משתמשים גם ב- MoreObjects.firstNonNull שיטה, שתחזיר את הפרמטרים הראשונים מבין שניים שאינם ריק.

קוד זה יעבוד בסדר ברוב המקרים, אך בואו נדמיין דוגמא אחרת:

Doubles.tryParse (MoreObjects.firstNonNull ("", "2.0"))

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

4.2. אפאצ'י קומונס לאנג NumberUtils

ה NumberUtils class מספק כלי עזר שימושיים רבים שמקלים על העבודה עם מספרים.

חפץ Apache Commons Lang זמין ממייבן סנטרל:

 org.apache.commons commons-lang3 3.9 

אז אנחנו יכולים פשוט להשתמש בשיטה להכפיל מ NumberUtils:

NumberUtils.toDouble ("1.0") NumberUtils.toDouble ("1.0", 1.0d) 

הנה, יש לנו שתי אפשרויות:

• המר א חוּט אל א לְהַכפִּיל, חוזר 0.0d אם ההמרה נכשלת
• המר א חוּט אל א לְהַכפִּיל, מתן ערך ברירת מחדל מוגדר אם ההמרה נכשלת

אם נעבור ריק או ריק ערך, 0.0d מוחזר כברירת מחדל:

assertThat (NumberUtils.toDouble ("")). isEqualTo (0.0d); assertThat (NumberUtils.toDouble (null)). isEqualTo (0.0d);

זה טוב יותר מהדוגמה הקודמת, שכן תמיד נקבל לְהַכפִּיל ערך החזר לא משנה מה יקרה במהלך ההמרה.

4.3. Vavr

אחרון חביב, בואו נסתכל על vavr.io, המציע גישה פונקציונלית.

כמו תמיד, ניתן למצוא את החפץ במרכז מייבן:

 io.vavr vavr 0.10.2 

שוב נגדיר שיטה פשוטה המשתמשת ב- vavr לְנַסוֹת מעמד:

פעמיים סטטיים פעמיים tryStringToDouble (ערך מחרוזת, ערך כפול default) {החזר Try.of (() -> Double.parseDouble (ערך)). getOrElse (defaultValue); } 

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

assertThat (tryStringToDouble ("1", 2.0d)). isEqualTo (1.0d); assertThat (tryStringToDouble (null, 2.0d)). isEqualTo (2.0d); assertThat (tryStringToDouble ("", 2.0d)). isEqualTo (2.0d);

5. מסקנה

במדריך מהיר זה בדקנו כמה דרכים לבדוק ריק ומיתרים ריקים לפני הפעלת ה- Double.parseDouble שיטה.

כמו תמיד, קוד המקור המלא של המאמר זמין באתר GitHub.