本文共 13251 字，大约阅读时间需要 44 分钟。

Lambda表达式是java8 添加的一个新的特性,Lambda是一个匿名函数

为什么要使用Lambda?

使用lambda表达式可以对一个接口进行非常简洁的实现

Lambda对接口的要求

要求接口中要实现的方法只能是一个

@FunctionalInterface

public class Test2 {       public static void main(String[] args) {           Comparator comparator = new MyComparator();		// 匿名内部类        Comparator comparator1 = new Comparator() {               @Override            public int compare(int a, int b) {                   return a - b;            }        };        Comparator comparator2 = (a, b) -> {               return a - b;        };        Comparator comparator3 = (a, b) -> (a - b);        int compare = comparator3.compare(6, 2);        // 4        System.out.println(compare);    }}@FunctionalInterfaceinterface Comparator {       int compare(int a, int b);}class MyComparator implements Comparator {       @Override    public int compare(int a, int b) {           return a - b;    }}

进阶

接口

/** * 无返回值,多个参数 */@FunctionalInterfacepublic interface LambdaNoneReturnMultipleParameter {       void test(int a, int b);}/** * 无返回值,无参数 */@FunctionalInterfacepublic interface LambdaNoneReturnNoneParameter {       void test();}/** * 无返回值,1个参数 */@FunctionalInterfacepublic interface LambdaNoneReturnSingleParameter {       void test(int i);}/** * 有返回值,多个参数 */@FunctionalInterfacepublic interface LambdaSingleReturnMultipleParameter {       int test(int a, int b);}/** * 有返回值,无参数 */@FunctionalInterfacepublic interface LambdaSingleReturnNoneParameter{       int test();}/** * 有返回值,1个参数 */@FunctionalInterfacepublic interface LambdaSingleReturnSingleParameter {       int test(int i);}

Lambda表达式的基础语法

public class Syntax1 {       public static void main(String[] args) {           // 1.Lambda表达式的基础语法        // Lambda是一个匿名函数        // 返回值类型 方法名 参数列表 方法体        // 参数列表 方法体        // () : 用来描述参数列表        // {} : 用来描述方法体        // -> : Lambda运算符 读作goes to        // 无参无返回        LambdaNoneReturnNoneParameter lambda1 = () -> {               System.out.println("Hello World");        };        // Hello World        lambda1.test();        // 无返回值单个参数        LambdaNoneReturnSingleParameter lambda2 = (int i) -> {               System.out.println(i);        };        // 10        lambda2.test(10);        // 无返回值多个参数        LambdaNoneReturnMultipleParameter lambda3 = (int a, int b) -> {               System.out.println(a + b);        };        // 8        lambda3.test(2, 6);        // 有返回值,没有参数        LambdaSingleReturnNoneParameter lambda4 = () -> {               return 10;        };        // 10        System.out.println(lambda4.test());        // 有返回值,单个参数        LambdaSingleReturnSingleParameter lambda5 = (int a) -> {               return a;        };        // 10        System.out.println(lambda5.test(10));        // 有返回值, 多个参数        LambdaSingleReturnMultipleParameter lambda6 = (int a, int b) -> {               return a + b;        };        // 8        System.out.println(lambda6.test(2, 6));    }}

语法精简

public class Syntax2 {       public static void main(String[] args) {           // 语法精简        // 1.参数类型        // 由于在接口的抽象方法中,已经定义了参数的数量和类型.所以在Lambda表达式中,参数类型可以省略        // 备注: 如果需要省略类型,则每一个参数的类型都要省略        LambdaNoneReturnMultipleParameter lambda1 = (a, b) -> {               System.out.println(a + b);        };        // 8        lambda1.test(2, 6);        // 2.参数小括号        // 如果参数列表中, 参数的数量只有一个,此时小括号可以省略        LambdaNoneReturnSingleParameter lambda2 = a -> {               System.out.println(a);        };        // 10        lambda2.test(10);        //3.方法花括号:        // 如果方法体只有一条语句,花括号可以省略        LambdaNoneReturnSingleParameter lambda3 = a -> System.out.println(a);        // 8        lambda3.test(8);        // 4.如果方法体中唯一的一条语句是返回语句,则在省略大括号的同时,return也要省略        LambdaSingleReturnNoneParameter lambda4 = () ->  10;        // 10        System.out.println(lambda4.test());        LambdaSingleReturnMultipleParameter lambda5 = (a, b) -> (a + b);        // 8        System.out.println(lambda5.test(2, 6));    }}

方法引用

public class Syntax3 {       public static void main(String[] args) {           // 方法引用        // 可以快速的将一个Lambda表达式的实现指向一个已经实现的方法        // 语法: 方法的隶属者 :: 方法名        // 注意:        // 1.参数数量和类型,一定要和接口中定义的方法一致        //2.返回值的类型也一定要和接口中定义方法的返回值一致        // LambdaSingleReturnSingleParameter lambda1 = a -> syntax3.change(a); // 也可以        LambdaSingleReturnSingleParameter lambda1 = a -> change(a);        // Hello Wolrd        // 4        System.out.println(lambda1.test(2));        // 方法引用 静态方法        LambdaSingleReturnSingleParameter lambda2 = Syntax3::change;    }    private static int change(int a) {           System.out.println("Hello Wolrd");        return a * 2;    }}

调用方法的构造方法

public class Person {       public String name;    public int age;    public Person() {           System.out.println("Person类的无参构造函数执行了");    }    public Person(String name, int age) {           this.name = name;        this.age = age;        System.out.println("Person类的有参构造执行了");    }}

interface PersonCreater {       Person getPerson();}interface PersonCreater2 {       Person getPerson(String name, int age);}public class syntax4 {       public static void main(String[] args) {           // 1        PersonCreater personCreater = () -> {               return new Person();        };        Person person = personCreater.getPerson();        person.name = "ll";        // ll        System.out.println(person.name);        // 2        PersonCreater personCreater1 = () -> new Person();        //无参构造方法的引用        PersonCreater personCreater2 = Person::new;        Person person1 = personCreater2.getPerson();        //有参构造方法的引用        PersonCreater2 creater = Person::new;        Person person2 = creater.getPerson("ll", 22);    }}

集合排序

public class Person {       public String name;    public int age;    public Person() {           System.out.println("Person类的无参构造函数执行了");    }    public Person(String name, int age) {           this.name = name;        this.age = age;        System.out.println("Person类的有参构造执行了");    }    @Override    public String toString() {           return "Person{" +                "name='" + name + '\'' +                ", age=" + age +                '}';    }}

public class Exercise1 {       public static void main(String[] args) {           // 集合排序        // 需求: 已知在一个ArrayList中有若干个Person对象,将这些Person对象按照年龄进行降序排序        ArrayList
   
