lambda表达式的五种写法& 四大内置函数式接口

/*
    Lambda表达式
        作用: 简化匿名内部类对象

        使用前提: 函数式接口
        函数式接口: 只有一个必须被重写的抽象方法的接口称为函数式接口
        检查函数式接口注解: @FunctionalInterface 强制检测

        语法:
            () ->  {}
            () :  要重写的抽象方法的参数列表
            -> :  箭头函数 lambda符号 ,具有上下文推到的作用
            {} :  要重写抽象方法的方法体

 */
public class Test01 {
    public static void main(String[] args) {

        String str = "";
        Smoke s =  new Smoke(){
            @Override
            public void behavior(int num) {
                System.out.println("抽烟一共花了" + num + "$");
            }
        };
        s.behavior(20);

        //1.lambda写法1

        Smoke s1 = (int num)->{
            System.out.println("lambda表达式写法1" + num);
        };
        s1.behavior(50);
        //2.lambda写法2 : 当lambda体(重写方法的方法体)中的语句只有一句,前后的{}可以省略
        Smoke s2 = (int num )-> System.out.println("lambda表达式写法二" + num);
        s2.behavior(222);
        ////3.lambda写法3 : 参数的数据类型可以省略
        Smoke s3 = (num) -> System.out.println("lambda表达式写法三" + num);
        s3.behavior(333333333);
        //4.lambda写法4 : 参数只有一个,前后的()可以省略
        Smoke s4 = num -> System.out.println("lambda表达式写法四" + num);
        s4.behavior(444444444);
        //5.lambda写法5 : 当方法存在返回值类型,{}lambda体中只有一条语句,并且是return语句,前后的{}与return关键字可以一起省略
        Moke m = () -> "lambda表达式写法五";
        System.out.println(m.mmm());
        //5.lambda写法5 : 当方法存在返回值类型,{}lambda体中只有一条语句,并且是return语句,前后的{}与return关键字可以一起省略
        Binary b = num -> num<<5;
        System.out.println(b.mmm(10));
    }
}

interface Smoke{
    public void behavior(int num);
}
interface Moke{
    public String mmm();
}
interface Binary{
    public int mmm(int num);
}

题目一

package com.yjxxt.oop.basic.Work04.day03;

import java.util.*;

/*
 * 题一:调用Collections.sort()方法,通过定值排序比较两个Employee(先按年龄比,年龄相同按姓名比),使用Lambda作为参数传递
 * 分析:
 * 	1.定制排序:指自定义比较器|定制排序
 * 	      自然排序:内部比较器|自然排序
 *  2.先比较年龄,年龄相同才比较姓名
 */
public class TestLambda02 {
    public static void main(String[] args) {
        List<Employee> list = new ArrayList<>();
        list.add(new Employee(18,"张三",1101));
        list.add(new Employee(14,"李四",1103));
        list.add(new Employee(19,"王王",1105));
        list.add(new Employee(18,"赵四",1104));
        list.add(new Employee(218,"克棒",1107));
        list.add(new Employee(18,"钱七",1110));
            
            //匿名内部类解法
//        Collections.sort(list, new Comparator<Employee>() {
//            @Override
//            public int compare(Employee o1, Employee o2) {
//                if(o1.getAge()==o2.getAge()){
//                    return o1.getName().compareTo(o2.getName());
//                }
//                return o1.getAge()-o2.getAge();
//            }
//        });
//        System.out.println(list);

        //lambda表达式
        Collections.sort(list,(o1,o2)->{
            if(o1.getAge()==o2.getAge()){
                return o1.getName().compareTo(o2.getName());
            }
            return o1.getAge()-o2.getAge();
        });
        System.out.println(list);

    }
}

class Employee{
    //属性
    private int age;
    private String name;
    private int id;

    public Employee() {
    }

    public Employee(int age, String name, int id) {
        this.age = age;
        this.name = name;
        this.id = id;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getId() {
        return id;
    }

    public void setId(int id) {
        this.id = id;
    }

    @Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (o == null || getClass() != o.getClass()) return false;
        Employee employee = (Employee) o;
        return age == employee.age &&
                id == employee.id &&
                Objects.equals(name, employee.name);
    }

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

    @Override
    public int hashCode() {
        return Objects.hash(age, name, id);
    }
}

题目二

