Java函数式接口

news2024/10/5 15:01:50

3 函数式接口

3.1 函数式接口概述

  • 函数式接口：有且仅有一个抽象方法的接口

  • Java中的函数式编程体现就是Lambda表达式，所以函数式接口就是可以适用于Lambda使用的接口只有确保接口中有且仅有一个抽象方法， Java中的Lambda才能顺利地进行推导

  • 如何检测一个接口是不是函数式接口呢?

    • @FunctionalInterface
    • 放在接口定义的上方:如果接口是函数式接口，编译通过；如果不是,编译失败

  • 注意：我们自己定义函数式接口的时候，@Functionallnterface是可选的, 就算我不写这个注解，只要保证满足函数式接口定义的条件，也照样是函数式接口。但是，建议加上该注解

3.2 函数式接口作为方法的参数

  • 需求
    在这里插入图片描述
package test;

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

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

    public static void startThread(Runnable r) { //Runnable为函数式接口，上方有@FunctionalInterface
//        Thread t  = new Thread(r);
//        t.start();
        new Thread(r).start();
    }
}
  • 如果方法的参数是函数式接口，可以使用Lambda表达式作为参数传递
startThread(() -> System.out.println(Thread.currentThread().getName() + "线程启动了"));

3.3 函数式接口作为方法的返回值

  • 需求
    在这里插入图片描述
package test;

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

public class Demo {
    public static void main(String[] args) {
        //构造使用场景
        //定义一个集合存储字符串
        ArrayList array = new ArrayList();
        array.add("cccc");
        array.add("aa");
        array.add("b");
        array.add("dd");

        System.out.println("排序前："+array); //排序前：[cccc, aa, b, dd]

        Collections.sort(array); //排序后:[aa, b, cccc, dd]

        Collections.sort(array,getComparator()); //排序后:[b, aa, dd, cccc]

        System.out.println("排序后:"+array);

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

//        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();
//        };

        return(s1,s2) -> s1.length()-s2.length();
    }
}
  • 如果方法的返回值是函数式接口，可以使用Lambda表达式作为结果返回
public static Comparator<String> getComparator() {
	return(s1,s2) -> s1.length()-s2.length();
}

3.4 常用函数式接口

  • Java 8在java.util.function包下预定义了大量的函数式接口供我们使用
  • 重点来学习下面的4个接口
    • Supplier [səˈplaɪər] 接口
    • Consumer [kənˈsuːmər] 接口
    • Predicate[ˈpredɪkət] 接口
    • Function接口

3.4.1 Supplier接口

  • Supplier<T>：包含一个无参的方法
  • T get()方法：获得结果
  • 该方法不需要参数， 它会按照某种实现逻辑(由Lambda表达式实现)返回一个数据
  • Supplier<T>接口也被称为生产型接口，如果我们指定了接口的泛型是什么类型,那么接口中的get()方法就会生产什么类型的数据供我们使用
package test;

import java.util.function.Supplier;

public class Demo {
    public static void main(String[] args) {
//        String s = getString(() -> {
//            return "小黑";
//        });

        String s = getString(() -> "小黑");
        System.out.println(s); //小黑

        int i = getInteger(() -> 10);
        System.out.println(i); //10
    }

    //定义一个方法，返回字符数据
    public static String getString(Supplier<String> sup) {
        return sup.get();
    }

    //定义一个方法，返回整数数据
    public static Integer getInteger(Supplier<Integer> sup) {
        return sup.get();
    }
}
  • 练习
    在这里插入图片描述
package test;

import java.util.function.Supplier;

public class Demo {
    public static void main(String[] args) {
        int[] arr = {22, 55, 11, 44, 33};

        int maxValue = getMax(() -> {
            int max = arr[0];
            for (int i = 1; i < arr.length; i++) {
                if (arr[i] > max) {
                    max = arr[i];
                }
            }
            return max;
        });
        System.out.println(maxValue); //55
    }

    public static int getMax(Supplier<Integer> sup) {
        return sup.get();
    }
}

3.4.2 Consumer接口

  • Consumer<T>接口也被称为消费型接口，它消费的数据的数据类型由泛型指定
  • Consumer ：包含两个方法
