Java Predicate na may mga Halimbawa

Pangkalahatang panaguri ay nangangahulugang isang pahayag na tumutukoy kung ang isang halaga ay maaaring tama o mali. Sa programming predicates ay nangangahulugan ng mga function na may isang argumento na nagbabalik ng boolean value. Ang Functional Interface Predicate ay natanto sa Java 8. Ang ibig sabihin ng "Functional" ay naglalaman lamang ito ng isang abstract na paraan. Tumatanggap ito ng argumento at nagbabalik ng boolean. Sa Java, ang mga functional na interface ay ginagamit para sa paghawak ng mga Lambda expression, constructor, at Method reference. Karaniwan ang Java 8 Predicate ay ginagamit upang maglapat ng filter para sa isang koleksyon ng mga bagay. Tingnan natin ang mga pangunahing aplikasyon nito at malawakang ginagamit na mga pamamaraan, gayundin ang paglutas ng ilang problema sa pagsasanay.

Bakit Gumagamit ang Mga Developer ng Predicate

Karaniwan, ang mga developer ay maaaring gumamit ng mga predicate para sa anumang mga gawain na may kinalaman sa pagsusuri ng mga item batay sa paunang natukoy na pamantayan at pagbabalik ng boolean na halaga. Narito ang mga halimbawa ng mga simpleng gawaing pinangangasiwaan ng mga developer gamit ang mga panaguri:

• Pag-filter ng isang hanay ng mga integer.
• Pag-uuri ng mga listahan sa pamamagitan ng pagtiyak na ang data ay sumusunod sa ilang mga paunang natukoy na kundisyon (hal. pag-aayos ng hanay ng mga item sa pamamagitan ng pagtatakda ng mga kondisyon ng presyo at timbang).
• Paggamit ng mga utility package sa kasabay na programming.

Ang mga predicate ay isang mahalagang tampok sa pagsubok ng software. Pinapadali ng functional na interface ang paghiwalayin ang mga unit para sa pagsubok, pinapahusay ang pagiging madaling mabasa at ang pamamahala ng code ng app.

Predicate Syntax sa Java

Ang java.util.function.Predicate ay ipinakilala sa Java 8 bilang isang alternatibong paraan upang pangasiwaan ang mga impression ng pagtatasa sa Lambda. Ang karaniwang view ng interface ay Predicate<T> , kung saan ang T ay isang solong argumento na nagbabalik ng boolean value. Ang Java Predicates ay mayroong functional (abstract) method test(Object) na sinusuri ang predicate na ito sa isang ibinigay na Object.

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

Narito ang isang halimbawa ng pagsusulat ng isang simpleng Predicate na nagpi-filter ng mga integer batay sa mga kundisyon na “greater than”, “lesser than”.

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

Magiging totoo ang output dahil 10 < 18. Isa pang halimbawa na may Predicate sa filter() . Tumutulong ang predicate na i-filter ang lahat ng nasa hustong gulang mula sa listahan ng mga edad.

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

Ang output ay:

Java 8 Predicate Methods

Ang Predicate Interface ay may ilang mga pamamaraan.

• Sinusuri ng boolean test(T t) ang predicate sa ibinigay na argumento.
• ang default na Predicate<T> at(Predicate<? super T> other) ay nagbabalik ng isang predicate na kumakatawan sa isang short-circuiting na lohikal na AT ng predicate na ito at isa pa.
• default Predicate<T> o nagbabalik ng isang composed predicate na kumakatawan sa isang short-circuiting logical OR ng predicate na ito at ng isa pa.
• Ang default na Predicate<T> negate() ay nagbabalik ng isang panaguri na kabaligtaran ng panaguri na ito nang lohikal.
• default Predicate<T> isEqual(Object targetRef) ay nagbabalik ng resulta ng pagsubok kung ang dalawang argumento ay pantay ayon sa Objects.equals(Object, Object) .

boolean test(T t)

Ito ay isang functional na paraan para sa Java predicates na sinusuri kung ang isang ibinigay na argumento ay nakakatugon sa kundisyon ng isang predicate. Halimbawa: dito lumikha kami ng isang predicate adult para sa lahat na 18 o higit pang taong gulang. test() method ay nakakakuha ng integer value at sinusuri ito.

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

Ano ang magiging output para sa code sa itaas? Sa unang kaso, dahil ang 12 ay mas mababa sa 18, ito ay magiging mali. Para sa pangalawa at pangatlong senaryo, ang mga kondisyon ay natutugunan upang ang pagbabalik ay magiging totoo.

default na Predicate.and()

