java函数式接口（2）——常用的函数式接口

常用的函数式接口

一、Supplier接口

（1）Supplier接口的定义
      Supplier< t >接口是在java.util.function包下的一个接口， 其接口中仅包含一个无参方法：Tget()。该方法用来获取一个泛型参数指定类型的对象数据。
备注：Supplier接口被称为生产型接口，指定接口中的泛型是什么类型，那么接口中的Tget方法就会生产什么类型的数据。比方说泛型执行的是String，那么get方法就会返回一个String。

（2）Supplier接口的使用

import java.util.function.Supplier;
public class DemoSupplier{
//定义一个方法，参数传递Supplier接口，泛型执行String。
public static String getString(Supplier<String> sup){
    return suo.get();
    }
public static void main(Stringp[] args){
//调用getStirng方法,方法参数是函数式接口，所以可以使用lambda表达式
    String s = getString(()->{
        return "字符串";
        });
//优化lambda表达式
    String s1 = getStrng(()->"字符串”）；
    System.out.println(s1);
     }
 }   
 输出结果：
  字符串    

二、Consumer接口

（1）Consumer接口的定义
      java.util.function.Consumer< t >接口与Supplier接口相反是消费（输出、计算…）数据，其数据类型由泛型决定。
（2）抽象方法accept的使用
      Consumer接口中抽象方法accept(T t)的作用是用来消费一个指定泛型的数据。
基本使用如下：

import java.util.function.Consumer;
public class DemoConsumer{
//这里将Consumer接口当做方法参数来使用
//定义一个方法，传递参数一个字符串的姓名，传递参数Consumer接口泛型为String
public static void cs (String name,Consumer<String> con){
//使用accept方法来处理字符串
       con.accept(name);
       }
public static void main(String[] args){
//调用方法cs，传递一个字符串姓名，方法另一个参数是Consumer接口，是一个函数式接口，所以可以传递lambda表达式 
    cs("程序员",(String name)->System.out.println(name));//消费方式：直接输出字符串    
    }
  }
 输出结果：
 程序员

（3）默认方法andThen的使用
      andThen接口的作用是将两个Consumer接口组合起来，再进行消费数据。
使用方法：

public class andThenDemo{
/*  定义一个方法
    方法的参数传递一个字符串和两个Consumer接口
    Consumer接口的泛型使用字符串*/
public static void method(String s , Consumer<Stirng> con1 , Consumer<String> con2){
     con1.andThen(con2).accept(s);//使用andThen方法将两个Consumer接口连在一起，在进行消费数据。（谁写在前面谁先被消费）这里con1先执行消费，con2后执行消费
 }
 public static void main(String[] args){
       method(s:"HelloWord",
       (c)->{
       //消费方式：大写输出
             System.out.println(c.toUpperCase);
       },
       (c)->{
       //消费方式：小写输出
             System.out.println(c.toLowerCase);
       });
       }
 }
 输出结果;
 HELLOWORD
 helloword

三、Predicate接口

（1）Predicate接口的定义
      java.until.function.Predicate< t >接口的作用是对某种数据进行判断，结果返回一个boolean值。
**（2）抽象方法boolean test（T t）的使用 **
      boolean test（T t）是对数据进行判断的方法。（结果：符合条件返回ture，不符合条件返回false）
使用方法：

public class testDemo{
/*定义一个方法
  方法的参数传递一个字符串和一个Predicate接口
  Predicate接口的泛型使用String
  用test方法判断字符串，结果返回布朗值*/
public static boolean method(String s,Predicate<String> pre){
     retrun pre.test(s);
 }
 
public static void main(String[] args){
    String s = "abcde"
//调用metho方法对字符串进行判段，判断输出字符串长度是否大于5，并把判断结果返回
    boolean b = method(s,str->return str.length()>5);
    System.out.println(b);
    }
 }   
输出结果：
false

（3）默认方法and、or、negate的使用
      既然是判断条件，就会存在与、或、非得逻辑关系，首先我们先看一下这三个默认方法的源代码。
and的源代码

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

or的源代码

default Predicate<T> or(Predicate<? super T> other) { 
        Objects.requireNonNull(other);
        return (t) ‐> test(t) || other.test(t);
         }

negate的源代码

default Predicate<T> negate() {
       return (t) ‐> !test(t); 
       }

通过源代码可以发现，and、or、negate这三个方法的作用和逻辑运算符与（&&）、或（||）、非（！）的作用一样。
      默认and是将两个 Predicate 条件使用“与”逻辑连接起来实 现“并且”的效果。只要有一个条件不符合，返回结果就是false。
      默认方法or实现逻辑关系中的“或”。只要有一个条件符合， 返回的结果就是true
      默认方法negate是执行了test方法之后，对结果boolean值进行“!”取反。
1、默认方法and的使用：
需求:判断一个字符串,有两个判断的条件
1.判断字符串的长度是否大于5
2.判断字符串中是否包含a
两个条件必须同时满足,使用and方法连接两个条件

public class andDemo{
/*定义一个方法
  方法的参数传递一个字符串两个Precate接口
  接口的泛型使用String*/
public static boolean method(String s , Predicate<String> pre1, Predicate<String> pre2){
     return pre1.and(pre2).test(s);
    }
public static void main(String[] args){
//定义一个字符串
     String s = "asdfgs";
//调用methos方法,参数传递字符串和两个Lambda表达式
      boolean b = method(s,
         (String str)->{
//判断字符串长度是否大于5
          retrun str.length()>5;
         },
         (String str)->{
//判断字符串是否包含z
          retrun str.contains("z");
         });
         System.out.println(b);
       }
  }
输出结果：
false     

2、默认方法or的使用：
需求:判断一个字符串,有两个判断的条件
1.判断字符串的长度是否大于5
2.判断字符串中是否包含a
两个条件满足一个即可,使用or方法连接两个条件

public class orDemo{
/* 定义一个方法
   方法的参数传递一个字符串两个Precate接口
   接口的泛型使用String*/
public static boolean method(String s , Predicate<String> pre1, Predicate<String> pre2){
     return pre1.or(pre2).test(s);
    }
public static void main(String[] args){
//定义一个字符串
     String s = "asdfg";
//调用methos方法,参数传递字符串和两个Lambda表达式
      boolean b = method(s,
         (String str)->{
//判断字符串的长度是否大于5
          retrun str.length()>5;
         },
         (String str)->{
//判断字符串中是否包含a
          retrun str.contains("a");
         });
         System.out.println(b);
       }
  }
 输出结果：
 true

3、默认方法negate的使用：
需求:判断一个字符串长度是否大于5
如果字符串的长度大于5,那返回false
如果字符串的长度不大于5,那么返回true
使用取反符号!对判断的结果进行取反完成上面的需求

public class Demo04Predicate_negate {    
/* 定义一个方法,方法的参数
   传递一个字符串,使用Predicate接口
   判断字符串的长度是否大于5*/
    public static boolean method(String s, Predicate<String> pre){
        return  pre.negate().test(s);
    }
    public static void main(String[] args) {
//定义一个字符串
        String s = "abc";
//调用checkString方法,参数传递字符串和Lambda表达式
        boolean b = method(s,(String str)->{
//判断字符串的长度是否大于5,并返回结果
            return str.length()>5;
        });
        System.out.println(b);
    }
}
输出结果：
true

四、Function接口的使用

（1）Function接口的定义
      java.util.function.Function<T,R>接口可以用来根据一个类型的数据得到另一个类型的数据，前者称为前置条件， 后者称为后置条件。
（2）抽象方法：apply的使用
抽象方法R apply(T t) 根据类型T的参数获取类型R的结果。
使用方法：
需求：将 String 类型转换为 Integer 类型

public class applyDemo{
/* 定义一个方法
   方法参数传递一个字符串一个Function接口
   Function接口的泛型使用<String, Integer>*/
public static void method(String s,Function< Stirng,Integer> fc){
      integer i = fc.appyl(s);//
      System.out.println(i);
      }
 public static void main(String[] args){
// 定义一个字符串
      String s = "12345";
//调用method方法，传递字符串类型的整数和lambda表达式
      method(s,str->return Integer.paserInt(str));   
    }
  }
输出结果：
12345

（3）默认方法andThen的使用
      Function接口中的andThen方法跟Consumer接口中的andThen方法一样，也是用来进行组合操作。

使用方法：
需求：
       把String类型的"1",转换为Inteter类型,把转换后的结果加1
       把增加之后的Integer类型的数据,转换为String类型

 
public class andThenDemo2 {
/*  
    定义一个方法参数串一个字符串类型的整数
    参数再传递两个Function接口
            一个泛型使用Function<String,Integer>
            一个泛型使用Function<Integer,String>
  */  
    public static void method(String s, Function<String,Integer> fc1,Function<Integer,String> fuc2){
        String t = fc1.andThen(fc2).apply(s);
        System.out.println(s);
    }

    public static void main(String[] args) {
        //定义一个字符串类型的整数
        String s = "1";
        //调用method方法,传递字符串和两个Lambda表达式
        mehtod(s,str->Integer.parseInt(str)+1,i->i+"");
    }
}
输出结果：
2