首页 > 代码库 > java语法糖

java语法糖

2024-10-18 22:25:02   202人阅读

语法糖

    Java语法糖系列，所以首先讲讲什么是语法糖。语法糖是一种几乎每种语言或多或少都提供过的一些方便程序员开发代码的语法，它只是编译器实现的一些小把戏罢了，编译期间以特定的字节码或者特定的方式对这些语法做一些处理，开发者就可以直接方便地使用了。这些语法糖虽然不会提供实质性的功能改进，但是它们或能提高性能、或能提升语法的严谨性、或能减少编码出错的机会。Java提供给了用户大量的语法糖，比如泛型、自动装箱、自动拆箱、foreach循环、变长参数、内部类、枚举类、断言（assert）等

 

 

 

断言（assert）

开启断言

  • 用java 命令在console下直接运行class文件，跟 -ea 启动参数即可

技术分享

参考文章

  • 单独给某个程序制定运行参数

技术分享

  • 给整个java运行环境配置默认参数

技术分享

 

一、

 

语法形式

Java2在1.4中新增了一个关键字：assert。在程序开发过程中使用它创建一个断言(assertion)，它的
语法形式有如下所示的两种形式：
1、assert condition;
这里condition是一个必须为真(true)的表达式。如果表达式的结果为true，那么断言为真，并且无任何行动
如果表达式为false，则断言失败，则会抛出一个AssertionError对象。这个AssertionError继承于Error对象，
而Error继承于Throwable，Error是和Exception并列的一个错误对象，通常用于表达系统级运行错误。
2、asser condition:expr;
这里condition是和上面一样的，这个冒号后跟的是一个表达式，通常用于断言失败后的提示信息，说白了，它是一个传到AssertionError构造函数的值，如果断言失败，该值被转化为它对应的字符串，并显示出来。

使用示例：
技术分享

技术分享

 

 

 

语法改进

Foreach与变长参数

技术分享

技术分享

 

Foreach和边长参数都是语法糖。

For Array循环是标准的数组下标循环的语法糖。

技术分享

For Collection 是迭代器的语法糖。

技术分享

技术分享

 

技术分享

技术分享

 

可变长参数，每次都会初始化一个参数长度数组，并申请内存和赋值。在多次调用的情况这个消耗是没有必要且明显的。应当根据提供固定参数个数的方法。

关于返回值的问题。

技术分享

基本类型拆箱装箱

技术分享

技术分享

true | false的原因

Integer的享元设计，上限取决于业务数字使用范围。

技术分享

技术分享

空指针原因是integer.intValue();这是个对象方法

技术分享

 

内部类与资源自动管理

技术分享

技术分享

字节码文件中没有其他类信息，只有本类方法和类描述，内部类表

技术分享

自动关闭资源在字节码文件中还是生成了close方法

技术分享

 

泛型(Generic)

    支持创建可以按类型进行参数化的类.可以把类型参数看作是使用参数类型时指定的类型占位符，泛型能保证大型应用程序的类型安全和良好的维护性。Java泛型的实现是语法糖，在编译完成后并没有保留参数化类型的信息。因此你可以通过反射获取后添加非泛型数据，当然一般不会这么做。泛型的好处在于：可以定义一类数据集合，进行相同的操作，如果非泛型成员，在编译时候就可以检测；可以在声明时指定具体类型，这样避免写过多的子类。

泛型可以在方法和类（接口、抽象类）上声明。语法为<T> ，T表示泛型，可以是任意字母，一般T便是type类型，E表示元素等。在运行时T已经确定。

    数组与泛型

数组是协变的，例如：参数类型为Object[]，表示可以传任意数组。如果Sub为Super的子类型，那么数组类型Sub[]就是Super[]的子类型。List<Sub>与List<Super>并没有什么关系。

如果进行类型转换，数组在运行时才知道具体的类型，这会导致ArrayStoreException异常，而泛型在编译期间检查错误，确保为某一类型。

泛型的运行时擦除，导致不能定义泛型数组。因为运行时并不保存泛型类型信息。

 

泛型用法

List<E>、List<?>与原生List。

泛型的上限与下限

 

枚举

