How to sort classes according to their inheritance level

Question

Please create an algorithm that takes a list of classes and sorts them in a way, that whenever

1. Class A is subclass of class B

2. Class A implements interface B

The index of B is smaller than A.

What I tried so far is,

public void sortClasses(Class... classes) {
        List<Class> classesToSort = new ArrayList<>();
        for(Class c : classes) {
            Class superClass = c.getSuperclass();
            if(superClass != null) {
                classesToSort.add(superClass);
            }
            Class[] interfaces = c.getInterfaces();
            if(interfaces.length > 0) {
                classesToSort.addAll(Arrays.asList(interfaces));
            }
            classesToSort.add(c);
        }
    }

I'm not sure whether this works or not.

Answer 1

If you hear "sorting" in Java, always think "Comparator". If you have a Comparator which is able to compare two elements of a given type (in your case, Class), you can sort a list of those elements using Collections.sort(elements, comparator).

To write a Comparator, you need to implement its method

public int compare(E el1, E el2);

with E being the type of the elements, so in your case

public int compare(Class<?> c1, Class<?> c2);

because you're comparing Class objects. You need to return -1 if c1 < c2, or 1 if c2 < c2, or 0 if they're equal (for this comparison).

Now you have two requirements that will help you implement the comparison:

1. class A is subclass of class B
2. class A implements the interface B

Both of these can be checked by using the method Java provides in Class called isAssignableFrom.

c1.isAssignableFrom(c2)

is true if c1 "is either the same as, or is a superclass or superinterface of, the class or interface represented by the specified Class parameter" (ie c2) - so basically c1.isSuperclassOf(c2). For your comparison, that means, if it returns true, c1 < c2.

So let's use this to write the Comparator.

public HierarchyComparator implements Comparator<Class<?>> {
    public int compare(Class<?> c1, Class<?> c2) {
        int result;
        // we need to do this check because isAssignableFrom is true in this case
        // and we would get an order that doesn't exist
        if (c1.equals(c2)) {
            return 0;
        }
        if (c1.isAssignableFrom(c2)) {
            return -1;
        } else if (c2.isAssignableFrom(c1)) {
            return 1;
        }
        // no hierarchy
        return 0;
    }
}

Then, you can sort classes by

public List<Class<?>> sort(Class<?>... classes) {
    List<Class<?>> result = new ArrayList<>(Arrays.asList(classes));
    Collections.sort(result, new HierarchyComparator());
}

Answer 2

Hope this helps. Class PrintClassHierarchy needs the input of classes which you want to print in hierarchy order.

//sample classes for tutorial
class A{

}

class B extends A {

}


class C extends A {

}


class D extends C {

}
class E extends B {

}
    class F extends B {

    }

//print hierarchy
    public class PrintClassHierarchy {
        private static final String PADDING = "        ";
        private static final String PADDING_WITH_COLUMN = "   |    ";
        private static final String PADDING_WITH_ENTRY = "   |--- ";
        private static final String BASE_CLASS = Object.class.getName();

        private final Map<String, List<String>> subClazzEntries = new HashMap<>();

        public static void main(final String[] args) {
            new PrintClassHierarchy(
                A.class,
                B.class,
                C.class,
                D.class,
                E.class,
                F.class
            ).printHierarchy();
        }

        public PrintClassHierarchy(final Class<?>... clazzes) {
            // get all entries of tree
            traverseClasses(clazzes);
        }

        public void printHierarchy() {
            // print collected entries as ASCII tree
            printHierarchy(BASE_CLASS, new Stack<Boolean>());
        }

        private void printHierarchy(final String clazzName, final Stack<Boolean> moreClassesInHierarchy) {
            if (!moreClassesInHierarchy.empty()) {
                for (final Boolean hasColumn : moreClassesInHierarchy.subList(0, moreClassesInHierarchy.size() - 1)) {
                    System.out.print(hasColumn.booleanValue() ? PADDING_WITH_COLUMN : PADDING);
                }
            }

            if (!moreClassesInHierarchy.empty()) {
                System.out.print(PADDING_WITH_ENTRY);
            }

            System.out.println(clazzName);

            if (subClazzEntries.containsKey(clazzName)) {
                final List<String> list = subClazzEntries.get(clazzName);

                for (int i = 0; i < list.size(); i++) {
                    // if there is another class that comes beneath the next class, flag this level
                    moreClassesInHierarchy.push(new Boolean(i < list.size() - 1));

                printHierarchy(list.get(i), moreClassesInHierarchy);

                moreClassesInHierarchy.removeElementAt(moreClassesInHierarchy.size() - 1);
            }
        }
    }

    private void traverseClasses(final Class<?>... clazzes) {
        // do the traverseClasses on each provided class (possible since Java 8)
        Arrays.asList(clazzes).forEach(c -> traverseClasses(c, 0));
    }

    private void traverseClasses(final Class<?> clazz, final int level) {
        final Class<?> superClazz = clazz.getSuperclass();

        if (superClazz == null) {
            // we arrived java.lang.Object
            return;
        }

        final String name = clazz.getName();
        final String superName = superClazz.getName();

        if (subClazzEntries.containsKey(superName)) {
            final List<String> list = subClazzEntries.get(superName);

            if (!list.contains(name)) {
                list.add(name);
                Collections.sort(list); // SortedList
            }
        } else {
            subClazzEntries.put(superName, new ArrayList<String>(Arrays.asList(name)));
        }

        traverseClasses(superClazz, level + 1);
    }
}

OUTPUT:

java.lang.Object
       |--- A
               |--- B
               |       |--- E
               |       |--- F
               |--- C
                       |--- D

Answer 3

You can do this using constructor.

List<String> listOfClasses = new ArrayList<>();
public class MyClass{
   public MyClass(){
      listOfClasses.add(this.getClass().getSimpleName());
   }
}
public class SubClass extends MyClass{
   public SubClass(){
       // here, first statement super() which calls constructor of superclass
       listOfClasses.add(this.getClass().getSimpleName());
   } 
}

So,when you create object in subclass, then constructor of all classes are called and these are stored in listOfClasses in sorted way.