函数式接口

  • 开发
  • 45

文章目录

函数式接口

只有一个抽象方法的接口，转为lambda而生的接口
接口带有==@FunctionalInterface==

函数式接口当做方法的参数

案例：通过Runnable创建线程，把Runnable接口当做参数进行传递

package com.itxs.demo08;

/**
 * @Classname : demo01
 * @Description : TODO 函数式接口当做参数进行传递
 * @Author : lin_refuel@qq.com
 */
public class demo01 {
   
    public static void main(String[] args) {
   
         // 案例：创建线程
        // 方式一：匿名内部类的形式
        MyThread(new Runnable() {
   
            @Override
            public void run() {
   
                System.out.println("我是匿名内部类的方式创建的线程");
            }
        });
        // 方式二：完整的lambda
        MyThread(()->{
   
            System.out.println("完整的lambda创建的线程");
        });
        // 省略的lambda
        MyThread(()-> System.out.println("省略的lambda创建的线程"));
    }
    private static void MyThread(Runnable r){
   
        new Thread(r).start();
    }
}

运行结果：
在这里插入图片描述

函数式接口作为返回值

案例：字符串长度比较进行排序

package com.itxs.demo08;

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

/**
 * @Classname : demo02
 * @Description : TODO 字符串的长度进行比较
 * @Author : lin_refuel@qq.com
 */
public class demo02 {
   
    public static void main(String[] args) {
   
          // 定义一个String类型集合
        ArrayList<String> list = new ArrayList<>();
         // 添加元素
        list.add("123456555557");
        list.add("1234568");
        list.add("123456789");
        list.add("56789");
        //调用方法
        Collections.sort(list);// 自然规则进行排序
        for (String s : list) {
   
            System.out.println(s);
        }
        System.out.println("========================");
        Collections.sort(list,getCompare());// getCompare返回设置的比较器

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

    /**
     * 设置比较器的排序规则
     * @return 返回一个Comparator接口
     */
    private static Comparator<String> getCompare() {
   
        // 匿名内部类的方式
//        return new Comparator<String>() {
   
//            @Override
//            public int compare(String o1, String o2) {
   
//                return o1.length() - o2.length(); // 根据字符串长度进行比较 短的在前面
//            }
//        };
        // 通过lambda的方式
           return (o1,o2)->o1.length() - o2.length();
           // 引用方式
         //  return Comparator.comparingInt(String::length);

    }
}

运行结果：
在这里插入图片描述

生产者接口 - Supplier

Supplier

是一个生产者接口，用来生产数据，通常返回的是一个数据（可以使用Lambda表达式）

通过Supplier返回一个字符串和找到数组中的最大值

package com.itxs.demo08;

import java.util.function.Supplier;

/**
 * @Classname : demo01
 * @Description : TODO supplier生产者接口
 * @Author : lin_refuel@qq.com
 */
public class demo01 {
   
    public static void main(String[] args) {
   
          // 生产一个数据
          // 匿名内部类重写
//        String str = getString(new Supplier<String>() {
   
//            @Override
//            public String get() {
   
//                return "我是字符串";
//            }
//        });
        // lambda形式
//        String str = getString(()->{
   
//            return "我是一个字符串";
//        });
        // lambda省略方式
        String str = getString(()->"我是字符串".substring(2,4));
        System.out.println(str);
        //======================================================
        // 定义一个数组找到数组中的最大值
        int[] array = {
   1,2,3,4,5,6,7,8,9,10};
        int max = getMax(()->{
   
            int Max = array[0];
            for (int i = 1; i < array.length; i++) {
   
                if(Max < array[i])
                    Max = array[i];
            }
            return Max;
        });
        System.out.println("最大值Max = " + max);
    }

    /**
     * 找出最大值
     * @param sp Supplier接口，重写并调用里面抽象方法get
     * @return 最大值
     */
    private static Integer getMax(Supplier<Integer> sp) {
   
        return sp.get();
    }

    /**
     * 字符串返回
     * @param sp Supplier接口，重写并调用里面抽象方法get
     * @return 字符串
     */
    public static String getString(Supplier<String> sp) {
   
        return sp.get();
    }
}

运行结果：
在这里插入图片描述

消费者接口 - Consumer

是一个消费者接口，针对于数据做一些提取的操作，不需要返回值

使用方式：

demo: 对字符串进行操作

package com.itxs.demo08;

import java.util.function.Consumer;

/**
 * @Classname : demo02
 * @Description : TODO
 * @Author : lin_refuel@qq.com
 */
public class demo02 {
   
