streamalism.org

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

ספריית Apache Commons Lang 3 היא חבילה פופולרית ומלאה של שיעורי שירות, שמטרתה להרחיב את הפונקציונליות של ה- API של Java.

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

במדריך זה, נצלול עמוק בשיעורי השירות השימושיים ביותר בספרייה.

2. התלות של Maven

כרגיל, כדי להתחיל להשתמש ב- Apache Commons Lang 3, ראשית עלינו להוסיף את התלות של Maven:

 org.apache.commons commons-lang3 3.8 

3. ה StringUtils מעמד

מחלקת השירות הראשונה שעליה נסקור בסיכום היכרות זה היא StringUtils.

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

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

@Test הציבור בטל כאשר CalledisBlank_thenCorrect () {assertThat (StringUtils.isBlank ("")). IsTrue (); } @Test ציבורי בטל כאשר CalledisEmpty_thenCorrect () {assertThat (StringUtils.isEmpty ("")). IsTrue (); } @Test ציבורי בטל כאשר CalledisAllLowerCase_thenCorrect () {assertThat (StringUtils.isAllLowerCase ("abd")). IsTrue (); } @Test ציבורי בטל כאשר CallDisAllUpperCase_thenCorrect () {assertThat (StringUtils.isAllUpperCase ("ABC")). IsTrue (); } @Test ציבורי בטל כאשר CalledisMixedCase_thenCorrect () {assertThat (StringUtils.isMixedCase ("abC")). IsTrue (); } @Test ציבורי בטל כאשר CalledisAlpha_thenCorrect () {assertThat (StringUtils.isAlpha ("abc")). IsTrue (); } @Test ציבורי בטל כאשר CalledisAlphanumeric_thenCorrect () {assertThat (StringUtils.isAlphanumeric ("abc123")). IsTrue (); } 

כמובן, ה StringUtils מחלקה מיישמת שיטות רבות אחרות, שהשמטנו כאן לשם הפשטות.

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

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

4. ה ArrayUtils מעמד

ה ArrayUtils class מיישם קבוצה של שיטות שימוש המאפשרות לנו לעבד ולבדוק מערכים בצורות וצורות רבות ושונות.

נתחיל משני היישומים העמוסים של toString () שיטה, המחזירה א חוּט ייצוג הנתון מַעֲרָך וספציפי חוּט כאשר מַעֲרָך הוא אפס:

@ מבחן ציבורי בטל כאשר נקרא String_thenCorrect () {String [] array = {"a", "b", "c"}; assertThat (ArrayUtils.toString (array)) .isEqualTo ("{a, b, c}"); } @Test הציבור בטל כאשר CalledtoStringIfArrayisNull_thenCorrect () {assertThat (ArrayUtils.toString (null, "Array is null")) .isEqualTo ("Array is null"); } 

לאחר מכן, יש לנו את hasCode () ו למפות() שיטות.

הראשון מייצר יישום hashCode מותאם אישית עבור מַעֲרָך, ואילו האחרון ממיר מַעֲרָך אל א מַפָּה:

@ מבחן פומבי בטל כאשר CalledhashCode_thenCorrect () {String [] array = {"a", "b", "c"}; assertThat (ArrayUtils.hashCode (מערך)) .isEqualTo (997619); } @Test ציבורי בטל כאשר קוראים למפה_אתקראקט () {String [] [] array = {{"1", "one",}, {"2", "two",}, {"3", "three"}}; מפת מפה = HashMap חדש (); map.put ("1", "one"); map.put ("2", "שניים"); map.put ("3", "שלוש"); assertThat (ArrayUtils.toMap (מערך)) .isEqualTo (מפה); }

לבסוף, בואו נסתכל על ה- isSameLength () ו אינדקס של() שיטות.

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

@ מבחן ציבורי בטל whenCalledisSameLength_thenCorrect () {int [] array1 = {1, 2, 3}; int [] מערך 2 = {1, 2, 3}; assertThat (ArrayUtils.isSameLength (array1, array2)) .isTrue (); } @Test ציבורי בטל whenCalledIndexOf_thenCorrect () {int [] array = {1, 2, 3}; assertThat (ArrayUtils.indexOf (מערך, 1, 0)) .isEqualTo (0); } 

כמו עם StringUtils מעמד, ArrayUtils ליישם הרבה יותר שיטות נוספות. תוכלו ללמוד עוד עליהם במדריך זה.

במקרה זה, הצגנו רק את המייצגים ביותר.

