java 泛型初识

jdk Comparator类 源码片段,读起来一脸懵逼
public static <T, U extends Comparable<? super U>> Comparator<T> comparing(
        Function<? super T, ? extends U> keyExtractor)
{
    Objects.requireNonNull(keyExtractor);
 //下面的return是什么语法,一脸懵逼
    return (Comparator<T> & Serializable)
        (c1, c2) -> keyExtractor.apply(c1).compareTo(keyExtractor.apply(c2));
}

泛型基础知识:
U extends Comparable<? super U> 表示实际运行时的U类型必须是Comparable的子类型
Comparable<? super U> 表示Comparable要比较的类型至少是U类型或者U类型的父类
extends 限定泛型的上限 super限定泛型的下限

源码的comparing()方法接收一个函数式接口的参数,返回一个Comparator<T>实例对象,该接口的内部实现逻辑将接收T类型参数转化为U类型返回

上面的代码演变:
public static <T, U extends Comparable<? super U>> Comparator<T> comparing(
    Function<? super T, ? extends U> keyExtractor) {
  Objects.requireNonNull(keyExtractor);
  return new Comparator<T>() {
    @Override
    public int compare(T o1, T o2) {
      return keyExtractor.apply(o1).compareTo(keyExtractor.apply(o2));
    }
  };
}
由于keyExtractor.apply(o1)返回U类型,而U类型又做了泛型限定,是Comparable的子类型,所以可以调用compareTo方法

再次演变:
public static <T, U extends Comparable<? super U>> Comparator<T> comparing(
    Function<? super T, ? extends U> keyExtractor) {
  Objects.requireNonNull(keyExtractor);
  // lambda表达式写法
  return (o1, o2) -> keyExtractor.apply(o1).compareTo(keyExtractor.apply(o2));
}

最终:
public static <T, U extends Comparable<? super U>> Comparator<T> comparing(
    Function<? super T, ? extends U> keyExtractor) {
  Objects.requireNonNull(keyExtractor);
  return (Comparator<T> & Serializable)  
      (o1, o2) -> keyExtractor.apply(o1).compareTo(keyExtractor.apply(o2));
}

应用场景:

@Data
@AllArgsConstructor
class Dog {
  private int age;
  private String name;
}

@Test
public void test2() {
  Dog[] arr = new Dog[] {new Dog(2, "ketty"), new Dog(2, "apple")};
  List<Dog> collect =
      Arrays.asList(arr).stream()
          .sorted(Comparator.comparing(Dog::getName))
          .collect(Collectors.toList());
  System.out.println(collect); 
//[Testclass1.Dog(age=2, name=apple), Testclass1.Dog(age=2, name=ketty)]
}

sorted()方法需要传入一个Comparator<Dog>实例对象,传统做法:
Arrays.asList(arr).stream()
    .sorted(
        new Comparator<Dog>() {
          @Override
          public int compare(Dog o1, Dog o2) {
            return o1.getName().compareTo(o2.getName());
          }
        })
    .collect(Collectors.toList());

lambda表达式写法:
Arrays.asList(arr).stream()
    .sorted((o1, o2) -> o1.getName().compareTo(o2.getName()))
    .collect(Collectors.toList());

comparing()方法就是用来返回一个Comparator实例对象的,所以调用comparing方法改进
Arrays.asList(arr).stream()
    .sorted(
        Comparator.comparing(
            new Function<Dog, String>() {
              @Override
              public String apply(Dog dog) {
                return dog.getName();
              }
            }))
    .collect(Collectors.toList());

lambda的写法:
Arrays.asList(arr).stream()
    .sorted(Comparator.comparing(dog -> dog.getName()))
    .collect(Collectors.toList());

lambda表达式方法引用的写法:
Arrays.asList(arr).stream()
    .sorted(Comparator.comparing(Dog::getName))
    .collect(Collectors.toList());

Comparator.comparing(Dog::getName)内部实现了Dog按照name属性排序的逻辑,
所以最终收集回来的List<Dog>就是按照name属性排序了的