函数式接口

（一）、函数式接口的概念

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

①、
@FunctionalInterface ②、放在接口定义的上方：如果接口是函数式接口，编译通过；如果不是，编译失败。

//定义一个函数式接口
@FunctionalInterface
public interface MyInterface {
    void show();
}

/*函数式接口：有且仅有一个抽象方法的接口*/
public class MyInterfaceDemo {
    public static void main(String[] args) {
        //函数式接口作为局部变量的时候，将Lambda表达式赋值给它
        MyInterface my = () -> System.out.println("函数时接口");
        my.show();
    }
}

注意：我们自己定义函数式接口的时候，@FunctionalInterface是可选的，就算我不写这个注解，只要保证满足函数式接口定义的条件，也照样是函数式接口。但是，建议加上该注解。

（二）、函数式接口作为方法的参数

1. 需求

定义一个类 （RunnableDemo）
，在类中提供两个方法

①、一个方法是：
startThread(Runnable r) 方法参数 Runnable
是一个函数式接口。

②、一个方法是主方法：在主方法中调用
startThread 方法。

public class RunnableDemo {
    public static void main(String[] args) {
        //匿名内部类的方式
        startThread(new Runnable() {
            @Override
            public void run() {
                System.out.println(Thread.currentThread().getName()+"线程启动了...");
            }
        });

        //Lambda表达式的方式
        startThread(() -> System.out.println(Thread.currentThread().getName()+"线程启动了..."));
    }

    //Runnable是一个函数式接口,作为参数
    private static void startThread(Runnable r){
		//Thread t = new Thread();
		//t.start();
        new Thread(r).start();
    }
}

运行结果：

Thread-0线程启动了...
Thread-1线程启动了...

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

（三）、函数式接口作为方法的返回值

1. 需求

定义一个类 （ComparatorDemo）
，在类中提供两个方法

①、一个方法：
Comparator<String> getComparator() 方法返回值 Compartor
是一个函数式接口

②、一个方法是主方法，在主方法中调用
getComparator 方法。

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

public class ComparatorDemo {
    public static void main(String[] args) {
        //构造使用场景

        //定义集合，存储字符串元素
        ArrayList<String> array = new ArrayList<>();

        array.add("cccc");
        array.add("aa");
        array.add("b");
        array.add("ddd");

        System.out.println("排序前："+array);

        //Collections.sort(array);
        Collections.sort(array,getComparator());

        System.out.println("排序后："+array);
    }

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

运行结果：

排序前：[cccc, aa, b, ddd]
排序后：[b, aa, ddd, cccc]

如果方法的返回值是一个函数式接口，我们可以使用Lambda表达式作为结果返回

private static Comparator<String> getComparator(){
	return (s1,s2) -> s1.length()-s2.length();
}

（四）、常用的函数式接口

Java 8在java.util.function包下预定义了大量的函数式接口供我们使用

1. Supplier接口

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

（1）简答使用

import java.util.function.Supplier;

public class SupplierDemo {
    public static void main(String[] args) {
//        String s = getString(() -> {
//            return "林青霞";
//        });

        //优化代码
        String s = getString(() -> "林青霞");
        System.out.println(s);

        Integer i = getInteger(() -> 30);
        System.out.println(i);
    }

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

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

（2）练习

定义一个类（SupplierTest），在类中提供两个方法

①、一个方法是：int getMax(Supplier< Integer > sup)用于返回一个int数组得最大值。

②、一个方法是主方法，在主方法中调用getMax方法。

import java.util.function.Supplier;

public class SupplierTest {
    public static void main(String[] args) {
        //定义一个int数组
        int[] arr = {19,50,28,37,46};

        int maxValue = getMax(() -> {
            int max = arr[0];

            for (int i = 0; i < arr.length; i++) {
                if (arr[i] > max) {
                    max = arr[i];
                }
            }
            return max;
        });
        System.out.println(maxValue);//50
    }

    //返回一个int数组中的最大值
    private static int getMax(Supplier<Integer> sup){
        return sup.get();
    }
}

2. Consumer接口

Consumer< T >：包含两个方法。

①、
void accept(T t)
：对给定的参数执行此操作。

②、
default Consumer <T> andThen(Consumer after)
：返回一个组合的Consumer，依次执行操作，然后执行after操作。

③、
Consumer<T> 接口也被称为消费型接口，它消费的数据的数据类型由泛型指定

（1）简单使用

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());//霞青林
//        });
        //优化代码
        operatorString("林青霞",s -> System.out.println(new StringBuilder(s).reverse().toString()));//霞青林
    }

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

import java.util.Comparator;
import java.util.function.Consumer;

public class ConsumerDemo {
    public static void main(String[] args) {
        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);
    }
}

（2）练习

String[] strArray = {"林青霞,30", "张曼玉,35", "王祖贤,33"};
字符串数组中有多条信息，请按照格式：“姓名：XX,年龄：XX"的格式将信息打印出来
要求：

①、把打印姓名的动作作为第一个Consumer接口的Lambda实例

②、把打印年龄的动作作为第二个Consumer接口的Lambda实例

③、将两个Consumer接口按照顺序组合到一起使用

import java.util.function.Consumer;

public class ConsumerTest {
    public static void main(String[] args) {
        String[] strArray = {"林青霞,30", "张曼玉,35", "王祖贤,33"};

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

        //优化代码
        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);
        }
    }
}