创建枚举类型要使用 enum 关键字，隐含了所创建的类型都是 java.lang.Enum 类的子类（java.lang.Enum 是一个抽象类）。枚举类型符合通用模式 Class Enum<E extends Enum<E>>，而 E 表示枚举类型的名称。枚举类型的每一个值都将映射到 protected Enum(String name, int ordinal) 构造函数中，在这里，每个值的名称都被转换成一个字符串，并且序数设置表示了此设置被创建的顺序。但是并不推荐显示调用序数作为枚举映射列表。

简介

这个例子描述人类的性别，人类的性别记录应该为三种男、女、不确定。枚举的元素是确定的而且在加载类的时候就会初始化为一个对象。枚举对象跟普通的类对象，没有任何区别。你可以增加一个方法，做一些操作。我们一般利用枚举对象是特定做一些除了数据枚举外的高级操作。
枚举中可以只有枚举属性。

技术分享

技术分享

技术分享

每个枚举对象会走对应的构造方法。不能new 枚举对象。通过枚举的官方定义，枚举是按照创建顺序的。

技术分享

 

 

应用

在使用int常量作为枚举是，我们通过大写的名称对应相应的int值，表述此类使用的多个常量。不同类型的int枚举类型可以用命名前缀来区分。这种做法性能好，省力，可读性也很好。但它作为人为的口头约束。如果没有了解约束，放任何int值是可能的，甚至用枚举做运算。外部调用时可能出错。再者，int枚举类型并不能很好的表述含义，它至少一个0,1,2,4等等。你不知道它的名称。

Java的枚举类型，即天然是int值类型，又支持名称的意义。而且枚举作为类，你可以非常方便的拓展需要的成员或者方法。枚举final并不提供实例化的构造器，让它完全避免了反射等可能造成的对象实例受限破坏。枚举的值为顺势的transient，序列化不会造成枚举常量实例多份的危险。设计非常巧妙。

如果需要用枚举做映射，实现高性能的类似位图的枚举映射数据结构可以参考EnumSet<E extends Enum<E>>、EnumMap<K extends Enum<K>,V>。

 

EnumSet<E extends Enum<E>>

与枚举类型一起使用的专用 Set 实现。枚举 set 中所有键都必须来自单个枚举类型，该枚举类型在创建 set 时显式或隐式地指定。枚举 set 在内部表示为位向量。此表示形式非常紧凑且高效。此类的空间和时间性能应该很好，足以用作传统上基于 int 的"位标志"的替换形式，具有高品质、类型安全的优势。如果其参数也是一个枚举 set，则批量操作（如 containsAll 和 retainAll）也应运行得非常快。

由 iterator 方法返回的迭代器按其自然顺序 遍历这些元素（该顺序是声明枚举常量的顺序）。返回的迭代器是弱一致的：它从不抛出 ConcurrentModificationException，也不一定显示在迭代进行时发生的任何 set 修改的效果。

不允许使用 null 元素。试图插入 null 元素将抛出 NullPointerException。但是，试图测试是否出现 null 元素或移除 null 元素将不会抛出异常。

像大多数 collection 实现一样，EnumSet 是不同步的。如果多个线程同时访问一个枚举 set，并且至少有一个线程修改该 set，则此枚举 set 在外部应该是同步的。这通常是通过对自然封装该枚举 set 的对象执行同步操作来完成的。如果不存在这样的对象，则应该使用 Collections.synchronizedSet(java.util.Set) 方法来"包装"该 set。最好在创建时完成这一操作，以防止意外的非同步访问：

Set<MyEnum> s = Collections.synchronizedSet(EnumSet.noneOf(MyEnum.class));

 

实现注意事项：所有基本操作都在固定时间内执行。虽然并不保证，但它们很可能比其 HashSet 副本更快。如果其参数也是一个枚举 set ，则批量操作会在固定时间内执行。

语法糖的实现

初始化，枚举三原色，成员变量name，index

技术分享

按需要定义普通方法

技术分享

枚举中关键的属性

技术分享

输出结果

技术分享

利用枚举对象实例的确定性质，枚举元素只有一个就是一个规范的单例，你可以按需定义成员。此种方式可以保证该单例线程安全、防反射攻击、防止序列化生成新的实例。

技术分享

技术分享

枚举元素的初始化过程

技术分享

枚举类编译后的类中没有任何构造方法。自然没办法进行反射new对象。下面是普通对象的构造方法。

技术分享

枚举禁用clone保证唯一性

技术分享

关于序列化的问题

