字符串排序空值

Question

I have a string arraylist with some null values and some strings. I don't want to sort the arraylist but I should sort the arraylist such that null values comes last. Lets say arraylist is {1,2,null,6,5,null, 3} , I should get null values last {1,2,6,5,3,null,null} .

Solution , I currently have: Right now, I am constructing new arraylist and If the value is null , I am not pushing it to new list otherwise I am adding it to new arraylist.

Any other better solution?

Thanks for the help.

Answer 1

If you are using Java 8, you can easily build the comparator you need:

Arrays.sort(stringArray, Comparator.nullsLast(Comparator.naturalOrder()));

But if you not using java 8 you can have a comparator like below

public class StringNullComparator implements Comparator<String> {
    public int compare(String stringOne, String stringTwo) {
        if (stringOne != null && stringTwo != null)
            return stringOne.compareTo(stringTwo);
        return (stringOne == stringTwo)?0:(stringOne==null? 1 : -1);
    }
}

And you can use at stated below

Arrays.sort(stringArray, new StringNullComparator());   

Answer 2

Custom Comparator to pass to sort:

public class StringComparator implements Comparator<String> {
    public int compare(String s1, String s2) {
        if (s1 != null && s2 != null)
            return s1.compareTo(s2);
        return (s1 == null) ? 1 : -1;
    }
}

then:

Collectios.sort(list, new StringComparator());

Answer 3

If you want to avoid explicitly iterating over the whole list you could use ArrayList.indexOf() to find the null values, then remove() them. If you want to keep the values in the list you can then just add a null value to the end of the list. However I would imagine this approach is not great in terms of performance if this is a concern.

Answer 4

您可以使用apache 中的 NullComparator 。

Collections.sort(list, new NullComparator());

Answer 5

如何构造新的数组列表，如果它是一个真正的值，则将其添加到新列表中，如果它是一个空增量一个计数器。最后添加等于计数器值的空值。

Answer 6

If you want to sort null to the end and keep the order for the non-null elements this Comparator would do that :

class CompareStrings implements Comparator<String> {

    @Override
    public int compare(String o1, String o2) {
        if (o1 == null && o2 != null)
            return 1;
        if (o2 == null && o1 != null)
            return -1;
        return 0;
    }   
}

If both String are null or non-null they will compare equal. If only one is null it will compare as smaller than the non-null one.

Answer 7

How about:

class MyInteger implements Comparator<Integer> {
    public int compare(Integer arg0, Integer arg1) {
        if(arg1 == null) {
            return -1;
        }
        return 0;
    }
}

And we can use it like:

List<Integer> al = new ArrayList<Integer>();
al.add(1);
al.add(2);
al.add(null);
al.add(6);
al.add(5);
al.add(null);
al.add(3);

Collections.sort(al, new MyInteger());

Answer 8

All other solutions involve sorting. As you mentioned, you don't really need sorting. In case time complexity is a concern, you can use the following linear time solution (in-place):

  public static <T> void nullsToEndInPlace(List<T> l) {
    int i = 0;
    int j = l.size() - 1;
    while (i < j) {
      T left = l.get(i);
      T right = l.get(j);
      if (left != null) {
        i++;
      } else if (right == null) {
        j--;
      } else {
        l.set(i, right);
        l.set(j, null);
        i++;
        j--;
      }
    }
  }

Answer 9

Try this.

    List<String> list = new ArrayList<>();
    list.add("BR64");
    list.add("SWG620");
    list.add("");
    list.add("sw0");
    list.add("R124");
    list.add("R219");
    list.add("TaGh20");
    list.add("SW6505");
    list.add("");
    list.add(null);
    list.add("SW_6505");
    list.add("swd_157");
    list.add("localhost");
    list.add("qaGh20_241");
    list.add("gen");
    list.add(null);
    list.add("taGh20");
    list.add("zen");
    list.add("QWG");
    list.add("SWG62_");
    list.add("SWG620");

    Collections.sort(list, new Comparator<String>() {
        @Override
        public int compare(String o1, String o2) {
            if (o1 != null && o2 != null && o1.length() > 0 && o2.length() > 0) {
                return (Character.toLowerCase(o1.charAt(0)) == Character.toLowerCase(o2.charAt(0)))
                        ? o1.compareTo(o2)
                        : (Character.toLowerCase(o1.charAt(0)) + o1.substring(1))
                                .compareTo((Character.toLowerCase(o2.charAt(0)) + o2.substring(1)));
            } else {
                return (o1 == o2) ? 0 : ((o1 == null || o1 == "") ? 1 : -1);
            }
        }
    });
    System.out.println(list);

Output-:[BR64, gen, localhost, QWG, qaGh20_241, R124, R219, SW6505, SWG620, SWG620, SWG62_, SW_6505, sw0, swd_157, TaGh20, taGh20, zen, , , null, null]

Answer 10

Both list.sort() and sorted() have a key parameter to specify a function to be called on each list element prior to making comparisons.

For example, here's a case-insensitive string comparison:

sorted("This is a test string from sohan".split(), key=str.lower)                                                                                                                   
['a', 'from', 'is', 'sohan', 'string', 'test', 'This'] 

here, key=str.lower() will convert every string to lower case and then sort the result.

For more info about sorting click here