二十、Java8新特性——函数式接口【黑马JavaSE笔记】

最新推荐文章于 2024-06-03 00:45:24 发布
最新推荐文章于 2024-06-03 00:45:24 发布
阅读量821 收藏 5
点赞数 3
分类专栏： JavaSE_学习笔记 文章标签： java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_58233406/article/details/126817354
版权

文章目录

函数式接口

（一）函数式接口概述

在这里插入图片描述

（二）函数式接口作为方法的参数

在这里插入图片描述

测试类：

public class RunnableDemo {
    public static void main(String[] args) {
        //匿名内部类
        startThread(new Runnable() {
            @Override
            public void run() {
                System.out.println(Thread.currentThread().getName() + "启动了");
            }
        });

        //Lambda表达式
        startThread(() -> System.out.println(Thread.currentThread().getName() + "启动了"));
    }

    private static void startThread(Runnable r) {
        new Thread(r).start();
    }
}

（三）函数式接口作为方法的返回值

在这里插入图片描述

代码演示：

import java.util.ArrayList;
import java.util.Collections;
import java.util.Comparator;

public class ComparatorDemo {
    public static void main(String[] args) {
        ArrayList<String> array = new ArrayList<>();
        array.add("aaabbb");
        array.add("sdas");
        array.add("sda");
        System.out.println("排序前：" + array);//排序前：[aaabbb, sdas, sda]
        Collections.sort(array, getComparator());
        System.out.println("排序后：" + array);//排序后：[sda, sdas, aaabbb]
    }

    private static Comparator<String> getComparator() {
        //匿名内部类实现
//        Comparator<String> c = new Comparator<String>() {
//            @Override
//            public int compare(String s1, String s2) {
//                return s1.length() - s2.length();
//            }
//        };
//        return c;

        //匿名内部类简写
//        return new Comparator<String>() {
//            @Override
//            public int compare(String s1, String s2) {
//                return s1.length() - s2.length();
//            }
//        };

        //Lambda表达式
//        return (String s1,String s2) -> {
//          return s1.length() - s2.length();
//        };

        //Lambda表达式简写
        return (s1, s2) -> s1.length() - s2.length();
    }
}

（四）常用的函数式接口

Java8在java.util.function包下预定义了大量的函数式接口供我们使用

我们重点来学习下面的4个接口

  • Supplier接口
  • Consumer接口
  • Predicate接口
  • Function接口
1.Supplier接口

在这里插入图片描述

代码演示：

import java.util.function.Supplier;

public class SupplierDEmo {
    public static void main(String[] args) {
//        String s = getString(new Supplier<String>() {
//            @Override
//            public String get() {
//                return "小明";
//            }
//        });

        String s = getString(() -> "小明");
        System.out.println(s);//小明
        Integer i = getInteger(() -> 10);
        System.out.println(i);//10

    }
    private static Integer getInteger(Supplier<Integer> sup){
        return sup.get();
    }

    private static String getString(Supplier<String> sup) {
        return sup.get();
    }
}
2.Supplier接口练习（获取最大值）

代码演示：

import java.util.function.Supplier;

public class SupplierTest {
    public static void main(String[] args) {
        int[] arr = {19, 50, 28, 37, 46};
        int maxValue = getMax(() -> {
            int max = 0;
            for (int i = 0; i < arr.length; i++) {
                if (max < arr[i]) {
                    max = arr[i];
                }
            }
            return max;
        });
        System.out.println(maxValue);
    }

    private static int getMax(Supplier<Integer> sup) {
        return sup.get();
    }
}
3.Consumer接口

在这里插入图片描述

代码演示：

import java.util.function.Consumer;

public class ConsumerDemo {
    public static void main(String[] args) {
        //匿名内部类
        operatorString("小明", new Consumer<String>() {
            @Override
            public void accept(String s) {
                System.out.println(s);
            }
        });
        //Lambda表达式
        operatorString("小明", s -> System.out.println(s));
        //方法引用
        operatorString("小明", System.out::println);

        operatorString("小明", s -> System.out.println(new StringBuilder(s).reverse().toString()));

        operatorString("王老五", s -> System.out.println(s), s -> System.out.println(new StringBuilder(s).reverse().toString()));
    }
    
