Java笔记

最新推荐文章于 2022-08-20 05:00:00 发布

雪里看海

最新推荐文章于 2022-08-20 05:00:00 发布

阅读量132

点赞数

文章标签： java 开发语言后端

本文链接：https://blog.csdn.net/weixin_46045873/article/details/123131436

版权

函数式接口

1.函数式接口概述

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

如何检测一个接口是不是函数式接口？
@FunctionalInterface
放在接口定义的上方：如果接口是函数式接口，编译通过；如果不是，编译失败

注：自己定义函数式接口时，@FunctionalInterface是可选取的，无论是否写这个注解，只要满足函数式接口定义的条件，照样是函数式接口，一般建议加上该注解

2.函数式接口作为方法的参数

需求;
定义一个类（RunnableDemo），在类中提供两个方法
一个方法是：startThread(Runnable r)方法参数Runnable是一个函数式接口
一个是主方法，在主方法中调用startThread方法

如果方法的参数是一个函数式接口，我们可以使用Lambda表达式作为参数传递
startThread(()-> System.out.println(Thread.currentThread().getName()+“线程启动了”));

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

需求：
定义一个类（ComparatorDemo），在类中提供两个方法
一个方法是：Comparator< String > getComparator() 方法返回值Comparator是一个函数式接口
一个方法是主方法，在主方法中调用getComparator方法

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

4.常用的函数式接口
Java8在java.util.function包下预定义了大量的函数式接口供我们使用;
Supplier接口
Consumer接口
Predicate接口
Function接口

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

import java.util.function.Supplier;

public class SupplierDemo {
    public static void main(String[] args) {
        //函数式接口，用Lambda表达式调用
        String s = getString(() -> {
            return "路飞";
        });

        String s1 = getString(() -> "索隆");

        System.out.println(s);
        System.out.println(s1);
        System.out.println("------------");

        Integer i = getInteger(() -> {
            return 123;
        });

        Integer i1 = getInteger(() -> 412);

        System.out.println(i);
        System.out.println(i1);

    }

    //定义一个方法，返回一个整数数据
    private static Integer getInteger(Supplier<Integer> sup) {
        return sup.get();
    }

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

练习
定义一个类（Supplier Test），在类中提供两个方法
一个方法是：int getMax(Supplier< Integer >sup) 用于返回一个int数组中的最大值
一个方法是主方法，在主方法中调用getMax方法

import java.util.function.Supplier;

public class SupplierTest {
    public static void main(String[] args) {
        //定义一个int数组
        int[] arr = {13, 19, 66, 52, 36};

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

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

6.Consumer接口

Consumer< T >：包含两个接口
void accept(T t)：对给定的参数执行此操作。
default Consumer< T > andThen(Consumer after)：返回一个组合的 Consumer ，依次执行此操作，然后执行 after操作。
Consumer< T >接口也被称为消费型接口，它消费的数据的数据类型由泛型指定

import java.util.function.Consumer;

public class ConsumerDemo {
    public static void main(String[] args) {
        operatorString("路飞",(String s)->{
            System.out.println(s);
        });

        operatorString("路飞",s-> System.out.println(s));  //王路飞

        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){
//        con1.accept(name);
//        con2.accept(name);
        con1.andThen(con2).accept(name);

    }

    //定义一个方法，消费一个字符串
    private static void operatorString(String name, Consumer<String> con){
        con.accept(name);
    }
}

练习:
String[] strArray = {“路飞,23”, “索隆,25”, “艾斯,24”};
字符串数组中有多条信息，请按照格式：“姓名：XX,年龄：XX”的格式将信息打印出来
要求：
把打印姓名的动作作为第一个Consumer接口的Lambda实例
把打印年龄的动作作为第二个Consumer接口的Lambda实例
将两个Consumer接口按照顺序组合到一起使用

import java.util.function.Consumer;

public class ConsumerTest {
    public static void main(String[] args) {
        String[] strArray = {"路飞,23", "索隆,25", "艾斯,24"};

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

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

7.Predicate接口

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

import java.util.function.Predicate;

public class PredicateDemo02 {
    public static void main(String[] args) {
        boolean b1 = checkString("hello", s -> s.length() > 8);
        System.out.println(b1);

        boolean b2 = checkString("helloworld", s -> s.length() < 15);
        System.out.println(b2);

        boolean b3 = checkString("hello", s -> s.length() > 8, s -> s.length() < 15);
        System.out.println(b3);

        boolean b4 = checkString("helloworld", s -> s.length() > 8, s -> s.length() < 15);
        System.out.println(b4);

    }

    //同一个字符串给出两个不同的判断条件，最后把这两个判断的结果做逻辑与运算的结果作为最终结果
    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;

        return pre1.and(pre2).test(s);

    }

    //判断给定的字符串是否满足要求
    private static boolean checkString(String s, Predicate<String> pre) {
        return pre.test(s);
    }
}

练习
String[] strArray ={“路飞,23”,“索隆,25”,“乌索普,28”,“萨博,26”,“汉库克,24”};
字符串数组中有多条信息，请通过Predicate接口的拼装将符合要求的字符串筛选到集合ArrayList中，并遍历ArrayList集合
同时满足如下要求：姓名长度大于2；年龄大于27
分析：
有两个判断条件，所以需要使用两个Predicate接口，对条件进行判断
必须同时满足两个条件，所以可以使用and方法连接两个判断条件

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

public class PredicateTest {
    public static void main(String[] args) {
        String[] strArray = {"路飞,23", "索隆,25", "乌索普,28", "萨博,26", "汉库克,24"};

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

        for (String str : array) {
            System.out.println(str);
        }
    }

    //通过Predicate接口的拼装将符合要求的字符串筛选到集合ArrayList中，并遍历ArrayList集合
    private 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;

    }

}

8.Function接口
Function< T,R >：常用的两个方法
R apply(T t) ：将此函数应用于给定的参数
default < V > Function andThen(Function<? super R,? extends V> after) ：返回一个组合函数，首先将after函数应用于其输入，然后将 after函数应用于结果。

import java.util.function.Function;

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

        System.out.println("-------------");
        convert(12,i-> String.valueOf(i+66));

        System.out.println("-------------");
        convert("100",s->Integer.parseInt(s),i->String.valueOf(i+62));

    }

    //定义一个方法,把一个字符串转换int类型,在控制台输出
    private static void convert(String s, Function<String,Integer> fun){
        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);
    }

}

练习
String s = “路飞,25”;
请按照指定的要求进行操作
1.将字符串截取得到数字年龄部分
2.将上一步的年龄字符串转换成int类型的数据
3.将上一步的int数据加75，得到一个int结果，在控制台输出
请通过Function接口来实现函数拼接

import java.util.function.Function;

public class FunctionTest {
    public static void main(String[] args) {
        String s = "路飞,25";

        covert(s, (String ss) -> {
            return s.split(",")[1];
        }, (String ss) -> {
            return Integer.parseInt(ss);
        }, (Integer i) -> {
            return i + 75;
        });

        //简化后
        covert(s, ss -> ss.split(",")[1], ss -> Integer.parseInt(ss), i -> i + 75);

        //方法引用
        covert(s, ss -> ss.split(",")[1], Integer::parseInt, i -> i + 75);

    }

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