Lambda表达式笔记

Lambda表达式：

语法：
(parameters)->expression 或者 (parameters)->{statements;}
即：(形参)->表达式 (形参)->{代码块}
->:左边的参数作用指向

总结：类似一个function，可以带参与不带参，可以有返回与无返回值

案例：

1.无参数，直接返回结果
()->1    或  ()->{System.out.print("你好Labmbda!")}
2.带一个参数
(int a)->a 或 (int a)-> {System.out.print(a);}
//JVM根据上下文推断参数的类型
(a)->a*1   或 (a)->{System.out.print(a++);}
//如左边单个参数时可省略（），右边也是单句表达式或代码语句可省{}
a->a++   或 a->System.out.print(a)
3.带两个或两个以上的参数
(int a , String b )->{System.out.print(a);System.out.print("你好"+b)}

函数式接口

//A,B为数据类型，有方法形参 数据类似，有方法返回值 数据类型，随自己定义
public interface  Transform<A,B> {
	B transform(A a);
}

传统方式与lambda分别对该接口的使用

//传统方式使用接口
Tranform<String, Integer> transform1 = new Tranform<String, Integer(){
	@Override
        public Integer transform(String s) {
            return Integer.valueOf(s);
        }
};


//lambda 表达式
Transform<String,Integer> transform2 = (e)->Integer.valueOf(e);

访问权限
1.在Lambda表达式使用中，Lambda表达式外面的局部变量会被JVM隐式的编译成final类型，Lambda表达式内部只能访问，不能修改
案例：

public static void main(String[] args) {
        int  num = 6;//局部变量

//        System.out.println(num++);这里会编译出错
        Sum sum = value -> {
//            num = 8; 这里会编译出错
            return num + value;
        };
        System.out.println( sum.add(8));
    }
    /**
     * 函数式接口
     */
    @FunctionalInterface
    interface Sum{
        int add(int value);
    }

2.Lambda表达式内部对静态变量和成员变量是可读可写的
案例：

public class test {
    public static void main(String[] args) {
        test test = new test();
        System.out.println(test.getSum());
        test.setNum1(12);
        System.out.println(test.getSum());
    }

    public int num1 = 6;
    public static int num2 = 8;
    private int getSum(){
        Sum sum = value -> {
            num1 = value;//修改了成员变量
            num2 = 10;//修改静态变量
            return  num1 + num2;
        };
        return sum.add(1);
    }

    private void setNum1(int num1) {
        this.num1 = num1;
    }

    /**
     * 函数式接口
     */
    @FunctionalInterface
    interface Sum{
        int add(int value);
    }
}

Lambda能访问函数接口的默认方法，在函数接口中可以添加default关键字定义默认的方法

/**
     * 函数式接口
     */
    @FunctionalInterface
    interface Sum{
        int add(int value);
        default void del (int id){
            System.out.println("default方法"+id);
        }
    }
    
public static void main(String[] args) {
        Sum sun1 = value -> {
            return 1+value;
        };
        System.out.println(sun1.add(3));
        sun1.del(0);
    }

方法引用
在lambda表达式中，方法引用是一种简化写法，引用的方法就是Lambda表达式的方法体的实现
1.语法结构：ObjectRef:: methodName
类名或者实例名 :: 方法名
2.方法引用一般分为三类：
静态方法引用

public class test {
    public static void main(String[] args) {
        //传统方式
        Transform<String ,Integer> transform1 = new Transform<String, Integer>() {
            @Override
            public Integer transform(String s) {
                return test.strToInt(s);
            }
        };
        int result1 = transform1.transform("100");
        System.out.println(result1);
        //lambda表达式
        Transform<String, Integer> transform2 = test::strToInt;
        int result = transform2.transform("200");
        System.out.println(result);
    }

    static int strToInt(String str){
        return Integer.valueOf(str);
    }

    /**
     * 函数式接口
     * @param <A>
     * @param <B>
     */
    @FunctionalInterface
    interface Transform<A,B>{
        B transform(A a);
    }
}

实例方法引用