    private static void operatorString(String name, Consumer<String> con) {
        con.accept(name);
    }
    //对同一个字符串数据用不同的方式消费两次
    private static void operatorString(String name, Consumer<String> con1, Consumer<String> con2) {
        con1.andThen(con2).accept(name);
    }
}
4.Consumer接口练习（按要求打印信息）

代码演示：

import java.util.function.Consumer;

public class ConsumerTest {
    public static void main(String[] args) {
        String[] strArray = {"王老五,20", "张三,30", "李四,22"};
        
        operatorString(strArray, (String str) -> {
            String name = str.split(",")[0];
            System.out.print("姓名：" + name);
        }, (String str) -> {
            int age = Integer.parseInt(str.split(",")[1]);
            System.out.println(", 年龄：" + age);
        });

        //简化代码
        operatorString(strArray, str -> System.out.print("姓名：" + str.split(",")[0]), 
                str -> System.out.println(", 年龄：" + Integer.parseInt(str.split(",")[1])));
    }

    private static void operatorString(String[] strArray, Consumer<String> con1, Consumer<String> con2) {
        for (String str : strArray) {
            con1.andThen(con2).accept(str);
        }
    }
}
5.Predicate接口

在这里插入图片描述

代码演示：

import java.util.function.Predicate;

public class PredicateDemo {
    public static void main(String[] args) {
        boolean result = checkString("hello", (String s) -> {
            return s.length() > 6;
        });
        System.out.println(result);

        //简写
        boolean result2 = checkString("helloWorld", s -> s.length() > 6);
        System.out.println(result2);

        boolean result3 = checkString("hello", s -> s.length() > 6, s -> s.length() < 15);
        System.out.println(result3);
        boolean result4 = checkString("helloWorld", s -> s.length() > 6, s -> s.length() < 15);
        System.out.println(result4);

        boolean result5 = checkString2("hello", s -> s.length() > 6, s -> s.length() < 15);
        System.out.println(result5);
        boolean result6 = checkString2("helloWorld", s -> s.length() > 6, s -> s.length() < 15);
        System.out.println(result6);
    }

    private static boolean checkString(String s, Predicate<String> p) {
//        return p.test(s);
        //否定操作
        return p.negate().test(s);
    }

    //对同一个字符串给出不同的判断条件，最后把这两个判断的结果做逻辑与运算的结果作为最终的结果
    private static boolean checkString(String s, Predicate<String> p1, Predicate<String> p2) {
//        boolean b1 = p1.test(s);
//        boolean b2 = p2.test(s);
//        boolean b = b1 && b2;
//        return  b;
        return p1.and(p2).test(s);
    }

    //对同一个字符串给出不同的判断条件，最后把这两个判断的结果做逻辑或运算的结果作为最终的结果
    private static boolean checkString2(String s, Predicate<String> p1, Predicate<String> p2) {
//        boolean b1 = p1.test(s);
//        boolean b2 = p2.test(s);
//        boolean b = b1 && b2;
//        return  b;
        return p1.or(p2).test(s);
    }
}
6.Predicate接口练习（筛选满足条件数据）

代码实现：

import java.util.ArrayList;
import java.util.function.Predicate;

public class PredicateTest {
    public static void main(String[] args) {
        String[] strArray = {"张三三,20", "王五,22", "李四四,40", "吕布布,55", "曾小贤,30"};

        //调用方法，编写满足条件
//        ArrayList<String> people = checkPeople(strArray, str -> {
//            String name = str.split(",")[0];
//            return name.length() > 2;
//        }, str -> {
//            int age = Integer.parseInt(str.split(",")[1]);
//            return age > 33;
//        });

        //简写
        ArrayList<String> people = checkPeople(strArray, str -> str.split(",")[0].length() > 2
                , str -> Integer.parseInt(str.split(",")[1]) > 33);

        //遍历集合
        for (String s : people) {
            System.out.println(s);
        }
    }

    private static ArrayList<String> checkPeople(String[] strArray, Predicate<String> p1, Predicate<String> p2) {
        //定义一个集合
        ArrayList<String> array = new ArrayList<>();

        //遍历数组，将满足条件的数据添加进入集合中
        for (String str : strArray) {
            if (p1.and(p2).test(str)) {
                array.add(str);
            }
        }
        return array;
    }
}
7.Function接口

在这里插入图片描述

代码演示：

import java.util.function.Function;

