Java 8 Boolean.logical lub metoda

Question

W języku Java dodano 8 nowych metod w klasie Boolean.

Porozmawiajmy o jednym z nich

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

Teraz moje pytanie brzmi, dlaczego były potrzebne?

Jaka jest różnica między dwoma następującymi przypadkami.

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

Co jest takiego specjalnego Boolean.logicalOr() i kiedy należy preferować jeden nad drugim.

Answer 1

Głównie te metody są dla wygody użytkownika i sprawiają, że kod jest bardziej czytelny przy użyciu odwołań do metod w lambdas/streamach. Spójrzmy na przykład:

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

próbuje napisać to z a || b:

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

nie tak czytelny, prawda?

Jak powiedział Sotirios Delimanolis w komentarzu, możesz również chcieć rzucić okiem na javadoc i śledzić @see BinaryOperator. Lub spójrz na function package summary javadoc.

Answer 2

Ma to związek z referencjami metod. W ten sposób można użyć operatora || (logicznego lub) również w lambdas.

W ten sposób tam także inne nowe funkcje, takie jak Objects.isNull itp

pomocą odwołań funkcyjnych zamiast wyrażenia lambda jak (a,b) -> a || b jest bardziej zgodne ze strumieniami i lambda „look-and-feel”.
Ponadto, odwołanie do metody spowoduje mniej kodu bajtowego, a tym samym oznacza krótszy czas wykonania (przynajmniej nieco).

Answer 3

Jaka jest różnica między dwoma następującymi przypadkami.
wynik boolowski = a || b; lub Boolean result = Boolean.logicalOr (a, b);

Chciałbym przedstawić moje uwagi dotyczące powyższego pytania. Oto ciało Boolean.logicalOr

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

Widzimy więc, że robi a || b ostatecznie. Ale staje się nie zwarcie, gdy używamy Boolean.logicalOr zamiast ||. Ponieważ (Boolean.logicalOr) będzie traktowany jako (a || b), który różni się od a || b, gdy jest dostarczany z innymi operatorami logicznymi.
Przykład-: zapoznaj się z poniższym fragmentem kodu ...

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

Poniżej są WYNIKI:

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 

Widzimy to produkujące różne wyniki, kiedy to był używany z innego operatora logicznego. Dlatego należy zachować ostrożność w używaniu || przez Boolean.logicalOr lub odwrotnie. Oczywiście Boolean.logicalOr jest bardziej czytelny niż ||. Ale każdy ma swoje znaczenie i może być użyty jak poniżej.
if(bCheck1 && bCheck2 || bCheck3) nie może być zastąpiony przez if(bCheck1 && Boolean.logicalOr(bCheck2, bCheck3))
Jednak zastąpienie if(bCheck1 && (bCheck2 || bCheck3)) na if(bCheck1 && Boolean.logicalOr(bCheck2, bCheck3)) zdecydowanie byłoby dobrym pomysłem.