方法名说明
void accept(T t) [əkˈsept]对给定的参数执行此操作
default Consumer<T> andThen(Consumer after)返回一个组合的Consumer，依次执行此操作，然后执行after操作
  • 范例
package test;


import java.util.function.Consumer;

public class Demo {
    public static void main(String[] args) {
//        operatorString("小白",(String s)->{
//            System.out.println(s); //小白
//        });

        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(new StringBuilder(s).reverse().toString())); //猫熊大
        System.out.println("---------");

        operatorString("小熊猫",s -> System.out.println(s),
        		s -> System.out.println(new StringBuilder(s).reverse().toString()));
//        小熊猫
//        猫熊小
    }

    //定义一个方法，用不同的方式消费同一个字符串数据两次
    private static void operatorString(String name, Consumer<String> con1,Consumer<String> con2) {
        //1,void accept(T t) [əkˈsept] 	对给定的参数执行此操作
//        con1.accept(name);
//        con2.accept(name);
        //2,Consumer<T> andThen(Consumer after) 	返回一个组合的Consumer，依次执行此操作，然后执行after操作
        con1.andThen(con2).accept(name);
    }
    //定义一个方法，消费一个字符串数据
    private static void operatorString(String name, Consumer<String> con) {
        con.accept(name);
    }
}
  • 练习
    在这里插入图片描述
package test;

import java.util.function.Consumer;

public class Demo {
    public static void main(String[] args) {
        String[] strArray = {"小白,10", "小黑,20"};
//        printInfo(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);
//        });
        //姓名:小白,年龄:10
        //姓名:小黑,年龄:20

        printInfo(strArray, str -> System.out.print("姓名:" + str.split(",")[0]),
                str -> System.out.println(",年龄:" + Integer.parseInt(str.split(",")[1])));
    }

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

3.4.3 Predicate [predɪkeɪt] 接口

  • Predicate<T>接口通常用于判断参数是否满足指定的条件
  • 常用的四个方法
方法名说明
boolean test(T t)对给定的参数进行判断(判断逻辑由Lambda表达式实现，返回一个布尔值
default Predicate<T> negate()返回一个逻辑的否定，对应逻辑非
default Predicate <T> and(Predicate other)返回一个组合判断，对应短路与
default Predicate <T> or(Predicate other)返回一个组合判断，对应短路或
  • 范例
package test;

import java.util.function.Predicate;

public class Demo {
    public static void main(String[] args) {
//        boolean b1 = checkString("hello",(String s) ->{
//            return s.length()>8;
//        });
        boolean b1 = checkString("hello", s -> s.length() > 8);
        System.out.println(b1); //1：false，2：true

        boolean b2 = checkString("hello",s->s.length()>8,s -> s.length()<15);
        System.out.println(b2); //3:false,4:true

        boolean b3 = checkString("hellojava",s->s.length()>8,s -> s.length()<15);
        System.out.println(b3); //3:true,4:true
    }

    //判断给定的字符串是否满足要求
    private static boolean checkString(String s, Predicate<String> pre) {
        //1,boolean test(T t) 	对给定的参数进行判断(判断逻辑由L ambda表达式实现，返回一个布尔值
//        return pre.test(s);
//        return !pre.test(s); //输出相反的，不过用下一个方法

        //2,default Predicate<T> negate() 	返回一个逻辑的否定，对应逻辑非
        return pre.negate().test(s);
    }

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

        //3,default Predicate <T> and(Predicate other) 	返回一个组合判断，对应短路与
//        return pre1.and(pre2).test(s); //源码：return (t) -> test(t) && other.test(t);

        //default Predicate <T> or(Predicate other) 	返回一个组合判断，对应短路或
        return pre1.or(pre2).test(s); //源码：return (t) -> test(t) || other.test(t);
    }
}
  • 练习
    在这里插入图片描述
package test;

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

public class Demo {
    public static void main(String[] args) {
        String[] strArray = {"小黑,50", "大熊猫,40", "小白,20", "奥特曼,100"};

        ArrayList<String> array = myFilter(strArray, s -> s.split(",")[0].length() > 2,
                s -> Integer.parseInt(s.split(",")[1]) > 33);

        for(String str:array) {
            System.out.println(str);
//            大熊猫,40
//            奥特曼,100
        }
    }

