java lambda可以有多个参数吗？

在Java中，是否可以让lambda接受多种不同的类型

即： 单变量工作：

    Function <Integer, Integer> adder = i -> i + 1;
    System.out.println (adder.apply (10));

函数加法器=i->i+1；
System.out.println（adder.apply（10））；

Varargs也可以工作：

    Function <Integer [], Integer> multiAdder = ints -> {
        int sum = 0;
        for (Integer i : ints) {
            sum += i;
        }
        return sum;
    };

    //.... 
    System.out.println ((multiAdder.apply (new Integer [] { 1, 2, 3, 4 })));

函数多加法器=整数->{
整数和=0；
for（整数i:int）{
总和+=i；
}
回报金额；
};
//.... 
System.out.println（（multiAdder.apply（新整数[]{1,2,3,4}））；

但我想要的东西可以接受许多不同类型的论点，例如：

    Function <String, Integer, Double, Person, String> myLambda = a , b, c, d->  {
    [DO STUFF]
    return "done stuff"
    };

函数myLambda=a、b、c、d->{
[做事]
返回“已完成的内容”
};

主要用途是为了方便起见，在函数内部有小的内联函数

---

我环顾了谷歌，检查了Java的功能包，但没有找到。这可能吗？

如果您使用多个类型参数定义这样的功能接口，这是可能的。没有这样的内置类型。（有几个具有多个参数的有限类型。）

@functioninterface
接口功能6{
公开六申请（一一二三四五五）；
}
公共静态void main（字符串[]args）引发异常{
函数6 func=（a，b，c，d，e）->‘z’；
}

我在这里称它为

Function6

。名称由您自行决定，只是尽量不要与Java库中现有的名称冲突

---

如果这是您要问的，那么也没有办法定义数量可变的类型参数

---

---

有些语言，如Scala，使用1、2、3、4、5、6等类型参数定义了许多内置类型。

对于具有2个参数的类型，可以使用

BiFunction

。如果需要更多，可以定义自己的函数接口，如下所示：

@FunctionalInterface
interface Function6<One, Two, Three, Four, Five, Six> {
    public Six apply(One one, Two two, Three three, Four four, Five five);
}

public static void main(String[] args) throws Exception {
    Function6<String, Integer, Double, Void, List<Float>, Character> func = (a, b, c, d, e) -> 'z';
}

@FunctionalInterface
public interface FourParameterFunction<T, U, V, W, R> {
    public R apply(T t, U u, V v, W w);
}

FourParameterFunction<String, Integer, Double, Person, String> myLambda = (a, b, c, d) -> {
    // do something
    return "done something";
};

@functioninterface
公共接口四参数函数{
公共R应用（T、U、V、W）；
}

如果有多个参数，则需要在参数列表周围加括号，如下所示：

@FunctionalInterface
public interface FourParameterFunction<T, U, V, W, R> {
    public R apply(T t, U u, V v, W w);
}

FourParameterFunction<String, Integer, Double, Person, String> myLambda = (a, b, c, d) -> {
    // do something
    return "done something";
};

FourParameterFunction myLambda=（a，b，c，d）->{
//做点什么
返回“做了某事”；
};

在这种情况下，您可以使用默认库（java 1.8）中的接口：

界面中有一个小的（不是最好的）默认方法示例：

default BiFunction<File, String, String> getFolderFileReader() {
    return (directory, fileName) -> {
        try {
            return FileUtils.readFile(directory, fileName);
        } catch (IOException e) {
            LOG.error("Unable to read file {} in {}.", fileName, directory.getAbsolutePath(), e);
        }
        return "";
    };
}}

默认双功能getFolderFileReader（）{
返回（目录、文件名）->{
试一试{
返回FileUtils.readFile（目录，文件名）；
}捕获（IOE异常）{
LOG.error（“无法读取{}中的{}文件，文件名，目录.getAbsolutePath（），e”）；
}
返回“”；
};
}}

另一种选择，不确定这是否适用于您的特定问题，但可能适用于某些问题，即在java.util.function库中使用

UnaryOperator

。 它返回与您指定的类型相同的类型，因此您将所有变量放在一个类中，并将其作为参数：

public class FunctionsLibraryUse {

    public static void main(String[] args){
        UnaryOperator<People> personsBirthday = (p) ->{
            System.out.println("it's " + p.getName() + " birthday!");
            p.setAge(p.getAge() + 1);
            return p;
        };
        People mel = new People();
        mel.setName("mel");
        mel.setAge(27);
        mel = personsBirthday.apply(mel);
        System.out.println("he is now : " + mel.getAge());

    }
}
class People{
    private String name;
    private int age;
    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;
    }
}

