Java: Arrays.sort(…) with Objects and nulls

You don't want to have nulls in your code, you don't want to check against null, you don't want to stumble upon a null, and you don't want a null to carry semantics.

Therefore you don't want an array.

If you like to use an Collection with varying size, don't use Arrays.

Use an ArrayList for example, easy to use, variable size, no need to use nulls.

If you remove element 2 from an ArrayList:

   List <JPanel> al = new ArrayList <JPanel> ();
   al.add (new JPanel ());
   al.add (new JPanel ());
   al.add (new JPanel ());
   al.add (new JPanel ());

   al.remove (1); // 0-based numbering like in Arrays. 

Now element 2 and 3 will slip one position to the front. How long is your Array now?

   System.out.println (al.size ()); 

No null in the List, no need to test against null, iteration?

   for (JPanel jp : al) 
        // do something to every jp.

Don't use null in your code, but ban it!

Don't use Arrays for collections of varying size!

Your example is unclear, and clearly doesn't match your real application requirements. (It makes no sense to sort a bunch of undifferentiated Object instances!)

So I'm going to take a stab ... and guess that you are really just trying to move the nulls to the end. (The other non-null elements were already sorted, and removing one / some won't alter that. Or maybe they don't need to be sorted at all ...)

If that is the case, then the simple way is to do this:

• create a temporary 1-D array of the right size
• iterate the the 2-D array in the order that you want the elements to appear ( e.g. rows within columns ) and copy the non-null elements into the 1-D array.
• iterate the 2-D array again, copying back from the 1-D array.

Alternatively, if you DO need to sort the non-null elements, you can do the sorting in the 1-D array using Arrays.sort(Object[], int, int). Choose the bounds to exclude the nulls at the end of the array. This avoids the need to create a "complex" comparator that understands null.

Your current approach is just too complicated ... and unnecessarily complicated code is a bad idea.

And if your intention is to just move the nulls to the end while preserving the order of the other objects, then sort is an expensive way to do it. (It will work with the Comparator that you defined, because the sort(Object[] ...) methods are documented as doing a stable sort. But in this case, I'm tempted to say that it is unfortunate that it works.)

Reason your code is failing as you are just checking if the outer array is null or not, you should also check the contents of the outer array.

See this code:

import java.util.Arrays;
import java.util.Comparator;

public class Test2DArrayComparator {
    public static void main(String[] args) {
        Object[][] array = new Object[][]{
                {new Object(), null, new Object(), new Object()}, 
                {null, null, new Object(), new Object()},
                {new Object(), new Object(), new Object(), new Object()}
                };

        for (int i = 0; i < 3; i++) {
            for (int j = 0; j < 4; j++) {
                System.out.println("Before sorting: (i = " + i + " j = " + j + " null = " + (array[i][j] == null) + ")");
            }
        }

        class ArrayComparator implements Comparator<Object>{

            @Override
            public int compare(Object a, Object b) {
                if(a == null && b == null){
                    return 0;
                } else if(a != null && b == null){
                    return 1;
                } else if(a == null && b != null){
                    return -1;
                } else {
                    return checkConents(((Object[])a), ((Object[])b));
                }
            }

        }
        Arrays.sort(array, new ArrayComparator());

        for (int i = 0; i < 3; i++) {
            for (int j = 0; j < 4; j++) {
                System.out.println("After sorting: (i = " + i + " j = " + j + " null = " + (array[i][j] == null) + ")");
            }
        }

    }

    static int checkConents(Object[] first, Object[] second){
        for(int iDx = 0; iDx < first.length; iDx++){
            if(first[iDx] != null && second[iDx] == null){
                return -1;
            } else if(first[iDx] == null && second[iDx] == null){
                return 0;
            } else if(first[iDx] == null && second[iDx] != null){
                return 1;
            }
        }
        return -1;
    }
}

After checking for the validity of outer array checkContent is called to compare the contents, also note checkContent assumes that both the array are of same size.

Array is of type Object[][]. So when you do sort(array, theComparator) you are arranging each of the three Object[] that are held within array. You are not sorting the contents of each of those three arrays.

And since none of the three Object[] in array are null, your comparator returns zero on each comparison and so those Object[] stay in place within array.

So you'll need to convert to a 1-D array of Object, sort it, then break it back up into a 2-D array.