    public static ArrayList<String> myFilter(String[] strArray, Predicate<String> pre1, Predicate<String> pre2) {
        //定义一个集合
        ArrayList<String> array = new ArrayList<String>();

        //遍历数组
        for (String str : strArray) {
            if (pre1.and(pre2).test(str)) {
                array.add(str);
            }
        }
        return array;
    }
}

3.4.4 Function接口

  • Function<T,R> 接口通常用于对参数进行处理,转换（处理逻辑由Lambda表达式实现），然后返回一个新的值
  • 常用的两个方法
方法名说明
R apply(T t)将此函数应用于给定的参数
default <V> Function andThen(Function after)返回一个组合函数,首先将该函数应用于输入,然后将after函数应用于结果
  • 案例
package test;

import java.util.function.Function;

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

        convert(100, i -> String.valueOf(i + 566)); //666

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

    //定义一个方法，把一个字符串转换成int类型，在控制台输出
    public static void convert(String s, Function<String, Integer> fun) {
        //1,R apply(T t) 	将此函数应用于给定的参数
//        Integer i = fun.apply(s);
        int i = fun.apply(s);
        System.out.println(i);
    }

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

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

        //2,default <V> Function andThen(Function after) 	返回一个组合函数,首先将该函数应用于输入,然后将after函数应用于结果
        String ss = fun1.andThen(fun2).apply(s);//源码：return (T t) -> after.apply(apply(t));相当于上两步

        System.out.println(ss);
    }
}
  • 练习
    在这里插入图片描述
package test;

import java.util.function.Function;

public class Demo {
    public static void main(String[] args) {
        String s = "小黑,20";

        convert(s, ss -> ss.split(",")[1], ss -> Integer.parseInt(ss), i -> i + 70); //90
    }

    public static void convert(String s, Function<String, String> fun1, Function<String, Integer> fun2, Function<Integer, Integer> fun3) {
        int i = fun1.andThen(fun2).andThen(fun3).apply(s);
        System.out.println(i);
    }
}

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处：http://www.coloradmin.cn/o/360527.html

如若内容造成侵权/违法违规/事实不符，请联系多彩编程网进行投诉反馈，一经查实，立即删除！

相关文章

不容错过！飞桨深度学习与大模型产业应用专场24日等你来！

不容错过！飞桨深度学习与大模型产业应用专场24日等你来！

人工智能教父Hinton曾评价&#xff0c;“深度学习将无所不能”&#xff0c;从聊天机器人、自动驾驶到语音助手&#xff0c;深度学习早已在不知不觉中渗透进我们的生活&#xff0c;而AI大模型又是一项深度学习技术的新突破。深度学习、大模型作为人工智能发展的重要方向&#xf…
阅读更多...
前端开发项目规范写法介绍

前端开发项目规范写法介绍

1. 基本原则 结构、样式、行为分离 尽量确保文档和模板只包含 HTML 结构，样式都放到样式表里，行为都放到脚本里。 缩进 统一两个空格缩进（总之缩进统一即可），不要使用 Tab 或者 Tab、空格混搭。 文件编码 使用不带 BOM 的 UTF-8 编码。 在 HTML中指定编码 <meta c…
阅读更多...
C# 利用FluentFTP实现FTP上传下载功能

C# 利用FluentFTP实现FTP上传下载功能

FTP作为日常工作学习中&#xff0c;非常重要的一个文件传输存储空间&#xff0c;想必大家都非常的熟悉了&#xff0c;那么如何快速的实现文件的上传下载功能呢&#xff0c;本文以一个简单的小例子&#xff0c;简述如何通过FluentFTP实现文件的上传和下载功能。仅供学习分享使用…
阅读更多...
c++提高篇——queque容器

c++提高篇——queque容器