公共类函数库使用{
公共静态void main（字符串[]args）{
一元运算符personsarthy=（p）->{
System.out.println（“这是”+p.getName（）+“生日！”）；
p、 设置（p.getAge（）+1）；
返回p；
};
People mel=新人（）；
mel.setName（“mel”）；
梅尔赛特（27）；
mel=个人生日。应用（mel）；
System.out.println（“他现在：+mel.getAge（））；
}
}
阶级人士{
私有字符串名称；
私人互联网；
公共字符串getName（）{
返回名称；
}
公共void集合名（字符串名）{
this.name=名称；
}
公共整数getAge（）{
回归年龄；
}
公共无效设置（整数）{
这个。年龄=年龄；
}
}

因此，您拥有的类（在本例中为

Person

）可以有许多实例变量，并且不必更改lambda表达式的参数

---

对于那些感兴趣的人，我已经写了关于如何使用java.util.function library的说明：

您也可以使用jOOL library-

---

它已经准备了具有不同数量参数的功能接口。例如，您可以使用

org.jooq.lambda.function.Function3

等从

Function0

到

Function16

来使用lambda：有三种类型的操作：
1.接受参数-->使用者
2.测试参数返回布尔-->谓词
3.操作参数和返回值-->函数

Java函数接口最多两个参数：
单参数界面
消费者
谓词
功能

双参数接口
双消费者
双预测
双功能

对于两个以上的，您必须创建如下功能界面（消费者类型）：

@functioninterface
公共接口FiveParameterConsumer{
公共无效接受（T，U，V，W，X）；
}

一些lambda函数：

import org.junit.Test;
import java.awt.event.ActionListener;
import java.util.function.Function;

public class TestLambda {

@Test
public void testLambda() {

    System.out.println("test some lambda function");

    ////////////////////////////////////////////
    //1-any input | any output:
    //lambda define:
    Runnable lambda1 = () -> System.out.println("no parameter");
    //lambda execute:
    lambda1.run();


    ////////////////////////////////////////////
    //2-one input(as ActionEvent) | any output:
    //lambda define:
    ActionListener lambda2 = (p) -> System.out.println("One parameter as action");
    //lambda execute:
    lambda2.actionPerformed(null);


    ////////////////////////////////////////////
    //3-one input | by output(as Integer):
    //lambda define:
    Function<String, Integer> lambda3 = (p1) -> {
        System.out.println("one parameters: " + p1);
        return 10;
    };
    //lambda execute:
    lambda3.apply("test");


    ////////////////////////////////////////////
    //4-two input | any output
    //lambda define:
    TwoParameterFunctionWithoutReturn<String, Integer> lambda4 = (p1, p2) -> {
        System.out.println("two parameters: " + p1 + ", " + p2);
    };
    //lambda execute:
    lambda4.apply("param1", 10);


    ////////////////////////////////////////////
    //5-two input | by output(as Integer)
    //lambda define:
    TwoParameterFunctionByReturn<Integer, Integer> lambda5 = (p1, p2) -> {
        System.out.println("two parameters: " + p1 + ", " + p2);
        return p1 + p2;
    };
    //lambda execute:
    lambda5.apply(10, 20);


    ////////////////////////////////////////////
    //6-three input(Integer,Integer,String) | by output(as Integer)
    //lambda define:
    ThreeParameterFunctionByReturn<Integer, Integer, Integer> lambda6 = (p1, p2, p3) -> {
        System.out.println("three parameters: " + p1 + ", " + p2 + ", " + p3);
        return p1 + p2 + p3;
    };
    //lambda execute:
    lambda6.apply(10, 20, 30);

}


@FunctionalInterface
public interface TwoParameterFunctionWithoutReturn<T, U> {
    public void apply(T t, U u);
}

@FunctionalInterface
public interface TwoParameterFunctionByReturn<T, U> {
    public T apply(T t, U u);
}

@FunctionalInterface
public interface ThreeParameterFunctionByReturn<M, N, O> {
    public Integer apply(M m, N n, O o);
}
}

import org.junit.Test；
导入java.awt.event.ActionListener；
导入java.util.function.function；
公共类TestLambda{
@试验
公共无效testLambda（）{
System.out.println（“测试一些lambda函数”）；
////////////////////////////////////////////
//1-任何输入|任何输出：
//lambda定义：
Runnable lambda1=（）->System.out.println（“无参数”）；
//lambda执行：
lambda1.run（）；
////////////////////////////////////////////
//2-1个输入（作为ActionEvent）|任何输出：
//lambda定义：
ActionListener lambda2=（p）->System.out.println（“作为操作的一个参数”）；
//lambda执行：
lambda2.actionPerformed（null）；
////////////////////////////////////////////
//3-1输入|输出（整数）：
//lambda定义：
函数lambda3=（p1）->{
System.out.println（“一个参数：+p1”）；
返回10；
};
//lambda执行：
lambda3.应用（“测试”