Lambda表达式

1、Lambda表达式

lambda表达式是一种语法糖，主要使用形式就是 -> 加方法名

要使用lambda表达式的前提就是这个接口有且仅有一个抽象方法，即是函数式接口，这个时候就可以忽略方法的名称，而只关注方法的实现即可

如果lambda体只有一条执行语句，比如return，也是可以省略return的

具体的方法实现如下所示：

1、使用lambda表达式来解决foreach遍历集合

    @Test
    public void test1() {
        List<Integer> list = new ArrayList<>(Arrays.asList(1,2,3,4,5,6,7,7));
        // 普通遍历集合的方法
        for (int i = 0; i < list.size(); i++) {
            System.out.print(list.get(i));
        }
        System.out.println();
        // 使用lambda表达式遍历
        list.forEach( x -> System.out.print(x));
    }

2、使用lambda表达式创建线程

    @Test
    public void test2() {
        // 传统创建线程的方法
        new Thread(new Runnable() {
            @Override
            public void run() {
                System.out.println("当前式线程1");
            }
        }).start();

        // 使用lambda表达式创建线程
        new Thread(() -> System.out.println("线程2启动")).start();
    }

3、使用lambda表达式遍历map

    @Test
    public void test3() {
        Map<Integer,Integer> map = new HashMap<>();
        map.put(1,2);
        map.put(2,3);
        map.put(3,4);
        map.put(4,5);
        // 常规遍历集合的方式
        Set<Map.Entry<Integer, Integer>> entries = map.entrySet();
        for (Map.Entry<Integer, Integer> entry : entries) {
            System.out.print(entry.getKey() + ":" +  entry.getValue() + " ");
        }
        System.out.println();
        // 使用lambda表达式
        map.forEach((k, v) -> System.out.print(k + ":" + v + " "));
    }

常见的函数式接口

使用lambda表达式的前提式这个接口是一个函数式接口，常规的函数式接口又分为4种，@FunctionalInterface可以使用这个注解加在接口之上，来检查节格接口是否式一个函数式接口

代码示例

消费型接口 Consumer

只接收数据进行处理，不返回结果

    /**
     * Consumer 消费型接口
     */
    @Test
    public void test4() {
        // 正常方式调用方法
        happyTime("胡琦", new Consumer<String>() {
            @Override
            public void accept(String s) {
                System.out.println(s + " 开始工作了。。");
            }
        });

        // 使用lambda表达式之后
        happyTime("张三", s -> System.out.println(s + " 开始唱歌了。。"));
    }

    public void happyTime(String str, Consumer<String> consumer) {
        consumer.accept(str);
    }
    
    // 输出结果
    // 胡琦 开始工作了。。
	// 张三 开始唱歌了。。

Supplier 供给型接口

不用提供任何数据，他也会给你返回数据

Predicate 断言型接口

给一个数据，来对这个数据进行判定进行断言

	@Test
    public void test5() {
        // 常规方法
        List<String> list = testPredicate(new ArrayList<String>(Arrays.asList("北京", "南京", "东京", "武汉", "杭州")), new Predicate<String>() {
            @Override
            public boolean test(String s) {
                // 只能展示包含京字的
                return s.contains("京");
            }
        });
        System.out.println(list);

        // lambda
        List<String> list1 = testPredicate(new ArrayList<String>(Arrays.asList("北京", "南京", "东京", "武汉", "杭州")), s -> s.contains("京"));
        System.out.println(list1);
    }

    /**
     * 根据据给定的规则过滤集合中的字符串
     */
    public List<String> testPredicate(List<String> list, Predicate<String> predicate) {
        ArrayList<String> filterList = new ArrayList<>();

        for (String s : list) {
            if (predicate.test(s)) {
                filterList.add(s);
            }
        }
        return filterList;
    }

// [北京, 南京, 东京]
// [北京, 南京, 东京]

方法引用&构造器引用

​

    /**
     * 情况一： 对象:: 实例方法
     * Concumer 中的void accept（T t）
     * PrintStream中的void println（T t）
     */	
	@Test
    public void test6() {
        // 普通lambda表达式方式
        Consumer<String> consumer = str -> System.out.println(str);
        consumer.accept("huqi");
        
        // 使用方法引用后
        PrintStream out = System.out;
        Consumer<String> consumer1 = out::println;
        consumer1.accept("zhangsan");
    }

 /**
     * 情况2： 类：：静态方法
     * Comparator类中的int compare(T t1,T t2)
     * Integer中的int compare(T t1,T t2)
     */
    @Test
    public void test7() {
        // 使用lambda
        Comparator<Integer> com1 = (t1,t2) -> Integer.compare(t1,t2);
        System.out.println(com1.compare(12,21));

        // 使用方法引用
        Comparator<Integer> com2 = Integer::compareTo;
        System.out.println(com2.compare(21,12));
    }

// -1 // 后面的比前面的大
// 1

/**
     * 四舍五入
     * Function中的R apply(T t)
     * Math中的Long round（Double d）
     */
    @Test
    public void test8() {
        // 普通方式
        Function<Double,Long> fun = new Function<Double, Long>() {
            @Override
            public Long apply(Double aDouble) {
                return Math.round(aDouble);
            }
        };

        // lambda
        Function<Double,Long> fun2 = d -> Math.round(d);
        System.out.println(fun2.apply(12.3));

        // 方法引用
        Function<Double,Long> fun3 = Math::round;
        System.out.println(fun3.apply(12.6));
    }

// 12
// 13

    /**
     * 情况三： 类：：实例方法
     * Comparator中的int compare（T t1，T t2）
     * String中的int t1.compareTo（t2）
     */
    @Test
    public void test9() {
        Comparator<String> comparator = (s1,s2) -> s1.compareTo(s2);
        System.out.println(comparator.compare("abc","abd"));
        
        Comparator<String> comparator1 = String::compareTo;
        System.out.println(comparator1.compare("abc","abe"));
    }

// -1
// -2

    /**
     * BiPredicate中的boolean test（T t1, T t2）
     * String 中的boolean t1.equals(t2)
     */
    @Test
    public void test10() {
        BiPredicate<String,String> biPredicate = (s1,s2) -> s1.equals(s2);
        System.out.println(biPredicate.test("huqi","huqi"));
        
        BiPredicate<String,String> biPredicate1 = String::equals;
        System.out.println(biPredicate1.test("zhang","zhang"));
    }

// true
// true

构造器引用&数组引用