public class FunctionDemo {
    public static void main(String[] args) {
        convert("100", s -> Integer.parseInt(s));
//        convert("100", Integer::parseInt);//方法引用

        convert(100, i -> String.valueOf(i + 10));

        convert("100", s -> Integer.parseInt(s), i -> String.valueOf(i + 10));
    }

    //定义一个方法，把一个int类型的数据加上一个整数之后，转换为字符串在控制台输出
    private static void convert(String s, Function<String, Integer> fun) {
//        Integer i = fun.apply(s);
        //自动拆箱
        int i = fun.apply(s);
        System.out.println(i);
    }

    //定义一个方法，把一个字符串转换为int类型的数据加上一个整数后，转换为字符串在控制台输出
    private static void convert(int i, Function<Integer, String> fun) {
        String s = fun.apply(i);
        System.out.println(s);
    }

    //定义一个方法，把一个字符串转换为int类型，把int类型的数据加上一个整数之后，转换为字符串在控制台输出
    private static void convert(String s, Function<String, Integer> fun1, Function<Integer, String> fun2) {
//        Integer i = fun1.apply(s);
//        String ss = fun2.apply(i);
//        System.out.println(ss);
        String ss = fun1.andThen(fun2).apply(s);
        System.out.println(ss);
    }
}
8.Function接口练习（按照指定要求操作数据）

代码实现：

import java.util.function.Function;

public class FunctionTest {
    public static void main(String[] args) {
        String s = "林小青,30";
        convert(s, ss -> ss.split(",")[1], ss -> Integer.parseInt(ss), i -> i + 70);
    }

    private static void convert(String s, Function<String, String> fun1, Function<String, Integer> fun2, Function<Integer, Integer> fun3) {
        //这里解释上面调用时 s和ss的混乱
//        String ss = fun1.apply(s);
//        Integer i = fun2.apply(ss);
//        Integer i2 = fun3.apply(i);
        int i2 = fun1.andThen(fun2).andThen(fun3).apply(s);
        System.out.println(i2);
    }
}