一、queque容器基本概念 Queue是一种先进先出(FIFO)的教据结构&#xff0c;它有两个出口 队列容器允许从一端新增元素&#xff0c;从另一端移除元素。队列中只有队头和队尾才可以被外界使用&#xff0c;因此队列不允许有遍历行为队列中进数据。 queque容器可以形象化为生活中…
阅读更多...
第一个Java程序（初识Java）

第一个Java程序（初识Java）

个人主页&#xff1a;平行线也会相交 欢迎 点赞&#x1f44d; 收藏✨ 留言✉ 加关注&#x1f493;本文由 平行线也会相交 原创 收录于专栏【JavaSE_primary】 文章目录1.Java概述1.1什么是Java1.2Java之父2.0第一个Java程序编译运行.class3.0程序如何跑起来的&#xff1f;3.1J…
阅读更多...
39、基于51单片机声控光控灯人体感应路灯照明灯系统设计

39、基于51单片机声控光控灯人体感应路灯照明灯系统设计

摘 要 随着社会的不断进步&#xff0c;人们对低碳生活逐步认识和接受&#xff0c;并从很多方面开始关注&#xff0c;尤其是在环保上做出了很多努力。利用声音和光线的强弱来控制开关的断开或者闭合的电子产品来能够有效的降低能耗&#xff0c;节约能源。它不仅适用于住宅区的…
阅读更多...
CMake构建静态库与动态库以及使用

CMake构建静态库与动态库以及使用

CMake构建静态库与动态库一、任务二、准备工作三、编译共享库四、ADD_LIBRARY指令五、编译静态库5.1、SET_TARGET_PROPERTIES指令5.2、GET_TARGET_PROPERTY指令六、动态库版本号七、安装共享库和头文件八、使用外部共享库和头文件8.1、准备工作8.2、引入头文件搜索路径8.3、为 …
阅读更多...
leetcode 11~20 学习经历

leetcode 11~20 学习经历

LeetCode 习题 11 - 2011. 盛最多水的容器12. 整数转罗马数字13. 罗马数字转整数14. 最长公共前缀15. 三数之和16. 最接近的三数之和17. 电话号码的字母组合18. 四数之和19. 删除链表的倒数第 N 个结点20. 有效的括号小结11. 盛最多水的容器 给定一个长度为 n 的整数数组 heigh…
阅读更多...
【Servlet篇】Request请求转发详细解读

【Servlet篇】Request请求转发详细解读

文章目录1. 前言2. 实战案例3. 特点1. 前言 请求转发是一种在服务器内部的资源跳转方式&#xff0c;如图&#xff1a; 上图的大致过程为&#xff0c;浏览器发送请求给服务器&#xff0c;服务器中 a 资源接收到请求&#xff0c;资源 a 处理完请求后将请求发送给资源 b&#xff…
阅读更多...
cdr最新2023版本发布更新及CorelDraw功能介绍

cdr最新2023版本发布更新及CorelDraw功能介绍

CDR作为一款专业的平面设计软件&#xff0c;拥有着庞大的用户群体&#xff0c;而每年春天CorelDRAW新版本的发布也牵动着每一位小伙伴的心。CorelDraw2023近期刚刚发布本人就开始试用&#xff0c;感觉非常良好&#xff0c;特别给大家提出升级的N个理由!CorelDRAW2023最新版内置…
阅读更多...
【基础算法】差分的应用（一维差分和二维差分）

【基础算法】差分的应用（一维差分和二维差分）

