Subsorting with multiple Comparators
I find your code fairly complicated. Especially the part where you split the list into sequences of sublists of equal elements is a bit convoluted. Here's what you're doing in pseudocode:

given a comparator,
for each element in the list:
    for each sublist:
       if per the comparator, the element is equal to an element in that sublist:
           add the element to the sublist,
           continue with next element
    if no sublist matched:
        add a new sublist containing that element


The most straightforward way to implement that in Java is using a labeled loop. Using that, we can continue with the next element in the outer loop once a match was found. We do not have to maintain a matchFound variable:

List&lt;List&lt;T&gt;&gt; subCollections = new ArrayList&lt;&gt;();

element:
for (T element : list) {
    for (List&lt;T&gt; subList : subCollections) {
        if (comparators[0].compare(element, subList.get(0)) == 0) {
            subList.add(element);
            continue element;
        }
    }
    // no sublist matched
    List&lt;T&gt; newList = new ArrayList&lt;&gt;();
    newList.add(element);
    subCollections.add(newList);
}


There's also no need to use a lastIndex here.

Unfortunately, what you are doing is tremendously inefficient. You re-sort each list multiple times, and invoke each comparator unnecessarily often. You are more or less implementing a crazy inefficient multi-level quicksort that partitions into multiple parts per level.

The better solution would be to create a custom comparator that loops through the list of comparators and stops when they are no longer equal:

class MultiComparator&lt;T&gt; implements Comparator&lt;T&gt; {
    private final List&lt;Comparator&lt;T&gt;&gt; comparators;

    public MultiComparator(List&lt;Comparator&lt;? super T&gt;&gt; comparators) {
        this.comparators = comparators;
    }

    public MultiComparator(Comparator&lt;? super T&gt;... comparators) {
        this(Arrays.asList(comparators));
    }

    public int compare(T o1, T o2) {
        for (Comparator&lt;T&gt; c : comparators) {
            int result = c.compare(o1, o2);
            if (result != 0) {
                return result;
            }
        }
        return 0;
    }

    public static &lt;T&gt; void sort(List&lt;T&gt; list, Comparator&lt;? super T&gt;... comparators) {
        Collections.sort(list, new MultiComparator&lt;T&gt;(comparators));
    }
}


(untested)