Предикат на Java с примери

Обикновено предикатът означава изявление, което определя дали дадена стойност може да бъде вярна or невярна. В програмирането предикатите означават функции с един аргумент, които връщат булева стойност. Предикатът на функционалния интерфейс е реализиран в Java 8. „Функционален“ означава, че съдържа само един абстрактен метод. Той приема аргумент и връща булево meaning. В Java функционалните интерфейси се използват за работа с ламбда изрази, конструктори и препратки към методи. Обикновено Java 8 Predicate се използва за прилагане на филтър за колекция от обекти. Нека да разгледаме основните му applications и широко използвани методи, Howто и да решим някои практически задачи.

Защо разработчиците използват предикат

По принцип разработчиците могат да използват предикати за всяHowви задачи, които включват оценяване на елементи въз основа на предварително зададени критерии и връщане на булева стойност. Ето примерите за прости задачи, които разработчиците обработват с помощта на предикати:

• Филтриране на набор от цели числа.
• Сортиране на списъци чрез гарантиране, че данните са в съответствие с няколко предварително зададени условия (напр. организиране на набор от артикули чрез задаване на условия за цена и тегло).
• Използване на помощни пакети при едновременно програмиране.

Предикатите са важна характеристика в софтуерното тестване. Функционалният интерфейс улеснява отделянето на единици за тестване, подобрява четливостта и управляемостта на codeа на приложението.

Предикатен синтаксис в Java

java.util.function.Predicate беше въведен в Java 8 като алтернативен начин за обработка на импресии за оценка в Lambda. Стандартният изглед на интерфейса е Predicate<T> , където T е един аргумент, връщащ булева стойност. Предикатите на Java имат функционален (абстрактен) метод test(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() . Предикатът помага да се филтрират всички възрастни от списъка с възрасти.

  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

Предикатният интерфейс има шепа методи.

• boolean test(T t) оценява предиката на дадения аргумент.
• default Predicate<T> and(Predicate<? super T> other) връща предикат, който представлява късо свързващо логическо И на този предикат и друг.
• default Predicate<T> or връща съставен предикат, който представлява късо логическо ИЛИ на този предикат и друг.
• default Predicate<T> negative() връща предикат, който е логически противоположен на този предикат.
• по подразбиране Predicate<T> isEqual(Object targetRef) връща резултат от тестване, ако два аргумента са равни според Objects.equals(Object, Object) .

булев тест (T t)

Това е функционален метод за Java предикати, който оценява дали даден аргумент удовлетворява or не conditionто на предикат. Пример: тук създаваме предикат възрастен за всеки, който е на 18 or повече години. методът 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));
   }
}

Какъв ще бъде изходът за codeа по-горе? В първия случай, тъй като 12 е по-малко от 18, то ще бъде невярно. Що се отнася до втория и третия сценарий, условията са изпълнени, така че връщането ще бъде вярно.

по подразбиране Predicate.and()

Този метод представлява оператора „и“. Ето защо, ако един от дадените предикати не отговаря на зададено condition, друг няма да получи оценка. Пример: Нека съставим предикати в Java, филтрирайки всички хора, които вече са възрастни, но под 65 години, използвайки and() . Нека използваме predicate.add () и напишем java предикат с ламбда за тези условия: Ако conditionто е вярно, приложението ще върне следния оператор:

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));
       }
   }

Резултатът е:

предикат по подразбиране.or()

Методът Predicate.or() представлява оператора „ИЛИ“. Това означава, че conditionто ще остане вярно, дори ако един от двата предиката е верен, а другият е фалшив. Пример: нека оценим символните низове сега. Опитайте да използвате метода OR, за да сортирате всички фрази, които съдържат подниз „my“ or „crayon“.

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"));
      }
  }

Резултатът е:

предикат по подразбиране negative()

методът negative() се използва за събиране на всички стойности, които не отговарят на предварително зададени критерии. Пример: ако искате да сортирате класа „Домати“ и да намерите всички записи, които не са „Червени“, можете да напишете Предикат и бързо да сканирате цялата последователност. Опитайте сами да напишете codeа за този и го проверете спрямо решението, след като сте готови.

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))
  }
   }

Резултатът е:

статичен предикат isEqual(Object targetRef)

Този метод е много полезен, ако искате да определите дали два обекта са равни на стойност, дефинирана като параметър на Objects.equals(). Този метод е особено полезен, ако трябва да сравните подобни резултати от тестване. Пример: да речем, че сравнявате два вагона круши и искате да се уверите дали и двата имат плодове със стандартно тегло и цвят. В този случай static Predicate isEqual(Object targetRef) е точно методът, от който се нуждаете. Нека да разгледаме How isEqual проверява equalsството на два низа:

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"));
   }
}

Ако обектът, който анализирате, отговаря на стандартните условия, функцията ще върне true. Резултатът е:

Java IntPredicate

Java IntPredicate е функционален интерфейс, така че можете да го използвате като цел за присвояване за ламбда израз or препратка към метод. IntPredicate работи с цяло число и връща стойност на предикат въз основа на condition. Като предикатния интерфейс, IntPredicate също има методи test() и() , negative() or () . Ето един пример за IntPredicate. Той също така филтрира всички възрастни (18 or повече) от масива.

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

Java Predicates са изключително функционални и забавни за работа. Въпреки това, освен ако не сте наясно How ламбда изразите, които пишете, влияят върху codeа, съществува риск от намаляване на поддържаемостта на codeа с разхвърляни предикати. Ето няколко прости практики, които ще ви помогнат да гарантирате, че вашите функционални интерфейси са лесни за управление и четене.

• Не се повтаряйте — не съставяйте предикати с Java с повтарящи се стойности, методи и условия повече от веднъж. По този начин губите продуктивното си време и правите codeа объркан.
• Отделете предикатите от codeа на приложението, за да осигурите възможност за тестване. Освен това, създайте график за тестване на предикатен модул и се придържайте към него.
• Използвайте шаблони за импортиране и съставяне, за да гарантирате, че вашите класове не са раздути и остават лесни за управление.
• Помислете за преместване на предикатите на Java към помощни класове — по този начин подобрявате повторното използване на вашия code и улеснявате поддръжката.
• Четивност - когато е възможно, предпочитайте едноредови изрази пред сложни предикати. Може да е изкушаващо да покажете разбирането си за сложни функционални интерфейси. Въпреки това, когато става въпрос за поддръжка, по-малкото е повече.