Java-8-Function

interface Function<T, R>

源码:

@FunctionalInterfacepublic interface Function
   
     {        R apply(T t);       default 
    
      Function
     
       compose(Function
       before) {        Objects.requireNonNull(before);        return (V v) -> apply(before.apply(v));    }       default 
      
        Function
       
         andThen(Function
         after) {        Objects.requireNonNull(after);        return (T t) -> after.apply(apply(t));    }       static 
        
          Function
         
           identity() { return t -> t; }}

可以看出:

Function是一个泛型类，其中定义了两个泛型参数T和R，在Function中，T代表输入参数，R代表返回的结果,Function 就是一个函数，其作用类似于数学中函数的定义，（x,y）跟<T,R>的作用几乎一致

就像:

y = f(x)

Function中没有具体的操作，具体的操作需要我们去为它指定，因此apply具体返回的结果取决于传入的lambda表达式

小例子:

public static void main(String[] args) {        Function
   
     function1 = integer ->                integer + integer;        System.out.println(function1.apply(100));    }

在函数式编程之前我们定义一组操作首先想到的是定义一个方法，然后指定传入参数，返回我们需要的结果。函数式编程的思想是先不去考虑具体的行为，而是先去考虑参数，具体的方法我们可以后续再设置

简单例子

public class M1 {    public static void main(String[] args) {        Function
   
     function1 = integer ->                integer + integer;        System.out.println(function1.apply(100));        System.out.println("-----------------");        Function
    
      function2 = integer ->        {            return integer + "号";        };        System.out.println(calculate(function2,100));        System.out.println("-----------------");        Function
     
       function3 = integer ->        {            if (integer >= 100) {                return " >= 100";            } else {                return " < 100 ";            }        };        System.out.println(calculate(function3,1000));    }    //通过传入不同的Function，实现了在同一个方法中实现不同的操作。在实际开发中这样可以大大减少很多重复的代码    public static String calculate(Function
      
        function,                                   Integer integer) {        return  function.apply(integer);    }}

compose和andThen

compose接收一个Function参数，返回时先用传入的逻辑执行apply，然后使用当前Function的apply

andThen跟compose正相反，先执行当前的逻辑，再执行传入的逻辑

例子:

public class M2 {    public static void main(String[] args) {        Function
   
     function1 = integer ->                integer + 100;        Function
    
      function2 = integer ->                integer * 100;        // 先执行传入的 function2  也就是 * 100        // 在执行  function1 + 100        System.out.println(function1.compose(function2).apply(1));        System.out.println("-------------------------------");        Function
     
       function3 = s ->                s.toUpperCase();        Function
      
        function4 = s ->                s + "---" +s.length();        System.out.println(function3.compose(function4).apply("abc"));        System.out.println("-------------------------------");        Function
       
         function5 = integer ->                integer * 200;        Function
        
          function6 = integer -> integer - 200; // 先执行 function5 再执行 function6 System.out.println(function5.andThen(function6).apply(100)); }}

identity()

Function.identity()返回一个输出跟输入一样的Lambda表达式对象，等价于形如t -> t形式的Lambda表达式

例子:

public class M3 {    public static void main(String[] args) {        Function
   
     function = Function.identity();        String s = function.apply("lol");        System.out.println(s);        System.out.println("--------------");        Stream
    
      stream = Stream.of("I", "love", "you", "too");        Map
     
       map = stream.collect(Collectors.toMap(Function.identity(), String::length));        System.out.println(map);    }}

把一个对象转换成另一个对象

public class Shanghai_People {    private String name;    private int age;    public Shanghai_People(String name, int age) {        this.name = name;        this.age = age;    }    @Override    public String toString() {        return "Shanghai_People{" +                "name='" + name + '\'' +                ", age=" + age +                '}';    }}public class M4 {    public static void main(String[] args) {        Function
   