    public static void main(String[] args) {
   
        // 匿名内部类
         consumptionCharacters("小肆", new Consumer<String>() {
   
             @Override
             public void accept(String s) {
   
                 System.out.println("你的名字是: " + s);
             }
         });
         // lambda方式
        consumptionCharacters("小三",(str)->{
   
            System.out.println("你的名字反过来是：" + new StringBuilder(str).reverse());
        });
         //=======================================================================
        // Consumer连续消费，例如操作同一个字符串
        consumer02("小三",(str)-> System.out.println(str),(str)-> System.out.println(new StringBuilder(str).reverse()));

    }
    private static void consumptionCharacters(String str, Consumer<String> con){
   
        con.accept(str);
    }
    private static void consumer02(String str,Consumer<String> con01,Consumer<String> con02){
   
       // con01.accept(str);//01
        //con02.accept(str);//02
        con01.andThen(con02).accept(str);// 这行代码==上面的01和02缩写
    }
}

运行结果：
在这里插入图片描述

案例：字符串拆分

package com.itxs.demo08;

import java.util.function.Consumer;

/**
 * @Classname : demo03
 * @Description : TODO Consumer - 应用场景
 * @Author : lin_refuel@qq.com
 */
public class demo03 {
   
    public static void main(String[] args) {
   
         // 定义一个数组
        String[] name = {
   "东邪:黄固","西毒:欧阳锋","南帝:段智兴","北丐:洪七公","中神通:王重阳"};
         // 通过Consumer接口使其分开
        separate(name,(info)->{
   
            // info.split(":")[0]; 相当于是把字符串拆分成了字符数组，取下标为0的
            String outerNumber = info.split(":")[0];
            System.out.println("绰号：" + outerNumber);
        },(info)->{
   
            String originalName = info.split(":")[1];
            System.out.println("真名：" + originalName);
        });
    }
    private static void separate(String[] info, Consumer<String> con01,Consumer<String> con02){
   
        for (String s : info) {
   
            // 两个接口对同一个数组进行操作
            con01.andThen(con02).accept(s);
            System.out.println("=========================");
        }
    }
}

在这里插入图片描述

判断接口 - Predicate

使用方式

通常用于判断参数是否满足指定的条件

demo: 判断参数字符串的长度是否满足条件

package com.itxs.demo08;

import com.sun.xml.internal.ws.api.model.wsdl.WSDLOutput;

import java.util.function.Predicate;

/**
 * @Classname : demo04
 * @Description : TODO 判断接口  -Predicate<>()
 * @Author : lin_refuel@qq.com
 */
public class demo04 {
   
    public static void main(String[] args) {
   
          // Predicate接口的使用方式
        boolean b01 = res("JavaSE Linux MySQL redis", (str) -> {
   
            return str.length() > 10;// 判断字符串的长度是否超过10
        });
        System.out.println(b01); // 输出返回值
        System.out.println("===================================");
        boolean b02 = res("JavaSE Linux MySQL redis",
                str -> str.length()>20, // 字符串的长度是否超过20
                str -> str.length() < 30); // 字符串的长度是小于30
        System.out.println(b02);
    }

    /**
     *  根据字符串的是否符合要求来进行返回
     * @param str 目标字符串
     * @param p01 判断接口
     * @return 一个true or false
     */
    private static boolean res(String str,Predicate<String> p01){
   
        //return p01.test(str); // true
        // !return p01.test(str);// 逻辑非
        return p01.negate().test(str); // 等于上一个行
    }
    /**
     * 多重判断条件
     * @param str 目标字符串
     * @param p01 判断条件接口1
     * @param p02 判断条件接口2
     * @return false or true
     */
    private static boolean res(String str,Predicate<String> p01,Predicate<String> p02){
   
        //return p01.test(str) && p02.test(str);
        return p01.and(p02).test(str); // 逻辑与 等同于上面一行
    }
}

运行结果：
在这里插入图片描述

应用场景

筛选数据 - 找出年龄超过40的，名字是三个字的

package com.itxs.demo08;

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

/**
 * @Classname : demo05
 * @Description : TODO Predicate - 应用场景 （筛选数据）
 * @Author : lin_refuel@qq.com
 */
public class demo05 {
   
    public static void main(String[] args) {
   
         // 定义一个字符串数组 , 中原五绝的姓名和年龄
        String[] name = {
   "黄固,29","欧阳锋,31","段智兴,35","洪七公,43","王重阳,46"};
        // 找出名字长度为3 年龄超过40的
        ArrayList<String> res01 = res(name, (s) -> {
   
            return s.split(",")[0].length() == 3;// 判断分离的字符串长度是否为3
        }, (s) -> {
   
            return Integer.parseInt(s.split(",")[1]) > 40;
        });
        System.out.println(res01);
    }

