Predicato Java con esempi

Generalmente predicato significa un'affermazione che determina se un valore potrebbe essere vero o falso. Nella programmazione i predicati significano funzioni con un argomento che restituiscono un valore booleano. Functional Interface Predicate è stato realizzato in Java 8. “Funzionale” significa che contiene un solo metodo astratto. Accetta un argomento e restituisce un valore booleano. In Java, le interfacce funzionali vengono utilizzate per gestire le espressioni Lambda, i costruttori e i riferimenti ai metodi. Di solito Java 8 Predicate viene utilizzato per applicare un filtro per una raccolta di oggetti. Diamo un'occhiata alle sue principali applicazioni e ai metodi ampiamente utilizzati, oltre a risolvere alcuni problemi pratici.

Perché gli sviluppatori usano Predicate

Fondamentalmente, gli sviluppatori possono utilizzare i predicati per qualsiasi attività che implichi la valutazione di elementi in base a criteri predefiniti e la restituzione di un valore booleano. Ecco gli esempi di semplici attività che gli sviluppatori gestiscono utilizzando i predicati:

• Filtraggio di un insieme di numeri interi.
• Ordinare le liste assicurandosi che i dati siano conformi a diverse condizioni predefinite (es. organizzare una gamma di articoli impostando condizioni di prezzo e peso).
• Utilizzo di pacchetti di utilità nella programmazione concorrente.

I predicati sono una caratteristica importante nei test del software. L'interfaccia funzionale semplifica la separazione delle unità per il test, migliora la leggibilità e la gestibilità del codice dell'app.

Sintassi dei predicati in Java

java.util.function.Predicate è stato introdotto in Java 8 come un modo alternativo per gestire le impressioni di valutazione in Lambda. La vista standard dell'interfaccia è Predicate<T> , dove T è un singolo argomento che restituisce un valore booleano. I predicati Java hanno un metodo funzionale (astratto) test(Object) che valuta questo predicato su un dato Object.

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

Ecco un esempio di scrittura di un predicato semplice che filtra gli interi in base alle condizioni "maggiore di", "minore di".

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

L'output sarà vero perché 10 < 18. Un altro esempio con Predicate in filter() . Il predicato aiuta a filtrare tutti gli adulti dall'elenco delle età.

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

L'uscita è:

Metodi dei predicati Java 8

L'interfaccia del predicato ha una manciata di metodi.

• boolean test(T t) valuta il predicato sull'argomento dato.
• default Predicate<T> and(Predicate<? super T> other) restituisce un predicato che rappresenta un AND logico cortocircuitante di questo predicato e di un altro.
• default Predicate<T> o restituisce un predicato composto che rappresenta un OR logico di cortocircuito di questo predicato e di un altro.
• default Predicate<T> negate() restituisce un predicato logicamente opposto a questo predicato.
• default Predicate<T> isEqual(Object targetRef) restituisce un risultato del test se due argomenti sono uguali secondo Objects.equals(Object, Object) .

test booleano(T t)

Questo è un metodo funzionale per i predicati Java che valuta se un dato argomento soddisfa o meno la condizione di un predicato. Esempio: qui creiamo un predicato adulto per tutti coloro che hanno 18 anni o più. Il metodo test() ottiene un valore intero e lo controlla.

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

Quale sarà l'output per il codice sopra? Nel primo caso, poiché 12 è minore di 18, sarà falso. Per quanto riguarda il secondo e il terzo scenario, le condizioni sono soddisfatte per cui il rendimento sarà vero.

default Predicate.and()

Questo metodo rappresenta l'operatore "e". Ecco perché, se uno dei predicati dati non soddisfa una determinata condizione, un altro non otterrà una valutazione. Esempio: componiamo i predicati in Java, filtrando tutte le persone che sono già adulte ma hanno meno di 65 anni usando and() . Usiamo predicate.add () e scriviamo un predicato java con lambda per queste condizioni: Se la condizione è vera, l'app restituirà la seguente istruzione:

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

L'uscita è:

default Predicate.or()

Il metodo predicate.or() rappresenta l'operatore "OR". Ciò significa che la condizione rimarrà vera anche se uno dei due predicati è vero e l'altro è falso. Esempio: valutiamo ora le stringhe di caratteri. Prova a utilizzare il metodo OR per ordinare tutte le frasi che contengono la sottostringa "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"));
      }
  }

L'uscita è:

default Predicato negato()

Il metodo negate() viene utilizzato per raccogliere tutti i valori che non sono conformi ai criteri predefiniti. Esempio: se vuoi ordinare la classe "Pomodori" e trovare tutte le voci che non sono "Rosse", puoi scrivere un predicato e scorrere rapidamente l'intera sequenza. Prova a scrivere il codice per questo da solo e confrontalo con la soluzione una volta che hai finito.

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

L'uscita è:

Predicato statico isEqual(Oggetto targetRef)

Questo metodo è molto utile se si desidera determinare se due oggetti sono uguali a un valore definito come parametro di Objects.equals(). Questo metodo è particolarmente utile se è necessario confrontare risultati di test simili. Esempio: diciamo che stai confrontando due carri di pere e vuoi assicurarti che entrambi abbiano frutti di peso e colore standard. In questo caso, il predicato statico isEqual(Object targetRef) è esattamente il metodo di cui hai bisogno. Diamo un'occhiata a come isEqual controlla l'uguaglianza di due stringhe:

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

Se un oggetto che stai analizzando soddisfa le condizioni standard, la funzione restituirà true. L'uscita è:

Predicato Java Int

Java IntPredicate è un'interfaccia funzionale, quindi puoi usarla come destinazione dell'assegnazione per un'espressione lambda o un riferimento al metodo. IntPredicate opera su un numero intero e restituisce un valore del predicato in base a una condizione. Come Predicate Interface, IntPredicate ha anche metodi test() , and() , negate() o or() . Ecco un esempio di IntPredicate. Filtra anche tutti gli adulti (18 o più) dall'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);
   }
}

L'uscita è:

Scrivere predicati puliti in Java

I predicati Java sono altamente funzionali e divertenti con cui lavorare. Tuttavia, a meno che tu non sia consapevole di come le espressioni lambda che scrivi influiscono sul codice, c'è il rischio di ridurre la manutenibilità del codice con predicati disordinati. Ecco alcune semplici pratiche che ti aiuteranno a garantire che le tue interfacce funzionali siano facili da gestire e leggere.

• Non ripetere te stesso: non comporre predicati con Java con valori, metodi e condizioni ripetuti più di una volta. In questo modo, sprechi il tuo tempo produttivo e rendi il codice disordinato.
• Predicati separati dal codice dell'app per garantire la testabilità. Oltre a questo, crea un programma di test unitario del predicato e rispettalo.
• Usa le importazioni e i modelli di composizione per assicurarti che le tue classi non siano "gonfie e rimangano facili da gestire.
• Prendi in considerazione lo spostamento dei predicati Java nelle classi Helper: in questo modo migliorerai la riusabilità del tuo codice e faciliterai la manutenzione.
• Leggibilità: quando possibile, preferisci le dichiarazioni di una riga rispetto ai predicati complessi. Potrebbe essere allettante mostrare la tua comprensione di interfacce funzionali complesse. Tuttavia, quando si tratta di manutenzione, meno è meglio.