jdk8_lambda笔记

最新推荐文章于 2025-09-28 20:30:00 发布

原创最新推荐文章于 2025-09-28 20:30:00 发布 · 132 阅读

0 ·

CC 4.0 BY-SA版权

文章标签：

#lambda

lambda表达式及函数接口专栏收录该内容

1 篇文章

订阅专栏

这篇博客主要介绍了Java编程中Lambda表达式的使用，包括如何创建匿名内部类和使用Lambda简化代码。同时，文章详细讲解了函数式接口的概念，并展示了JDK内置的消费性、供给型和函数型函数式接口的实例应用。通过这些例子，读者可以更好地理解和掌握Java 8及更高版本中的函数式编程特性。

1. lambda表达式。

$[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-JHJz49H0-1620263030124)(C:\Users\ADMINI~1\AppData\Local\Temp\1620262808610.png)]$

2. 函数式接口

$[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-m4mQ2MDD-1620263030126)(C:\Users\ADMINI~1\AppData\Local\Temp\1620262821905.png)]$

package com.tyt.test;

public class Test01 {
    public static void main(String[] args) {
        /**
         * 匿名内部类
         */
        /*Thread thread = new Thread(new Runnable() {
            public void run() {
                System.out.println("李浩辰你是个啥子嘛");
            }
        });*/
//Runnable target
       /* Runnable runnable = ()-> {
            System.out.println("李浩辰你是个啥子嘛");
        };
*/
/**
 * lambda表达式
 */
        Thread thread = new Thread(()-> System.out.println("李浩辰你是个啥子嘛"));
        thread.start();
    }


}

3.JDK内置的函数式接口

（1）消费性函数式接口： void accept(T t)由一个参数，但是没有返回值

package com.tyt.test;

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

public class Test02 {
    public static void main(String[] args) {
        /*Consumer<Double> consumer = new Consumer<Double>() {
            @Override
            public void accept(Double aDouble) {
                System.out.println("消费金额:" + aDouble);
            }
        };*/
        Consumer<Double> consumer = a -> System.out.println("消费金额:" + a);
        hobby(consumer,1000);

       /* Supplier<Integer> supplier = new Supplier<Integer>() {
            @Override
            public Integer get() {
                return new Random().nextInt(10);
            }
        };*/
        Supplier<Integer> supplier = () -> new Random().nextInt(10);
        System.out.println(Arrays.toString(getSupplier(supplier, 5)));

      /*  Function<String, String> function = new Function<String, String>() {
            @Override
            public String apply(String s) {
                return s.toUpperCase();
            }
        };*/
        Function<String, String> function = s -> s.toUpperCase();
        System.out.println(Supper(function, "zhangsan"));

        List<String> list=new ArrayList<>();
        list.add("zhangsan");
        list.add("lisi");
        list.add("wangwu");
        list.add("zhaoliu");
        list.add("tianqi");
        /*Predicate<String> predicate = new Predicate<String>() {
            @Override
            public boolean test(String s) {
                return s.length() > 2;
            }
        };*/
        Predicate<String> predicate =s -> s.length() > 2;
        List<String> list1 = predicate(predicate, list);
        System.out.println(list1);
    }
    //消费性函数式接口的使用。
    public static void hobby(Consumer<Double> consumer, double money) {
        consumer.accept(money);
    }
    //供给型函数式接口
    public static int[] getSupplier(Supplier<Integer> supplier, Integer id) {
        int[] arr = new int[id];
        for (int i = 0; i < id; i++) {
            arr[i] = supplier.get();
        }
        return arr;
    }
    //函数型函数式接口
    public static String Supper(Function<String,String> function,String str) {
        return function.apply(str);
    }

    public static List<String> predicate(Predicate<String> predicate, List<String> list) {
        ArrayList<String> strings = new ArrayList<>();
        for (int i = 0; i < list.size(); i++) {
            if (predicate.test(list.get(i))) {
                strings.add(list.get(i));
            }
        }
        return strings;
    }
}