streamalism.org

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

במדריך המהיר הזה, נדון בדרכים שונות לשרשור מנבא בג'אווה 8.

2. דוגמה בסיסית

ראשון, בואו נראה איך להשתמש בפשטות לְבַסֵס לסנן א רשימה של שמות:

@ מבחן ציבורי בטל כאשר FilterList_thenSuccess () {שמות רשימה = Arrays.asList ("אדם", "אלכסנדר", "ג'ון", "טום"); תוצאת רשימה = names.stream () .filter (name -> name.startsWith ("A")) .collect (Collectors.toList ()); assertEquals (2, result.size ()); assertThat (התוצאה מכילה ("אדם", "אלכסנדר")); }

בדוגמה זו סיננו את שלנו רשימה של שמות כדי להשאיר רק שמות שמתחילים ב- "A" באמצעות לְבַסֵס:

name -> name.startsWith ("A")

אבל מה אם נרצה ליישם מספר רב מנבא?

3. מספר פילטרים

אם היינו רוצים ליישם מספר רב מנבא, אפשרות אחת היא פשוט לשרשר מסננים מרובים:

@ מבחן ציבורי בטל כאשר FilterListWithMultipleFilters_thenSuccess () {List result = names.stream () .filter (name -> name.startsWith ("A")). Filter (name -> name.length () <5) .collect (Collectors. למנות()); assertEquals (1, result.size ()); assertThat (התוצאה מכילה ("אדם")); }

כעת עדכנו את הדוגמה שלנו לסינון הרשימה שלנו על ידי חילוץ שמות שמתחילים ב- "A" ואורכם נמוך מ- 5.

השתמשנו בשני פילטרים - אחד לכל אחד לְבַסֵס.

4. מורכב לְבַסֵס

עכשיו, במקום להשתמש במסננים מרובים, אנו יכולים להשתמש במסנן אחד עם קומפלקס לְבַסֵס:

@ מבחן ציבורי בטל כאשרFilterListWithComplexPredicate_thenSuccess () {List result = names.stream () .filter (name -> name.startsWith ("A") && name.length () <5) .collect (Collectors.toList ()); assertEquals (1, result.size ()); assertThat (תוצאה, מכיל ("אדם")); }

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

5. שילוב מנבא

לאחר מכן, אם אנחנו לא רוצים לבנות מתחם לְבַסֵס באמצעות פעולות סיביות, Java 8 לְבַסֵס יש שיטות שימושיות שנוכל להשתמש בהן לשילוב מנבא.

נשלב מנבא תוך שימוש בשיטות Predicate.and (), Predicate.or (), ו Predicate.negate ().

5.1. Predicate.and ()

בדוגמה זו נגדיר את שלנו מנבא במפורש, ואז נשלב אותם באמצעות Predicate.and ():

@ מבחן ציבורי בטל כאשר FilterListWithCombinedPredicatesUsingAnd_thenSuccess () {Predicate predicate1 = str -> str.startsWith ("A"); חזוי predicate2 = str -> str.length () <5; תוצאת רשימה = names.stream () .filter (predicate1.and (predicate2)) .collect (Collectors.toList ()); assertEquals (1, result.size ()); assertThat (תוצאה, מכיל ("אדם")); }

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

5.2. Predicate.or ()

אנחנו יכולים גם להשתמש Predicate.or () לשלב מנבא.

בואו נחלץ שמות מתחילים עם "J", כמו גם שמות שאורכם קטן מ -4:

@ מבחן ציבורי בטל כאשרFilterListWithCombinedPredicatesUsingOr_thenSuccess () {Predicate predicate1 = str -> str.startsWith ("J"); חזוי predicate2 = str -> str.length () <4; תוצאת רשימה = names.stream () .filter (predicate1.or (predicate2)) .collect (Collectors.toList ()); assertEquals (2, result.size ()); assertThat (התוצאה מכילה ("ג'ון", "טום")); }

5.3. Predicate.negate ()

אנחנו יכולים להשתמש Predicate.negate () כשמשלבים שלנו מנבא גם כן:

@ מבחן ציבורי בטל כאשרFilterListWithCombinedPredicatesUsingOrAndNegate_thenSuccess () {Predicate predicate1 = str -> str.startsWith ("J"); חזוי predicate2 = str -> str.length () <4; תוצאת רשימה = names.stream () .filter (predicate1.or (predicate2.negate ())) .collect (Collectors.toList ()); assertEquals (3, result.size ()); טוענים כי (התוצאה מכילה ("אדם", "אלכסנדר", "ג'ון")); }

הנה, השתמשנו בשילוב של אוֹ() ו לִשְׁלוֹל() לסנן את רשימה לפי שמות שמתחילים ב- "J" או שאורכם אינו קטן מ -4.

5.4. לְשַׁלֵב מנבא בשורה

אנחנו לא צריכים להגדיר במפורש את שלנו מנבא להשתמש ו- (),אוֹ(), ו לִשְׁלוֹל().

אנו יכולים להשתמש בהם גם על ידי הליהוק לְבַסֵס:

@ מבחן ציבורי בטל כאשרFilterListWithCombinedPredicatesInline_thenSuccess () {List result = names.stream () .filter (((Predicate) name -> name.startsWith ("A")). And (name -> name.length () <5)) .collect (Collectors.toList ()); assertEquals (1, result.size ()); assertThat (תוצאה, מכיל ("אדם")); }

6. שילוב אוסף של מנבא

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

בדוגמה הבאה, יש לנו רשימה שֶׁל מנבא ששילבנו באמצעות Predicate.and ():

@Test הציבור בטל כאשרFilterListWithCollectionOfPredicatesUsingAnd_thenSuccess () {רשימה allPredicates = ArrayList חדש(); allPredicates.add (str -> str.startsWith ("A")); allPredicates.add (str -> str.contains ("d")); allPredicates.add (str -> str.length ()> 4); תוצאת רשימה = names.stream () .filter (allPredicates.stream (). להפחית (x-> true, Predicate :: ו-)) .collect (Collectors.toList ()); assertEquals (1, result.size ()); assertThat (תוצאה מכילה ("אלכסנדר")); }

שים לב שאנו משתמשים בזהות הבסיסית שלנו כ:

x-> נכון

אבל זה יהיה שונה אם נרצה לשלב אותם באמצעות Predicate.or ():

@Test הציבור בטל כאשרFilterListWithCollectionOfPredicatesUsingOr_thenSuccess () {List result = names.stream () .filter (allPredicates.stream (). Reduce (x-> false, Predicate :: or)) .collect (Collectors.toList ()); assertEquals (2, result.size ()); assertThat (התוצאה מכילה ("אדם", "אלכסנדר")); }

7. מסקנה

במאמר זה בדקנו דרכים שונות לשרשר Predicates ב- Java 8 באמצעות לְסַנֵן(), מתחם בניין מנבא, ושילוב מנבא.

קוד המקור המלא זמין ב- GitHub.