Java中的lambda表达式

概述：

　　lambda表达式表示一个匿名的函数，可以用很少的代码实现抽象方法，必须实现函数式接口，并且返回一个函数式接口的对象

　　语法格式：

　　()->结果表达式

　　一个参数->结果表达式

　　（参数1，参数2，...）->结果表达式　　

　　简单来说三个部分就是“方法”、“按照”、“实现代码”

函数式接口：
　　指的是仅包含一个抽象方法的接口，如线程接口Runnable，事件监听接口ActionListener，也可以自定义接口

• 无参抽象方法实现

interface Print{
    String print();
}
public class LambdaTest {
    public static void main(String[] args) {
        Print p=()->"Hello World";
        System.out.println(p.print());
    }
}

• 有参抽象方法实现

interface Print{
    void print(String str);
}
public class LambdaTest {
    public static void main(String[] args) {
        String str="Hello World";
        Print p=(s)-> System.out.println(s);
        p.print(str);
    }
}

　　lambda除了可以调用定义好的参数，还可以调用表达式以外的参数，并且可以改变外部类的成员变量，但不能更改局部变量

• 更改类成员变量　　

interface Print{
    void change();
}
public class LambdaTest {
   int i=0;
   public void ChangeNum(){
       Print p=()-> {
           i++;
       };
       p.change();
       System.out.println(i);
   }
    public static void main(String[] args) {
        LambdaTest l=new LambdaTest();
        l.ChangeNum();
    }

• 更改局部变量

interface Print{
    void change();
}
public class LambdaTest {
   public void ChangeNum(){
       int i=0;
       Print p=()-> {
           //尝试更改局部变量会被标注编译错误
           i++;
       };
       p.change();
       System.out.println(i);
   }
    public static void main(String[] args) {
        LambdaTest l=new LambdaTest();
        l.ChangeNum();
    }
}

lambda的异常处理:

　　lambda表达式中并没有抛出异常的语法，会默认抛出原抽象方法的异常

interface Print{
    void check(int n) throws AgeLimit;
}
class AgeLimit extends Exception{
    public AgeLimit(String str){
        super(str);
    }
}
public class LambdaTest {
    public static void main(String[] args) {
        Print p=(n)-> {
            if (n < 18) {
                throw new AgeLimit("未满18岁");
            } else {
                System.out.println("欢迎您");
            }
        };
        Scanner sc=new Scanner(System.in);
        System.out.println("请输入您的年龄：");
        int age=sc.nextInt();
        try{
            p.check(age);
        }catch (AgeLimit a) {
            a.printStackTrace();
        }
    }
}

方法引用：

• 引用静态方法

　　类名::静态方法

interface UseMethod{
    void Use();
}
public class LambdaTest {

    public static void method(){
        System.out.println("方法引用");
    }
    public static void main(String[] args) {
        UseMethod u = LambdaTest::method;
        u.Use();
    }
}

• 引用成员方法

　　对象名::成员方法

interface UseMethod{
    void Use();
}
public class LambdaTest {

    public void method(){
        System.out.println("方法引用");
    }
    public static void main(String[] args) {
        LambdaTest l=new LambdaTest();
        UseMethod u = l::method;
        u.Use();
    }
}

• 引用带泛型的方法

interface UseMethod<T>{
    void Use(T t);
}
public class LambdaTest {
    //静态方法在方法名前定义泛型
    public static <T> void method(T t){
        System.out.println(t);
    }
    public static void main(String[] args) {
        String str="方法调用";
        UseMethod<String> u = LambdaTest::<String>method;
        u.Use(str);
    }
}

　　注意泛型前后类型要一致

• 引用构造方法

　　　　类名::new   

• • 引用无参构造方法

 

interface UseMethod{
    void Use();
}
public class LambdaTest {
    //静态方法在方法名前定义泛型
    public LambdaTest(){
        System.out.println("引用无参构造函数");
    }
    public static void main(String[] args) {
        UseMethod u = LambdaTest::new;
        u.Use();
    }
}

• • 引用有参构造方法

interface UseMethod{
    void Use(String str);
}
public class LambdaTest {
    //静态方法在方法名前定义泛型
    public LambdaTest(String s){
        System.out.println("引用有参构造函数，参数为"+s);
    }
    public static void main(String[] args) {
        String str="方法调用";
        UseMethod u = LambdaTest::new;
        u.Use(str);
    }
}

• • 引用数组构造方法

　　　　类名[]::new 　　　

interface UseMethod<T>{
    //返回指定个数的数组对象
    T Use(int n);
}
public class LambdaTest {
    //静态方法在方法名前定义泛型
    public static void main(String[] args) {
        UseMethod<LambdaTest[]> u = LambdaTest[]::new;
        Scanner sc=new Scanner(System.in);
        System.out.println("输入元素个数");
        int n=sc.nextInt();
        LambdaTest[] ls=u.Use(n);
        //数组元素实例化
        int i=0;
        for(LambdaTest l:ls){
            l=new LambdaTest();
            System.out.println("第"+i+++"个对象");
        }
    }
}

　Fuction接口：

　　提供了很多预定义式接口，仅用来封装lambda表达式的对象，最常用的接口是Function<T,R>，T:被操作的类型，可以理解为方法参数类型　　R:操作结果类型，可以理解为方法返回类型

public class LambdaTest {
    //创建Function对象
    Function<Integer[],String>function=(n)->{
      StringBuffer stringBuffer=new StringBuffer();
      for(Integer i:n){
          //在数字后面添加小数点
          stringBuffer.append(i).append(".");
      }
      //去除最后多余的小数点
      stringBuffer.deleteCharAt(stringBuffer.length()-1);
      return stringBuffer.toString();
    };
    public static void main(String[] args) {
        Integer[] ip={192,168,1,1};
        LambdaTest ls=new LambdaTest();
        //apply(T t)Function接口定义方法
        String str=ls.function.apply(ip);
        System.out.println(str);
    }
}