     list = new ArrayList<>();        list.add(new Person("ll1",10));        list.add(new Person("ll2",20));        list.add(new Person("ll3",50));        list.add(new Person("ll4",40));        list.add(new Person("ll5",30));        list.add(new Person("ll6",10));        //list.sort((o1, o2) -> {return o2.age - o1.age;});        list.sort((o1, o2) -> o2.age - o1.age);        System.out.println(list);    }}
   

集合排序2

public class Exercise2 {       public static void main(String[] args) {           /**         *      public interface Comparator
   
     {         *          int compare(T o1, T o2);         *      }         *         *     public TreeSet(Comparator
     comparator) {         *         this(new TreeMap<>(comparator));         *     }         */        // 使用lambda表达式来实现Comparator接口,并实例化一个Treeset        // 元素不能重复        //TreeSet
    
      treeSet = new TreeSet<>((o1, o2) -> o1.age - o2.age);        // 元素不能重复        TreeSet
     
       treeSet = new TreeSet<>((o1, o2) ->{               if(o1.age >= o2.age){                   return -1;            }else {                   return 1;            }        });        treeSet.add(new Person("ll1",10));        treeSet.add(new Person("ll2",20));        treeSet.add(new Person("ll3",50));        treeSet.add(new Person("ll4",40));        treeSet.add(new Person("ll5",30));        treeSet.add(new Person("ll6",10));        System.out.println(treeSet);    }}
     
    
   

集合遍历

public class Exercise3 {       public static void main(String[] args) {           // 集合的遍历        ArrayList
   
     list = new ArrayList<>();        Collections.addAll(list, 1,2,3,4,5,6,7,8,9,0);        // 将集合中每一个元素都带入到方法accept中        list.forEach(System.out::println);        // 输出集合中所有的偶数        list.forEach(ele -> {               if(ele % 2 == 0){                   System.out.println(ele);            }        });    }}
   

删除集合中满足条件的元素

public class Exercise4 {       public static void main(String[] args) {           // 删除集合中满足条件的元素        ArrayList
   