    private static ArrayList<String> res(String[] name, Predicate<String> p01,Predicate<String> p02){
   
        ArrayList<String> list = new ArrayList<>();// 一个空的集合
        for (String s : name) {
   
            if(p01.and(p02).test(s)){
   
                list.add(s); // 满足条件进行添加
            }
        }
        return list;// 返回集合
    }

运行结果：
在这里插入图片描述

加工接口 - Function

接收一个参数，并产生一个结果

Function<T,R>：接口通常用于对参数进行处理，转换（处理逻辑有 啦么大 实现）,然后返回一个新的值

demo：

package com.itxs.demo08;

import java.util.function.Function;

/**
 * @Classname : demo06
 * @Description : TODO 加工接口 - 用于数据转换
 * @Author : lin_refuel@qq.com
 */
public class demo06 {
   
    public static void main(String[] args) {
   
        // 将字符串转换为Integer类型数据
        // lambda省略方式
        //conversion("9527",str->Integer.parseInt(str));
        // 引用方式
        conversion("9527", Integer::parseInt);
        System.out.println("==========================");
        // 将Integer类型数据转换为String类型
        // lambda省略写法
        //conversion(9527,integer -> String.valueOf(integer));
        // 引用写法
        conversion(9527, String::valueOf);
        System.out.println("==========================");
        // TODO ===========二次加工===========
        conversion("9527",
                s->Integer.parseInt(s+1),// Integer类型数据95271加工出来了
                s->String.valueOf(s+1)); // String类型数据 95272加工出来了

    }

    /**
     * 将String类型数据转为Integer类型
     *
     * @param str  目标字符串
     * @param ft01 转换接口
     */
    private static void conversion(String str, Function<String, Integer> ft01) {
   
        Integer res = ft01.apply(str); // 字符串9527转为了Integer类型9527
        System.out.println(res + 1);// 9527 + 1 = 9528
    }

    /**
     * 将Integer类型数据转字符串类型
     *
     * @param integer 目标整数类
     * @param ft01    转换接口
     */
    private static void conversion(Integer integer, Function<Integer, String> ft01) {
   
        String res = ft01.apply(integer); //Integer类型9527转成String类型 9527
        System.out.println(res + 1); // 9527 + 1 = 95271，相当于是字符串拼接
    }

    /**
     * 二次加工
     * 字符串转Integer ,Integer转字符串
     * @param str 目标字符串
     * @param ft01 字符串转Integer的接口
     * @param ft02 Integer转字符串的接口
     */
    private static void conversion(String str, Function<String, Integer> ft01, Function<Integer, String> ft02) {
   
        String RES = ft01.andThen(ft02).apply(str);
        System.out.println(RES + 1); // String类型95272 + 1 = 952721
    }
}
阅读全部

相关推荐

  1. Kotlin函数式接口

    2024-01-25 11:52:03       58 阅读

  4. 函数式接口 Consumer、Function、Supplier、Predicate

    2024-01-25 11:52:03       34 阅读

  5. Lambda表达式与函数式接口

    2024-01-25 11:52:03       31 阅读

  10. 多种异构数据的分析设计方案：使用策略模式+函数式接口

    2024-01-25 11:52:03       28 阅读

最近更新

  3. docker php8.1+nginx base 镜像 dockerfile 配置

    2024-01-25 11:52:03       98 阅读

  4. Could not load dynamic library ‘cudart64_100.dll‘

    2024-01-25 11:52:03       106 阅读

  9. 在Django里面运行非项目文件

    2024-01-25 11:52:03       87 阅读

  19. Python语言-面向对象

    2024-01-25 11:52:03       96 阅读

  20. 如何分清楚常见的 Git 分支管理策略Git Flow、GitHub Flow 和 GitLab Flow

    2024-01-25 11:52:03       91 阅读

热门阅读

  4. 【笔记】Helm-4 最佳实践-依赖

    2024-01-25 11:52:03       59 阅读

  5. harmonyOS app 开发环境配置流程

    2024-01-25 11:52:03       52 阅读

  16. 安卓MediaRecorder(4)视频采集编码写入详细源码分析

    2024-01-25 11:52:03       68 阅读

  17. Jenkins相关

    2024-01-25 11:52:03       58 阅读

  19. android:excludeFromRecents

    2024-01-25 11:52:03       41 阅读

  24. c# 策略模式

    2024-01-25 11:52:03       60 阅读

  25. 为什么需要数据仓库

    2024-01-25 11:52:03       60 阅读

  26. 《设计模式的艺术》笔记 - 策略模式

    2024-01-25 11:52:03       53 阅读