streamalism.org

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

במאמר זה נדון ב חוּט עיצוב ב- Java באמצעות java.util.Formatter בכיתה, המספקת תמיכה בצידוק וביישור הפריסה.

2. כיצד להשתמש ב- מעצב

זכור את C printf? עיצוב א חוּט בג'אווה מרגיש מאוד דומה.

ה פוּרמָט() שיטת ה- מעצב נחשף באמצעות שיטה סטטית מה- חוּט מעמד. שיטה זו מקבלת תבנית חוּט ורשימת ארגומנטים לאכלוס התבנית:

ברכות מחרוזת = String.format ("שלום אנשים, ברוכים הבאים ל-% s!", "Baeldung");

כתוצאה מכך חוּט הוא:

"שלום אנשים, ברוכים הבאים לבלדונג!"

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

במקרה הזה, יש מפרט פורמט יחיד % s, אשר מוחלף על ידי הטיעון המקביל.

3. פורמט מפרט

3.1. תחביר כללי

התחביר של מפרט הפורמט עבור כללי, אופי, ו מספרי סוג הוא:

המרת% [argument_index $] [דגלים] [רוחב] [. דיוק]

מפרטים argument_index, דגל, רוחב, ו דיוק הם אופציונליים.

• טיעון_אינדקס החלק הוא מספר שלם אני - המציין כי ith יש להשתמש כאן בטיעון מרשימת הטיעונים
• דגלים היא קבוצת תווים המשמשת לשינוי פורמט הפלט
• רוֹחַב הוא מספר שלם חיובי המציין את מספר התווים המינימלי שייכתב לפלט
• דיוק הוא מספר שלם המשמש בדרך כלל להגבלת מספר התווים, שהתנהגותם הספציפית תלויה בהמרה
• הוא החלק המחייב. זהו דמות המציינת כיצד יש לעצב את הטיעון. מערך ההמרות החוקיות עבור טיעון נתון תלוי בסוג הנתונים של הטיעון

בדוגמה שלנו לעיל, אם ברצוננו לציין את מספר הארגומנט במפורש, אנו יכולים לכתוב אותו באמצעות 1$ ו 2$ מדדי טיעון.

שני אלה הם הטיעון הראשון והשני בהתאמה:

ברכות מחרוזת = String.format ("שלום% 2 $ s, ברוך הבא ל-% 1 $ s!", "Baeldung", "אנשים");

3.2. ל תאריך שעה יִצוּג

המרת% [argument_index $] [flags] [רוחב]

שוב ה argument_index, דגלים, ו רוֹחַב הם אופציונליים.

בואו ניקח דוגמה כדי להבין זאת:

@Test הציבור בטל כאשרFormatSpecifierForCalendar_thenGotExpected () {לוח שנה c = גרגוריאני חדש Kalender (2017, 11, 10); מחרוזת s = String.format ("התאריך הוא:% tm% 1 $ te,% 1 $ tY", c); assertEquals ("התאריך הוא: 12 10,2017", s); }

כאן, עבור כל מפרט פורמט, ישמש את הארגומנט הראשון, ומכאן 1$. הנה אם אנו מדלגים על טיעון_אינדקס למפרט פורמט 2 ו -3, הוא מנסה למצוא 3 ארגומנטים, אך עלינו להשתמש באותו ארגומנט עבור כל 3 המפרט פורמטים.

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

ה דֶגֶל כאן מורכב משתי דמויות. איפה שהדמות הראשונה היא תמיד א 'T' אוֹ 'T'. הדמות השנייה תלויה באיזה חלק של לוּחַ שָׁנָה אמור להיות מוצג.

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

3.3. פורמט מפרטי ללא ויכוחים

המרה% [דגלים] [רוחב]

האופציונלי דגלים ו רוֹחַב זהים כהגדרתם בסעיפים לעיל.

הנדרש הֲמָרָה הוא דמות או חוּט המציין תוכן שיש להכניס לפלט. נכון לעכשיו, רק ה ‘%' וקו חדש 'N' ניתן להדפיס באמצעות זה:

@ מבחן ציבורי בטל כאשר NoArguments_thenExpected () {String s = String.format ("ג'ון השיג 90 %% בסמסטר סתיו"); assertEquals ("ג'ון השיג 90% בסמסטר סתיו", s); } 