     list = new ArrayList<>();        list.add(new Person("ll1", 10));        list.add(new Person("ll2", 20));        list.add(new Person("ll3", 50));        list.add(new Person("ll4", 40));        list.add(new Person("ll5", 30));        list.add(new Person("ll6", 10));        // 删除集合中年龄大于20岁的元素        /*ListIterator
    
      iterator = list.listIterator();        while (iterator.hasNext()) {            Person ele = iterator.next();            if(ele.age > 20){                iterator.remove();            }        }        System.out.println(list);*/        /**         * 删除集合中年龄大于20岁的元素         * lambda实现         * public boolean removeIf(Predicate
      filter) {         * }         * public interface Predicate
     
       {         *  boolean test(T t);         *  }         * 集合中的每一个元素都带入到test方法中,如果返回值是true则删除元素         */        list.removeIf(ele -> {               if (ele.age > 20) {                   return true;            } else {                   return false;            }        });        // 简化        list.removeIf(ele -> ele.age > 20);        System.out.println(list);    }}
     
    
   

线程

public class Exercise5 {       public static void main(String[] args) {           // 开辟一条线程, 做一个数字输出        Thread thread = new Thread(() -> {               for (int i = 0; i < 100; i++) {                   System.out.println(i);            }        });        thread.start();    }}

系统内置函数式接口

public class FunctionalInterface {       public static void main(String[] args) {           // 系统内置的一些函数式接口        /**         * 返回值 boolean,参数 T         * public interface Predicate
   
     {         *      boolean test(T t);         * }         */        /**         * 返回值 boolean,参数 int         * public interface IntPredicate {         *   boolean test(int value);         * }         */        //类推        // LongPredicate        //DoublePredicate        //====================================        /**         * 无返回,参数 T         * public interface Consumer
    
      {         *  void accept(T t);         * }         */        /**         * 无返回, 参数int         * public interface IntConsumer {         *  void accept (int value);         * }         */        //LongConsumer        //DoubleConsumer        //================================        /**         * 返回值R ,参数T         * public interface Function
     
       {         *   R apply(T t);         *  }         */        /**         * 返回值long, 参数 int         * public interface IntToLongFunction {         *  long applyAsLong(int value);         *  }         */        //DoubleToLongFunction  参数Double, 返回值Long        //DoubleToIntFunction   参数Double, 返回值Int        /**         * 返回R, 参数 int         * public interface IntFunction
      
        {         *   R apply(int value);         * }         */        //LongFunction        //DoubleFunction        //================================        /**         * 返回值T, 参数无         * public interface Supplier
       
         {         *   T get();         * }         */        /** 返回值int, 参数无         * public interface IntSupplier {         *  int getAsInt ();         * }         */        //DoubleSupplier        //================================        /**         * 返回值 T, 参数 T         * public interface UnaryOperator
        
          extends Function
         
           { * static 
          
            UnaryOperator
           
             identity() { * return t -> t; * } * } */ /** * 返回值 R, 参数 T, U * public interface BiFunction
            
              { * R apply(T t, U u); * } */ /** * 返回值T, 参数 T, T * public interface BinaryOperator
             
               extends BiFunction
              
                { */ /** * 返回值 boolean, 参数 T,U * public interface BiPredicate
               
                 { * boolean test(T t, U u); * } */ /** * 无返回, 参数T, U * public interface BiConsumer
                
                  { * void accept(T t, U u); * } */ }}
                
               
              
             
            
           
          
         
        
       
      
     
    
   

lambda表达式 闭包

public class ClosureDemo {       public static void main(String[] args) {           int n = getNumber().get();    }    /**     * public interface Supplier
   
     {     * T get();     * }     */    private static Supplier
    
      getNumber() {           int num = 10;        return () -> {               return num;        };    }}
    
   

public class ClosureDemo2 {       public static void main(String[] args) {           // 在闭包中引用的变量一定是常量,会自动加final修饰        final int num = 10;        /**         * public interface Consumer
   
     {         *  void accept(T t);         * }         */        Consumer
    
      consumer = ele -> {               System.out.println(ele);        };        // 10        consumer.accept(num);                        // 匿名内部类        Consumer
     
       consumer1 = new Consumer
      
       () {               @Override            public void accept(Integer integer) {                   System.out.println(integer);            }        };        // 10        consumer1.accept(10);                        Consumer
       
         consumer2 = ele -> {               System.out.println(num);        };        // 10        consumer2.accept(num);        // 10        consumer2.accept(100);    }}