Check two negations on an if expression

Your problem is in interpreting the order in which subexpressions are evaluated.

If you have an expression if (a || b) , it will be evaluated like this:

• If a is true, then all expression will be true and b will not be evaluated.
• If a is true, then b will be evaluated and expression will be true if b is true or false if b is false.

Similarly, a if (a && b) expression will be evaluated like this:

• If a is false, then all expression will be false and b will not be evaluated.
• If a is true, then b will be evaluated and expression will be true if b is true or false if b is false.

In your case, to avoid a NullPointerException , it makes sense to first check if an object is null and then try to use it (otherwise it does not make sense). And this is achieved by reversing the order of the subexpressions:

if((!(teste == null)) || !teste.trim().equals("")){
    // ...faz algo sem NullPointerException...
}

The reason is that if teste is null , then attempting to evaluate teste.trim() causes NullPointerException , which is why !(teste == null) must be before !teste.trim() . >

However, the code will still not work. There is yet another conceptual error, which can be easily revealed by trying to simplify it. First a !(a == b) expression is equivalent to a != b , and therefore (!(teste == null)) is the same as teste != null . So his expression would look like this:

if (teste != null || !teste.trim().equals("")) {
    // ...faz algo sem NullPointerException...
}

Knowing that the second subexpression will only be evaluated when the first subexpression is false, it is questioned: In what circumstance is the first subexpression false? The answer is that this occurs when teste is null , so the second subexpression will only be evaluated when teste is null . However, if teste is null , then you are guaranteed to have NullPointerException when evaluating the second subexpression!

What you really want is to enter within if if teste is not null E nor is it empty. That is, it was to use && instead of || :

if (teste != null && !teste.trim().equals("")) {
    // ...faz algo sem NullPointerException...
}

Note that this is equivalent to the contour solution you found:

if (sampleString != null) {
    if (!sampleString.tri‌​m().equals("")) {
        // ...faz algo sem NullPointerException...
    }
}

What these two if s do is exactly the same as && would do: It will only enter when both expressions are true and the second one will only be evaluated if the first one is true. In fact, one way to simplify if (a) { if (b) { ... }} is to exactly transform it into if (a && b) { ... } .

This is basic but can be tricky for anyone who is starting. Before invoking a method on any instance of the object always ask if it is null:

teste == null 
teste != null

If you try to invoke a method in a variable of a class type any assigned with null will face NullPointerException :

String teste = null;
teste.isEmpty();      //Vai dar NullPointerException

So in your case it would look like this:

if (!(teste == null) && !(teste.trim().equals("")) {
    // ...faz algo sem nullpointerException...
}

Or simpler:

if (teste != null && !teste.trim().isEmpty()) {
    // ...faz algo sem nullpointerException...
}

The error is in the comparison of the condition. In fact you have to first check if the variable teste is null, then make any kind of verification.

!(teste == null)

You have to do it this way to check if the value is null:

teste != null

Explaining why the first form does not work ...

Let's say test is not null .

The first expression that is validated is the one within the parentheses, so teste == null returns false. What the! does is invert the result, so returns true.

What happens is that you were validating correctly and then taking the opposite result.