Untitled

        public static class TopNExtractor {
                private static class ReverseOrderComparator<G extends Comparable<? super G>> implements Comparator<G> {
                        @Override
                        public int compare(G o1, G o2) {
                                return -(o1.compareTo(o2));
                        }
                }
                public static <G extends Comparable<? super G>> List<G> extract(List<G> source, int n) {
                        List<G> result = extractWithoutSort(source, n);
                        // how can i sort as reverse order
                        Collections.sort(result, new ReverseOrderComparator<G>());
                        Collections.reverse(result);
                        return result;
                }
                public static <G extends Comparable<? super G>> List<G> extractWithoutSort(List<G> source, int n) {
                        if (source.size() == 0)
                                return null;
                        G pivot = source.get(0);
                        int sourceSize = source.size();
                        List<G> below = new ArrayList<G>(sourceSize / 2), above = new ArrayList<G>(sourceSize / 2);
                        List<G> equal = new ArrayList<G>();
                        for (G s : source) {
                                if (s.compareTo(pivot) < 0)
                                        below.add(s);
                                else if (s.compareTo(pivot) > 0)
                                        above.add(s);
                                else
                                        equal.add(s);
                        }
                        if (above.size() > n)
                                return extractWithoutSort(above, n);
                        else if (above.size() + equal.size() > n) {
                                above.addAll(equal.subList(0, n - above.size()));
                                return above;
                        } else {
                                above.addAll(equal);
                                above.addAll(extractWithoutSort(below, n - above.size()));
                                return above;
                        }
                }
        }