Java枚举序列化不会把枚举对象序列化，只会序列化枚举的名字，反序列化会把常量作为参数。来保证只有枚举对象的唯一性。

1.12 Serialization of Enum Constants

Enum constants are serialized differently than ordinary serializable or externalizable objects. The serialized form of an enum constant consists solely of its name; field values of the constant are not present in the form. To serialize an enum constant, ObjectOutputStream writes the value returned by the enum constant‘s name method. To deserialize an enum constant, ObjectInputStream reads the constant name from the stream; the deserialized constant is then obtained by calling the java.lang.Enum.valueOf method, passing the constant‘s enum type along with the received constant name as arguments. Like other serializable or externalizable objects, enum constants can function as the targets of back references appearing subsequently in the serialization stream.

The process by which enum constants are serialized cannot be customized: any class-specific writeObject, readObject, readObjectNoData, writeReplace, and readResolvemethods defined by enum types are ignored during serialization and deserialization. Similarly, any serialPersistentFields or serialVersionUID field declarations are also ignored--all enum types have a fixed serialVersionUID of 0L. Documenting serializable fields and data for enum types is unnecessary, since there is no variation in the type of data sent.

 

枚举的扩展

技术分享

技术分享

技术分享

技术分享

技术分享

技术分享

 

为了方便使用，在接口中添加default方法，需要jdk1.8

技术分享

技术分享

这个写法调用两次PLUS，但在编译期间可以检测实例是否是枚举和Operation接口类型。

Lambda

本文介绍了Java SE 8中新引入的lambda语言特性以及这些特性背后的设计思想。这些特性包括：

  1. lambda表达式（又被成为"闭包"或"匿名方法"）
  2. 方法引用和构造方法引用
  3. 扩展的目标类型和类型推导
  4. 接口中的默认方法和静态方法

    1. 背景

    Java是一门面向对象编程语言。面向对象编程语言和函数式编程语言中的基本元素（Basic Values）都可以动态封装程序行为：面向对象编程语言使用带有方法的对象封装行为，函数式编程语言使用函数封装行为。但这个相同点并不明显，因为Java的对象往往比较"重量级"：实例化一个类型往往会涉及不同的类，并需要初始化类里的字段和方法。不过有些Java对象只是对单个函数的封装。

     

    What is lambda?

  • Lambda表达式是一段可以传递的代码

场景一：线程逻辑

技术分享

技术分享

技术分享

场景二：自定义比较器

 

技术分享

技术分享场景三：事件按钮回调

技术分享技术分享幻

2. 函数式接口（Functional interfaces）

可以通过@FunctionalInterface注解来显式指定一个接口是函数式接口。    我们选择了"使用已知类型"这条路——因为现有的类库大量使用了函数式接口，通过沿用这种模式，我们使得现有类库能够直接使用lambda表达式。例如下面是Java SE 7中已经存在的函数式接口：

  • java.lang.Runnable
  • java.util.concurrent.Callable
  • java.security.PrivilegedAction
  • java.util.Comparator
  • java.io.FileFilter
  • java.beans.PropertyChangeListener

除此之外，Java SE 8中增加了一个新的包：java.util.function，它里面包含了常用的函数式接口，例如：

  • Predicate<T>——接收T对象并返回boolean
  • Consumer<T>——接收T对象，不返回值
  • Function<T, R>——接收T对象，返回R对象
  • Supplier<T>——提供T对象（例如工厂），不接收值
  • UnaryOperator<T>——接收T对象，返回T对象
  • BinaryOperator<T>——接收两个T对象，返回T对象
  • IntSupplier，LongBinaryOperator——原始类型（Primitive type）的特化（Specialization）函数式接口
  • BiFunction<T, U, R>——接收T对象和U对象，返回R对象

技术分享

匿名类型最大的问题就在于其冗余的语法。有人戏称匿名类型导致了"高度问题"（height problem），lambda表达式是匿名方法，它提供了轻量级的语法，从而解决了匿名内部类带来的"高度问题"。

下面是一些lambda表达式： 

(int x, int y) -> x + y
									

() -> 42
					

(String s) -> { System.out.println(s); }

第一个lambda表达式接收x和y这两个整形参数并返回它们的和；第二个lambda表达式不接收参数，返回整数‘42‘；第三个lambda表达式接收一个字符串并把它打印到控制台，不返回值。

