Way to optimize comparator

Is there any way to order people name's by surname1, if not, surname2, if not, name, more efficiently than this?
This is too slow, thanks!

		Collections.sort(lResult, new java.util.Comparator<Map>() {
	       public int compare(Map m1, Map m2) {
	    	   
	    	   int lResult;	    	   
	    	   String i1= (String)m1.get("surname1");
	    	   String i2= (String)m2.get("surname1");
	    	   if((i1 == null) || (i2==null)) {lResult = 0;}
	    	   else {lResult = i1.compareTo(i2);}
	
		       if (lResult == 0) {		        	
					String t1= (String)m1.get("surname2");
					String t2= (String)m2.get("surname2");
		    	    if((t1 == null) || (t2==null)) {lResult = 0;}
		    	    else {lResult = t1.compareTo(t2);}
					
		        }  
		       
		       if (lResult == 0) {
					String x1= (String)m1.get("name");
					String x2= (String)m2.get("name	");	
		    	    if((x1 == null) || (x2==null)) {lResult = 0;}
		    	    else {lResult = x1.compareTo(x2);}
		        }  
		        return lResult;
	       }
		});

Irrespective of speed, your comparator isn't correct.

The only things which should be considered equal are, well, equal things. You would currently consider null to be equal to "non-null", and so that would lead to odd behavior.

Specifically, what you seem to be doing is comparing the first pair of corresponding values which are both non-null. This violates the transitivity requirement of Comparator implementations. Consider, for example:

A = {"surname1": "A",  "surname2", null, "name": "A"}
B = {"surname1": null, "surname2", "B",  "name": "B"}
C = {"surname1": "A",  "surname2", "C",  "name": null}

According to your comparator, A < B and B < C. However, A == C, thus making it an invalid comparator.

The easiest way to write this Comparator - correctly - would be something like:

nullsLast(comparing(m -> (String) m.get("surname1")))
    .thenComparing(nullsLast(comparing(m -> (String) m.get("surname2"))))
    .thenComparing(nullsLast(comparing(m -> (String) m.get("name"))));

where nullsLast and comparing are methods from Comparator. (nullsFirst can be used instead, if that's how you'd prefer to handle nulls).

With pre-Java 8, you can write an equivalent comparison using a helper method:

public int compare(Map m1, Map m2) {
  int lResult;

  lResult = compare(m1, m2, "surname1");
  if (lResult != 0) return lResult;

  lResult = compare(m1, m2, "surname2");
  if (lResult != 0) return lResult;

  return compare(m1, m2, "name");
}

private int compare(Map m1, Map m2, String key) {
  String v1= (String)m1.get(key);
  String v2= (String)m2.get(key);
  if (v1 != null && v2 != null) {
    return v1.compareTo(v2);
  }
  return Boolean.compare(v1 != null, v2 != null);
}

Or use something like Guava's ComparisonChain.