5. ה NumberUtils מעמד

מרכיב מרכזי נוסף של Apache Commons Lang 3 הוא מחלקת NumberUtils.

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

בואו נסתכל על היישומים העמוסים של ה- לְהַשְׁווֹת() שיטה, המשווה את השוויון בין פרימיטיבים שונים, כגון int ו ארוך:

@ מבחן פומבי בטל כאשר CalledcompareWithIntegers_thenCorrect () {assertThat (NumberUtils.compare (1, 1)) .isEqualTo (0); } @Test הציבור בטל כאשר CalledcompareWithLongs_thenCorrect () {assertThat (NumberUtils.compare (1L, 1L)) .isEqualTo (0); }

בנוסף, קיימות יישומים של לְהַשְׁווֹת() שפועלים בתים ו קצר, שעובדים דומים מאוד לדוגמאות לעיל.

הבאים בסקירה זו הם createNumber () ו isDigit () שיטות.

הראשון מאפשר לנו ליצור ייצוג מספרי של a חוּט, ואילו השנייה בודקת אם א חוּט מורכב רק מספרים:

@Test הציבור בטל כאשר CalledcreateNumber_thenCorrect () {assertThat (NumberUtils.createNumber ("123456")) .isEqualTo (123456); } @Test הציבור בטל כאשר CallDisDigits_thenCorrect () {assertThat (NumberUtils.isDigits ("123456")). IsTrue (); } 

כשמדובר במציאת התמהיל והערכים המקסימליים של מערך מסופק, ה- NumberUtils class מספק תמיכה חזקה בפעולות אלה באמצעות יישומים עמוסים מדי של דקה () ו מקסימום () שיטות:

@ מבחן ציבורי בטל כאשר CalledmaxwithIntegerArray_thenCorrect () {int [] array = {1, 2, 3, 4, 5, 6}; assertThat (NumberUtils.max (array)) .isEqualTo (6); } @Test הציבור בטל כאשר CalledminwithIntegerArray_thenCorrect () {int [] array = {1, 2, 3, 4, 5, 6}; assertThat (NumberUtils.min (array)). isEqualTo (1); } @Test הציבור בטל כאשר CalledminwithByteArray_thenCorrect () {byte [] array = {1, 2, 3, 4, 5, 6}; assertThat (NumberUtils.min (array)) .isEqualTo ((byte) 1); }

6. ה שבריר מעמד

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

ה שבריר מחלקה עושה הוספת, חיסור והכפלת שברים בבריזה:

@ מבחן ציבורי בטל כאשר CalledgetFraction_thenCorrect () {assertThat (Fraction.getFraction (5, 6)). IsInstanceOf (Fraction.class); } @Test הציבור בטל givenTwoFractionInstances_whenCalledadd_thenCorrect () {Fraction fraction1 = Fraction.getFraction (1, 4); שבר שבר 2 = Fraction.getFraction (3, 4); assertThat (fraction1.add (fraction2) .toString ()). isEqualTo ("1/1"); } @Test הציבור בטל givenTwoFractionInstances_whenCalledsubstract_thenCorrect () {Fraction fraction1 = Fraction.getFraction (3, 4); שבר שבר 2 = Fraction.getFraction (1, 4); assertThat (fraction1.subtract (fraction2) .toString ()). isEqualTo ("1/2"); } @Test public void givenTwoFractionInstances_whenCalledmultiply_thenCorrect () {Fraction fraction1 = Fraction.getFraction (3, 4); שבר שבר 2 = Fraction.getFraction (1, 4); assertThat (fraction1.multiplyBy (fraction2) .toString ()). isEqualTo ("3/16"); }

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

7. ה SystemUtils מעמד

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

Apache Commons Lang 3 מספק את מחלקת SystemUtils על כך שהושג זאת בדרך ללא כאבים.

בואו ניקח בחשבון, למשל, את getJavaHome (), getUserHome () ו isJavaVersionAtLeast () שיטות:

@Test ציבורי בטל כאשר CalledgetJavaHome_thenCorrect () {assertThat (SystemUtils.getJavaHome ()) .isEqualTo (קובץ חדש ("path / to / java / jdk")); } @Test ציבורי בטל כאשר CalledgetUserHome_thenCorrect () {assertThat (SystemUtils.getUserHome ()) .isEqualTo (קובץ חדש ("path / to / user / home")); } @Test ציבורי בטל כאשר CalledisJavaVersionAtLeast_thenCorrect () {assertThat (SystemUtils.isJavaVersionAtLeast (JavaVersion.JAVA_RECENT)). IsTrue (); }

