Question

I would like to know is there any difference in performance between these two codes.

String sample="hello";
    if(sample!=null)
    {
       if(!sample.equals(""))
        {
            // some code in here
         }
    }

or

String sample="hello";
    if(sample!=null && !sample.equals(""))
    {

            // some code in here
    }

As far as i have understood, in the first code, if sample is not null then only it will go in to the block. same is the case with 2nd piece of code.
What i would like to know is what is the difference in performance or better coding standards and why?

Answer 1

If you’re asking about performance you should always measure. But No, there shouldn’t be a difference. Besides, if that is your only performance-problematic code then I envy you, seriously.

As for coding standards. Less nesting is almost always nicer to read and follow. Which means that putting both in a single if, especially since they are related is preferrable. The pattern

if (check_foo_for_null && compare_foo)

is very common and thus much less surprising than another nested if.

EDIT: To back it up:

I have the two little methods:

static boolean x(String a) {
    if (a != null && a.equals("Foo"))
        return true;
    else return false;
}

static boolean y(String a) {
    if (a != null) {
        if (a.equals("Foo")) {
            return true;
        } else return false;
    } else return false;
}

which produce the following code:

  static boolean x(java.lang.String);
    Code:
       0: aload_0       
       1: ifnull        15
       4: aload_0       
       5: ldc           #16                 // String Foo
       7: invokevirtual #21                 // Method java/lang/String.equals:(Ljava/lang/Object;)Z
      10: ifeq          15
      13: iconst_1      
      14: ireturn       
      15: iconst_0      
      16: ireturn       

  static boolean y(java.lang.String);
    Code:
       0: aload_0       
       1: ifnull        17
       4: aload_0       
       5: ldc           #16                 // String Foo
       7: invokevirtual #21                 // Method java/lang/String.equals:(Ljava/lang/Object;)Z
      10: ifeq          15
      13: iconst_1      
      14: ireturn       
      15: iconst_0      
      16: ireturn       
      17: iconst_0      
      18: ireturn       

So apart from an extraneous else jump target the code is identical. If you don’t even have the else:

static boolean z(String a) {
    if (a != null) {
        if (a.equals("Foo"))
            return true;
    return false;
}

then the result is really the same:

  static boolean z(java.lang.String);
    Code:
       0: aload_0       
       1: ifnull        15
       4: aload_0       
       5: ldc           #16                 // String Foo
       7: invokevirtual #21                 // Method java/lang/String.equals:(Ljava/lang/Object;)Z
      10: ifeq          15
      13: iconst_1      
      14: ireturn       
      15: iconst_0      
      16: ireturn