&#x1f339;作者:云小逸 &#x1f4dd;个人主页:云小逸的主页 &#x1f4dd;Github:云小逸的Github &#x1f91f;motto:要敢于一个人默默的面对自己&#xff0c;强大自己才是核心。不要等到什么都没有了&#xff0c;才下定决心去做。种一颗树&#xff0c;最好的时间是十年前…
阅读更多...
FPGA 20个例程篇：20.USB2.0/RS232/LAN控制并行DAC输出任意频率正弦波、梯形波、三角波、方波(一）

FPGA 20个例程篇：20.USB2.0/RS232/LAN控制并行DAC输出任意频率正弦波、梯形波、三角波、方波(一）

在最后一个例程中笔者精挑细选了一个较为综合性的项目实战&#xff0c;其中覆盖了很多知识点&#xff0c;也是从一个转产产品中所提炼出来的&#xff0c;所以非常贴近实战项目。 整个工程实现了用户通过对上位机PC端人机界面的操作&#xff0c;即可达到控制豌豆开发并行DAC输出…
阅读更多...
Java---高级流

Java---高级流

目录 一、转换流 &#xff08;1&#xff09;指定的字符集读写数据 二、序列化流和反序列化流 三、解压缩流和压缩流 &#xff08;1&#xff09;解压缩流 &#xff08;2&#xff09;压缩流 一&#xff1a;压缩文件 二&#xff1a;压缩文件夹 注&#xff1a;本文并未介绍J…
阅读更多...
CVE-2023-24055 KeePass信息明文传输漏洞复现

CVE-2023-24055 KeePass信息明文传输漏洞复现

前言 由于传播、利用此文所提供的信息而造成的任何直接或者间接的后果及损失&#xff0c;均由使用者本人负责&#xff0c;文章作者不为此承担任何责任。 如果文章中的漏洞出现敏感内容产生了部分影响&#xff0c;请及时联系作者&#xff0c;望谅解。 一、漏洞描述 漏洞简述 Kee…
阅读更多...
STM32 SystemInit()函数学习总结

STM32 SystemInit()函数学习总结

拿到程序后如何看系统时钟&#xff1f;User文件夹——system_stm32f4xx程序&#xff0c;先找systemcoreclock(系统时钟&#xff09;但是这里这么多个系统时钟应该如何选择?点击魔法棒&#xff0c;然后点击C/C可以看到define的是F40_41XXX.USE这一款 &#xff0c;对应着就找出了…
阅读更多...
R语言、MaxEnt模型融合技术的物种分布模拟、参数优化方法、结果分析制图与论文写作

R语言、MaxEnt模型融合技术的物种分布模拟、参数优化方法、结果分析制图与论文写作

基于R语言、MaxEnt模型融合技术的物种分布模拟、参数优化方法、结果分析制图与论文写作技术应用第一章、理论篇以问题导入的方式&#xff0c;深入掌握原理基础什么是MaxEnt模型&#xff1f;MaxEnt模型的原理是什么&#xff1f;有哪些用途&#xff1f;MaxEnt运行需要哪些输入文件…
阅读更多...
对云原生集群网络流量可观测性的一点思考

对云原生集群网络流量可观测性的一点思考

问题背景 在云原生技术的广泛普及和实施过程中&#xff0c;笔者接触到的很多用户需求里都涉及到对云原生集群的可观测性要求。 实现集群的可观测性&#xff0c;是进行集群安全防护的前提条件 。而在可观测性的需求中&#xff0c;集群中容器和容器之间网络流量的可观测性需求是…
阅读更多...
别错过！4C首发直播，上届全国总冠军带你入门赛题

别错过！4C首发直播，上届全国总冠军带你入门赛题

和志同道合的伙伴并肩作战&#xff0c;用指尖敲出奇思妙想&#xff0c;飞桨黑客马拉松PaddlePadddle Hackathon第四期全新升级&#xff0c;开放报名啦&#xff01; 玩技术&#xff0c;秀操作&#xff01;这是一场高手云集的开发者盛会。四大赛道&#xff1a;核心框架开源贡献&…
阅读更多...
Python每日一练(20230221)

Python每日一练(20230221)

目录 1. 不同路径 II 2. 字符串转换整数 (atoi) 3. 字符串相乘 1. 不同路径 II 一个机器人位于一个 m x n 网格的左上角 &#xff08;起始点在下图中标记为“Start” &#xff09;。 机器人每次只能向下或者向右移动一步。机器人试图达到网格的右下角&#xff08;在下图中…
阅读更多...
一文讲明Hystrix熔断器

一文讲明Hystrix熔断器

前言 解决问题: 主要防止服务器集群发生雪崩, 起到对服务器的保护作用 GitHub地址&#xff1a;https://github.com/Netflix/Hystrix/wiki 1 Hystrix是什么 1.1 分布式系统面临的问题 复杂分布式体系结构中的应用程序有数十个依赖关系&#xff0c;每个依赖关系在某些时候将不…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023