程序化交易ETF接口-Java成神路函数式接口_ 股票程序化软件自动交易接口

函数式接口概述

概念

只包含一个抽象方法的接口称为函数式接口

如何检测一个接口是不是函数式接口

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

注意事项

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

函数式接口作为方法的参数

示例代码：

函数式接口作为方法的返回值

示例代码：

Supplier函数式接口

Supplier接口也被称为生产型接口，如果我们指定了接口的泛型是什么类型，那么接口中的get方法就会生产什么类型的数据供我们使用。

常用方法

只有一个无参的方法

T get()

按照某种实现逻辑(由Lambda表达式实现)返回一个数据

代码演示

import java.util.function.Supplier;

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

        //定义一个int数组
        int[] arr = {19, 50, 28, 37, 46};

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

            for(int i=1; i max) {
                    max = arr[i];
                }
            }
            return max;
        });

        System.out.println(maxValue);

    }

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

Consumer函数式接口

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

常用方法

Consumer：包含两个方法

void accept(T t)	对给定的参数执行此操作
default Consumer andThen(Consumer after)	返回一个组合的Consumer，依次执行此操作，然后执行after操作

代码演示

import java.util.function.Consumer;

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

        //操作一
        operatorString('小红', s -> System.out.println(s));

        //操作二
        operatorString('小红', s -> System.out.println(new StringBuilder(s).reverse().toString()));
        
        System.out.println('--------');

        //传入两个操作使用andThen完成
        operatorString('小红', s -> System.out.println(s), s -> 
                System.out.println(new StringBuilder(s).reverse().toString()));
    }
    
    //定义一个方法，用不同的方式消费同一个字符串数据两次
    private static void operatorString(String name, Consumer con1,
                                       Consumer con2) {

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

Predicate函数式接口

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

常用方法

boolean test(T t)	对给定的参数进行判断(判断逻辑由Lambda表达式实现)，返回一个布尔值
default Predicate negate()	返回一个逻辑的否定，对应逻辑非
default Predicate and(Predicate other)	返回一个组合判断，对应短路与
default Predicate or(Predicate other)	返回一个组合判断，对应短路或

代码演示

示例

import java.util.function.Predicate;

public class Demo {
    public static void main(String[] args) {
        boolean b1 = checkString('hello', s -> s.length() > 8);
        System.out.println(b1);
        boolean b2 = checkString('helloworld',s -> s.length() > 8);
        System.out.println(b2);
    }
    
    //判断给定的字符串是否满足要求
    private static boolean checkString(String s, Predicate pre) {

        // return !pre.test(s);
        return pre.negate().test(s);
    }
}

示例

import java.util.function.Predicate;

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

        boolean b1 = checkString('hello', s -> s.length() > 8);
        System.out.println(b1);

        boolean b2 = checkString('helloworld', s -> s.length() > 8);
        System.out.println(b2);

        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 pre1, Predicate pre2) {
        return pre1.or(pre2).test(s);
    }
    
    //判断给定的字符串是否满足要求
    private static boolean checkString(String s, Predicate pre) {
        return pre.test(s);
    }
}

Function函数式接口

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

常用方法

R apply(T t)	将此函数应用于给定的参数
default Function andThen(Function after)	返回一个组合函数，首先将该函数应用于输入，然后将after函数应用于结果

代码演示

import java.util.function.Function;

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

        //操作一
        convert('100',s -> Integer.parseInt(s));

        //操作二
        convert(100,i -> String.valueOf(i + 566));

        //使用andThen的方式连续执行两个操作
        convert('100', s -> Integer.parseInt(s), i -> String.valueOf(i + 566));
    }
    
    //定义一个方法，把一个字符串转换int类型，在控制台输出
    private static void convert(String s, Function fun) {

        // Integer i = fun.apply(s);
        int i = fun.apply(s);
        
        System.out.println(i);
    }
    
    //定义一个方法，把一个int类型的数据加上一个整数之后，转为字符串在控制台输出
    private static void convert(int i, Function fun) {
        String s = fun.apply(i);
        System.out.println(s);
    }

    //定义一个方法，把一个字符串转换int类型，把int类型的数据加上一个整数之后，转为字符串在控制台输出
    private static void convert(String s, Function fun1,
                                Function fun2) {
       
        String ss = fun1.andThen(fun2).apply(s);
        
        System.out.println(ss);
        
    }
}

文章为作者独立观点，不代表股票程序化软件自动交易接口观点