Méthode Java 8 Boolean.logicalOr

En Java, 8 nouvelles méthodes dans Boolean classe Boolean ont été ajoutées.

Parlons de l’un d’eux

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

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

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

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

Quelle est la particularité de Boolean.logicalOr() et quand devrais-je préférer l’un à l’autre?

Principalement ces méthodes sont là pour votre commodité et pour rendre le code plus lisible en utilisant les références de méthode dans lambdas / streams. Regardons un exemple:

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

essayant d’écrire ceci avec a || b a || b :

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

pas si lisible, non?

Comme Sotirios Delimanolis l’a indiqué dans le commentaire, vous pouvez également consulter le javadoc et suivre @see BinaryOperator . Ou jetez un coup d’œil à javadoc, le résumé du paquet de fonctions .

Cela concerne les références de méthodes. Comme ça, vous pouvez utiliser le || opérateur (logique ou) également en lambda.

De cette manière, 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 (a,b) -> a || b est plus en phase avec les stream et lambda ‘look-and-feel’.
De plus, une référence de méthode produira moins de code d’octet, et donc des temps d’exécution plus rapides (au moins un peu).

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

Je voudrais mettre ici mes points concernant la question ci-dessus. Voici le corps de Boolean.logicalOr

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

Donc on peut voir que ça fait a || b a || b fin de compte Mais cela devient un court-circuit quand on utilise Boolean.logicalOr au lieu de || . Parce qu’il ( Boolean.logicalOr ) serait considéré comme (a || b) différent de a || b a || b quand il vient avec d’autres opérateurs logiques.
Exemple: Veuillez vous référer au code ci-dessous de l’extrait de code …

 public static void main(Ssortingng[] 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 chaque fois qu’il est utilisé avec un autre opérateur logique. Il faut donc être prudent avec l’utilisation de || sur Boolean.logicalOr ou vice versa. Evidemment, 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))
Cependant, remplacer if(bCheck1 && (bCheck2 || bCheck3)) par if(bCheck1 && Boolean.logicalOr(bCheck2, bCheck3)) serait certainement une bonne idée.