使用 lambda 表达式进行比较 假设错误修复问题只是 lambda比较器和自然顺序在简单的情况下，你不需要?

如何解决使用 lambda 表达式进行比较 假设错误修复问题只是 lambda比较器和自然顺序在简单的情况下，你不需要?

import java.util.*;  
import java.io.*; 

class Simpson implements Comparable<Simpson> {
    String name;

    Simpson(String name) {
        this.name = name;
    }

    @Override
    ( simpson) -> {
        return this.name.compareto(simpson.name);
    }
}

public class Main {

     public static void main(String... sortingWithList) {
        List<Simpson> simpsons = new ArrayList<>();
        simpsons.add(new Simpson("Homer "));
        simpsons.add(new Simpson("Marge "));
        simpsons.add(new Simpson("Bart "));
        simpsons.add(new Simpson("Lisa "));

        Collections.sort(simpsons);
        simpsons.stream().map(s -> s.name).forEach(System.out::print);

我想将 lambda 表达式用于可比对象，但出现错误。

解决方法

用它代替 Collections.sort：

simpsons.sort((s1,s2) -> s1.compareToIgnoreCase(s2));

,

我认为问题在于您正在实现 Comparable，这意味着它实现了 compareTo 方法。

import java.util.*;  
import java.io.*; 

class Simpson implements Comparable<Simpson> {
    String name;

    Simpson(String name) {
        this.name = name;
    }

    @Override
    int compareTo(Simpson other){
        return this.name.compareTo(other.name);
    }
}

public class Main {

     public static void main(String... sortingWithList) {
        List<Simpson> simpsons = new ArrayList<>();
        simpsons.add(new Simpson("Homer "));
        simpsons.add(new Simpson("Marge "));
        simpsons.add(new Simpson("Bart "));
        simpsons.add(new Simpson("Lisa "));

        Collections.sort(simpsons);
        simpsons.stream().map(s -> s.name).forEach(System.out::print);

     }

}

,

查看接口 Comparable<T> 的 Java 文档。

它提供了一种方法来将此对象与相同类型的另一个对象（传入参数 o）进行比较（在您的情况下：T 是 Simpson）

int compareTo(T o)

此外，您的 name 属性已经具有可比性，因为 String 类型也是 implements this interface。所以你可以简单地委托（正如你已经做得很好）。

假设错误

请更正方法签名，它目前不完整，可能是编译错误的原因：

@Override（辛普森）-> { 返回 this.name.compareTo(simpson.name); . }

修复问题

为方法提供与接口规定相同的名称和返回类型和参数：

public int compareTo(Simpson o) {
    if (o == null || this.name == null) return -1; // could adjust to your needs to avoid NPE
    return this.name.compareTo( o.name );
}

最重要的是：由于接口是从外部调用的，实现的方法必须是public！

只是 lambda

或者只是按照前面的答案 ?

中的建议，使用适当的 lambda 表达式 来流式传输

simpsons.stream()
    .map(s -> s.name) // map serves like delegation to name
    .sorted((s1,s2) -> s1.compareToIgnoreCase(s2)) // sort previous with current element,here: names alphabetically
    .forEach(System.out::print);

在流中排序时的区别：

• 像集合一样使用 sorted()，而不是 sort()
• 您可以将 Comparator 指定为 functional 或 lambda 表达式
• 您还可以按自然顺序排序（如下面的问题所示）

还有另一种更简单的方法来按字典顺序对字符串进行排序：

Java 8 Stream sorting List of String

比较器和自然顺序

您也可以将两者结合起来： (1) 可比较的接口，由 Simpson 实现 (2) 带有函数的流，按比较器或 lambda 表达式排序（视情况而定）。

simpsons.stream() 
   .sorted((s1,s2) -> s1.compareTo(s2)) // sort previous with current Simpson ! explicit comparator passed as lambda
   .forEach( s -> System.out.println(s.name) );  // print name of Simpson in new line

在简单的情况下，你不需要?

或者您可以使用智能排序和！通过替换为 .sorted()，隐式重用现有的自然顺序。 也尝试一下开箱即用的情况（没有任何 compareTo ⁉️）：

class Simpson {
    String name;

    Simpson(String name) {
        this.name = name;
    }

    @Override
    public String toString() {
        return name;
    }

}

// main omitted,just the usage example:
simpsons.stream().sorted().forEach(System.out::println );

如果没有可比性，自然排序会回退到使用 toString。打印使用 toString 的方式相同。

排序是否正确，打印是否吸引人❔