博客

参考

https://www.liaoxuefeng.com/article/001411306573093ce6ebcdd67624db98acedb2a905c8ea4000/

Java 8终于引进了lambda表达式，这标志着Java往函数式编程又迈进了一小步。

在Java 8以前的代码中，为了实现带一个方法的接口，往往需要定义一个匿名类并复写接口方法，代码显得很臃肿。比如常见的

Comparator

接口：

String[] oldWay = "Improving code with Lambda expressions in Java 8".split(" ");
Arrays.sort(oldWay, new Comparator<String>() {
    @Override
    public int compare(String s1, String s2) { // 忽略大小写排序: return s1.toLowerCase().compareTo(s2.toLowerCase()); } }); System.out.println(String.join(", ", oldWay)); 

对于只有一个方法的接口，在Java 8中，现在可以把它视为一个函数，用lambda表示式简化如下：

String[] newWay = "Improving code with Lambda expressions in Java 8".split(" ");
Arrays.sort(newWay, (s1, s2) -> {
    return s1.toLowerCase().compareTo(s2.toLowerCase()); }); System.out.println(String.join(", ", newWay)); 

Java 8没有引入新的关键字lambda，而是用

()->{}

这个奇怪的符号表示lambda函数。函数类型不需要申明，可以由接口的方法签名自动推导出来，对于上面的lambda函数：

(s1, s2) -> {
    return s1.toLowerCase().compareTo(s2.toLowerCase());
});

参数由

Comparator<String>

自动推导出

String

类型，返回值也必须符合接口的方法签名。

实际上，lambda表达式最终也被编译为一个实现类，不过语法上做了简化。

稍微变动一下

参考：

https://www.nowcoder.com/practice/8fecd3f8ba334add803bf2a06af1b993?tpId=13&tqId=11185&rp=2&ru=/ta/coding-interviews&qru=/ta/coding-interviews/question-ranking

String[] strArr={"32","43"}; 
Arrays.sort(strArr,new Comparator<String>(){ @Override public int compare(String s1, String s2) { String c1 = s1 + s2; String c2 = s2 + s1; return c1.compareTo(c2); }

用java8方式改写成如下形式：
String[] strArr={"21","33"};
Arrays.sort(strArr,(a,b)->{
                String c=a+""+b;
                String d=b+""+a; return c.compareTo(d); }); 
上面代码实现的是：
for (int i=0;i<numbers.length;i++){
for (int j=i+1;j<numbers.length;j++){
 Long a=Long.valueOf(numbers[i]+""+numbers[j]);
 Long b=Long.valueOf(numbers[j]+""+numbers[i]);
if(a>b){
int temp=numbers[i];
 numbers[i]=numbers[j];
 numbers[j]=temp;
 }
 }
}

对于Java自带的标准库里的大量单一方法接口，很多都已经标记为

@FunctionalInterface

，表明该接口可以作为函数使用。

以

Runnable

接口为例，很多时候干活的代码还没有定义class的代码多，现在可以用lambda实现：

public static void main(String[] args) {
    // old way:
    Runnable oldRunnable = new Runnable() { @Override public void run() { System.out.println(Thread.currentThread().getName() + ": Old Runnable"); } }; Runnable newRunnable = () -> { System.out.println(Thread.currentThread().getName() + ": New Lambda Runnable"); }; new Thread(oldRunnable).start(); new Thread(newRunnable).start(); } 

在未来的Java代码中，会出现越来越多的

()->{}

表达式。