JDK8新特性

函数式接口

概念

函数式接口在Java中是指:有且仅有一个抽象方法的接口

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

备注:“语法糖"是指使用更加方便,但是原理不变的代码语法。例如在遍历集合时使用的for-each语法,其实底层的实现原理仍然是迭代器,这便是"语法糖"。从应用层面来讲,Java中的Lambda可以被当做是匿名内部类的“语法糖”,但是二者在原理上是不同的。

格式

只要确保接口中有且仅有一个抽象方法即可:

修饰符 interface 接口名称{
	public abstract 返回值类型 方法名称(可选参数信息);
    //其他非抽象方法内容
}

由于接口当中抽象方法的public abstract 是可以省略的,所以定义一个函数式接口很简单

public interface MyFunctionalInterface {
	void myMethod( );
}

函数式接口的使用

package MyDiyInterface;
/*
    函数式接口的使用:一般可以作为方法的参数和返回值类型
 */
public class DemosFunctionalInterfaceTest {
    //定义一个方法,参数使用函娄数式接口MyFunctionalInterface
    public static void show(MyFunctionalInterface myInter) {
        myInter.method();
    }

    public static void main(String[] args) {
        //调用show方法,方法的参数是一个接口,所以可以传递接口的实现类对象
        show(new MyFunctionalInterfaceImpl());

        //调用show方法,方法的参数是一个接口,所以可以传递接口的匿名内部类
        show(new MyFunctionalInterface() {
            @Override
            public void method() {
                System.out.println("使用匿名内部类重写接口中的抽象方法");
            }
        });

        //调用show方法,方法的参数是一个函数式接口,所以我们可以春娣Lambda表达式
        show(()->{
            System.out.println("使用Lambda表达式重写接口中的抽象方法");
        });
        //简化Lambda表达式代码
        show(()-> System.out.println("使用Lambda表达式重写接口中的抽象方法"));
    }

}


Lambda的延迟执行

有些场景的代码执行后,结果不一定会被使用,从而造成性能浪费。而fambda表达式是延迟执行的,这正好可以作为解决方案,提升性能。

性能浪费的日志案例

注:日志可以帮助我们快速的定位问题,记录程序运行过程中的情况,以便项目的监控和优化。
一种典型的场景就是对参数进行有条件使用,例如对日志消息进行拼接后,在满足条件的情况下进行打印输出︰

package MyDiyInterface;
/*
    日志案例
    发现以下代码存在的一些性能浪费的问题
    
    调用showLog方法,传递的第二个参数是一个拼接后的字符串
    
    先把字符串拼接好,然后在调用showLog方法
    
    showLog方法中如果传递的日志等级不是1级
    那么就不会是如此拼接后的字符串
    所以感觉字符串就白拼接了,存在了浪费
 */
public class Demo01Logger {
    private static void showLog(int level,String msg){
        if ( level == 1) {
            System.out.println(msg);
        }
    }
    public static void main( String[] args){
        String msgA = "Hello";
        String msgB = "world";
        String msgC = "Java";
        showLog(1,msgA + msgB + msgC);
    }
}

日志案例代码优化【使用Lambda表达式】

package MyDiyInterface;
/*
    使用Lambda优化日志案例
    Lambda的特点:延迟加载
    Lambda的使用前提,必须存在函数式接口
 */
public class Demo02Lambda {
    //定义一个显示日志的方法,方法的参数传递日志的等级和MessageBuilder接口
    public static void showLog(int level,MessageBuilder mb){
        //对日志的等级进行判断,如果是1级,则调用MessageBuilder接口中的builderMessage方法
        if (level == 1){
            System.out.println(mb.builderMessage());
        }
    }

    public static void main(String[] args) {
        //定义三个日志信息
        String msgA = "Hello ";
        String msgB = "world ";
        String msgC = "Java ";
        //调用showLog方法,参数MessageBuilder是一个函数式接口,所以可以传递Lambda表达式
        showLog(1,()->{
            //返回一个拼接好的字符串
            return msgA+msgB+msgC;
        });

        /*
            使用Lambda表达式作为参数传递,仅仅是把参数传递到showLog方法中
            只有满足条件,日志的等级是1级
                才会调用接口NessageBuilder中的方法buiLderMessage
                才会进行字符串的拼接
            如果条件不满足,日志的等级不是1级
                那么NessageBuilder接口中的方法builderMessage也不会执行
                所以拼接字符串的代码也不会执行
                所以不会存在性能的浪费
         */

    }

}