-BoBooY-
关注
专栏目录
java8 新特性 - 函数式接口
simple_start的博客
05-27 274
函数式接口 函数式接口(Functional Interface)就是一个有且仅有一个抽象方法，但是可以有多个非抽象方法的接口。 函数式接口可以被隐式转换为 lambda 表达式。 Lambda 表达式和方法引用（实际上也可认为是Lambda表达式）上。 @FunctionalInterface 注解作用检验是否是函数式接口 代码练习 package com.sgl.lambda; /** * 自定义函数式接口 * *@FunctionalInterface 注解作用检验是否是..
黑马程序员Javase笔记
01-18
"黑马程序员Javase笔记"是一个自学者在学习黑马程序员提供的Java全套课程过程中整理的笔记，主要涵盖了Java Standard Edition (Javase) 的核心内容。下面将详细讨论其中的关键知识点。 首先，DOS命令是操作系统中的...
函数式接口
qq_31410959的博客
01-04 505
Java 8 函数式接口 原文地址 http://www.runoob.com/java/java8-functional-interfaces.html 函数式接口(Functional Interface)就是一个具有一个方法的普通接口。 函数式接口可以被隐式转换为lambda表达式。 函数式接口可以现有的函数友好地支持 lambda。 JDK 1.8之前已有的函数式
函数式接口-Java 8 新特性
清尘
08-10 212
函数式接口入门学习
JAVA8新特性- 函数式接口
my博客
08-25 2618
java8 stream 内置的function
Java8新特性--函数式接口
张氏小毛驴的博客
08-23 283
（重写时候不需要加default关键字）。注意：函数式接口中有且只能有一个抽象方法，但可以有多个static方法或default方法。
黑马JavaSE笔记.zip
11-20
2020最新黑马Java SE从入门到精通-IDEA版「已完结」1.JAVASE从零开始，深入浅出实战java项目
黑马java se视频笔记
11-01
这部分内容是任何计算机课程，尤其是像黑马Java SE这样的课程的起点。 首先，计算机的定义是电子计算机，俗称电脑，它是一种能够根据预设程序自动、高速处理大量数据的现代化智能设备。计算机由硬件和软件组成。...
JDK8-Java8-JavaSE8新特性和增强功能-第一部
06-18
熟悉JDK8新特性和库对Android开发(基于Java语言)更加得心应手。 5. 熟悉JDK8新特性能方便进行Java底层开发,比如Spring MVC. 6. IDE目前基于轻便的VSCode开发说明, 也可以自行通过IDEAJ建立项目运行。
java8新特性
12-14
java SE8 新特性，每一位java开发工程师的必备宝典，其中包括lambda表达式以及lambda编程、stream API处理、新的日期与时间API、JavaScript引擎、并发增强处理、杂项处理等等。
java8新特性--函数式接口
qq_37822914的博客
06-29 352
java.util.function
Java８新特性之函数式接口
weixin_44022886的博客
05-30 194
函数式接口：如果一个接口中，只声明了一个抽象方法，则此接口就称为函数式接口。 你可以通过Lambda表达式来创建该接口的对象。（若Lambda表达式抛出一个受检异常（即非运行时异常），那么该异常需要在目标接口的抽象方法上进行声明）。 我们可以在一个接口上使用＠Ｆｕｎｃｔｉｏｎｇａｌｌｎｔｅｒｆａｃｅ注解，这样做可以检查它是否是一个函数式接口。同时Ｊａｖａｄｏｃ也会包含一条声明，说明这个接口是一...
Java 8 新特性：函数式接口（Functional Interface）
最新发布
qq_33326733的博客
06-03 2302
函数式接口的定义很简单：有且只有一个抽象方法的接口。但它可以包含多个默认方法和静态方法。通常情况下，使用注解来标识一个接口为函数式接口，这样做的目的是在编译时强制规范定义。java// 可以包含多个默认方法// 可以包含多个静态方法Java 8 引入的包中提供了一组通用的函数式接口，如PredicateConsumerFunction等。这些接口为常见的函数式编程模式提供了统一的定义，使得代码更具通用性和可重用性。
Java8 新特性——函数式接口
weixin_47203903的博客
12-08 537
@FunctionalInterface注解 该注解可以用来检测该接口是否为函数式接口，将该注解放在 接口定义的上方，如果接口是函数式接口，编译通过；如果不是，编译失败需要注意的是，即使不使用该注解，只要满足函数式接口的定义，这仍然是一个函数式接口，使用起来都一样。 作为返回值进行使用 常用函数式接口 Supplier接口 接口仅包含一个无参的方法：，用来获取一个泛型参数指定类型的对象数据该接口被称为生产型接口,指定接口的泛型是什么类型,那么get方法就会产生什么类型的数据 Consu
【Java8新特性】函数式接口
大脑不能为空
10-31 535
Java8新特性函数式接口详细介绍，并且介绍了与函数式接口密切相关的lambda表达式的使用，还有常用函数式接口的使用方法。
java8新特性之函数式接口
不敲代码的码农的博客
09-28 763
虽然刚发布了java11版本，但是对于java8中新的特性我们仍需要掌握，毕竟大部分开发都是用的jdk8，以及java11中仍然保留着这些特性，接下来我就网上查找资料做了一下总结，如果哪里说的不对头，还请各位大佬指出来，我会及时更正。 1.函数式接口定义： 那么函数接口到底是什么呢？是个接口，只包含一个抽象方法，则该接口称之为函数式接口，我们可以在任意函数式接口上使用 @FunctionalI...
Java8新特性：函数式接口
littlening的博客
04-25 529
目录定义自定义函数式接口jdk自带函数式接口JDK 1.8 之前已有的函数式接口:JDK 1.8 新增加的函数接口：使用实例 定义 函数式接口(Functional Interface)就是一个有且仅有一个抽象方法，但是可以有多个非抽象方法的接口。 函数式接口可以被隐式转换为 lambda 表达式。 Lambda 表达式和方法引用（实际上也可认为是Lambda表达式）上。 自定义函数式接口 如定义了一个函数式接口如下： @FunctionalInterface interface GreetingServi
Java8 新特性 函数式接口
qq_40193787的博客
11-01 536
Stream（流）是一个来自数据源的元素队列并支持聚合操作元素是特定类型的对象，形成一个队列。Java中的Stream并不会存储元素，而是按需计算。数据源流的来源。可以是集合，数组，I/O channel， 产生器generator 等。聚合操作类似SQL语句一样的操作， 比如filter, map, reduce, find, match, sorted等。Pipelining: 中间操作都会返回流对象本身。这样多个操作可以串联成一个管道， 如同流式风格（fluent style）。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

-BoBooY-

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值