בְּתוֹך פוּרמָט(), אם אנחנו רוצים להדפיס ‘%' עלינו לברוח ממנו באמצעות ‘%%'.

4. המרות

בואו נתבונן כעת בכל פרט ופרט בתחביר המפרט Format, החל מ- a הֲמָרָה. שים לב שתוכל למצוא את כל הפרטים ב מעצב ג'אוודוקים.

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

בואו נסתכל על כל אחד על ידי דוגמאות.

4.1. כללי

משמש לכל סוג ארגומנט. ההמרות הכלליות הן:

1. 'ב' אוֹ 'ב' - ל בוליאני ערכים
2. 'H' אוֹ 'H' - ל HashCode
3. 'S אוֹ 'ש' - ל חוּט, אם ריק, זה מדפיס "null", אחרת arg.toString ()

ננסה להציג כעת בוליאני ו חוּט ערכים, תוך שימוש בהמרות המתאימות:

@Test ציבורי בטל givenString_whenGeneralConversion_thenConvertedString () {String s = String.format ("התשובה הנכונה היא% s", שקר); assertEquals ("התשובה הנכונה שקרית", s); s = String.format ("התשובה הנכונה היא% b", null); assertEquals ("התשובה הנכונה שקרית", s); s = String.format ("התשובה הנכונה היא% B", נכון); assertEquals ("התשובה הנכונה היא TRUE", s); }

4.2. אופי

משמש לסוגים הבסיסיים המייצגים תווי Unicode: char, אופי, בת, בת, קצר, ו קצר. ניתן להשתמש בהמרה זו גם לסוגים int ו מספר שלם כאשר Character.isValidCodePoint (int) החזרות נָכוֹן בשבילם.

אפשר לכתוב את זה כמו 'ג' אוֹ 'C' על סמך המקרה שאנחנו רוצים.

בואו ננסה להדפיס כמה תווים:

@Test public void givenString_whenCharConversion_thenConvertedString () {String s = String.format ("התשובה הנכונה היא% c", 'a'); assertEquals ("התשובה הנכונה היא a", s); s = String.format ("התשובה הנכונה היא% c", null); assertEquals ("התשובה הנכונה היא null", s); s = String.format ("התשובה הנכונה היא% C", 'b'); assertEquals ("התשובה הנכונה היא B", s); s = String.format ("תו unicode החוקי:% c", 0x0400); assertTrue (Character.isValidCodePoint (0x0400)); assertEquals ("תו unicode התקף: Ѐ", s); }

ניקח דוגמה נוספת לנקודת קוד לא חוקית:

@Test (צפוי = IllegalFormatCodePointException.class) בטל בציבור כאשר IllegalCodePointForConversion_thenError () {String s = String.format ("תו unicode תקף:% c", 0x11FFFF); assertFalse (Character.isValidCodePoint (0x11FFFF)); assertEquals ("תו unicode התקף: Ā", s); }

4.3. מספרי - בלתי נפרד

אלה משמשים לסוגים אינטגרליים של Java: בת, בת, קצר, קצר, אינט ו שלם, ארוך, ארוך, ו ביג-שלם. ישנן שלוש המרות בקטגוריה זו:

1. 'ד' - למספר עשרוני
2. 'או' - למספר אוקטלי
3. 'איקס' אוֹ 'איקס' - למספר הקסדצימלי

בואו ננסה להדפיס כל אחד מאלה:

@ מבחן ציבורי בטל כאשר NumericIntegralConversion_thenConvertedString () {String s = String.format ("המספר 25 בעשרוני =% d", 25); assertEquals ("המספר 25 בעשרוני = 25", s); s = String.format ("המספר 25 באוקטל =% o", 25); assertEquals ("המספר 25 באוקטל = 31", s); s = String.format ("המספר 25 בהקסדצימלי =% x", 25); assertEquals ("המספר 25 בהקסדצימלי = 19", s); }

4.4. מספרי - נקודה צפה

משמש לסוגי נקודות נקודה צפה ב- Java: צף, צף, כפול, כפול, ו BigDecimal

1. 'E' אוֹ 'E' – מעוצב כמספר עשרוני בסימון מדעי ממוחשב
2. 'F' – מעוצב כמספר עשרוני
3. 'G' אוֹ 'G' – בהתבסס על הערך המדויק לאחר העיגול, המרה זו פורמטים לסימון מדעי ממוחשב או לפורמט עשרוני

