[NP] Распоредувач на задачи

import java.lang.reflect.Array;
import java.util.*;
import java.util.stream.Collectors;
import java.util.stream.IntStream;

/**
 * I Partial exam 2016
 */

interface Task {
    int getOrder();
}

interface TaskScheduler<T extends Task> {
    List<T> schedule(T tasks[]);
}


class TimedTask implements Task {
    private final int time;

    public TimedTask(int time) {
        this.time = time;
    }

    @Override
    public String toString() {
        return String.format("TT -> %d", getOrder());
    }

    @Override
    public int getOrder() {
        return time;
    }
}

class PriorityTask implements Task {
    private final int priority;

    public PriorityTask(int priority) {
        this.priority = priority;
    }


    @Override
    public String toString() {
        return String.format("PT -> %d", getOrder());
    }

    @Override
    public int getOrder() {
        return priority;
    }
}

class Schedulers<T extends Task> implements TaskScheduler<T> {

    /*
    TaskScheduler<T> result = new TaskScheduler<T>() {
        @Override
        public List<T> schedule(T tasks[]) {
            ArrayList<T> listTasks = new ArrayList<T>(Arrays.asList(tasks));
            Comparator<? super T> comparator = new Comparator<T>() {
                @Override
                public int compare(T left, T right) {
                    if (left.getOrder() < right.getOrder()) return -1;
                    else if (left.getOrder() > right.getOrder()) return 1;
                    return 0;
                }
            };
            listTasks.sort(comparator);
            return listTasks;
        }
    };
     */

    private Comparator<T> comparator = Comparator.comparing(Task::getOrder);

    public static <T extends Task> TaskScheduler<T> getOrdered() {
        return new TaskScheduler<T>() {
            @Override
            public List<T> schedule(T[] tasks) {
                return Arrays.stream(tasks)
                        .sorted(Comparator.comparing(Task::getOrder))
                        .collect(Collectors.toList());
            }
        };

    }

    /*
    TaskScheduler<T> result = new TaskScheduler<T>() {
            @Override
            public ArrayList<T> schedule(T[] tasks) {
                ArrayList<T> listTasks = new ArrayList<T>();
                for (int i = 0; i < tasks.length; i++) {
                    if (tasks[i].getOrder() < order) {
                        listTasks.add(tasks[i]);
                    }
                }
                return listTasks;
            }
        };
        return result;

     */

    public static <T extends Task> TaskScheduler<T> getFiltered(int order) {
        return tasks -> IntStream.range(0, tasks.length) // generates Integers from 0 to tasks.length
                .filter(i -> tasks[i].getOrder() < order) // returns each Integer for which the expression is satisfied
                .mapToObj(i -> tasks[i]) // returns Task[Integer]
                .collect(Collectors.toList()); // collects all those Task[Integers] into one List


        /* Before changing the TaskScheduler<T> interface to use List<T> instead of ArrayList<T> */

        /* Doesn't Work */
        /*return (ArrayList<T>) tasks -> Arrays.stream(tasks)
                .filter(task -> task.getOrder() < order)
                .collect(Collectors.toList());*/

        /* Works! using toCollection(ArrayList::new) */

        /*return tasks -> Arrays.stream(tasks)
                .filter(task -> task.getOrder() < order)
                .collect(Collectors.toCollection(ArrayList::new));*/

        /*return tasks -> IntStream.range(0, tasks.length)
                .filter(i -> tasks[i].getOrder() < order)
                .mapToObj(i -> tasks[i])
                .collect(Collectors.toCollection(ArrayList::new));*/
    }

    @Override
    public List<T> schedule(T[] tasks) {
        List<T> listTasks = new ArrayList<T>(Arrays.asList(tasks));
        return listTasks;
    }
}

class TaskRunner<T extends Task> {
    public void run(TaskScheduler<T> scheduler, T[] tasks) {
        List<T> order = scheduler.schedule(tasks);
        order.forEach(System.out::println);
    }
}

public class TaskSchedulerTest {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        int n = scanner.nextInt();
        Task[] timeTasks = new Task[n];
        for (int i = 0; i < n; ++i) {
            int x = scanner.nextInt();
            timeTasks[i] = new TimedTask(x);
        }
        n = scanner.nextInt();
        Task[] priorityTasks = new Task[n];
        for (int i = 0; i < n; ++i) {
            int x = scanner.nextInt();
            priorityTasks[i] = new PriorityTask(x);
        }
        Arrays.stream(priorityTasks).forEach(System.out::println);
        TaskRunner<Task> runner = new TaskRunner<>();
        System.out.println("=== Ordered tasks ===");
        System.out.println("Timed tasks");
        runner.run(Schedulers.getOrdered(), timeTasks);
        System.out.println("Priority tasks");
        runner.run(Schedulers.getOrdered(), priorityTasks);
        int filter = scanner.nextInt();
        System.out.printf("=== Filtered time tasks with order less then %d ===\n", filter);
        runner.run(Schedulers.getFiltered(filter), timeTasks);
        System.out.printf("=== Filtered priority tasks with order less then %d ===\n", filter);
        runner.run(Schedulers.getFiltered(filter), priorityTasks);
        scanner.close();
    }
}