lambda表达式的语法由参数列表、箭头符号->和函数体组成。函数体既可以是一个表达式，也可以是一个语句块：

  • 表达式：表达式会被执行然后返回执行结果。
  • 语句块：语句块中的语句会被依次执行，就像方法中的语句一样——
    • return语句会把控制权交给匿名方法的调用者
    • break和continue只能在循环中使用
    • 如果函数体有返回值，那么函数体内部的每一条路径都必须返回值

表达式函数体适合小型lambda表达式，它消除了return关键字，使得语法更加简洁。

lambda表达式也会经常出现在嵌套环境中，比如说作为方法的参数。为了使lambda表达式在这些场景下尽可能简洁，我们去除了不必要的分隔符。不过在某些情况下我们也可以把它分为多行，然后用括号包起来，就像其它普通表达式一样。

下面是一些出现在语句中的lambda表达式： 

FileFilter java = (File f) -> f.getName().endsWith("*.java");


String user = doPrivileged(() -> System.getProperty("user.name"));


new Thread(() -> {


  connectToService();


  sendNotification();


}).start();

3. 目标类型（Target typing）

对于给定的lambda表达式的类型是由其上下文推导而来，这符合

这就意味着同样的lambda表达式在不同上下文里可以拥有不同的类型： 

Callable<String> c = () -> "done";


PrivilegedAction<String> a = () -> "done";

第一个lambda表达式() -> "done"是Callable的实例，而第二个lambda表达式则是PrivilegedAction的实例。

编译器负责推导lambda表达式的类型。它利用lambda表达式所在上下文所期待的类型进行推导，这个被期待的类型被称为目标类型。lambda表达式只能出现在目标类型为函数式接口的上下文中。

当然，lambda表达式对目标类型也是有要求的。编译器会检查lambda表达式的类型和目标类型的方法签名（method signature）是否一致。当且仅当下面所有条件均满足时，lambda表达式才可以被赋给目标类型T：

  1. T是一个函数式接口
  2. lambda表达式的参数和T的方法参数在数量和类型上一一对应
  3. lambda表达式的返回值和T的方法返回值相兼容（Compatible）
  4. lambda表达式内所抛出的异常和T的方法throws类型相兼容

    由于目标类型（函数式接口）已经"知道"lambda表达式的形式参数（Formal parameter）类型，所以我们没有必要把已知类型再重复一遍。也就是说，lambda表达式的参数类型可以从目标类型中得出： 

    Comparator<String> c = (s1, s2) -> s1.compareToIgnoreCase(s2);

    在上面的例子里，编译器可以推导出s1和s2的类型是String。此外，当lambda的参数只有一个而且它的类型可以被推导得知时，该参数列表外面的括号可以被省略： 

    FileFilter java = f -> f.getName().endsWith(".java");
										

    button.addActionListener(e -> ui.dazzle(e.getModifiers()));

     

    在前三个上下文（变量声明、赋值和返回语句）里，目标类型即是被赋值或被返回的类型： 

    Comparator<String> c;c = (String s1, String s2) -> s1.compareToIgnoreCase(s2);


    public
								Runnable toDoLater() {


    
							return () -> {


    
							System.out.println("later");


      }


    }

    数组初始化器和赋值类似，只是这里的"变量"变成了数组元素，而类型是从数组类型中推导得知： 

    filterFiles(new FileFilter[] {
									

                  f -> f.exists(), f -> f.canRead(), f -> f.getName().startsWith("q")


                });

    方法参数的类型推导要相对复杂些：目标类型的确认会涉及到其它两个语言特性：重载解析（Overload resolution）和参数类型推导（Type argument inference）。

    重载解析会为一个给定的方法调用（method invocation）寻找最合适的方法声明（method declaration）。由于不同的声明具有不同的签名，当lambda表达式作为方法参数时，重载解析就会影响到lambda表达式的目标类型。编译器会通过它所得之的信息来做出决定。如果lambda表达式具有显式类型（参数类型被显式指定），编译器就可以直接 使用lambda表达式的返回类型；如果lambda表达式具有隐式类型（参数类型被推导而知），重载解析则会忽略lambda表达式函数体而只依赖lambda表达式参数的数量。

    如果在解析方法声明时存在二义性（ambiguous），我们就需要利用转型（cast）或显式lambda表达式来提供更多的类型信息。如果lambda表达式的返回类型依赖于其参数的类型，那么lambda表达式函数体有可能可以给编译器提供额外的信息，以便其推导参数类型。 

    List<Person> ps = ...


    Stream<String> names = ps.stream().map(p -> p.getName());

    在上面的代码中，ps的类型是List<Person>，所以ps.stream()的返回类型是Stream<Person>。map()方法接收一个类型为Function<T, R>的函数式接口，这里T的类型即是Stream元素的类型，也就是Person，而R的类型未知。由于在重载解析之后lambda表达式的目标类型仍然未知，我们就需要推导R的类型：通过对lambda表达式函数体进行类型检查，我们发现函数体返回String，因此R的类型是String，因而map()返回Stream<String>。绝大多数情况下编译器都能解析出正确的类型，但如果碰到无法解析的情况，我们则需要：

  • 使用显式lambda表达式（为参数p提供显式类型）以提供额外的类型信息
  • 把lambda表达式转型为Function<Person, String>
  • 为泛型参数R提供一个实际类型。（.<String>map(p -> p.getName())）