בואו ננסה להדפיס את מספרי הנקודות הצפות:

@ מבחן ציבורי בטל כאשר NumericFloatingConversion_thenConvertedString () {String s = String.format ("הפורמט המדעי הממוחשב של 10000.00" + "=% e", 10000.00); assertEquals ("הפורמט המדעי הממוחשב של 10000.00 = 1.000000e + 04", s); מחרוזת s2 = String.format ("הפורמט העשרוני של 10.019 =% f", 10.019); assertEquals ("הפורמט העשרוני של 10.019 = 10.019000", s2); }

4.5. המרות אחרות

• תאריך שעה - עבור סוגי Java המסוגלים לקודד תאריך או שעה: ארוך, ארוך, לוח שנה, תַאֲרִיך ו TemporalAccessor. לשם כך עלינו להשתמש בקידומת 'T' אוֹ 'T', כפי שראינו קודם
• אָחוּז - מדפיס מילולית '%' ('\ U0025')
• מפריד קו - מדפיס מפריד קווים ספציפי לפלטפורמה

בואו נסתכל על דוגמה פשוטה:

@Test ציבורי בטל כאשר LineSeparatorConversion_thenConvertedString () {String s = String.format ("קו ראשון% n שניה שורה"); assertEquals ("השורה הראשונה \ n" + "השורה השנייה", s); }

5. דגלים

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

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

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

@ מבחן ציבורי בטל כאשרSpecifyFlag_thenGotFormattedString () {String s = String.format ("ללא דגל מוצדק שמאלה:% 5d", 25); assertEquals ("ללא דגל מוצדק משמאל: 25", s); s = String.format ("עם דגל מוצדק משמאל:% -5d", 25); assertEquals ("עם דגל מוצדק משמאל: 25", s); }

6. דיוק

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

ההצהרה הראשונה היא דוגמה לדיוק במספרי נקודות צפות, והשנייה בהמרות כלליות:

@Test ציבורי בטל כאשרSpecifyPrecision_thenGotExpected () {String s = String.format ("פלט של 25.09878 עם דיוק 2:% .2f", 25.09878); assertEquals ("פלט של 25.09878 עם דיוק 2: 25.10", s); String s2 = String.format ("פלט מסוג המרה כללי עם דיוק 2:% .2b", נכון); assertEquals ("פלט מסוג המרה כללי עם דיוק 2: tr", s2); }

7. אינדקס ויכוחים

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

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

@Test ציבורי בטל כאשרSpecifyArgumentIndex_thenGotExpected () {לוח שנה c = Calendar.getInstance (); מחרוזת s = String.format ("התאריך הוא:% tm% 1 $ te,% 1 $ tY", c); assertEquals ("התאריך הוא: 12 10,2017", s); s = String.format ("התאריך הוא:% tm%<>

8. דרכי שימוש אחרות מעצב

עד עכשיו ראינו את השימוש ב פוּרמָט() שיטת ה- מעצב מעמד. אנחנו יכולים גם ליצור מעצב למשל, והשתמש בזה כדי להפעיל את פוּרמָט() שיטה.

אנו יכולים ליצור מופע על ידי העברת an ניתן לצרף, OutputStream, קוֹבֶץ או שם קובץ. על סמך זה, המעוצב חוּט מאוחסן ב- ניתן לצרף, OutputStream, קוֹבֶץ בהתאמה.

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

8.1. באמצעות מעצב עם ניתן לצרף

בואו ניצור StringBuilder למשל sb, וליצור a מעצב משתמש בזה. ואז נפעיל פוּרמָט() לעצב א חוּט:

@Test הציבור בטל כאשרCreateFormatter_thenFormatterWithAppendable () {StringBuilder sb = StringBuilder חדש (); מעצב מעצב = מעצב חדש (sb); formatter.format ("אני כותב למופע% s.", sb.getClass ()); assertEquals ("אני כותב למעמד java.lang.StringBuilder Instance.", sb.toString ()); }

9. מסקנה

במאמר זה ראינו את מתקני העיצוב שמספק ה- java.util.Formatter מעמד. ראינו תחביר שונים שבעזרתם ניתן לעצב את ה- חוּט וסוגי ההמרות בהם ניתן להשתמש עבור סוגי נתונים שונים.

כרגיל, ניתן למצוא את הקוד לדוגמאות שראינו ב- Github.