public class test {
    public static void main(String[] args) {

        //传统方式
        Transform<String ,Integer> transform1 = new Transform<String, Integer>() {
            @Override
            public Integer transform(String s) {
                return new Obj().strToInt(s);
            }
        };
        int result1 = transform1.transform("100");
        System.out.println(result1);

        //lambda表达式
        Obj obj = new Obj();
        Transform<String, Integer> transform2 = obj::strToInt;
        int result = transform2.transform("200");
        System.out.println(result);
    }

    /**
     * 实例对象类
     */
    static class Obj{
        public int strToInt(String str){
            return Integer.valueOf(str);
        }
    }

    /**
     * 函数式接口
     * @param <A>
     * @param <B>
     */
    @FunctionalInterface
    interface Transform<A,B>{
        B transform(A a);
    }
}

构造方法引用

public class test {
    public static void main(String[] args) {
        Factory factory1 = new Factory() {
            @Override
            public Parent create(String name, int age) {
                return new Boy(name,age);
            }
        };
        Boy boy = (Boy) factory1.create("小明",18);
        factory1 = new Factory() {
            @Override
            public Parent create(String name, int age) {
                return new Girl(name,age);
            }
        };
        Girl girl = (Girl) factory1.create("小红",18);
        //Lambda方式
        Factory<Boy> boyFactory = Boy::new;
        Boy boy1 = boyFactory.create("小明",18);
        boy1.doSome();
        Factory<Girl> girlFactory = Girl::new;
        Girl girl1 = girlFactory.create("小红",18);
        girl1.doSome();
    }

}

//工厂类接口
interface Factory<T extends Parent> {
    T create(String name,int age);
}

//父类
class Parent {
    private String name ;
    private int age;
    public Parent(String name, int age) {
        this.name = name;
        this.age = age;
    }
    public void doSome(){

    }
}

//男孩类
class Boy extends Parent {
    private int age ;
    private String name;
    public Boy(String name, int age) {
        super(name, age);
        this.age = age;
        this.name = name;
    }

    @Override
    public void doSome() {
        System.out.println(name+"是个男孩,"+age+"岁");
    }
}
//女孩类
class Girl extends Parent {
    private int age;
    private String name;
    public Girl(String name, int age) {
        super(name, age);
        this.age=age;
        this.name=name;
    }

    @Override
    public void doSome() {
        System.out.println(name+"是个女孩,"+age+"岁");
    }
}

五种常见的接口

Consumer接口

//Consumer接口：对入参进行操作，无返回值
//实现Consumer接口的accept方法
 Consumer<Integer> add = (a) ->{
     System.out.println("之前："+a);
     a += 10;
     System.out.println("之后："+ a);
 };
 //调用方法
 add.accept(5);

Predicate接口

 //Predicate接口：输入一个参数，返回boolean值，内置多种逻辑判断的默认方法
        Predicate<String> predicateStr = s -> s.length()>8;
        boolean result = predicateStr.test("test");
        System.out.println(result);
        result = predicateStr.negate().test("test");//取反，s.length<=8
        System.out.println("取反后："+result);

Function接口

//Function接口：接受一个参数，返回单一的结果。
        //Function<参数数据类型,返回值数据类型>   返回值的类型::valueOf
        Function<String, Integer> toInteger = Integer::valueOf;
        //toInteger的执行结果作为第二个backToString的输入
        // 默认的方法（andThen）可将多个函数串在一起，形成复合Funtion（有输入，有输出）结果
        Function<String, String> backToString = toInteger.andThen(String::valueOf);
        String result = backToString.apply("123");
        System.out.println(result);

        Function<Integer, Integer> add = (i) -> {
            System.out.println("frist input:" + i);
            return i * 2;
        };
        Function<Integer, Integer> zero = add.andThen((i) -> {
            System.out.println("second input:" + i);
            return i * 0;
        });

        Integer res = zero.apply(8);
        System.out.println(res);

    }

Supplier接口

 //Supplier接口：返回一个给定类型的结果。不需要输入参数，无输入有输出
        Supplier<String> supplier = () -> "我就是输出";
        String s = supplier.get();
        System.out.println(s);

BinaryOperator接口

//BinaryOperator接口:带两个参数,数据类与返回值类型一致
        BinaryOperator<String> binaryOperare = (o1, o2)->{
            System.out.println("第一个参数："+o1);
            return o1 + o2;
        };
        String str = binaryOperare.apply("张","小侯");
        System.out.println(str);

原文地址
添加链接描述