lambda表达式本身也可以为它自己的函数体提供目标类型，也就是说lambda表达式可以通过外部目标类型推导出其内部的返回类型，这意味着我们可以方便的编写一个返回函数的函数： 

Supplier<Runnable> c = () -> () -> { System.out.println("hi"); };

类似的，条件表达式可以把目标类型"分发"给其子表达式： 

Callable<Integer> c = flag ? (() ->
						23) : (() ->
						42);

在无法确认目标类型时，转型表达式（Cast expression）可以显式提供lambda表达式的类型： 

// Object o = () -> { System.out.println("hi"); }; 这段代码是非法的


Object o = (Runnable) () -> { System.out.println("hi"); };

除此之外，当重载的方法都拥有函数式接口时，转型可以帮助解决重载解析时出现的二义性。

目标类型这个概念不仅仅适用于lambda表达式，泛型方法调用和"菱形"构造方法调用也可以从目标类型中受益，下面的代码在Java SE 7是非法的，但在Java SE 8中是合法的： 

List<String> ls = Collections.checkedList(new ArrayList<>(), String.class);
													

Set<Integer> si = flag ? Collections.singleton(23) : Collections.emptySet();

基于词法作用域的理念，lambda表达式所在上下文中的局部变量不可以重复定义。

在Java SE 7中，编译器对内部类中引用的外部变量（即捕获的变量）要求被声明为final。对于lambda表达式和内部类，我们允许在其中捕获那些符合有效只读（Effectively final）的局部变量。

    如果一个局部变量在初始化后从未被修改过，那么它就符合有效只读的要求，换句话说，加上final后也不会导致编译错误的局部变量就是有效只读变量。 

Callable<String> helloCallable(String name) {
									


					String hello = "Hello";



					return () -> (hello + ", " + name);


}

对this的引用，以及通过this对未限定字段的引用和未限定方法的调用在本质上都属于使用final局部变量。包含此类引用的lambda表达式相当于捕获了this实例。在其它情况下，lambda对象不会保留任何对this的引用。

这个特性对内存管理是一件好事：内部类实例会一直保留一个对其外部类实例的强引用，而那些没有捕获外部类成员的lambda表达式则不会保留对外部类实例的引用。要知道内部类的这个特性往往会造成内存泄露。

错误例子： 

int
						sum = 0;
									

list.forEach(e -> { sum += e.size(); });

为什么要禁止这种行为呢？因为这样的lambda表达式很容易引起race condition。除非我们能够强制（最好是在编译时）这样的函数不能离开其当前线程，但如果这么做了可能会导致更多的问题。简而言之，lambda表达式对值封闭，对变量开放。lambda expressions close over values, not variables，我在这里增加一个例子以说明这个特性： 

int sum = 0;list.forEach(e -> { sum += e.size(); }); // Illegal, close over values
										

List<Integer> aList = new
									List<>();list.forEach(e -> { aList.add(e); }); // Legal, open over variables

lambda表达式不支持修改捕获变量的另一个原因是我们可以使用更好的方式来实现同样的效果：使用规约（reduction）。java.util.stream包提供了各种通用的和专用的规约操作（例如sum、min和max），就上面的例子而言，我们可以使用规约操作（在串行和并行下都是安全的）来代替forEach： 

int
						sum = list.stream()
								

              .mapToInt(e -> e.size())


              .sum();

sum()等价于下面的规约操作： 

