Méthode Java 8 Boolean.logicalOr

Question

En Java 8, de nouvelles méthodes dans Boolean ont été ajoutés.

Parlons juste de l'un d'entre eux

public static boolean Boolean.logicalOr(boolean a , boolean b)

Maintenant, ma question est : pourquoi étaient-ils nécessaires ?

Quelle est la différence entre les deux cas suivants.

boolean result = a || b; o Boolean result = Boolean.logicalOr(a,b);

Qu'est-ce qu'il y a de si spécial dans Boolean.logicalOr() et quand dois-je préférer l'un à l'autre.

Answer 1

Ces méthodes sont principalement là pour votre confort et pour rendre le code plus lisible en utilisant les références des méthodes dans les lambdas/streams. Prenons un exemple :

Stream.of(/* .. some objects .. */)
      .map(/* some function that returns a boolean */)
      .reduce(Boolean::logicalOr);

J'essaie d'écrire ceci avec a || b :

Stream.of(...)
      .map(...)
      .reduce((a, b) -> a || b); // logicalOr is actually using ||

pas si lisible, n'est-ce pas ?

Comme Sotirios Delimanolis l'a indiqué dans le commentaire, vous pouvez également consulter la javadoc et suivre les instructions suivantes @see BinaryOperator . Ou bien, jetez un coup d'œil à la fonction résumé du paquetage javadoc .

Answer 2

Il s'agit des références aux méthodes. Ainsi, vous pouvez utiliser la méthode || (ou logique) également dans les lambdas.

De cette façon, il y a aussi d'autres nouvelles fonctions comme Objects.isNull etc.

Utiliser des références de fonctions au lieu d'une expression lambda comme (a,b) -> a || b est plus conforme à l'aspect et à la convivialité des flux et des lambdas.
De plus, une référence à une méthode produira moins de code octet, et donc des temps d'exécution plus rapides (un peu au moins).

Answer 3

Quelle est la différence entre les deux cas suivants.
résultat booléen = a || b ; ou résultat booléen = Boolean.logicalOr(a,b) ;

Je voudrais faire part ici de mes observations concernant la question ci-dessus. Voici le corps du texte Boolean.logicalOr

  public static boolean logicalOr(boolean paramBoolean1, boolean paramBoolean2)
  {
    return (paramBoolean1) || (paramBoolean2);
  }

Donc on peut voir qu'il fait a || b en fin de compte. Mais ça devient un non court-circuit quand on utilise Boolean.logicalOr au lieu de || . Parce qu'il ( Boolean.logicalOr ) serait considéré comme (a || b) qui est différent de a || b lorsqu'elle est associée à d'autres opérateurs logiques.
Exemple- : Veuillez vous référer au code du snippet ci-dessous...

public static void main(String[] args) {

    boolean bCheck1 = false, bCheck2 = true, bCheck3 = false;
    System.out.println("bCheck1\t" + "bCheck2\t" + "bCheck3\t" + "checkOR-Result\t" + "checkLogicalOr-Result");

    bCheck1 = true; bCheck2 = true; bCheck3 = true;
    System.out.println(bCheck1 +"\t"+ bCheck2 +"\t"+ bCheck3 +"\t"+ checkOR(bCheck1, bCheck2, bCheck3) + "\t\t" + checkLogicalOr(bCheck1, bCheck2, bCheck3));
    bCheck1 = true; bCheck2 = true; bCheck3 = false;
    System.out.println(bCheck1 +"\t"+ bCheck2 +"\t"+ bCheck3 +"\t"+ checkOR(bCheck1, bCheck2, bCheck3) + "\t\t" + checkLogicalOr(bCheck1, bCheck2, bCheck3));
    bCheck1 = true; bCheck2 = false; bCheck3 = true;
    System.out.println(bCheck1 +"\t"+ bCheck2 +"\t"+ bCheck3 +"\t"+ checkOR(bCheck1, bCheck2, bCheck3) + "\t\t" + checkLogicalOr(bCheck1, bCheck2, bCheck3));
    bCheck1 = true; bCheck2 = false; bCheck3 = false;
    System.out.println(bCheck1 +"\t"+ bCheck2 +"\t"+ bCheck3 +"\t"+ checkOR(bCheck1, bCheck2, bCheck3) + "\t\t" + checkLogicalOr(bCheck1, bCheck2, bCheck3));
    bCheck1 = false; bCheck2 = true; bCheck3 = true;
    System.out.println(bCheck1 +"\t"+ bCheck2 +"\t"+ bCheck3 +"\t"+ checkOR(bCheck1, bCheck2, bCheck3) + "\t\t" + checkLogicalOr(bCheck1, bCheck2, bCheck3));
    bCheck1 = false; bCheck2 = true; bCheck3 = false;
    System.out.println(bCheck1 +"\t"+ bCheck2 +"\t"+ bCheck3 +"\t"+ checkOR(bCheck1, bCheck2, bCheck3) + "\t\t" + checkLogicalOr(bCheck1, bCheck2, bCheck3));
    bCheck1 = false; bCheck2 = false; bCheck3 = true;
    System.out.println(bCheck1 +"\t"+ bCheck2 +"\t"+ bCheck3 +"\t"+ checkOR(bCheck1, bCheck2, bCheck3) + "\t\t" + checkLogicalOr(bCheck1, bCheck2, bCheck3));
    bCheck1 = false; bCheck2 = false; bCheck3 = true;
    System.out.println(bCheck1 +"\t"+ bCheck2 +"\t"+ bCheck3 +"\t"+ checkOR(bCheck1, bCheck2, bCheck3) + "\t\t" + checkLogicalOr(bCheck1, bCheck2, bCheck3));
}

private static boolean checkOR(boolean bCheck1, boolean bCheck2, boolean bCheck3){
    return bCheck1 && bCheck2 || bCheck3;
}

private static boolean checkLogicalOr(boolean bCheck1, boolean bCheck2, boolean bCheck3){
    return bCheck1 && Boolean.logicalOr(bCheck2, bCheck3);
}

Voici les résultats :

bCheck1 bCheck2 bCheck3 checkOR-Result  checkLogicalOr-Result
true    true    true    true            true
true    true    false   true            true
true    false   true    true            true
true    false   false   false           false
false   true    true    true            false
false   true    false   false           false
false   false   true    true            false
false   false   true    true            false

Nous pouvons voir qu'il produit des résultats différents lorsqu'il est utilisé avec d'autres opérateurs logiques. Il faut donc faire attention à l'utilisation de || sur Boolean.logicalOr ou vice versa. Évidemment, Boolean.logicalOr est plus lisible que || . Mais chacun a sa signification et peut être utilisé comme ci-dessous.
if(bCheck1 && bCheck2 || bCheck3) ne peut pas être remplacé par if(bCheck1 && Boolean.logicalOr(bCheck2, bCheck3))
Toutefois, le remplacement if(bCheck1 && (bCheck2 || bCheck3)) à if(bCheck1 && Boolean.logicalOr(bCheck2, bCheck3)) serait certainement une bonne idée.