java 函数式编程 Function 入参多个

目录

四大核心函数式接口

自定义函数式接口

方法引用

对象::实例方法

类::静态方法名字

类::实例方法名字

构造器引用 class::new

数组引用 数组::new

---

四大核心函数式接口

概念：有且只有一个抽象方法的接口，但可以有默认方法，和静态方法

@FunctionalInterface 用于检查是否是一个函数接口，同时javadoc也会包含一条声名，说明这个接口是一个函数式的接口

主要有四个：Function Predicate Customer  Supplier

函数式接口： 表示接受一个参数并产生结果的函数 Function 方法：apply

源码：

举例：

public static void main(String[] args) {
//        输入一个返回一个
        Function<Integer, String> function = new Function<Integer, String>() {
            @Override
            public String apply(Integer integer) {
                return String.valueOf(integer+1);
            }
        };
//        进去的整型，返回的是字符串
        Function<Integer, String> f1=(a)->{

            return String.valueOf(a+1);
        };
        System.out.println(f1.apply(2));
    }

断定型接口:Predicate 方法：test

源码：

举例：

Predicate<Integer> p = new Predicate<Integer>() {
            @Override
            public boolean test(Integer integer) {
                if (integer==3){
                    return true;
                }else {
                    return false;
                }
            }
        };
        Predicate<Integer> p1=(s)->{
            if (s==3){
                return true;
            }{
                return false;
            }
        };

消费型接口：Customer 表示接受单个不能返回源码 f方法accept

源码：

 举例：

Consumer<String> c1 = new Consumer<String>() {
            @Override
            public void accept(String o) {
                System.out.println("accept输出"+o);
            }
        };
//        抽象类类和接口不可以被new
        Consumer<String> c2 =(s)->{
            System.out.println(s);
        };
        c1.accept(String.valueOf(123));

    }

供给型接口：Supplier只有返回值

源码

举例：

Supplier<String> s1 = new Supplier<String>() {
            @Override
            public String get() {
                System.out.println("供给型接口");
                return "123";
            }
        };
        String s = s1.get();
        System.out.println(s);
        Supplier<String> s2 =()->{
            return "789";
        };
        String s3 = s2.get();
        System.out.println(s3);
    }

自定义函数式接口

使用函数接口实现加法

public class Test1 {
    public static void main(String[] args) {
        fun((a, b) -> {
            int i = a + b;
            return i;
        }, 33, 10);
        System.out.println("+++++++++++");
//        可以去掉{}
       fun((x,y)->x+y,12,9);
    }

    //    传入一个接口，两个参数，通过调用参数的方式来调用结果
    public static void fun(NumAdd n, int a, int b) {
        int add = n.add(a, b);
        System.out.println("结果为" + add);
    }
}

//定义一个接口
@FunctionalInterface
interface NumAdd {
    public int add(int a, int b);
}

//实现类
class number implements NumAdd {
    @Override
    public int add(int a, int b) {
        return a + b;
    }
}

方法引用

补充概念：

语法糖：代码功能前后功能保持一致，同样的方法，代码更精炼。方法引用为Lambda代码更深层的表达，相当于lambda的语法糖

要求：实现接口的抽象方法的参数列表和返回值的类型，必须与方法引用的方法的参数列表和返回值类型保持一致.

操作符号 ::

五种种情况使用：

对象::实例方法

@FunctionalInterface
interface Count {
    int way(int a, int b);
}

class DMath {
//    注意非静态方法
    public int add(int a, int b) {
        System.out.println("DMath中:a+b=" + (a + b));
        return a + b;
    }
}

public class Test2 {
    public static void main(String[] args) {

//        对象实例方法 通常写法
        DMath dMath = new DMath();
        Count e = (a, b) -> dMath.add(a, b);
        e.way(4,4);
//        对象：：方法
        Count f=dMath::add;
        f.way(9,5);

    }
}

类::静态方法名字

ps:非static方法归属于对象        static方法归属于类

@FunctionalInterface
interface Count{
     int way(int a,int b);
}
class DMath{
//    静态方法名字
    public static int add(int a,int b){
        System.out.println("DMath中:a+b="+(a+b));
        return a+b;
    }
}
public class Test2 {
    public static void main(String[] args) {
//        重写了way中的方法，但调用的是DMath中的方法
        Count c=(a,b)->DMath.add(a,b);
        c.way(1,2);
//        类：：方法
        Count d=DMath::add;
        d.way(9,1);
    }
}

结果：

类::实例方法名字

  1.当对象调用方法的时候，有一个参数是函数式接口，
  2.函数式接口方法中的参数的第一个为调用者的所属类，就可以引用方法

  3.可以引用调者类中定义的，不包含函数式接口第一个的参数方法

public class Test6 {
    public static void main(String[] args) {
//        原lambda表达式
        OneClass1 oneClass1 = new OneClass1();
        oneClass1.a = 10;
        InteaFace inteaFace = (a, b) -> oneClass1.add(b);
        System.out.println(inteaFace.way(3, 5));
        //类::实例方法
        OneClass1 oneClass2 = new OneClass1();
        oneClass2.a = 9;
        int startadd = oneClass2.startadd(OneClass1::add, 5);
        System.out.println(startadd);
    }
}

@FunctionalInterface
interface InteaFace<T> {
    int way(T a, int b);
}

class OneClass1 {
    int a;

    public int add(int b) {
        return this.a + b;
    }

    public int startadd(InteaFace<OneClass1> a, int b) {
        return a.way(this, b);
    }
}

构造器引用 class::new

public class Test4 {
    public static void main(String[] args) {
        InFac inFac=(a)->new TargetClass();
        inFac.getTargetClass("a");

    }
}
@FunctionalInterface
interface InFac {
    //    必须是类的构造方法
//    有参构造
    TargetClass getTargetClass(String a);
//    无参构造
//    TargetClass getTargetClass();
}

class TargetClass {
    private String str;
    public TargetClass() {
        str = "default";
        System.out.println("无参构造方法:"+str);
    }
    public TargetClass(String str) {
        this.str = str;
        System.out.println("无参构造方法:"+str);
    }
}

数组引用 数组::new

public class Test5 {
    public static void main(String[] args) {
        TArray<int[]> tArray=int[]::new;
        int[] array = tArray.getArray(10);
        System.out.println(array.length);

    }
}
@FunctionalInterface
interface TArray<T>{
//    因为数组的长度固定，这里必须定义长度
    T getArray(int s);
}