Java8的Lambda学习

一.Java8四大内置函数式接口

1、Consumer 消费性接口：void accept(T t)； 有一个参数传入，无返回值

2、Supplier供给型接口： T get();  无参数传入,有一个返回值

3、Function 函数式接口：R apply(T t);   有一个参数传入,有一个返回值

4、Predicate 断言式接口：boolean test(T t);  有一个参数传入,返回一个boolean值

二.测试

import java.util.Comparator;
import java.util.Random;
import java.util.function.Consumer;
import java.util.function.Function;
import java.util.function.Predicate;
import java.util.function.Supplier;

/**
 * @author qinxun
 * @date 2023-06-02
 * @Descripion: lambda学习
 */
public class LambdaDemo {
    public static void main(String[] args) {
        test1();
        test2();
        test3();
        test4();
        test5();
        test6();
        test7();
    }

    /**
     * 普通匿名内部类实现多线程
     */
    public static void test1() {
        Thread thread = new Thread(new Runnable() {
            @Override
            public void run() {
                System.out.println("匿名内部类,实现线程启动");
            }
        });
        thread.start();
    }

    /**
     * lambda表达式 无参数传入,无返回值
     */
    public static void test2() {
        Thread thread = new Thread(() -> System.out.println("lambda表达式,实现线程启动"));
        thread.start();
    }

    /**
     * lambda中的Consumer接口  有一个参数传入，无返回值
     */
    public static void test3() {
        Consumer<Integer> consumer = data -> System.out.println("您的年龄:" + data);
        consumer.accept(28);
    }

    /**
     * lambda表达式中的Predicate  有一个参数传入,返回一个boolean值
     */
    public static void test4() {
        // 参数和默认值进行比较 返回boolean值
        Predicate<Integer> predicate = data -> data > 60;
        //传入参数70
        boolean flag = predicate.test(70);
        System.out.println(flag);
    }

    /**
     * lambda表达式中的Supplier  无参数传入,有一个返回值
     */
    public static void test5() {
        Supplier<Integer> supplier = () -> {
            Random random = new Random();
            // 返回一个0-9之间的整数
            return random.nextInt(10);
        };
        System.out.println(supplier.get());
    }

    /**
     * lambda表达式中的Function   有一个参数传入,有一个返回值
     */
    public static void test6() {
        Function<Integer, String> function = age -> age > 60 ? "可以退休了" : "还没有到退休年龄";
        String result = function.apply(65);
        System.out.println(result);
    }

    /**
     * Comparator 有两个的参数，有返回值
     */
    public static void test7() {
        // 返回两个参数的最大值
        Comparator<Integer> comparator = (x, y) -> x > y ? x : y;
        int max = comparator.compare(3, 4);
        System.out.println(max);
    }

}

匿名内部类,实现线程启动
lambda表达式,实现线程启动
您的年龄:28
true
2
可以退休了
4

三、方法引用与构造器引用

实现抽象方法的参数列表和返回值类型，必须与方法引用的方法的参数列表和返回值类型保持一致！

方法引用：使用操作符“::”将类与方法分隔开来。

对象::实例方法名

类::静态方法名

类::实例方法名

    /**
     * 方法引用测试
     */
    public static void test8() {
        // 没有使用方法引用的情况
        Comparator<Double> comparator1 = (x, y) -> Double.compare(x, y);
        // 使用方法引用
        Comparator<Double> comparator2 = Double::compare;

        // 两种方式返回的数据一样
        System.out.println(comparator1.compare(3.0, 4.0));
        System.out.println(comparator2.compare(3.0, 4.0));


        // 普通小写转换大写
        Function<String, String> consumer1 = s -> s.toUpperCase();
        // 构造器引用
        Function<String, String> consumer2 = String::toUpperCase;

        System.out.println(consumer1.apply("hello"));
        System.out.println(consumer2.apply("hello"));
    }

-1
-1
HELLO
HELLO

四、lambda表达式的一些常见用法

1.数据迭代

  /**
     * 数据迭代输出
     */
    public static void test9(){
        List<String> list = Arrays.asList("a","b","c");
        list.forEach(System.out::println);
    }

a
b
c

2、map转换数据

  /**
     * 转换数据 小写变大写
     */
    public static void test10() {
        List<String> list = Arrays.asList("a", "b", "c");
        List<String> stringList = list.stream().map(s -> s.toUpperCase()).collect(Collectors.toList());
        // 输出[A, B, C]
        System.out.println(stringList);
    }

3、reduce规约

  /**
     * reduce求和
     */
    public static void test11() {
        List<Integer> list = Arrays.asList(1, 2, 3);
        Integer result = list.stream().reduce(0, Integer::sum);
        // 输出6
        System.out.println(result);
    }

4、filter过滤操作

/**
     * filter过滤数据
     */
    public static void test12(){
        List<Integer> list = Arrays.asList(2,5,1,3,6,7);
        // 过滤获取大于3的数据
        List<Integer> resultList = list.stream().filter(s -> s > 3).collect(Collectors.toList());
        // 输出[5, 6, 7]
        System.out.println(resultList);
    }