使用lambda表达式对数组进行排序

最近做题，总是看到大佬们使用lambda表达式秀操作，之前一次周赛中，我疯狂排序hhh大佬一行代码5555~

什么是lambda表达式？

Java Lambda表达式的一个重要用法是简化某些匿名内部类（Anonymous Classes）的写法。
实际上Lambda表达式并不仅仅是匿名内部类的语法糖，JVM内部是通过invokedynamic指令来实现Lambda表达式的。

可查看教程：lambda表达式

Lambda 表达式可用于匿名内部类的简化写法。
匿名内部类中最关键的内容是方法的参数，方法体，以及返回值，而在 Lambda 表达式中，关注的就是这三个关键的东西。

Lambda 表达式的标准格式：

(参数类型 参数名) -> {
    方法体;
    return 返回值;
}

格式解释：

小括号中的参数和之前方法的参数写法一样，可以写任意个参数，如果多个参数，要使用逗号隔开。
-> 是一个运算符，表示指向性动作。
大括号中的方法体以及 return 返回值的写法和之前方法的大括号中的写法一样。

Lambda 表达式是函数式编程思想。
函数式编程：可推导，就是可省略。

因为在 Thread 构造方法中需要 Runnable 类型的参数，所以可以省略 new Runnable。
因为 Runnable 中的只有一个抽象方法 run，所以重写的必然是这个 run 方法，所以可以省略 run 方法的声明部分（public void run）

Lambda 表达式可以省略面向对象中的一些条条框框，让我们只关注最核心的内容。

Lambda 表达式的省略规则：

1. 小括号中的参数类型可以省略。
2. 如果小括号中只有一个参数，那么可以省略小括号。
3. 如果大括号中只有一条语句，那么可以省略大括号，return，分号。

Lambda 使用条件

Lambda 表达式的使用前提:
必须有接口（不能是抽象类），接口中有且仅有一个需要被重写的抽象方法。
必须支持上下文推导，要能够推导出来 Lambda 表达式表示的是哪个接口中的内容。
可以使用接口当做参数，然后传递 Lambda 表达式(常用)，也可以将 Lambda 表达式赋值给一个接口类型的变量。

lambda表达式用于数组的排序

lambda表达式有很多用途，这里重点查了一下用于排序。
从菜鸟教程看到了几种用法：(偷师一波）

String[] players = {"Rafael Nadal", "Novak Djokovic",   
    "Stanislas Wawrinka", "David Ferrer",  
    "Roger Federer", "Andy Murray",  
    "Tomas Berdych", "Juan Martin Del Potro",  
    "Richard Gasquet", "John Isner"};  
   
// 1.1 使用匿名内部类根据 name 排序 players  
Arrays.sort(players, new Comparator<String>() {  
    @Override  
    public int compare(String s1, String s2) {  
        return (s1.compareTo(s2));  
    }  
});

// 1.2 使用 lambda expression 排序 players

Comparator<String> sortByName = (String s1, String s2) -> (s1.compareTo(s2));  
Arrays.sort(players, sortByName);  

// 1.3 也可以采用如下形式:

Arrays.sort(players, (String s1, String s2) -> (s1.compareTo(s2)));  

其他的排序如下所示。
和上面的示例一样,代码分别通过匿名内部类和一些lambda表达式来实现Comparator :

// 1.1 使用匿名内部类根据 surname 排序 players

Arrays.sort(players, new Comparator<String>() {  
    @Override  
    public int compare(String s1, String s2) {  
        return (s1.substring(s1.indexOf(" ")).compareTo(s2.substring(s2.indexOf(" "))));  
    }  
});  
  

// 1.2 使用 lambda expression 排序,根据 surname

Comparator<String> sortBySurname = (String s1, String s2) ->   
    ( s1.substring(s1.indexOf(" ")).compareTo( s2.substring(s2.indexOf(" ")) ) );  
Arrays.sort(players, sortBySurname);  
 

// 1.3 或者这样,

Arrays.sort(players, (String s1, String s2) ->   
      ( s1.substring(s1.indexOf(" ")).compareTo( s2.substring(s2.indexOf(" ")) ) )   
    );  
 

// 2.1 使用匿名内部类根据 name lenght 排序 players

Arrays.sort(players, new Comparator<String>() {  
    @Override  
    public int compare(String s1, String s2) {  
        return (s1.length() - s2.length());  
    }  
});  
  

// 2.2 使用 lambda expression 排序,根据 name lenght

Comparator<String> sortByNameLenght = (String s1, String s2) -> (s1.length() - s2.length());  
Arrays.sort(players, sortByNameLenght);  

// 2.3 or this

Arrays.sort(players, (String s1, String s2) -> (s1.length() - s2.length()));  

// 3.1 使用匿名内部类排序 players, 根据最后一个字母

Arrays.sort(players, new Comparator<String>() {  
    @Override  
    public int compare(String s1, String s2) {  
        return (s1.charAt(s1.length() - 1) - s2.charAt(s2.length() - 1));  
    }  
});  

// 3.2 使用 lambda expression 排序,根据最后一个字母

Comparator<String> sortByLastLetter =   
    (String s1, String s2) ->   
        (s1.charAt(s1.length() - 1) - s2.charAt(s2.length() - 1));  
Arrays.sort(players, sortByLastLetter);  
  

// 3.3 or this

Arrays.sort(players, (String s1, String s2) -> (s1.charAt(s1.length() - 1) - s2.charAt(s2.length() - 1)));