ישנן מספר שיטות שימושיות נוספות ש- SystemUtils כלי כיתה. השמטנו אותם כדי לשמור על הדוגמאות קצרות.

8. שיעורי האתחול והבנייה העצלנים

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

למשל, נניח שיצרנו מחיר יקר מִשׁתַמֵשׁ בכיתה (לא מוצג בקיצור), ורוצים לדחות את האינסטימציה שלו עד שזה באמת נחוץ.

במקרה כזה, כל שעלינו לעשות הוא להרחיב את מחלקת האבסטרקט המופשטת LazyInitializer ולדרוס את לְאַתחֵל() שיטה:

מחלקה ציבורית UserInitializer מרחיב את LazyInitializer {@Override מוגן משתמש מאותחל () {להחזיר משתמש חדש ("John", "[email protected]"); }}

עכשיו, אם אנחנו רוצים לקבל את היקר שלנו מִשׁתַמֵשׁ כאשר זה נדרש, אנחנו פשוט קוראים UserInitializer מקבל () שיטה:

@Test ציבורי בטל כאשר Calledget_thenCorrect () זורק ConcurrentException {UserInitializer userInitializer = UserInitializer חדש (); assertThat (userInitializer.get ()). isInstanceOf (User.class); }

ה לקבל() השיטה היא יישום של המילוי של בדיקה כפולה (בטוח לשרשור) עבור שדה מופע, כמפורט ב "ג'אווה יעילה" של ג'ושוע בלוך, פריט 71:

