1. Toy模板网首页
  2. > Toy博客

Java函数式接口

10月前 作者：m0_64879847 分类：Toy博客 阅读(30) 违法举报

这篇具有很好参考价值的文章主要介绍了Java函数式接口。希望对大家有所帮助。如果存在错误或未考虑完全的地方，请大家不吝赐教，您也可以点击"举报违法"按钮提交疑问。

3 函数式接口

3.1 函数式接口概述

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

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

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

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

  • 注意：我们自己定义函数式接口的时候，@Functionallnterface是可选的, 就算我不写这个注解，只要保证满足函数式接口定义的条件，也照样是函数式接口。但是，建议加上该注解文章来源地址https://www.toymoban.com/news/detail-476517.html

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

  • 需求
    Java函数式接口 
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 函数式接口作为方法的返回值

  • 需求
    Java函数式接口 
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();
    }
}
  • 练习
    Java函数式接口 
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);
    }
}
  • 练习
    Java函数式接口 
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);
    }
}
  • 练习
    Java函数式接口 
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);
    }
}
  • 练习
    Java函数式接口 
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);
    }
}

到了这里，关于Java函数式接口的文章就介绍完了。如果您还想了解更多内容，请在右上角搜索TOY模板网以前的文章或继续浏览下面的相关文章，希望大家以后多多支持TOY模板网！

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处： 如若内容造成侵权/违法违规/事实不符，请点击违法举报进行投诉反馈，一经查实，立即删除！

分享到：
领支付宝红包 赞助服务器费用

相关文章

  • 【Java】抽象类和接口

    【Java】抽象类和接口

    在面向对象的概念中，所有的对象都是通过类来描绘的，但是反过来，并不是所有的类都是用来描绘对象的， 如果一个类中没有包含足够的信息来描绘一个具体的对象，那么这样的类就是抽象类 在Java中，一个类如果被 abstract 修饰称为抽象类，抽象类中被 abstract 修饰的方法

    2024年02月05日
    浏览(47)
  • JAVA-抽象类和接口

    JAVA-抽象类和接口

    文章目录 前言 1.1抽象类的概念 1. 2抽象类的语法 1.3抽象类的特性 1.3.1抽象类不能直接实例化对象 1.3.2抽象方法不能被private,final和static修饰 1.3.3 抽象类的子类要么也是抽象类,要么重写所有抽象方法 1.4抽象类的作用 2.1 接口的概念 2.2 语法规则 2.3 接口的使用  2.4 接口的特性

    2024年02月05日
    浏览(52)
  • Autofac中多个类继承同一个接口,如何注入？与抽象工厂模式相结合

    Autofac中多个类继承同一个接口,如何注入？与抽象工厂模式相结合

    需求: 原来是抽象工厂模式,多个类继承同一个接口。 现在需要使用Autofac进行选择性注入。 Autofac默认常识: Autofac中多个类继承同一个接口,默认是最后一个接口注入的类。 解决方案：(约定大于配置) :①工厂名默认4位字符 ② 命名Service的时候以工厂名开头 ③Autofac注入的时候先

    2024年02月10日
    浏览(61)
  • 【JAVA】抽象类与接口--下

    【JAVA】抽象类与接口--下

    ⭐ 作者：小胡_不糊涂 🌱 作者主页：小胡_不糊涂的个人主页 📀 收录专栏：浅谈Java 💖 持续更文，关注博主少走弯路，谢谢大家支持 💖 在Java中，类和类之间是单继承的，一个类只能有一个父类，即Java中不支持多继承，但是一个类可以实现多个接口。 通过类来表示一组动

    2024年02月11日
    浏览(33)
  • Java抽象类和接口【超详细】

    Java抽象类和接口【超详细】

    在面向对象的概念中，所有的对象都是通过类来描绘的，但是反过来，并不是所有的类都是用来描绘对象的， 如果一个类中没有包含足够的信息来描绘一个具体的对象，这样的类就是抽象类 。 比如： 在打印图形例子中, 我们发现, 父类 Shape 中的 draw 方法好像并没有什么实际

    2024年02月14日
    浏览(50)

  • Java中抽象类和接口的区别

    定义上来看，被abstract修饰的类称为抽象类。被abstract修饰的方法称为抽象方法。当父类的某些方法，需要声明，但是又不确定如何实现时，可以将其声明为抽象方法，那么这个类就是抽象类.例： 特征： 抽象类不可以实例化，可以被继承，可以看作是对类的进一

    2024年02月16日
    浏览(41)

  • Java中抽象类和接口的区别?

    抽象类是对具体概念的抽象 抽象类本质是为了继承 只能被public或默认修饰 行为层面抽象出来抽象方法 抽象类的注意事项 抽象类不可以被直接实例化 抽象类中可以存在构造方法 抽象类可以存在普通方法 抽象方法的注意 抽象方法必须定义在抽象类中 仅声明 实现需要交给子

    2023年04月26日
    浏览(85)

  • Effective Java笔记（20）接口优于抽象类

            Java提供了两种机制，可以用来定义允许多个实现的类型：接口和抽象类。自从Java 8为继承引入了 缺省方法 ( default method)，这两种机制都允许为某些实例方法提供实现。主要的区别在于，为了实现由抽象类定义的类型，类必须成为抽象类的一个子类。因为Java只允许

    2024年02月14日
    浏览(48)

  • Java抽象类和接口的详细区别（全）

    这两者经常在笔试以及面试中经常问及，甚至在项目实战中还在纠结用哪一种类型 今天就此问题详细剖析一下 以往我的文章中也有稍微提及： java框架零基础从入门到精通的学习路线（超全） 此处将其这些文章抽离公共部分，详细总结下这两概念 抽象类是类和类之间的共同

    2024年02月08日
    浏览(42)

  • Java面向对象之抽象类、类、接口分析参考

    Java 抽象类 抽象类不能实例化对象，所以抽象类必须被继承，才能被使用； Java 中抽象类表示的是一种继承关系，一个类只能继承一个抽象类，而一个类却可以实现多个接口 1. 抽象方法： 用Abstract 声明抽象方法，只包含一个方法名，没有方法体。方法名后面直接跟一

    2024年02月10日
    浏览(45)

觉得文章有用就打赏一下文章作者

支付宝扫一扫打赏

博客赞助

微信扫一扫打赏

请作者喝杯咖啡吧~博客赞助

支付宝扫一扫领取红包，优惠每天领

二维码1

领取红包

二维码2

领红包