使用Lambda作为参数个返回值

如果抛开实现原理不说,Java中的Lambda表达式可以被当作是匿名内部类的替代品。如果方法的参数是一个函数式接口类型,那么就可以使用Lambda表达式进行替代使用Lambda表达式作为方法参数,其实就是使用函数式接口作为方法参数。
例如java.lang .Runnable接口就是一个函数式接口假设有一个startThread方法使用该接口作为参数,那么就可以使用Lambda进行传参。这种情况其实和Thread类的构造方法参数为Runnable没有本质区别。

public class DemosRunnable {
    //定义一个方法,startThread,方法的参数使用函数式接口Runnable
    public static void startThread(Runnable run){
        //开启多线程
        new Thread(run).start();
    }

    public static void main(String[] args) {
        //调用startThread方法,方法的参数是一个接口,那么我们就可以传递这个接口的匿名内部类
        startThread(new Runnable() {
            @Override
            public void run() {
                System.out.println(Thread.currentThread().getName()+"--->"+"线程启动了");
            }
        });

        //用Lambda表达式优化上面的代码
        //调用startThread方法,方法的参数是一个函数式接口,那么我们就可以传递Lambda表达式
        startThread(()->System.out.println(Thread.currentThread().getName()+"--->"+"线程启动了")    );
    }
}

类似地,如果一个方法的返回值类型是一个函数式接口,那么就可以直接返回一个Lambda表达式。当需要通过一个方法来获取一个java.util.Comparator 接口类型的对象作为排序器时,就可以调该方法获取。

import java.util.Arrays;
import java.util.Comparator;

/*
    类似地,如果一个方法的返回值类型是一个函数式接口,那么就可以直接返回一个Lambda表达式。
    当需要通过一个方法来获取一个java.util.Comparator 接口类型的对象作为排序器时,就可以调该方法获取。
 */
public class DemosRunnable {
    //定义一个方法,方法的返回值类型使用函数式接口Comparator
    public static Comparator<String> getComparator(){
        //方法的返回值类型是一个接口,那么我们可以返回这个接口的匿名内部类
       /*return new Comparator<String>() {
            @Override
            public int compare(String o1, String o2) {
                //按照字符串的降序排序
                return o2.length()-o1.length();
            }
        };*/
        //方法的返回值类型是一个函数式接口,那么我们可以返回一个Lambda表达式
        return (o1, o2)->o2.length()-o1.length();

    }

    public static void main(String[] args) {
        //创建一个字符串数组
        String[] arr = {"a","b","CCC","dd","eeeeeee","ffff"};
        //输出排序前的数组
        System.out.println(Arrays.toString(arr));//[a, b, CCC, dd, eeeeeee, ffff]
        //调用Arrays中的sort方法,对字符串数组进行排序
        Arrays.sort(arr,getComparator());
        //输出排序后的数组
        System.out.println(Arrays.toString(arr));//[eeeeeee, ffff, CCC, dd, a, b]
    }
}

常用函数式接口

Supplier接口

java.util.function. supplier接口仅包含一个无参的方法:T get()。用来获取一个泛型参数指定类型的对象数据。由于这是一个函数式接口,这也就意味着对应的Lambda表达式需要对外提供"一个符合泛型类型的对象数据。

Supplier接口被称之为生产型接口,指定接口的泛型是什么类型,那么接口中的get方法就会生产什么类型的数据

package MyDiyInterface;
import java.util.function.Supplier;

/*
    常用的函威数式接口
        java.util. function .SuppLier<T>接口仅包含一个无参的方法: T get()。用来获取一个泛型参数指定类型的对象数据。
        Supplier<T>接口被称之为生产型接口,指定接口的泛型是什么类型,那么接口中的get方法就会生产什么类型的数据
 */
public class DemosSupplier {
    //定义一个方法,方法的参数传递SuppLier<T>接口,泛型指定string类型,get方法就会返回一个String字符串
    public static String getString(Supplier<String> sup){
        return sup.get();//返回一个字符串

    }

