This is what Java internal code uses (on other compare methods):

public static boolean compare(String str1, String str2) {
    return (str1 == null ? str2 == null : str1.equals(str2));
}

!c.equals(null)

That line is calling the equals method on c, and if c is null then you'll get that error because you can't call any methods on null. Instead you should be using

c != null

Using Java 8:

private static Comparator<String> nullSafeStringComparator = Comparator
        .nullsFirst(String::compareToIgnoreCase); 

private static Comparator<Metadata> metadataComparator = Comparator
        .comparing(Metadata::getName, nullSafeStringComparator)
        .thenComparing(Metadata::getValue, nullSafeStringComparator);

public int compareTo(Metadata that) {
    return metadataComparator.compare(this, that);
}

Here is another twist, roughly similar to dariosicily's proposal.

It differs in the following points:

• It create the aggregated comparator only once, then store it in a static field. Why? Because functions such as Comparator.nullsFirst() and Comparator.comparing() implies object allocation, which you definitely want to avoid if your comparator is called from tight loops (for example, a sort or tree insertion algorithm).
• Null checks on the LoadAccount objects themselves have also been delegated to Comparator.nullsFirst(). That means that absolutely no if statement is required!
• I moved that comparator to a public, static field of a utility class. I have learned from personal experience that comparators on domain model objects very often come in "families". In different places, you want different sorting strategies, for the same objects. Here, for demonstration, I also included one comparator for loadAmount (that is, without fallback on tie), and another one for creationDate. But you can see how this idea can be generalized.
• In this sample, I have adopted an uncommon indentation strategy. I think this is justified in this case because it helps make it easier to see which fields are sorted by each comparator, and in which order. This is of great importance when you have comparators that involve a significant number of fields.

    public class LoanAccountAmountComparators {

        /**
         * A comparator that sort LoanAccounts, by load's amount, in decreasing order.
         */
        public static final Comparator<LoanAccount> BY_AMOUNT = 
            Comparator.nullsFirst(
                Comparator.comparing(
                    LoanAccount::getLoanAmount, Comparator.nullsFirst(Comparator.reverseOrder())
                );
            );

        /**
         * A comparator that sort LoanAccounts, by creation date, in ascending order.
         */
        public static final Comparator<LoanAccount> BY_DATE = 
            Comparator.nullsFirst(
                Comparator.comparing(
                    LoanAccount::getCreationDate, Comparator.nullsFirst(Comparator.naturalOrder())
                );
            );

        /**
         * A comparator that sort LoanAccounts, by creation amount (in descending order),
         * then by date (in ascending order).
         */
        public static final Comparator<LoanAccount> BY_AMOUNT_AND_DATE = 
            Comparator.nullsFirst(
                Comparator.comparing(
                    LoanAccount::getLoanAmount, Comparator.nullsFirst(Comparator.reverseOrder())
                ).thenComparing(
                    LoanAccount::getCreationDate, Comparator.nullsFirst(Comparator.naturalOrder())
                );
            );
    }

It should be noted that, in this example, all fields involved are indeed some kind of objects. If, however, your comparator would involve fields containing primitive types, then you should use the corresponding Comparator.comparing<primitiveType> function (that is, never let some primitive be boxed to object only so it can be compared to Comparator.naturalOrder().

I would use boolean variables to make the code more readable:

private int compareDateStrings(BeanToDoTask arg0, BeanToDoTask arg1, String strProperty) {
    /* Don't worry too much about this part. */
    String strDate0 = BeanUtils.getProperty(arg0, strProperty); _logger.debug("strDate0 = " + strDate0);
    String strDate1 = BeanUtils.getProperty(arg1, strProperty); _logger.debug("strDate1 = " + strDate1);

    boolean isStrDate0Empty = (strDate0 == null || strDate0.isEmpty());
    boolean isStrDate1Empty = (strDate1 == null || strDate1.isEmpty());

    if (isStrDate0Empty && isStrDate1Empty)
        return 0;
    // at least one of them is not empty    
    if (isStrDate0Empty)
        return -1;
    if (isStrDate1Empty)
        return 1;
    //none of them is empty
    return strDate0.compareTo(strDate1);
}

Default value to char primitives is 0 , as its ascii value. you can check char if it is null. for eg:

char ch[] = new char[20]; //here the whole array will be initialized with '\u0000' i.e. 0
    if((int)ch[0]==0){
        System.out.println("char is null");
    }

Yes, there is no problem allowing null for instance fields - just make sure its sorting order is defined. Most natural would be putting it either before or after all real strings, but you could do anything here, just do it consistently. (For example, you could sort null like "null".)

Here is an example implementation for a single member:

class Example implements Comparable<Example> {

   @Nullable
   private String member;

   // TODO: getter, setter, constructor, ...

   public int compareTo(Example that) {
      if(this.member == null)
         if(that.member == null)
            return 0; //equal
         else
            return -1; // null is before other strings
       else // this.member != null
         if(that.member == null)
            return 1;  // all other strings are after null
         else
            return this.member.compareTo(that.member);
   }
}

Please note that the specification of Comparable.compareTo() only has a constraint for o.compareTo(null) (which should behave just like - null.compareTo(o), i.e. throw a NullPointerException), but not about how null fields are handled (it doesn't mention fields at all, so a class could return whatever it wants, as long as the antisymmetry, reflexivity and transitivity is ensured).