Java8新特性（内置的核心函数式接口）

###前言：

1.我们知道只要使用Lambda表达式，那么一定要有函数式接口的支持；但是如果我们没使用一个Lambda表达式都要自己创建一个接口，
这样很造成很大的不便。于是java8的工程师们已经帮我们把常用的函数式接口都帮我们定义好，拿来直接使用即可。
如果不能满足你的需求，那么这时你才需要自己定义函数式接口。


下面是我们常用的函数式接口：

###知识点一：消费性函数式接口
####特点：
1.接受一个或者多个参数，没有返回值
####典型函数式接口（常用）：

    1.Consumer  
		void accept(T t);//接受一个泛型类型参数无返回
	2.BiConsumer
		void accept(T t, U u);//接受两个泛型类型参数无返回
	3.DoubleConsumer	
		void accept(double value);//接收double类型，无返回
	4.IntConsumer
		void accept(int value);//接收int类型，无返回
	5.LongConsumer
		void accept(long value);//接收long类型，无返回
	6.ObjDoubleConsumer
		void accept(T t, double value);//接收两个参数，一个泛型，一个double
	7.ObjIntConsumer 
		void accept(T t, int value);//接收两个参数，一个泛型，一个int
	8.ObjLongConsumer
		void accept(T t, long value);//接收两个参数，一个泛型，一个long

####举例：这里使用Consumer举例，接收一个参数无返回值，其他的用法基本相同

//需求：消费给定的monkey,但是消费方式没有给定，需要具体消费的时候指定

    @org.junit.Test
    public void test1(){
        //消费100，洗澡
        consumerMonkey(100,(m) -> System.out.println("洗澡花费了100元"));
        //消费200，吃饭
        consumerMonkey(200,(m) -> System.out.println("洗澡花费了200元"));
    }

    /**
     *  消费monkey，但是没有指定出使用什么方式消费
     * */
     * 
    public static void consumerMonkey(double money, Consumer policy){
        policy.accept(money);
    }

###知识点二：供给型函数式接口

####特点：

1.没有参数（无参），提供返回值

####典型函数式接口（常用）:

1. Supplier
	 T get(); //无参，返回泛型
2. BooleanSupplier	 
	 boolean getAsBoolean(); //无参，返回boolean
3. DoubleSupplier
	double getAsDouble(); //无参，返回double
4. LongSupplier
	long getAsLong();	//无参，返回long

####举例：以 Supplier 接收泛型类型为例，其他都基本一致

   @org.junit.Test
    public void test2(){
        // 返回给定的String类型
        String s = get(() -> "Hello world !");
        System.out.println(s); //打印hello world !

        // 返回给定类型的 int 数据
        int i = get(() -> 123);
        System.out.println(i); //打印123
    }

    /**
     *  获取给定类型的对象，在调用的时候指定类型
     * */
    public static  T get(Supplier supplier){
        return supplier.get();
    }

###知识点三：函数型函数式接口
####特点：

1.接收一个或者多个参数，有返回值

####典型函数式接口（常用）:

  1. Function 
	    R apply(T t); //接收一个泛型参数，返回一个泛型参数
  2. BiFunction
        R apply(T t, U u);	 //接收两个泛型参数，返回泛型参数
  3. DoubleFunction
		R apply(double value);//接收一个double类型，返回一个泛型
  4. DoubleToIntFunction
	    int applyAsInt(double value);
  5. DoubleToLongFunction
	    long applyAsLong(double value);	    
  6. IntFunction 
	    R apply(int value);
  7. IntToDoubleFunction
	    double applyAsDouble(int value);
  8. IntToLongFunction
	    long applyAsLong(int value);	 
  9. LongFunction	
		 R apply(long value);
  10.LongToDoubleFunction      
		 double applyAsDouble(long value);  
  11.LongToIntFunction
	     int applyAsInt(long value);		
  12.ToDoubleBiFunction
	     double applyAsDouble(T t, U u);	 
  13.ToDoubleFunction
	     double applyAsDouble(T value);
  14.ToIntBiFunction
	     int applyAsInt(T t, U u);	  	
  15.ToIntFunction
	     int applyAsInt(T value);	
  16.ToLongBiFunction 
	     long applyAsLong(T t, U u);
  17.ToLongFunction
	     long applyAsLong(T value);	   	                  	    		           

####举例：以 Function接收一个泛型类型，返回一个泛型类型为例，其他都基本一致

 @org.junit.Test
    public void test3(){
        //需求1：接收一个String，返回一个name等于给定String的Student对象

        Student student = handleOperator("XiangYang", (t) -> new Student(t));
        System.out.println(student); //打印：Student{name='XiangYang', age=0}

        //需求二：就收一个String，返回List，并且list中包含传入的String
        List list1 = handleOperator("XiangYang", (t) -> {
            List list = new ArrayList<>();
            list.add(t);
            return list;
        });
        System.out.println(list1); //打印：[XiangYang]
    }


class Student{
    private String name;
    private int age;

    public Student(String name, int age) {
        this.name = name;
        this.age = age;
    }

    public Student(String name) {
        this.name = name;
    }

    public Student(int age) {
        this.age = age;
    }

    public Student() {
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }



    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    @Override
    public String toString() {
        return "Student{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }
}

###知识点四：断定性函数式接口

####特点：

1.接收一个或者多个参数，返回一个boolean类型

####常用的函数式接口：

1. Predicate
	  boolean test(T t);
2. BiPredicate
	  boolean test(T t, U u);	
3. DoublePredicate
	  boolean test(double value);
4. IntPredicate
	  boolean test(int value);
5. LongPredicate	
	  boolean test(long value);    

####举例：以 Predicate 为例

    @org.junit.Test
    public void test4(){
        //判断给定的整数是否大于50
        boolean b = is(80, (n) -> n > 50);
        System.out.println(b); //打印：true
    }

    public static   boolean is(T t,Predicate predicate){
        return predicate.test(t);
    }

###总结：

	1.每一中类型都给出了泛型情况，可以传入任何类型；而对于常用的类型，都单独定义了接口；例如： int 、 long 、double
	
	

本人博客：https://elfgirl.top/