    public static void main(String[] args) {
        //调用getString方法,方法得参数Supplier是一个函数值接口,所以可以传递Lambda表达式
        String str = getString(() ->"字符串jasjdkahsjd");//生产一个字符串并返回

        System.out.println(str);
    }
}

练习题:求数组中元素的最大值

使用Supplier 接口作为方法参数类型,通过Lambda表达式求出int数组中的最大值。提示:接口的泛型请使用java.lang.Integer类。

import java.util.function.Supplier;

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

    public static void main(String[] args) {
        Integer arr[] = {5,423,453,34,5,234,52};

        Integer max1 = getMax(() -> {
            int max = arr[0];
            /*for (int i = 0; i < arr.length-1; i++) {
                if (max > arr[i + 1]) {
                    max = max;
                } else {
                    max = arr[i + 1];
                }
            }*/
            for (Integer integer : arr) {
                if (integer>max){
                    max = integer;
                }
            }
            return max;
        });
        System.out.println("数组中最大值为:"+max1);
    }
}


Consumer接口【消费数据接口】

java.util.function.Consumer 接口则正好与Supplier接口相反,它不是生产一个数据,而是消费一个数据,其数据类型由泛型决定。

抽象方法: accept
Consumer接口中包含抽象方法void accept(T t),意为消费一个指定泛型的数据。基本使用如︰

import java.util.function.Consumer;
import java.util.function.Supplier;

public class DemosConsumer {
    /*
        定义一个方法
        方法的参数传递一个字符串的姓名
        方法的参数传递consumer接口,泛型使用string可以使用Consumer接口消费字符串的姓名
     */
    public static void method(String name,Consumer<String> cons){
        cons.accept(name);
    }

    public static void main(String[] args) {
        //调用method方法,传递字符串姓名,方法的另一个参数是Consumer接口,是一个函数式接口,所以可以传递Lambda表达式
        method("牛牛niu",(String name)->{
            //对传递的字符串进行消费
            //消费方式:直接输出字符串
            System.out.println(name);
            //消费方式:把字符串进行反转输出
            String reName = new StringBuilder(name).reverse().toString();
            System.out.println(reName);
        });
    }
}

Consumer接口中的默认方法:addThen

如果一个方法的参数和返回值全都是Consumer类型,那么就可以实现效果∶消费数据的时候,首先做一个操作,然后再做一个操作,实现组合。而这个方法就是Consumer 接口中的default方法 and Then 。下面是JDK的源代码∶

