0
点赞
收藏
分享

微信扫一扫

JavaScript break

Sophia的玲珑阁 2023-06-04 阅读 88
javajvm开发语言
加载失败

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);
    }
}
举报

相关推荐

javascript forEach break

数组javascript遍历数组JavaScript前端开发

JavaScript控制手段之break/continue

javapythonjavascriptjs数据结构Java编程语言

JavaScript switch语句、break、共享case

javascriptswitch

JavaScript-break 关键字

html循环结构javascriptJavaScript前端开发

【JavaScript 教程】第四章 程序流程07— JavaScript break 语句

javascript嵌套循环i++Linux系统/运维

break

i++C/C++编程语言

java break if

JavaSystem迭代后端开发

CSS之word-break : break-all

csshtml自动换行Html/CSS前端开发

Python小记——break

嵌套循环Python编程语言

Break 与Continue

java
0 条评论
加载失败