Java中Lambda表达式定义及应用实例(常见的函数接口+方法引用)

是一种新型的方法传递参数的方式，又称之为箭头函数，可以简化代码的编写
->：是Lambda表达式固定格式，被称之为Lambda表达式核心符号
->左侧：通过Lambda表达式改造的方法的参数部分
->右侧：通过Lambda表达式改造的方法的方法体
改造的前提：方法传递的参数必须是接口，接口中有且仅有一个抽象方法

(参数) -> {方法体}
-其中如果没有参数需要传递，需要保留空括号()
-当被改造的方法体中有且仅有一条语句时，{}和()都可以省略；当被改造的方法具有多条代码则不能省略
-被改造的方法仅有一条语句且是返回语句，return关键字可以省略；如果有多条语句，按照原样进行编写

//限制接口中有且仅有一个抽象方法，这种接口称之为函数接口
@FunctionalInterface
public interface MyPredicate {
    //判断传入的商品是否满足指定条件
    boolean test(Product product);
//    void fun();
}

public class OOPDemo {
    public static void main(String[] args) {
        //通过匿名类的方式，完成需求，打印一句话
        new Thread(new Runnable() {
            @Override
            public void run() {
                System.out.println("实现多线程操作-匿名内部类");
            }
        }).start();
        //通过Lambda表达式实现
        new Thread(()->System.out.println("实现多线程操作-Lambda表达式")).start();
    }
}

import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;

@NoArgsConstructor
@Data
@AllArgsConstructor
public class Product {

    private long id;
    private String proName;
    private Integer price;
    private String brand;
}

import java.util.ArrayList;
import java.util.List;

public class ProductLambdaTest {

    //初始化几条数据
    private static final List<Product> products = new ArrayList<>();
    static {
        products.add(new Product(1L,"电视1",3000,"HW"));
        products.add(new Product(2L,"电视2",4000,"HW"));
        products.add(new Product(3L,"手机3",5000,"HW"));
        products.add(new Product(4L,"手机4",6000,"RY"));
        products.add(new Product(5L,"电脑4",7000,"RY"));
        products.add(new Product(6L,"电脑4",8000,"RY"));
    }

    
    public static void main(String[] args) {
        //展示商品中带有手机两个字的商品信息
 /*       findProductByPredicate(new MyPredicate() {
            @Override
            public boolean test(Product product) {
                return product.getProName().contains("手机");
            }
        });*/
        findProductByPredicate(p->p.getProName().contains("手机"));
        //显示商品单价不小于4000的商品信息
/*        findProductByPredicate(new MyPredicate() {
            @Override
            public boolean test(Product product) {
                return product.getPrice()>=2000;
            }
        });*/
        findProductByPredicate(p->p.getPrice()>=4000);
    }

    private static void findProductByPredicate(MyPredicate predicate) {
        List<Product> prices = new ArrayList<>();
        for (Product product : products) {
            if (predicate.test(product)) {
                prices.add(product);
            }
        }
        System.out.println(prices);
    }
}

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

public class FunctionTest {

    public static void main(String[] args) {
    	//Consumer 消费型接口应用实现
        shop(200,i -> System.out.println("消费了"+i+"元"));
        //Supplier供给型接口应用实现
        System.out.println(getCode(4,()->(int) (Math.random()*10)));
        //Function<T,R>函数型接口应用实现        
        System.out.println(getStringLength("  12w   ",s -> s.trim().length()));
        //Predicate 断言型接口应用实现
        List<String> list = Arrays.asList("a","bsdfg","c2222","e");
        System.out.println(getStrings(list,s->s.length()>3));
    }

    //shop方法 统计消费多少元，应用Consumer 消费型接口
    public static void shop(int money, Consumer<Integer> consumer) {
        consumer.accept(money);
    }
    //生成指定长度的验证码，应用Supplier供给型接口
    public static String getCode(int length, Supplier<Integer> supplier) {
        StringBuilder sb = new StringBuilder();
        for (int i = 0; i < length; i++) {
            sb.append(supplier.get());
        }
        return sb.toString();
    }
    //获取字符串真实长度，应用Function<T,R>函数型
接口
    public static int getStringLength(String s, Function<String, Integer> function) {
        return function.apply(s);
    }

    //返回长度大于3 的字符串，应用Predicate 断言型接口
    public static List<String> getStrings(List<String> s, Predicate<String> predicate) {
        List<String> list = new ArrayList<>();
        for (String string : s) {
            if (predicate.test(string)){
                list.add(string);
            }
        }
        return list;
    }
}

import java.util.Arrays;
import java.util.List;
import java.util.function.Function;
import java.util.function.Supplier;

public class MethodQuoteTest {
    public static void main(String[] args) {
        System.out.println("对象::方法名");
        fun1();
        System.out.println("类名::静态方法");
        fun2();
        System.out.println("类名::实例方法");
        fun3();
        System.out.println("类名::new");
        fun4();
    }

    private static void fun4() {
        //使用供给型接口实现，返回一个字符串
        Supplier<String> supplier = new Supplier<String>() {
            @Override
            public String get() {
                return new String();
            }
        };
        //使用Lambda表达式实现
        Supplier<String> supplier1 = () -> new String();
        //使用接口引用实现
        Supplier<String> supplier2 = String::new;
    }

    private static void fun3() {
        //使用函数型接口实现
        Function<String,Integer> fun = new Function<String,Integer>() {
            @Override
            public Integer apply(String s) {
                return s.length();
            }
        };
        //使用Lambda表达式实现
        Function<String,Integer> fun1 = s->s.length();
        //使用方法引用实现
        Function<String,Integer> fun2 = String::length;
    }

    private static void fun2() {
        //使用供给型接口实现
/*        Supplier<Integer> supplier = new Supplier<Integer>() {
            @Override
            public Integer get() {
                return (int)(Math.random()*10);
            }
        };*/
        //方法调用的局限性：只能调用定义好的方法本身
        //Supplier<Double> supplier = () -> Math.random();
        //Lambda表达式可以使用方法引用替代
        Supplier<Double> supplier = Math::random;
    }

    private static void fun1() {
        List<String> list = Arrays.asList("aa","ab","ac");
        //list.forEach((String s)-> System.out.println(s));
        //Lambda表达式可以使用方法引用替代
        list.forEach(System.out::println);
    }
}