default consumer<T> andThen(Consumer<? super T> after){
    objects.requireNonNull(after);
    return (T t) -> { accept(t); after.accept(t);
}

备注: java.util.Objects 的 requireNonNull静态方法将会在参数为null时主动抛出 NullPointerException异常。这省去了重复编写if语句和抛出空指针异常的麻烦。

要想实现组合,需要两个或多个Lambda表达式即可,而 andThen 的语义正是"一步接一步"操作。例如两个步骤组合的情况:

两个lambda的情况:

import java.util.Locale;
import java.util.function.Consumer;

/*
    consumer接口的黑X认方法andThen
    作用:需要两个consumer接口,可以把两个Consumer接口组合到一起,在对数据进行消费例如:

    consumer<String> con1
    consumer<string> con2
    String s = "heLLo"";
    coni.accept(s);
    con2.accept(s);
    连接两个Consuwer接口,再进行消费
    coni.andThen( con2).accept(s);谁写前边谁先消费
 */
public class DemosAndThen {
    //定义一个方法,方法的参数传递一个字符串和两个Consumer接口, Consumer接口的泛型使用字符串
    public static void method(String str, Consumer<String> cons1, Consumer<String> cons2){
//        cons1.accept(str);
//        cons2.accept(str);
        //使用addThen方法,把两个Consumer接口连接在一起,然后再进行消费数据
        cons1.andThen(cons2).accept(str);///con1连接con2,先执行con1消费数据,再执行con2消费数据
    }

    public static void main(String[] args) {
        //调用method方法,传递一个字符串、两个Lambda表达式
        method("字符串ABCdjadka",(String str)->{
            //消费str,消费方式:把字符串变为大写
            System.out.println(str.toUpperCase());
        },(String str)->{
            //消费str,消费方式:把字符串变为小写
            System.out.println(str.toLowerCase());
        });

        //代码优化
        method("字符串ABCdjadka", (str)->System.out.println(str.toUpperCase()) , (str)->System.out.println(str.toLowerCase()) );
    }
}


两个以上lambda的情况:

import java.util.Locale;
import java.util.function.Consumer;

/*
    consumer接口的黑X认方法andThen
    作用:需要两个consumer接口,可以把两个Consumer接口组合到一起,在对数据进行消费例如:

    consumer<String> con1
    consumer<string> con2
    String s = "heLLo"";
    coni.accept(s);
    con2.accept(s);
    连接两个Consuwer接口,再进行消费
    coni.andThen( con2).accept(s);谁写前边谁先消费
 */
public class DemosAndThen {
    //定义一个方法,方法的参数传递一个字符串和两个Consumer接口, Consumer接口的泛型使用字符串
    public static void method(String str, Consumer<String> cons1, Consumer<String> cons2, Consumer<String> cons3){
//        cons1.accept(str);
//        cons2.accept(str);
        //使用addThen方法,把两个Consumer接口连接在一起,然后再进行消费数据
        cons1.andThen(cons2).andThen(cons3).accept(str);///con1连接con2,先执行con1消费数据,再执行con2消费数据,再执行con3消费数据
    }

    public static void main(String[] args) {
        //调用method方法,传递一个字符串、两个Lambda表达式
        method("字符串ABCdjadka",(String str)->{
            //消费str,消费方式:把字符串变为大写
            System.out.println(str.toUpperCase());
        },(String str)->{
            //消费str,消费方式:把字符串变为小写
            System.out.println(str.toLowerCase());
        },(String str)->{
            //消费str,消费方式:直接输出
            System.out.println(str);
        });
        System.out.println("==============================");
        //代码优化
        method("字符串ABCdjadka",
                (str)->System.out.println(str.toUpperCase()),
                (str)->System.out.println(str.toLowerCase()),
                (str)->System.out.println(str) );
    }
}


练习题:格式化打印信息

下面的字符串数组当中存有多条信息,请按照格式"姓名:XX。性别:XX。"的格式将信息打印出来。要求将打印姓名的动作作为第一个Consumer 接口的Lambda实例,将打印性别的动作作为第二个Consumer 接口的Lambda实例,将两个Consumer接口按照顺序"拼接”到一起。

import java.util.function.Consumer;

/*
    下面的字符串数组当中存有多条信息,请按照格式"姓名∶XX。性别:xxX."的格式将信息打印出来。

    要求
    将打印姓名的动作作为第一个consumer 接口的Lambda实例,
    将打印性别的动作作为第二个consumer 接口的Lambda实例,
    将两个Consumer接口按照顺序"拼接”到一起。
 */
public class DemosConsumer2 {

    public static void method(String[] arr, Consumer<String> cons1, Consumer<String> cons2){
        for (String s : arr) {
            cons1.andThen(cons2).accept(s);
        }

    }
    public static void main(String[] args) {
        String[] arr = {"阿牛,男","阿瓜,女","阿巴,未知"};
        method(arr,(s)->{
            System.out.print("姓名:"+s.split(",")[0]+"。");
        },(s)->{
            System.out.println("性别:"+s.split(",")[1]+"。");
        });
        System.out.println("==================================");
        //代码优化
        method(arr,
                (s)-> System.out.print("姓名:"+s.split(",")[0]+"。"),
                (s)-> System.out.println("性别:"+s.split(",")[1]+"。"));


    }



}


Predicate接口【判断接口】

有时候我们需要对某种类型的数据进行判断,从而得到一个boolean值结果。这时可以使用java.util.function.Predicate接口。

抽象方法: test

Predicate接口中包含一个抽象方法:boolean test(T t)。用于条件判断的场景∶

import java.util.function.Predicate;

/*
    java.util.function . Predicate<T>接口
        作用:对某种数据类型的数据进行判断,结果返回一个booLean值
        Predicate接口中包含一个抽象方法:
            boolean test(T t):用来对指定数据类型数据进行判断的方法
                结果:
                    符合条件,返回true
                    不符合条件,返回false
 */
public class DemosPredicate {
    /*
        定义一个方法
            参数传递一个string类型的字符串
            传递一个Predicate接口,泛型使用string
            使用Predicate中的方法test对字符串进行判断,并把判断的结果返回
     */
    public static boolean method(String str, Predicate<String> pre){
        return pre.test(str);
    }

    public static void main(String[] args) {
        /*boolean b = method("字符串jdhfahsfkasjdlhawidhlaw", (String s) -> {
            //对参数传递的字符串进行判断,判断字符串的长度是否大于5,并把判断的结果返回
            return s.length() > 5;
        });
        System.out.println(b);*/
        //代码优化
        boolean b = method("字符串jdhfahsfkasjdlhawidhlaw",(s)->s.length() > 5);
        System.out.println(b);
    }
}
Predicate接口中的3个默认方法
默认方法:and

既然是条件判断,就会存在与、或、非三种常见的逻辑关系。其中将两个Predicate条件使用“与"逻辑连接起来实现“并且"的效果时,可以使用default方法and。其JDK源码为∶

default Predicate<T> and( Predicate<? super T> other) {
	0bjects.requireNonNull(other);
	return (t) -> test(t) && other.test(t);
}

判断一个字符串既要包含大写字母H,又要包含大写字母W,且长度大于5

import java.util.function.Predicate;

/*
    逻辑表达式:可以连接多个判断的条件
    &&:与运算符,有false则false
    ||:或运算符,有true则true
    !:非(取反)运算符,非真则假,非假则真

    需求:判断一个字符串,有两个判断的条件
        1.判断字符串的长度是否大于5
        2.判断字符串中是否包含a
    两个条件必须同时满足,我们就可以使用&&运算符连接两个条件

    Predicate接口中有一个方法and ,表示并且关系,也可以用于连接两个判断条件
    default Predicate<T> and(Predicate<? super T> other) {
        objects.requireNonNulL ( other);
        return (t) -> this.test(t) && other.test(t);
    }
    方法内部的两个判断条件,也是使用&&运算符连接起来的

 */
public class DemosPredicateAdd {
    /*
        定义一个方法,方法的参数,传递一个字符串
        传递两个Predicate接口
            一个用于判断字符串的长度是否大于5
            一个用于判断字符串中是否包含a
            两个条件必须同时满足
     */
    public static boolean method(String str, Predicate<String> pre1,Predicate<String> pre2,Predicate<String> pre3){
        return pre1.test(str)&&pre2.test(str)&&pre3.test(str);
    }

    public static boolean method2(String str, Predicate<String> pre1,Predicate<String> pre2,Predicate<String> pre3){
        return pre1.and(pre2).and(pre3).test(str);//用and方法也可以
    }

    public static void main(String[] args) {
//        String s1 = "ajHshkWdu";
        String s2 = "ajhshkWdu";
//        String s3 = "ajasHkWdu";
        boolean b1 = method("ajhshkWdu", (String str) -> {
            return str.length()>5;
        }, (String str) -> {
            return str.contains("H");
        }, (String str) -> {
            return str.contains("W");
        });
        System.out.println(b1);//false

        //优化Lambda表达式
        boolean b2 = method(s2, (str) ->str.length()>5,(str) ->str.contains("H"),(str) ->str.contains("W"));
        System.out.println(b2);//false

        boolean b3 = method2("HkWsadsad", (str) ->str.length()>5,(str) ->str.contains("H"),(str) ->str.contains("W"));//用and方法也可以
        System.out.println(b3);//true
    }
}


默认方法:or
import java.util.function.Predicate;

/*
    需求:判断一个字符串,有两个手断的条件
        1 .判断字符串的长度是否大于5
        2.岁断字符串中是否包含a
    满足一个条件即可,我们就可以使用//运算符连接两个条件
    Predicate接口中有一个方法or,表示或者关系,也可以用于连接两个判断条件
    default Predicate<T> or ( Predicate<? super T> other){
        objects.requireNonNulL(other);
        return (t) -> test (t) || other.test(t);
    }
    方法内部的两个判断条件,也是使用||运算符连接起来的

 */
public class DemosPredicateOr {
    /*
        定义一个方法,方法的参数,传递一个字符串
        传递两个Predicate接口
            一个用于判断字符串的长度是否大于5
            一个用于判断字符串中是否包含a
            满足一个条件即可
     */
    public static boolean method(String str, Predicate<String> pre1,Predicate<String> pre2,Predicate<String> pre3){
        return pre1.test(str)||pre2.test(str)||pre3.test(str);
    }

    public static boolean method2(String str, Predicate<String> pre1,Predicate<String> pre2,Predicate<String> pre3){
        return pre1.or(pre2).or(pre3).test(str);//用and方法也可以
    }

    public static void main(String[] args) {
//        String s1 = "ajHshkWdu";
        String s2 = "ajhshkWdu";
//        String s3 = "ajasHkWdu";
        boolean b1 = method("aaa", (String str) -> {
            return str.length()>5;
        }, (String str) -> {
            return str.contains("H");
        }, (String str) -> {
            return str.contains("W");
        });
        System.out.println(b1);

        //优化Lambda表达式
        boolean b2 = method(s2, (str) ->str.length()>5,(str) ->str.contains("H"),(str) ->str.contains("W"));
        System.out.println(b2);

        boolean b3 = method2("HkWsadsad", (str) ->str.length()>5,(str) ->str.contains("H"),(str) ->str.contains("W"));//用and方法也可以
        System.out.println(b3);
    }
}


默认方法:negate
import java.util.function.Predicate;

/*
    需求:判断一个字符串长度是否大于5
        如果字符串的长良大于5,那返回false
        如果字特串的长度不大于5,那么返回true
    所以我们可以使用取反符号/对判断的结果进行取反

    Predicate接口中有一个方法negate,也表示职反的意思
    default Predicate<T negate(){
        return (t) ->!test(t);
    }
 */
public class DemosPredicateNegate {
    /*
        定义一个方法,方法的参数,传递一个字符串
        传递一个Predicate接口
            判断字符串的长度是否大于5,对判断结果取反
     */
    public static boolean method(String str, Predicate<String> pre1){
        return !pre1.test(str);
    }

    public static boolean method2(String str, Predicate<String> pre1){
        return pre1.negate().test(str);//用and方法也可以
    }

    public static void main(String[] args) {
//        String s1 = "ajHshkWdu";
        String s2 = "ajhshkWdu";
//        String s3 = "ajasHkWdu";
        boolean b1 = method("aaa", (String str) -> {
            return str.length()>5;
        });
        System.out.println(b1);//true

        //优化Lambda表达式
        boolean b2 = method(s2, (str) ->str.length()>5);
        System.out.println(b2);//false

        boolean b3 = method2("HkWsadsad", (str) ->str.length()>5);//用and方法也可以
        System.out.println(b3);//false
    }
}


练习题:集合信息删选
//Lambda表达式简化
        ArrayList<String> arraylist2 = method(array,
                str -> str.split(",")[1].equals("女"),
                str -> str.split(",")[0].length() == 4);

        System.out.println(arraylist2);
        for (String s : arraylist2) {
            System.out.println(s);
        }


Function接口【转换数据类型的接口】

java.util.function.Function<T,R>接口用来根据一个类型的数据得到另一个类型的数据,前者称为前置条件,后者称为后置条件

抽象方法:apply

Function接口中最主要的抽象方法为:R apply(T t),根据类型T的参数获取类型R的结果。
使用的场景例如∶将String 类型转换为Integer类型。

import java.util.function.Function;
/*
    java.util .function. Function<T.R>接口用来根据一个类型的激据得到另一个类型的数据,
        前者称为前置条件,后者称为后置条件。
    Function接口中最主要的抽象方法为: R apply(T t),根据类型T的参数获取类型R的结果。
    使用的场景例如:将string类型转换为Integer类型。
 */
public class DemosFunctionApply {
    /*
        定义一个方法
            方法的参数传递一个字符串类型的整数
            方法的参数传递一个Function接口,泛型使用<string,Integer>
            使用Function接口中的方法apply,把字符串类型的整数转换为Integer类型的整数
     */
    private static void method (String str, Function<String,Integer> fun){
        Integer num = fun.apply(str);
        System.out.println(num);
    }
    public static void main(String[] args){
        String s = "1234";
        method(s,(str)->{
            return Integer.parseInt(str);
        });

        method("9845783",(str)->{
            return Integer.parseInt(str);
        });
        //Lambda表达式简化
        method(s,str-> Integer.parseInt(str));
    }
}


默认方法:andThen

Function 接口中有一个默认的andThen方法,用来进行组合操作。JDK源代码如︰

default <v> Function<T,V> andThen(Function<? super R,? extends v> after){
        Objects.requireNonNull(after);
        return (T t) -> after.apply(apply(t));
}

该方法同样用于"先做什么,再做什么""的场景,和Consumer中的 andThen差不多:

import java.util.function.Function;
public class Demo12FunctionAndThen {
    private static void method(Function<String,Integer>one,Function<Integer,Integer> two){
        int num = one.andThen(two ).apply("10");
        system.out.println(num + 20);
    }
    public static void main( String[] args){
        method(Integer::parseInt, i->i*=10);
    }
}

第一个操作是将字符串解析成为int数字,第二个操作是乘以10。两个操作通过 andThen按照前后顺序组合到了一起。

import java.util.function.Function;
/*
    Function接口中的黑认方法andThen:用来进行组合操作

    需求:
        把string类型的"123”",转换为Inteter类型,把转换后的结果加10
        把增加之后的iInteger类型的数据,转换为string类型

    分析:
        转换了两次
        第一次是把string类型转换为了Integer类型
            所以我们可以使用Function<string, Integer> fun1
                Integer i = fun1.apply ("123")+10;
        第二次是把Integer类型转换为string类型
            所以我们可以使用Function<Integer,string> fun2
                string s = fun2.apply(i);
        我们可以使用andThen方法,把两次转换组合在一起使用
            string s = fun1.andThen(fun2 ). apply ( "123" );
            fun1先调用apply方法,把字符串转换为Integer
            fun2再调用apply方法,把Integer转换为字符串
 */
public class DemosFunctionApply {
    /*
        定义一个方法
            参数串一个字符串类型的整数
            参数再传递两个Function接口
                一个泛型使用Function<string , Integer>
                一个泛型使用Function<Integer ,string>
     */
    private static void method1(String str, Function<String,Integer> fun1,Function<Integer,String> fun2){
        Integer num1 = fun1.apply(str)+10;
        String num2 = fun2.apply(num1);
        System.out.println(num2);
    }

    private static void method2(String str, Function<String,Integer> fun1,Function<Integer,String> fun2){
        String num3 = fun1.andThen(fun2).apply(str);//使用addThen方法拼接fun1和fun2,一起apply
        System.out.println(num3);
    }
    public static void main(String[] args){
        String s = "1234";
        method1(s,(str)->{
            /*把字符串转换成整数*/
            return Integer.parseInt(str);
        },(integer)->{
            /*把整数转换成字符串*/
            return integer+"";
        });
        //简化Lambda表达式
        method1(s,/*把字符串转换成整数*/Integer::parseInt,/*双冒号用来简化Lambda表达式,连参数和箭头都不用写*/
                integer->/*把整数转换成字符串*/integer+"");

        method2(s, str->Integer.parseInt(str)+10,integer->integer+"");
    }
}    


练习题:自定义函数模型拼接
题目

请使用Function进行函数模型的拼接,按照顺序需要执行的多个函数操作为︰
String str = "赵丽颖,20";

  1. 将字符串截取数字年龄部分,得到字符串;
  2. 将上一步的字符串转换成为int类型的数字;
  3. 将上一步的int数字累加100,得到结果int数字。
import java.util.function.Function;

public class DemosDiyFunction {
    private static void method(String str, Function<String,String> fun1, Function<String,Integer> fun2, Function<Integer,Integer> fun3){
//        String f1 = fun1.apply(str);
//        Integer f2 = fun2.apply(f1);
//        int f3 = fun3.apply(f2);
        Integer num = fun1.andThen(fun2).andThen(fun3).apply(str);//使用addThen方法拼接fun1和fun2和fun3,一起apply
        System.out.println(num);
    }
    public static void main(String[] args){
        String s = "娜可露露,17";
        method(s,(str)->{
            return s.split(",")[1];
        },(String str)->{
            return Integer.parseInt(str);
        },(i)->{
            /*把整数转换成字符串*/
            return i+100;
        });
        //简化代码
        method(s,str->s.split(",")[1],Integer::parseInt,i->i+100);
    }
}


内容来源于网络如有侵权请私信删除

文章来源: 博客园

原文链接: https://www.cnblogs.com/niuniu-/p/14761071.html

你还没有登录,请先登录注册
  • 还没有人评论,欢迎说说您的想法!

相关课程