     function = person ->        {            if (person.getOrigin().equals("Shanghai")){                return new Shanghai_People(person.getName(),person.getAge());            } else {                return null;            }        };        List
    
      personList = Create_Data.supply_Persons();        for (Person person : personList){            if (function.apply(person) != null) {                System.out.println(person);            }        }    }}

针对特定类型

DoubleFunction IntFunction LongFunction

public class M1 {    public static void main(String[] args) {        DoubleFunction
   
     doubleFunction = d ->                String.valueOf(d);        System.out.println(doubleFunction.apply(12.36));        System.out.println("-------------------");        IntFunction
    
      intFunction = i ->                i + "号";        for (int i = 0; i < 10; i++) {            System.out.println(intFunction.apply(i));        }        System.out.println("-------------------");        LongFunction
     
       longFunction = l ->                String.valueOf(l);        System.out.println(longFunction.apply(11L));    }}

DoubleToIntFunction DoubleToLongFunction

public class M2 {    public static void main(String[] args) {        DoubleToLongFunction doubleToLongFunction = (d)->                (long) d;        System.out.println(doubleToLongFunction.applyAsLong(12.36));        System.out.println("------------");        DoubleToIntFunction doubleToIntFunction = d ->                (int) (d+100);        System.out.println(doubleToIntFunction.applyAsInt(125.369));    }}

IntToDoubleFunction IntToLongFunction

参照上面

LongToDoubleFunction LongToIntFunction

参照上面

多参数

BiFunction<T, U, R>

源码:

@FunctionalInterfacepublic interface BiFunction
   
     {       R apply(T t, U u);        default 
    
      BiFunction
     
       andThen(Function
       after) {        Objects.requireNonNull(after);        return (T t, U u) -> after.apply(apply(t, u));    }}

BiFunction的apply方法，接收两个参数，返回一个值

简单例子

public class M3 {    public static void main(String[] args) {        BiFunction
   
     f1 = (x,y) ->                String.valueOf(x+y);        System.out.println(f1.apply(100,250));        System.out.println("-----------------------");        BiFunction
    
      f2 = (s1,s2) ->                s1.toUpperCase() + s2.toLowerCase();        System.out.println(f2.apply("ABCsjhdhdh","POOPjsdhdhd"));        System.out.println("-----------------------");        System.out.println(compute3(2, 3, (v1, v2) -> v1 + v2));        System.out.println("-----------------------");        System.out.println(compute3(2, 3, (v1, v2) -> v1 - v2));        System.out.println("-----------------------");        System.out.println(compute3(2, 3, (v1, v2) -> v1 * v2));        System.out.println("-----------------------");        //首先执行(v1, v2) -> v1 + v2，然后执行 v1 -> v1 * v1        System.out.println(compute4(2, 3, (v1, v2) -> v1 + v2, v1 -> v1 * v1));    }    public static int compute3(int a, int b, BiFunction
     
       biFunction) {        return biFunction.apply(a, b);    }    public static int compute4(int a, int b, BiFunction
      
        biFunction, Function
       
         function) {        return biFunction.andThen(function).apply(a, b);    }}

ToDoubleBiFunction<T,U> ToIntBiFunction<T,U> ToLongBiFunction<T,U>

public class M4 {    public static void main(String[] args) {        ToDoubleBiFunction
   
     f1 = (i1,i2) ->                (i1+i2) * 100;        System.out.println(f1.applyAsDouble(1000,250));        System.out.println("--------------------");        ToIntBiFunction
    
      f2 = (s1,s2) ->                s1.length() + s2.length() ;        System.out.println(f2.applyAsInt("abv","123456"));        System.out.println("--------------------");        ToLongBiFunction
     
       f3 = (i1,i2) ->                i1 + i2;        System.out.println(f3.applyAsLong(123,115));            }}

转载地址：http://sccqb.baihongyu.com/

你可能感兴趣的文章

node util.log_如何解决Node.js中的util.pump不是函数错误