int
						sum = list.stream()
								

              .mapToInt(e -> e.size())


              .reduce(0 , (x, y) -> x + y);

规约需要一个初始值（以防输入为空）和一个操作符（在这里是加号），然后用下面的表达式计算结果： 

0 + list[0] + list[1] + list[2] + ...

规约也可以完成其它操作，比如求最小值、最大值和乘积等等。如果操作符具有可结合性（associative），那么规约操作就可以容易的被并行化。所以，与其支持一个本质上是并行而且容易导致race condition的操作，我们选择在库中提供一个更加并行友好且不容易出错的方式来进行累积（accumulation）。

4. 方法引用（Method references）

方法引用有很多种，它们的语法如下：

  • 静态方法引用：ClassName::methodName
  • 实例上的实例方法引用：instanceReference::methodName
  • 超类上的实例方法引用：super::methodName
  • 类型上的实例方法引用：ClassName::methodName
  • 构造方法引用：Class::new
  • 数组构造方法引用：TypeName[]::new

构造方法也可以通过new关键字被直接引用： 

SocketImplFactory factory = MySocketImpl::new;

数组的构造方法引用的语法则比较特殊，为了便于理解，你可以假想存在一个接收int参数的数组构造方法。参考下面的代码： 

IntFunction<int[]> arrayMaker = int[]::new;int[] array = arrayMaker.apply(10) // 创建数组 int[10]

5. 默认方法和静态接口方法（Default and static interface methods）

向函数式接口里增加默认方法，所有实现接口的类都自动继承这个默认方法并调用。

下面的例子展示了如何向Iterator接口增加默认方法skip： 

interface
						Iterator<E> {
											


					boolean
							hasNext();



					E next();



					void
							remove();

 


					default
							void
									skip(int i) {



					for ( ; i > 0 && hasNext(); i -= 1) next();


  }


}

除了默认方法，Java SE 8还在允许在接口中定义静态方法。这使得我们可以从接口直接调用和它相关的辅助方法（Helper method），而不是从其它的类中调用（之前这样的类往往以对应接口的复数命名，例如Collections）。比如，我们一般需要使用静态辅助方法生成实现Comparator的比较器，在Java SE 8中我们可以直接把该静态方法定义在Comparator接口中： 

public
						static <T, U extends Comparable<? super U>>
										

    Comparator<T> comparing(Function<T, U> keyExtractor) {



					return (c1, c2) -> keyExtractor.apply(c1).compareTo(keyExtractor.apply(c2));


}

比如说下面的代码： 

List<Person> people = ...
					

Collections.sort(people, new Comparator<Person>() {



					public
							int
									compare(Person x, Person y) {



					return x.getLastName().compareTo(y.getLastName());


  }


})

冗余代码实在太多了！

有了lambda表达式，我们可以去掉冗余的匿名类： 

Collections.sort(people,
								

                 (Person
								x, Person
												y) -> x.getLastName().compareTo(y.getLastName()));

尽管代码简洁了很多，但它的抽象程度依然很差：开发者仍然需要进行实际的比较操作（而且如果比较的值是原始类型那么情况会更糟），所以我们要借助Comparator里的comparing方法实现比较操作： 

Collections.sort(people, Comparator.comparing((Person
													p) -> p.getLastName()));

在类型推导和静态导入的帮助下，我们可以进一步简化上面的代码： 

Collections.sort(people, comparing(p
													-> p.getLastName()));

我们注意到这里的lambda表达式实际上是getLastName的代理（forwarder），于是我们可以用方法引用代替它： 

Collections.sort(people, comparing(Person::getLastName));

最后，使用Collections.sort这样的辅助方法并不是一个好主意：它不但使代码变的冗余，也无法为实现List接口的数据结构提供特定（specialized）的高效实现，而且由于Collections.sort方法不属于List接口，用户在阅读List接口的文档时不会察觉在另外的Collections类中还有一个针对List接口的排序（sort()）方法。

默认方法可以有效的解决这个问题，我们为List增加默认方法sort()，然后就可以这样调用： 

people.sort(comparing(Person::getLastName));;

此外，如果我们为Comparator接口增加一个默认方法reversed()（产生一个逆序比较器），我们就可以非常容易的在前面代码的基础上实现降序排序。 

people.sort(comparing(Person::getLastName).reversed());;

java语法糖


联系
我们