lambda表达式

lambda表达式：是一个可传递的代码块，可以在以后执行一次活多次；是一个匿名函数，是对匿名函数的简写形式，可以将lambda表达式理解为是一段可以传递的代码，可以卸除更简洁、更灵活的代码。

  • lambda表达式的核心：实现的接口中的抽象方法中的形参列表 -> 抽象方法；

Lambda表达式的基本作用

  • 简化函数式接口的匿名内部类的写法

Lambda表达式的使用前提

  • 必须是接口的匿名内部类，接口中只能有一个抽象方法

Lambda表达式的省略写法：

  • 参数类型可以省略不写

  • 如果只有一个参数，参数类型可以省略，同时()也可以省略

  • 入股Lambda表达式的方法体只有一行，大括号，分号，return可以省略不写，需要同时省略

lambda表达式的语法

  • 表示方法：实现的接口中的抽象方法中的形参列表 -> 抽象方法；

  • 简单示例：

    无返回值，有形式参数的抽象方法：

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    public class Mytest {
        public static void main(String[] args) {
            MyInterface  myInterface=(a,b)->{
                System.out.println(a+b);
            };
            myInterface.show(40,50);
        }
    }
    interface MyInterface{
        public abstract void show(int a,int b);
    }

  • 有返回值的抽象方法：

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    public class Mytest {
        public static void main(String[] args) {
            MyInterface1 myInterface1=(a,b)->{
                return a - b;
            };
            System.out.println(myInterface1.test(40,50));
        }
    }
    interface MyInterface1{
        public abstract int test(int a,int b);
    }

  • 有一个形参的抽象方法：

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    public class Mytest {
        public static void main(String[] args) {
            MyInterface2 myInterface2=(a)->{
                return a-20;
            };
            System.out.println(myInterface2.show(50));
        }
    }
    interface MyInterface2{
        int show(int a);
    }

    形式参数列表只有一个参数，可以去掉形参的括号；

  • Lambda表达式作为参数传递：

    1
    2
    3
    4
    5
    6
    7
    public class Mytest {
        public static void main(String[] args) {
            Integer[] ints={89,67,23};
            Arrays.sort(ints,(o2,o1)->o2-o1);
            System.out.println(Arrays.toString(ints));
        }
    }

    语法中o1和o2来决定这两个元素的排序顺序，o1和o2就代表了数组中需要进行比较的两个元素。

    • 如果o1-o2的结果为负数，那么o1将放在o2的前面，即o1排在o2前面；

    • 如果o1-o2的结果为正数，那么o1将放在o2的后面，即o1排在o2后面；

    • 如果o1-o2的结果为零，那么o1和o2的位置不变；

    这种方式是升序的方式进行排序，如果要改为降序就将o1和o2调换位置，即变成o2-o1；

lambda的应用场景

  • 遍历集合：Lambda表达式可以与增强版for循环使用，用于遍历集合：

    1
    2
    List<String> list = Arrays.asList("Apple", "Banana", "Cherry");
    list.forEach(item -> System.out.println(item));

  • 线程创建：Lambda表达式可以用于创建线程：

    1
    new Thread(()->System.out.println("hello from thread")).start();

  • 排序：Lambda表达式可以用于定义排序规则：

    1
    2
    List<Intger>number = Arrays.aslist(1,2,3,4,5);
    Collctions.sort(numbers,(o1,o2)->o2-o1);   //降序

  • 函数式接口：Lambda表达式可以用于实现1函数式接口：

    1
    2
    Predicate<String> lengthcheck=(s)->s.length()>5;
    System.out.println(lengthcheck.test("hello world"));  //输出true

函数式接口

  • 对于只有一个抽象方法的几口，需要这种接口的对象时候】，就可以提供一个lambda表达式。这种接口称为函数式接口；

    • 以Arrays.sort方法为例，它的第二个参数需要一个Comparator实例，Comparator就是只有一个方法的接口，所以可以提供一个lambda表达式：

      1
      Array.sort(words,first,second -> first.length() - second.length());

  • Predicate:

    • Predicate 接口在java.util.function包中；

      1
      2
      3
      4
      public interface Predicate<T>
      {
      	boolean test(T t);
      }

      ArrayList类有一个removeIf方法，它的参数就是一个Predicate。这个接口专门用来传递lambda表达式；