פרדיקט ג'אווה עם דוגמאות

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

מדוע מפתחים משתמשים ב-Predicate

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

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

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

תחביר פרדיקט ב-Java

java.util.function.Predicate הוצג ב-Java 8 כדרך חלופית לטיפול בהתרשמות הערכה בלמבדה. התצוגה הסטנדרטית של הממשק היא Predicate<T> , כאשר T הוא ארגומנט בודד המחזיר ערך בוליאני. ל-Java Predicates יש מבחן שיטה פונקציונלי (מופשט) (Object) שמעריך פרדיקט זה על אובייקט נתון.

@FunctionalInterface
public interface Predicate<T> {
boolean test(T t);
}

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

// An example of a simple Java predicate

import java.util.function.Predicate;
public class PredicateExample {
    public static void main(String[] args)
    {
        // Creating predicate
        Predicate<Integer> lesserThan = i -> (i < 18);

        // Calling Predicate method
        System.out.println(lesserThan.test(10));
    }
}

הפלט יהיה נכון כי 10 < 18. דוגמה נוספת עם Predicate ב- filter() . Predicate עוזר לסנן את כל המבוגרים מרשימת הגילאים.

import java.util.List;
  import java.util.function.Predicate;

  public class PredicateExample {
      public static void main(String[] args) {
          List<Integer> ages = List.of(17, 18, 19, 28, 18, 28, 46, 7, 8, 9, 21, 12);
          NotLessThan18<Integer> isAdult = new NotLessThan18<>();
          ages.stream().filter(isAdult).forEach(System.out::println);
      }
  }



class NotLessThan18<E> implements Predicate<Integer> {

      @Override
      public boolean test(Integer v) {
          Integer ADULT = 18;
          return v >= ADULT;
      }
  }

הפלט הוא:

Java 8 Predicate Methods

ל-Predicate ממשק יש קומץ שיטות.

• מבחן בוליאני (T t) מעריך את הפרדיקט על הארגומנט הנתון.
• ברירת המחדל Predicate<T> and(Predicate<? super T> other) מחזירה פרדיקט המייצג AND לוגי מקצר קצר של פרדיקט זה ושל אחר.
• ברירת המחדל Predicate<T> או מחזירה פרדיקט מורכב המייצג OR לוגי מקצר קצר של פרדיקט זה ושל אחר.
• ברירת המחדל Predicate<T> negate() מחזירה פרדיקט הפוכה לפרדיקט הזה מבחינה לוגית.
• ברירת המחדל Predicate<T> isEqual(Object targetRef) מחזירה תוצאת בדיקה אם שני ארגומנטים שווים לפי Objects.equals(Object, Object) .

מבחן בוליאני (T t)

זוהי שיטה פונקציונלית עבור פרדיקטים של Java שמעריכה אם ארגומנט נתון עומד בתנאי של פרדיקט או לא. דוגמה: כאן אנו יוצרים מבוגר פרדיקט לכל מי שגילו 18 ומעלה. שיטת test() מקבלת ערך שלם ובודקת אותו.

import java.util.function.Predicate;
public class PredicateTestTest {
   public static void main(String[] args) {
       Predicate<Integer> adult = i -> i >= 18;
       System.out.println(adult.test(12));
       System.out.println(adult.test(19));
       System.out.println(adult.test(21));
   }
}

מה יהיה הפלט עבור הקוד למעלה? במקרה הראשון, מכיוון ש-12 הוא פחות מ-18, הוא יהיה שקר. לגבי התרחיש השני והשלישי, מתקיימים התנאים כך שהתשואה תהיה נכונה.

ברירת המחדל Predicate.and()

שיטה זו מייצגת את האופרטור "ו". זו הסיבה שאם אחד מהפרדיקטים הנתונים אינו עומד בתנאי מוגדר, אחד אחר לא יקבל הערכה. דוגמה: בואו נחבר פרדיקטים בג'אווה, ונסנן את כל האנשים שכבר מבוגרים אך מתחת לגיל 65 באמצעות ו() . הבה נשתמש ב- predicate.add () ונכתוב פרדיקט ג'אווה עם lambda עבור התנאים האלה: אם התנאי נכון, האפליקציה תחזיר את המשפט הבא:

import java.util.function.Predicate;

   public class PredicateDemo {
       public static void main(String[] args) {
           Predicate<Integer> adultYet = i -> i >= 18;
           Predicate<Integer> adultStill = i -> i < 65;
           System.out.println(adultYet.and(adultStill).test(5));
           System.out.println(adultYet.and(adultStill).test(38));
           System.out.println(adultYet.and(adultStill).test(90));
       }
   }

הפלט הוא:

ברירת המחדל Predicate.or()

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

import java.util.function.Predicate;

  public class PredicateDemo2 {
      public static void main(String[] args) {
          Predicate<String> containsA = t -> t.contains("crayon");
          Predicate<String> containsB = t -> t.contains("my");
          System.out.println(containsA.or(containsB).test("here is my crayon"));
          System.out.println(containsA.or(containsB).test("here is my pencil"));
          System.out.println(containsA.or(containsB).test("here is John's crayon"));
          System.out.println(containsA.or(containsB).test("here is John's pencil"));
      }
  }

הפלט הוא:

ברירת המחדל Predicate negate()

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

import java.util.function.Predicate;

public class PredicateDemo3 {
public static void main(String[] args) {
 Predicate<Integer> adult = i -> i >= 18;
System.out.println(adult.negate().test(7));  System.out.println(adult.negate().test(19))
  }
   }

הפלט הוא:

Predicate static isEqual(Object targetRef)

שיטה זו שימושית מאוד אם ברצונך לקבוע אם שני אובייקטים שווים לערך המוגדר כפרמטר של Objects.equals(). שיטה זו שימושית במיוחד אם אתה צריך להשוות תוצאות בדיקות דומות. דוגמה: נניח שאתה משווה בין שתי קרונות של אגסים וברצונך לוודא שלשניהם יש פירות במשקל וצבע סטנדרטיים. במקרה זה, Predicate static isEqual(Object targetRef) היא בדיוק השיטה שאתה צריך. בואו נסתכל כיצד isEqual בודק את השוויון של שתי מחרוזות:

import java.util.function.Predicate;

public class PredicateDemo2 {
   public static void main(String[] args) {
       Predicate<String> i = Predicate.isEqual("here is my crayon");
       System.out.println(i.test("here is my pencil"));
       System.out.println(i.test("here is my crayon"));
   }
}

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

Java IntPredicate

Java IntPredicate הוא ממשק פונקציונלי, כך שתוכל להשתמש בו כיעד ההקצאה עבור ביטוי למבדה או התייחסות לשיטה. IntPredicate פועל על מספר שלם ומחזיר ערך פרדיקט על סמך תנאי. כמו Predicate Interface, ל-IntPredicate יש גם שיטות test() , ו-() , negate() , או() . הנה דוגמה של IntPredicate. זה גם מסנן את כל המבוגרים (18 ומעלה) מהמערך.

import java.util.Arrays;
import java.util.function.IntPredicate;

public class IntPredicateExample {

   public static void main(String[] args) {

       int[] ages = { 18, 28, 18, 46, 90, 45, 2, 3, 1, 5, 7, 21, 12 };

       IntPredicate p = n -> n >= 18;

       Arrays.stream(ages).filter(p).forEach(System.out::println);
   }
}

הפלט הוא:

כתיבת פרדיקטים נקיים ב-Java

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

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