Java 8 Lambda: Comparador

O método de Comparator tem de devolver um int, e parece que o teu está a devolver um long.

Podes mudar para:

(Message o1, Message o2)->Long.compare(o1.getTime(),o2.getTime())

Isto assume (com base na sua mensagem de erro)que o1.getTime() devolve um long.

Lambda

Java8 version:

Collections.sort(list, (o1, o2) -> o1.getTime() - o2.getTime());

Pré-Java8 versão:

    Collections.sort(list, new Comparator<Message>() {
        @Override
        public int compare(Message o1, Message o2) {
            return o1.getTime() - o2.getTime();
        }
    }); 

Aplicação

No seu problema específico, poderá ver o compare devolve int, onde o seu getTime devolve longo, que é a fonte de erro.

Pode usar qualquer um dos métodos como outro método de resposta, como:

Long.compare(o1.getTime(),o2.getTime())

Aviso

• deve evitar usar - em Comparator, o que pode causar transbordamento, em alguns casos, e interromper o seu programa.

Comparador

Usamos a interface de comparação para ordenar elementos homogéneos e heterogéneos por padrão, por ordem de ordenação personalizada.

int compare(T o1, T o2);

São precisos dois argumentos para encomendar. Devolve a

    negative integer(-1) « if first argument is less than the other
    zero             (0) « if both are equal
    positive integer (1) « if first greater than the second.

Anônimo Classes como classificar uma lista de objetos em versões anteriores do Java 8 usando Classes internas.

Uma classe anónima não pode aceder a variáveis locais no seu âmbito de inclusão que não são declarados finais ou efectivamente finais.

Comparator<Employee> timeCompare = new Comparator<Employee>() {
    @Override public int compare(Employee e1, Employee e2) {
        return e1.getCreationTime().compareTo( e2.getCreationTime() );
    }
};

Java 8 Lambda Expressions método de comparação de uing

uma expressão lambda é como um método: ela fornece uma lista de parâmetros formais e um corpo - uma expressão ou bloco - expresso em termos desses parâmetros.

LambdaExpression: LambdaParameters -> LambdaBody

qualquer variável local, parâmetro formal ou parâmetro de excepção utilizado mas não declarado num lambda a expressão deve ser declarada final ou efetivamente final, ou um erro de tempo de compilação ocorre quando a utilização é tentada.

Comparator<Employee> functional_semantics = (e1, e2) -> {
   return e1.getCreationTime().compareTo( e2.getCreationTime() );
};

Tipo Básico com suporte Lambda

Comparator<Employee> timeCompareLambda = (o1, o2) -> (int) ( o1.getCreationTime() - o2.getCreationTime());
Collections.sort(java8, timeCompareLambda );

Usando a chave extraída e comparando o método: um comparador que compara com uma chave extraída. Passar as referências usando:: keyword.

static <T> Comparator<T> comparingLong(ToLongFunction<? super T> keyExtractor)

ToLongFunction<Employee> keyExtracor = Employee::getCreationTime;
Comparator<Employee> byTime = Comparator.comparingLong( Employee::getCreationTime );

Código De Ensaio Da Amostra:

public class Lambda_Long_Comparator {
    public static void main(String[] args) {

        List<Employee> java7 = getEmployees();

        // Sort with Inner Class
        Comparator<Employee> timeCompare = new Comparator<Employee>() {
            @Override public int compare(Employee e1, Employee e2) {
                return e1.getCreationTime().compareTo( e2.getCreationTime() );
            }
        };

        // Collections.sort(list); // Defaults to Comparable<T> « @compareTo(o1)
        Collections.sort(java7, timeCompare); // Comparator<T> « @compare (o1,o2)
        System.out.println("Java < 8 \n"+ java7);

        List<Employee> java8 = getEmployees();
        Collections.sort(java8, Comparator
                .comparing( Employee::getCreationTime )
                .thenComparing( Employee::getName ));
        //java8.forEach((emp)-> System.out.println(emp));
        System.out.println("Java 8 \n"+java8);
    }

    static List<Employee> getEmployees() {
        Date date = Calendar.getInstance().getTime();
        List<Employee> list = new ArrayList<Employee>();
        list.add( new Employee(4, "Yash", date.getTime()+7));
        list.add( new Employee(2, "Raju", date.getTime()+1));
        list.add( new Employee(4, "Yas", date.getTime()));
        list.add( new Employee(7, "Sam", date.getTime()-4));
        list.add( new Employee(8, "John", date.getTime()));
        return list;
    }
}
class Employee implements Comparable<Employee> {
    Integer id;
    String name;
    Long creationTime;

    public Employee(Integer id, String name, Long creationTime) {
        this.id = id;
        this.name = name;
        this.creationTime = creationTime;
    }

    @Override public int compareTo(Employee e) {
        return this.id.compareTo(e.id);
    }

    @Override public String toString() {
        return "\n["+this.id+","+this.name+","+this.creationTime+"]";
    }

    // Other getter and setter methods
}

Ver estes postes além disso:

• Tutorial Java 8
• Java8 Lambdas vs classes anónimas
• Lambda vs desempenho anônimo da classe interna

Você deve mudar

 messagesByDeviceType.sort(
     (Message o1, Message o2) -> o1.getTime() - o2.getTime()
 );

A

messagesByDeviceType.sort(
    Comparator.comparing((Message m) -> m.getTime())
);

Que assume que o valor é Comparable, que fornece uma ordem natural de ordenação.

Se quiser adicionar mais campos, pode acorrentá-los ao comparador. por exemplo, Ordenar primeiro pelo tempo, e depois pelo remetente:

messagesByDeviceType.sort(
    Comparator
        .comparing((Message m) -> m.getTime())
        .thenComparing((m)     -> m.getSender())
);

Para reverter a ordem de qualquer Comparator, cadeia o método reveresed() para ele, por exemplo, para ordenar primeiro pelo tempo descendente, e depois pelo remetente:

messagesByDeviceType.sort(
    Comparator
        .comparing((Message m) -> m.getTime())
        .reversed()
        .thenComparing((m)     -> m.getSender())
);

Ver também https://docs.oracle.com/javase/8/docs/api/java/util/Comparator.html