<qhelp>

<overview>

There are a number of boolean expression patterns that can easily be rewritten to make them simpler. Boolean expressions involving comparisons with boolean literals, ternary conditionals with a boolean literal as one of the results, double negations, or negated comparisons can all be changed to equivalent and simpler expressions.

</overview>

<recommendation>

If `A` and `B` are expressions of boolean type, you can simplify them using the rewrites shown below. These rewrites are equally suitable for the primitive type `boolean` and the boxed type `Boolean`.

Expression |  | Simplified expression |
--- | --- | --- | ---
`A == true` |  | `A` | (*)
`A != false` |  | `A` | (*)
`A == false` |  | `!A` |
`A != true` |  | `!A` |
`A ? true : B` |  | `A || B` |
`A ? B : false` |  | `A && B` |
`A ? B : true` |  | `!A || B` |
`A ? false : B` |  | `!A && B` |
`A ? true : false` |  | `A` | (*)
`A ? false : true` |  | `!A` |
`!!A` |  | `A` | (*)

Note that all of these rewrites yield completely equivalent code, except possibly for those marked with (*) when `A` has type `Boolean`. These can depend on the context if `null` values are involved. This is because a comparison or test of a `Boolean` will perform an automatic unboxing conversion that throws a `NullPointerException` if `null` is encountered, so the rewrites marked (*) are only completely equivalent if the surrounding context of the expression unboxes the value, for example by occurring as the condition in an `if` statement.

In addition to the rewrites above, negated comparisons can also be simplified in the following way:

Expression |  | Simplified expression
--- | --- | ---
`!(A == B)` |  | `A != B`
`!(A != B)` |  | `A == B`
`!(A < B)` |  | `A >= B`
`!(A > B)` |  | `A <= B`
`!(A <= B)` |  | `A > B`
`!(A >= B)` |  | `A < B`

</recommendation>

<example>

In the following example the method `f2` is a straightforward simplification of `f1`; they will both throw a `NullPointerException` if a `null` is encountered. A similar rewrite of `g1` would however result in a method with a different meaning, and a rewrite along the lines of `g2` might be more appropriate.

In any case, care should be taken to ensure correct behavior for `null` values when the boxed type `Boolean` is used.

</example>

<references>

- The Java Language Specification: Logical Complement Operator !, Boolean Equality Operators == and !=, Conditional-And Operator &&, Conditional-Or Operator ||, Conditional Operator ? :.
</references>

</qhelp>