package com.yjxxt.oop.basic.Work04.day03;

import java.util.stream.Stream;

/*
 * 习题二:
 * 	1)声明函数式接口,接口中声明抽象方法,public String getValue(String str)
 * 	2)声明类 TestLambda,类中编写方法使用接口作为参数,讲一个字符串转成大写,并作为方法的返回值
 *  3)再将一个字符串的第2个和第4个索引位置进行截取子串
 */
public class TestLambdaTest03 {
    public static void main(String[] args) {
        // 把解决行为当形参，传给方法                                   行为使用了lambda表达式进行简化
        System.out.println(strHandler("yigezifuchaun", str -> str.toUpperCase())); // toUpperCase()  字符串转大写
        System.out.println(strHandler("diergezifuchaun", str -> str.substring(2, 5)));//substring(2, 5)  指定区间字符[)

    }
    public static String strHandler(String str,A a){
        return a.getValue(str);
    }
}
interface A{
    public String getValue(String str);
}

题目三

package com.yjxxt.oop.basic.Work04.day03;

/*
 * 习题三:
 * 	1)声明一个带两个泛型的函数式接口,泛型类型为<T,R> T为参数,R为返回值
 * 	2)接口中声明对应抽象方法
 *  3)在TestLambda类中声明方法,参数三个,两个long类型的参数,接口作为参数,接口实现中计算两个long型参数的和
 *  4)再计算两个long型参数的乘积
 */
public class LambdaTest04 {
    public static void main(String[] args) {
        // 把解决行为当形参，传给方法
        System.out.println(testLong(100L, 150L, (l1, l2) -> l1 + l2));  //计算两个long的和
        System.out.println(testLong(100L, 150L, (l1, l2) -> l1 * l2));  //计算两个long的乘机


    }
    public static Long testLong(Long l1 , Long l2,B<Long,Long> b){
        return b.test(l1,l2);
    }
}
interface B<X,Y>{
    Y test(X x,X x1);
}

四大内置函数式接口

package com.yjxxt.oop.basic.Work04.day03;

import java.util.ArrayList;
import java.util.List;
import java.util.Map;
import java.util.function.Consumer;
import java.util.function.Function;
import java.util.function.Predicate;
import java.util.function.Supplier;

/*
    四大内置函数式接口  必须掌握***
        消费型接口 Consumer<T>
            void accept(T t)  有一个参数没有返回值

        函数型接口 Function<T,R>
            R apply(T t)    有一个参数一个返回值

        段言型接口 Predicate<T>
            boolean test(T t)   一个参数一个boolean返回值

        供给型接口 Supplier<T>
            T get()             没有参数一个返回值
 */
public class Test05 {
    public static void main(String[] args) {
        // 消费型接口 Consumer<T>
        testConsumer(150D,d-> System.out.println("今天出去消费类了 " + d +"$"));
        // 函数型接口 Function<T,R>
        System.out.println(testFunction(88, num -> num << 5));   // <<
        //段言型接口 Predicate<T>
        System.out.println(testPredicate(List.of("dwadaw", "dsa", "dgw", "w", "rafgd", "s"), str -> str.length() > 3));
        //供给型接口 Supplier<T>
        System.out.println(testSupplier(5, () -> (int) (Math.random()* (50 - 10) + 10)));


    }

    //消费型
    // 消费型接口 Consumer<T>
    //            void accept(T t)  有一个参数没有返回值
    public static void testConsumer(Double d1, Consumer<Double> dd){
        dd.accept(d1);
    }

    // 函数型接口 Function<T,R>
    //            R apply(T t)    有一个参数一个返回值
    public static int testFunction(int num, Function<Integer,Integer> fct){
         return fct.apply(num);
    }

   // 段言型接口 Predicate<T>
    //boolean test(T t)   一个参数一个boolean返回值
    public static List<String> testPredicate(List<String> str, Predicate<String> prd){
        List<String> li = new ArrayList<>();
        for (String s:str){
            if(prd.test(s)){
                li.add(s);
            }
        }
         return li;
    }

    // 供给型接口 Supplier<T>
    //            T get()             没有参数一个返回值
    public static List testSupplier(int num , Supplier<Integer> supplier){
        List<Integer> list = new ArrayList<>();
        for (int i = 1;i<=num;i++){
             list.add(supplier.get());
        }
        return list;
    }

}