Java8新特性-001-Lambda表达式

概念

  • Lambda表达式的基本结构
    • (parma1,param2,param3) -> { 执行体 }
  • 函数式接口:可以认为是一个标识
    • 仅且只有一个抽象方法,独一无二的,只存在一个的
    • 接口中可以有覆盖了Object中的方法,万物皆是object的子类
    • 创建方式为下面三种
      1. lambda表达式
      2. 方法引用
      3. 构造器引用
  • 函数式接口注解
    • @FunctionalInterface
    • 如果一个接口使用了该注解表示函数式接口,如果不是下面的两个条件,编译器则报错
      1. 是一个接口,而不是其他类型,包括类,枚举
      2. 这个接口必须满足上面函数式接口的特点,只有一个独一无二的抽象方法。
    • 但是函数式接口可以不使用该注解,但是尽量使用,有下面好处
      • 强制让编译器来判断
      • 让使用者可以更好的明白其含义
总结
  1. 函数式接口:只有一个独一无二的抽象方法
  2. 函数式可以增加@FunctionalInterface来借助编译器来判断是否符合函数式接口的条件
  3. 如果加了@FunctionalInterface,如果接口不满足函数式接口的特点,则会报错

示例

Function

  • 输入一个参数,导出另外一个结果
    public interface Function<T, R> {
        R apply(T var1);
    
        default <V> Function<V, R> compose(Function<? super V, ? extends T> var1) {
            Objects.requireNonNull(var1);
            return (var2) -> {
                return this.apply(var1.apply(var2));
            };
        }
    
        default <V> Function<T, V> andThen(Function<? super R, ? extends V> var1) {
            Objects.requireNonNull(var1);
            return (var2) -> {
                return var1.apply(this.apply(var2));
            };
        }
    
        static default <T> Function<T, T> identity() {
            return (var0) -> {
                return var0;
            };
        }
    }
    
  • 使用
    • 其中使用类::方法的对象就是流中的前面输出的对象,即it
    public class FunctionDemo {
    
        public static void main(String[] args) {
            List<String> list = Arrays.asList("world","hello");
    
    
    
            //其中  使用String::toUpperCase的对象就是  it对象
            list.stream().map(String::toUpperCase).forEach(item-> System.out.println(item));
    
            list.stream().map(it->{
                return it.toUpperCase();
            }).forEach(item->{
                System.out.println(item);
            });
    
        }
    }
    
    

排序

Comparator函数式接口
```java
@FunctionalInterface
public interface Comparator<T> {

    //Comparator独一无二的抽象方法
    int compare(T o1, T o2);
    
    //继承自Objects的抽象方法,有默认的实现,即Object的实现
    //在判断函数式接口时,不能算接口数,所以Comparator仍是有
    //一个接口,即compare
    boolean equals(Object obj);
    
    
    //一些静态方法和默认方法
}
```
#### 示例
```java
public class LambdaSortDemo {

    public static void main(String[] args) {

        List<String> list = Arrays.asList("zhangsan","lisi","wangwu","zhaoliu");

        Collections.sort(list, new Comparator<String>() {
            @Override
            public int compare(String o1, String o2) {
                return o2.compareTo(o1);
            }
        });
        System.out.println(list);


        List<String> list1 = Arrays.asList("zhangsan","lisi","wangwu","zhaoliu");
        //lambda表达式,Comparator是函数式接口
        Collections.sort(list1,(String o1,String o2)->o2.compareTo(o1));
        System.out.println(list1);



        List<String> list2 = Arrays.asList("zhangsan","lisi","wangwu","zhaoliu");
        //lambda表达式,Comparator是函数式接口
        Collections.sort(list2,(o1,o2)->o2.compareTo(o1));
        System.out.println(list2);
    }
}
```

Lambda表达式

  • 通过上面的案例可以得出Lambda表达式的一些内容

概念

  • Lambda表达式,是一种匿名函数;没有声明的方法,即没有访问修饰符,返回值声明和名字

特点

  • 传递行为,而不是之前的值

基本语法

  • 基本语法
    (argument) -> (body)
    
  • 示例
    (arg1,arg2 . . . ) -> {  body }
    or
    (typ1 arg1,type2 arg2 . . . ) -> { body } //type1是类型,编译器可以自动推断出来,一般不写
    
  • 书写特点
    • 一个Lambda表达式可以有零个或者多个参数
    • 多个参数
      • 参数的类型可以明确申明,也可以根据上下文来推断,即type1 type2编译器可以自己推断出来,可以不写
      • 所有参数需包含在圆括号内,参数之间用逗号相隔,即(a,b)或(int a,int b)或者(String a,int b,float c)
      • 空圆括号代表参数集为空,即()->42,表示没有参数,但是返回是42
      //完整语法
      (type1 arg1,type2 arg2) -> { body }
      
      //由于type1 type2编译器可以自行推断出来,所以改变成如下
      (arg1,arg2) -> { body }
      
      
    • 一个参数
      • 当只有一个参数,且类型可推导时,圆括号()可以省略
      //完整语法
      (type1 arg1) -> { body }
      
      //类型推导
      (arg1) -> { body }
      
      //一个参数
      arg1 -> { body }
      
    • Lambda表达式的主题可包含零条或者多条语句
    • 如果Lambda表达式的主体只有一条语句,花括号{}可省略。匿名函数的返回类型与该主体表达式一致
    //完整语法
    (type1 arg1,type2 arg2...) -> { return arg1 + arg2; }
    
    //类型推断,此风格为statement风格
    (arg1,arg2) -> { return arg1 + arg2; }
    
    //表达式主体一条语句,那么返回的类型就是与之前主体的类型一致,即将主体的结果进行返回,此风格为表达式风格expression style,没有{},return,;
    (arg1,arg2) -> arg1 + arg2
    
    • 如果Lambda表达式的主体包含一条以上语句,则表达式必须包含在花括号{}中(形成代码块),匿名函数的返回类型和代码块的返回类型一致,若没有返回则为空。
©️2020 CSDN 皮肤主题: 像素格子 设计师:CSDN官方博客 返回首页