מופע משתמש נדיף פרטי; המשתמש מקבל () {if (מופע == null) {מסונכרן (זה) {if (מופע == null) מופע = משתמש חדש ("ג'ון", "[דוא"ל מוגן]"); }}} להחזיר מופע; }

בנוסף, Apache Commons Lang 3 מיישם את מחלקת HashCodeBuilder, המאפשרת לנו ליצור hashCode () יישומים על ידי אספקת פרמטרים שונים לבונה, בהתבסס על ממשק API שוטף טיפוסי:

@ מבחן ציבורי בטל כאשר קוראים ל- HashCode_thenCorrect () {int hashcode = חדש HashCodeBuilder (17, 37) .append ("John") .append ("[email protected]") .toHashCode (); assertThat (hashcode) .isEqualTo (1269178828); }

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

@Test ציבורי בטל כאשר CallBuilder_thenCorrect () {BasicThreadFactory מפעל = חדש BasicThreadFactory.Builder () .namingPattern ("עובד- thread%%"). Daemon (נכון) .priority (Thread.MAX_PRIORITY). בניין (); assertThat (מפעל) .isInstanceOf (BasicThreadFactory.class); }

9. ה ConstructorUtils מעמד

השתקפות הוא אזרח ממדרגה ראשונה באפצ'י קומונס לאנג 3.

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

לדוגמה, בואו נגיד שהטמענו נאיבי מִשׁתַמֵשׁ מחלקת תחום:

מחלקה ציבורית משתמש {שם פרטי מחרוזת; דוא"ל מחרוזת פרטי; // קונסטרוקציות סטנדרטיות / גטרים / סטרים / toString}

בהנחה שהבנאי הפרמטריאלי שלו הוא פּוּמְבֵּיאנו יכולים לגשת אליו בקלות באמצעות ה- ConstructorUtils מעמד:

@ מבחן ציבורי בטל כאשר CalledgetAccessibleConstructor_thenCorrect () {assertThat (ConstructorUtils .getAccessibleConstructor (User.class, String.class, String.class)) .isInstanceOf (Constructor.class); } 

לחלופין לייצוב כיתתי רגיל באמצעות קונסטרוקטורים, אנו יכולים ליצור באופן רפלקטיבי מִשׁתַמֵשׁ מקרים פשוט על ידי התקשרות ל invokeConstructor () ו הפעל את ExactConstructor () שיטות:

@ מבחן ציבורי בטל כאשר CalledinvokeConstructor_thenCorrect () זורק חריג {assertThat (ConstructorUtils.invokeConstructor (User.class, "name", "email")) .isInstanceOf (User.class); } @Test ציבורי בטל כאשר CalledinvokeExactConstructor_thenCorrect () זורק Exception {String [] args = {"name", "email"}; Class [] parameterTypes = {String.class, String.class}; assertThat (ConstructorUtils.invokeExactConstructor (User.class, args, parameterTypes)) .isInstanceOf (User.class); } 

10. ה FieldUtils מעמד

בדומה לכך, אנחנו יכולים להשתמש בשיטות של FieldUtils כיתה לקריאה / כתיבה רפלקטיבית של שדות כיתות.

בואו נניח שאנחנו רוצים להשיג שדה של מִשׁתַמֵשׁ בכיתה, או בסופו של דבר תחום שהכיתה יורשת ממעמד-על.

במקרה כזה, אנו יכולים להפעיל את getField () שיטה:

@ מבחן ציבורי בטל כאשר CalledgetField_thenCorrect () {assertThat (FieldUtils.getField (User.class, "name", true) .getName ()) .isEqualTo ("name"); } 

לחלופין, אם נרצה להשתמש בהיקף השתקפות מגביל יותר, ורק לקבל שדה שהוכרז ב מִשׁתַמֵשׁ בכיתה, ולא בירושה ממעמד-עלפשוט היינו משתמשים ב- getDeclaredField () שיטה:

@ מבחן ציבורי בטל כאשר CallTgetDeclaredFieldForceAccess_thenCorrect () {assertThat (FieldUtils.getDeclaredField (User.class, "name", true) .getName ()) .isEqualTo ("name"); }

בנוסף, אנו יכולים להשתמש ב- getAllFields () שיטה להשגת מספר השדות של המחלקה המשתקפת, וכתיבת ערך לשדה מוצהר או לשדה המוגדר בהיררכיה עם writeField () ו writeDeclaredField () שיטות:

@Test הציבור בטל כאשר CalledgetAllFields_thenCorrect () {assertThat (FieldUtils.getAllFields (User.class) .length) .isEqualTo (2); } @Test ציבורי בטל כאשר CalledwriteField_thenCorrect () זורק IllegalAccessException {FieldUtils.writeField (משתמש, "שם", "ג'ולי", נכון); assertThat (FieldUtils.readField (משתמש, "שם", נכון)) .isEqualTo ("ג'ולי"); } @Test הריק פומבי givenFieldUtilsClass_whenCalledwriteDeclaredField_thenCorrect () זורק IllegalAccessException {FieldUtils.writeDeclaredField (משתמש, "שם", "ג'ולי", נכון); assertThat (FieldUtils.readField (משתמש, "שם", נכון)) .isEqualTo ("ג'ולי"); }

11. ה MethodUtils מעמד

באותו קו, אנו יכולים להשתמש בהשתקפות על שיטות כיתה עם ה- MethodUtils מעמד.

במקרה זה, הנראות של מִשׁתַמֵשׁ מעמד' getName () השיטה היא פּוּמְבֵּי. אז אנחנו יכולים לגשת אליו באמצעות ה- getAccessibleMethod () שיטה:

@ מבחן ציבורי בטל כאשר CalledgetAccessibleMethod_thenCorrect () {assertThat (MethodUtils.getAccessibleMethod (User.class, "getName")) .isInstanceOf (Method.class); } 

כשמדובר בשיטות הפעלת רפלקטיביות, אנו יכולים להשתמש ב- הפעל את ExactMethod () ו InvokeMethod () שיטות:

@ מבחן ציבורי בטל כאשר CalledinvokeExactMethod_thenCorrect () זורק Exception {assertThat (MethodUtils.invokeExactMethod (משתמש חדש ("John", "[email protected]"), "getName")) .isEqualTo ("John"); } @Test ציבורי בטל כאשר CalledinvokeMethod_thenCorrect () זורק חריג {משתמש משתמש = משתמש חדש ("ג'ון", "[מוגן בדוא"ל]"); שיטת אובייקט = MethodUtils.invokeMethod (user, true, "setName", "John"); assertThat (user.getName ()). isEqualTo ("ג'ון"); }

12. ה MutableObject מעמד

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

יתר על כן, יצירת מחלקות ניתנות לשינוי דורשת הרבה קוד של Boilerplate, שאותו ניתן ליצור על ידי מרבית ה- IDE באמצעות קבצים שנוצרו אוטומטית.

לשם כך, Apache Commons Lang 3 מספק את ה- MutableObject class, כיתת עטיפה פשוטה ליצירת אובייקטים ניתנים לשינוי עם מינימום מהומה:

@BeforeClass חלל סטטי ציבורי setUpMutableObject () {mutableObject = new MutableObject ("ערך התחלתי"); } @Test הציבור בטל כאשר CallTgetValue_thenCorrect () {assertThat (mutableObject.getValue ()). IsInstanceOf (String.class); } @Test הציבור בטל כאשר CallSetValue_thenCorrect () {mutableObject.setValue ("ערך אחר"); assertThat (mutableObject.getValue ()). isEqualTo ("ערך אחר"); } @Test ציבורי בטל כאשרCalledtoString_thenCorrect () {assertThat (mutableObject.toString ()). IsEqualTo ("ערך אחר"); } 

כמובן, זו רק דוגמה כיצד להשתמש ב- MutableObject מעמד.

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

13. ה MutablePair מעמד

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

אז נניח שעלינו ליצור זוג אלמנטים הניתנים לשינוי.

במקרה כזה, נשתמש ב- MutablePair מעמד:

סטטי פרטי MutablePair mutablePair; @BeforeClass חלל סטטי ציבורי setUpMutablePairInstance () {mutablePair = new MutablePair ("leftElement", "rightElement"); } @Test הציבור בטל כאשר CalledgetLeft_thenCorrect () {assertThat (mutablePair.getLeft ()). IsEqualTo ("leftElement"); } @Test הציבור בטל כאשר CallTgetRight_thenCorrect () {assertThat (mutablePair.getRight ()). IsEqualTo ("rightElement"); } @ מבחן ציבורי בטל כאשר CallSetLeft_thenCorrect () {mutablePair.setLeft ("newLeftElement"); assertThat (mutablePair.getLeft ()). isEqualTo ("newLeftElement"); } 

הפרט הרלוונטי ביותר שכדאי להדגיש כאן הוא ה- API הנקי של הכיתה.

זה מאפשר לנו להגדיר ולגשת לאובייקטים השמאליים והימניים עטופים על ידי הזוג דרך הקובעים / הגטרים הסטנדרטיים.

14. ה ImmutablePair מעמד

באופן לא מפתיע, יש גם יישום מקביל שאינו משתנה MutablePair כיתה, נקרא ImmutablePair:

סטטי פרטי ImmutablePair immutablePair = ImmutablePair חדש ("leftElement", "rightElement"); @ מבחן ציבורי בטל כאשר CalledgetLeft_thenCorrect () {assertThat (immutablePair.getLeft ()). IsEqualTo ("leftElement"); } @Test הציבור בטל כאשר CallTgetRight_thenCorrect () {assertThat (immutablePair.getRight ()). IsEqualTo ("rightElement"); } @Test הציבור בטל כאשר Calledof_thenCorrect () {assertThat (ImmutablePair.of ("leftElement", "rightElement")) .isInstanceOf (ImmutablePair.class); } @Test (צפוי = UnsupportedOperationException.class) פומבי בטל כאשר CalledSetValue_thenThrowUnsupportedOperationException () {immutablePair.setValue ("newValue"); } 

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

15. ה לְשַׁלֵשׁ מעמד

מחלקת השירות האחרונה שתבחן כאן היא לְשַׁלֵשׁ.

מכיוון שהכיתה היא מופשטת, אנו יכולים ליצור לְשַׁלֵשׁ מקרים באמצעות שֶׁל() שיטת מפעל סטטית:

@BeforeClass ריק סטטי ציבורי setUpTripleInstance () {triple = Triple.of ("leftElement", "middleElement", "rightElement"); } @Test הציבור בטל כאשר CallTgetLeft_thenCorrect () {assertThat (triple.getLeft ()). IsEqualTo ("leftElement"); } @Test הציבור בטל כאשר CalledgetMiddle_thenCorrect () {assertThat (triple.getMiddle ()). IsEqualTo ("middleElement"); } @Test הציבור בטל כאשר CallTgetRight_thenCorrect () {assertThat (triple.getRight ()). IsEqualTo ("rightElement"); }

יש גם יישומים קונקרטיים עבור שלשות משתנות וגם בלתי ניתנות לשינוי, דרך ה- MutableTriple ו ImmutableTriple שיעורים.

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

במקרה זה, פשוט נדלג עליהם, מכיוון שממשקי ה- API שלהם נראים דומים מאוד לאלה של ה- MutablePair ו ImmutablePair שיעורים.

16. מסקנה

במדריך זה בדקנו לעומק כמה משיעורי השירות השימושיים ביותר ש- Apache Commons Lang 3 מספק כבוי המדף .

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

לממשק ה- API של הספרייה המלא, אנא בדוק את Javadocs הרשמי.

כרגיל, כל דגימות הקוד המוצגות במדריך זה זמינות ב- GitHub.