运行结果

姓名：林青霞,年龄：30
姓名：张曼玉,年龄：35
姓名：王祖贤,年龄：33

3. Predicate接口

Predicate<T>
：常用的四个方法

①、
boolean test(T t) ：对给定的参数进行判断(判断逻辑由Lambda表达式实现)，返回一个布尔值

import java.util.function.Predicate;

public class PredicateDemo {
    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);//false
        
        boolean b2 = checkString("hellowordl" ,s -> s.length() > 8);
        System.out.println(b2);//true
    }

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

②、 default Predicate<T> negate()
：返回一个逻辑的否定，对应逻辑非

通过替换return语句后再次运行代码就可以看出，与上面运行的结果是相反的

//判断给定的字符串是否满足要求
private static boolean checkString(String s, Predicate<String> pre){
	//return pre.test(s);
	
	//上下两个语句得到的结果相反
	
	//return !pre.test(s);
	return pre.negate().test(s);
}

③、 default Predicate<T> and(Predicate other) ：返回一个组合判断，对应短路与

import java.util.function.Predicate;

public class PredicateDemo {
    public static void main(String[] args) {
        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);
    }
}

④、 default Predicate<T> or(Predicate other) ：返回一个组合判断，对应短路或

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

⑤、 Predicate<T> 接口通常用于判断参数是否满足指定的条件

4. 练习

String[] strArray = {"林青霞,30", "柳岩,34", "张曼玉,35", "貂蝉,31", "王祖贤,33"};
字符串数组中有多条信息，请通过Predicate接口的拼装将符合要求的字符串筛选到集合ArrayList中，并遍历ArrayList集合
同时满足如下要求：姓名长度大于2；年龄大于33
分析

①、有两个判断条件,所以需要使用两个Predicate接口,对条件进行判断

②、必须同时满足两个条件,所以可以使用and方法连接两个判断条件

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

public class PredicateDemo {
    public static void main(String[] args) {
        String[] strArray = {"林青霞,30", "柳岩,34", "张曼玉,35", "貂蝉,31", "王祖贤,33"};
        ArrayList<String> array = myFilter(strArray,
                s -> s.split(",")[0].length() > 2,
                s -> Integer.parseInt(s.split(",")[1]) > 33
        );
        System.out.println(array);
    }

    //通过Predicate接口的拼装将符合的字符串选到集合ArrayList中
    private static ArrayList<String> myFilter(String[] strArray,Predicate<String> pre1, Predicate<String> pre2){
        //定义一个集合
        ArrayList<String> array = new ArrayList<>();

        //遍历数组
        for (String str:strArray){
            if (pre1.and(pre2).test(str)){
                array.add(str);
            }
        }
        return array;
    }
}

4. Function接口

Function<T,R>
：常用的两个方法

①、
R apply(T t) ：将此函数应用于给定的参数

import java.util.function.Function;

public class FunctionDemo {
    public static void main(String[] args) {
        // convert("100",(String s)->{
        //     return Integer.parseInt(s);
        // });

        //优化代码
        //方法一：
        convert("100",s -> Integer.parseInt(s));
        //方法二：
        convert(100,i -> String.valueOf(i+566));
        //方法三：
        convert("100",s -> Integer.parseInt(s),
                i -> String.valueOf(i+566)
        );
    }

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

②、

default <V> Function andThen(Function after)

：返回一个组合函数，首先将该函数应用于输入，然后将after函数应用于结果。

//定义一个方法，把一个字符串转换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);
}

③、

Function<T,R>

接口通常用于对参数进行处理，转换(处理逻辑由Lambda表达式实现)，然后返回一个新的值

2. 练习

String s = "林青霞,30";
请按照我指定的要求进行操作：

①、将字符串截取得到数字年龄部分

②、将上一步的年龄字符串转换成为int类型的数据

③、将上一步的int数据加70，得到一个int结果，在控制台输出
请通过Function接口来实现函数拼接

import java.util.function.Function;

public class FunctionTest {
    public static void main(String[] args) {
        String s = "林青霞,30";

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

        //代码优化
        convert(s,
                ss-> ss.split(",")[1],
                ss->Integer.parseInt(ss),i->i+70
        );
    }

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

函数式接口的相关概念以及常用的函数式接口（Supplier、Consumer、Predicate、Function）函数式接口

函数式接口

（一）、函数式接口的概念

（二）、函数式接口作为方法的参数

1. 需求

（三）、函数式接口作为方法的返回值

1. 需求

（四）、常用的函数式接口

1. Supplier接口

（1）简答使用

（2）练习

2. Consumer接口

（1）简单使用

（2）练习

3. Predicate接口

4. 练习

4. Function接口

2. 练习

继续阅读

关于Flex及AS3的百多条小小知识

AS3 Signals之入门篇

Flash AS3 连续加载外部若干图片

2.4和2.6内核的netfilter差异点

What are training set, validation set and test set?

java 编程思想第四版学习随记

ms sqlserver常用sql语句

java之单用户登录

Java反射是什么，为什么要用反射

Double类parseDouble和valueOf方法的区别

java调用Windows命令行

java打印任意边长的菱形

可变参数宏， Variadic Macros

不用iconv函数实现UTF-8编码转换GB2312的PHP函数

java 8 Lamda 求 List 中 Bigdecimal类型的各种值求最大值求最小值求和求平均值

无组件上传图片到数据库中，最完整解决方案