Ang pamamaraang ito ay kumakatawan sa "at" operator. Iyon ang dahilan kung bakit, kung ang isa sa mga ibinigay na panaguri ay hindi sumunod sa isang itinakdang kondisyon, ang isa pa ay hindi makakakuha ng pagsusuri. Halimbawa: Bumuo tayo ng mga panaguri sa Java, na sinasala ang lahat ng tao na nasa hustong gulang na ngunit wala pang 65 taong gulang gamit ang and() . Gamitin natin ang predicate.add () at magsulat ng java predicate na may lambda para sa mga kundisyong ito: Kung totoo ang kundisyon, ibabalik ng app ang sumusunod na pahayag:

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

Ang output ay:

default Predicate.or()

Ang pamamaraan ng Predicate.or() ay kumakatawan sa operator na "OR". Nangangahulugan ito na ang kundisyon ay mananatiling totoo kahit na ang isa sa dalawang panaguri ay totoo at ang isa ay mali. Halimbawa: suriin natin ang mga string ng character ngayon. Subukang gamitin ang OR method para pagbukud-bukurin ang lahat ng pariralang naglalaman ng substring na “my” o “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"));
      }
  }

Ang output ay:

default na Predicate negate()

negate() method ay ginagamit upang tipunin ang lahat ng value na hindi sumusunod sa paunang natukoy na pamantayan. Halimbawa: kung gusto mong pag-uri-uriin ang klase na "Mga Kamatis" at hanapin ang lahat ng mga entry na hindi "Pula", maaari kang magsulat ng Predicate at mabilis na i-scan ang buong pagkakasunud-sunod. Subukang isulat ang code para sa isang ito nang mag-isa at suriin ito laban sa solusyon kapag tapos ka na.

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

Ang output ay:

static Predicate isEqual(Object targetRef)

Ang pamamaraang ito ay lubos na kapaki-pakinabang kung gusto mong matukoy kung ang dalawang bagay ay katumbas ng isang halaga na tinukoy bilang isang parameter ng Objects.equals(). Ang pamamaraang ito ay lalong kapaki-pakinabang kung kailangan mong ihambing ang mga katulad na resulta ng pagsubok. Halimbawa: sabihin nating naghahambing ka ng dalawang karwahe ng peras at gusto mong tiyakin kung pareho ang mga prutas na may karaniwang timbang at kulay. Sa kasong ito, ang static Predicate isEqual(Object targetRef) ay eksaktong paraan na kailangan mo. Tingnan natin kung paano sinusuri ng isEqual ang pagkakapantay-pantay ng dalawang string:

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

Kung ang isang bagay na iyong sinusuri ay sumusunod sa mga karaniwang kundisyon, ang function ay magbabalik ng true. Ang output ay:

Java IntPredicate

Ang Java IntPredicate ay isang functional na interface, kaya maaari mo itong gamitin bilang target ng pagtatalaga para sa isang lambda expression o method reference. Gumagana ang IntPredicate sa isang integer at nagbabalik ng halaga ng predicate batay sa isang kundisyon. Gaya ng Predicate Interface, ang IntPredicate ay mayroon ding test() , at() , negate() , o() na mga pamamaraan. Narito ang isang halimbawa ng IntPredicate. Sinasala din nito ang lahat ng nasa hustong gulang (18 o higit pa) mula sa array.

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

Ang output ay:

Pagsusulat ng Malinis na Predicates sa Java

Ang Java Predicates ay lubos na gumagana at nakakatuwang gamitin. Gayunpaman, maliban kung iniisip mo kung paano nakakaapekto sa code ang mga expression ng lambda na isinusulat mo, may panganib na bawasan ang pagiging mapanatili ng code sa mga magugulong predicate. Narito ang ilang simpleng kasanayan na makakatulong sa iyong matiyak na ang iyong mga functional na interface ay madaling pamahalaan at basahin.

• Huwag Ulitin ang Iyong Sarili — huwag gumawa ng mga panaguri sa Java na may paulit-ulit na mga halaga, pamamaraan, at kundisyon nang higit sa isang beses. Sa ganitong paraan, sinasayang mo ang iyong produktibong oras at ginagawang magulo ang code.
• Paghiwalayin ang mga predicate mula sa app code upang matiyak na masusubok. Maliban doon, lumikha ng iskedyul ng pagsubok ng yunit ng predicate at manatili dito.
• Gumamit ng mga pag-import at mga pattern ng komposisyon upang matiyak na ang iyong mga klase ay hindi namumulaklak at manatiling madaling pamahalaan.
• Isaalang-alang ang paglipat ng mga predicate ng Java sa mga klase ng Helper — sa ganitong paraan, mapapabuti mo ang muling paggamit ng iyong code at mapadali ang pagpapanatili.
• Kakayahang mabasa — hangga't maaari, mas gusto ang isang linyang pahayag kaysa kumplikadong mga panaguri. Maaaring nakatutukso na ipakita ang iyong pag-unawa sa mga kumplikadong functional na interface. Gayunpaman, pagdating sa pagpapanatili, mas kaunti ang higit pa.