lamada表达式写法

接口

Lambda表达式需要“函数式接口”的支持，函数式接口的意思是:接口中只有一个抽象方法的接口,称为函数式接口。

无参无返回值

interface People {

    public void eat();
}


public class Test {
    public static void main(String[] args) {
        People people = new People() {
            @Override
            public void eat() {
                System.out.println("吃饭");
            }
        };
        people.eat();
        System.out.println("===============================");
        //用lamada表达式表示
        People people1 = () -> System.out.println("吃饭1");
        people1.eat();
    }
}

有一参无返回值

interface People {

    public void eat(String s);
}


public class Test {
    public static void main(String[] args) {
        People people = new People() {
            @Override
            public void eat(String s) {
                System.out.println("正在吃"+s);
            }
        };
        people.eat("葡挞");
        System.out.println("===============================");
        //用lamada表达式表示
        People people1 = (s) -> System.out.println("正在吃"+s);
        //若参数只有一个，小括号可以不写
        //People people1 = s -> System.out.println("正在吃"+s);
        people1.eat("葡挞1");

    }
}

有多参无返回值

interface People {
    public void eat2(String s,String s1);
}

public class Test {
    public static void main(String[] args) {
        People people = new People() {
            @Override
            public void eat2(String s, String s1) {
                System.out.println("正在吃"+s+"和"+s1);
            }
        };
        people.eat2("葡挞","香蕉");
        System.out.println("===============================");
        //用lamada表达式表示
        People people1 = (s,s1) -> System.out.println("正在吃"+s+"和"+s1);
        people1.eat2("葡挞","香蕉");

    }
}

有多参有返回值

interface Add {

    public Integer add(Integer a,Integer b);
}


public class Test2 {
    public static void main(String[] args) {
        Add add = new Add() {
            @Override
            public Integer add(Integer a, Integer b) {
                return a+b;
            }
        };
        System.out.println(add.add(5, 6));
        System.out.println("===============================");
        Add add1 = (a,b) -> {
            Integer c = a+b;
            return c;
        };
//        还可以简化为，上面那个有方法体，方法体里可以写多行代码
//        Add add1 = (a,b) -> a+b;
        System.out.println(add1.add(7, 7));
    }
}

看到了这里，应该很有感觉了吧能找出规律了，那无参有返回值的就不演示了。

People people1 = (s) -> System.out.println(“正在吃”+s);是不是发现括号里的s不需要标明数据类型，确实是可以省略，加了也没有关系不会报错。
Lambda表达式的参数列表的数据类型可以省略不写，因为JVM编译器通过上下文推断出，数据类型，即"类型锥断”。
像数组声明String[] str = {“abc”,“abc”,“abc”};括号里“abc”也没有去标明数据类型，像集合ArrayList< String> list = new ArrayList<>();后面的尖括号里面也可以不写。

方法引用

对象::实例方法名

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

        PrintStream ps = System.out;
//        Consumer<String> con = (x) -> ps.println(x);
        Consumer<String> con = ps::println;
        Consumer<String> con2 = System.out::println;
        con2.accept("abcd");
    }
}

类::静态方法名

public class Test2 {
    public static void main(String[] args) {
        //  第一种方法
//        Comparator<Integer> comparator = new Comparator<Integer>() {
//            @Override
//            public int compare(Integer o1, Integer o2) {
//                return Integer.compare(o1,o2);
//            }
//        };

        //   第二种方法
//        Comparator<Integer> comparator = (a,b) -> Integer.compare(a,b);
        //   第二种方法
        Comparator<Integer> comparator = Integer::compare;

        Integer[] str = {1,5,9,33,65,25,74,65,65,25,4,1};
        Arrays.sort(str,comparator);
        for (Integer integer : str) {
            System.out.println(integer);
        }
    }
}

类::实例方法名

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

//        BiPredicate<String,String> bip = (x,y) -> x.equals(y);
        BiPredicate<String,String> bip = String::equals;
        boolean test = bip.test("asd", "wer");
    }
}

构造器引用

class Cat{
    private Integer age;
    private String name;

    public Cat(Integer age, String name) {
        this.age = age;
        this.name = name;
    }

    public Cat() {
    }
}

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

//        Supplier<Cat> sup = () -> new Cat();
        Supplier<Cat> sup = Cat::new;   //用的是无参构造方法
        Cat cat = sup.get();
    }
}

需要调用的构造器的参数列表要与函数式接口中抽象方法的参数列表保持一致

class Cat{
    private Integer age;
    private String name;

    public Cat(Integer age, String name) {
        this.age = age;
        this.name = name;
    }

    public Cat() {
    }

    @Override
    public String toString() {
        return "Cat{" +
                "age=" + age +
                ", name='" + name + '\'' +
                '}';
    }
}

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

//        BiFunction<Integer,String,Cat> fun = (x, y) -> new Cat(x,y);
        BiFunction<Integer,String,Cat> fun = Cat::new; //用的是有参构造方法
        Cat tom = fun.apply(56, "tom");
        System.out.println(tom);
    }
}