blocks|key|4335905|text|您必须首先将lambda表达式赋给函数接口类型的变量。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|4335906|否则，编译器无法推断这些lambda表达式的类型。|4335907|I0+i0+=+(int+a,+int+b)+->+a+%2B+b;
I1+i1+=+(double+d)+->+(int)+(d+*+2);
List<Object>+test+=+Arrays.asList(
++++i0,
++++i1
);|code-block|syntax|javascript|4335908|也就是说，我不确定在List<Object>中存储这些lambda表达式的意义。如果不将它们转换回单独的函数接口类型，就不能使用它们。|offset|length|style|CODE|4335909|entityMap^0|0|0|0|A|C|0^^$0|@$1|2|3|4|5|6|7|Q|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|R|8|@]|9|@]|A|$]]|$1|D|3|E|5|F|7|S|8|@]|9|@]|A|$G|H]]|$1|I|3|J|5|6|7|T|8|@$K|U|L|V|M|N]]|9|@]|A|$]]|$1|O|3|-4|5|6|7|W|8|@]|9|@]|A|$]]]|P|$]]

You must assign the lambda expressions to variables of the functional interface types first.

Otherwise the compiler cannot infer the types of these lambda expressions.

<pre><code>I0 i0 = (int a, int b) -&gt; a + b;
I1 i1 = (double d) -&gt; (int) (d * 2);
List&lt;Object&gt; test = Arrays.asList(
 i0,
 i1
);
</code></pre>

That said, I'm not sure what's the point of storing these lambda expressions in a <code>List&lt;Object&gt;</code>. You can't use them without casting them back to the individual functional interface types.

blocks|key|4335653|text|您可以强制转换为相应的接口，如下所示：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|4335654|List<Object>+test+=+Arrays.asList(
++++(I0)+(int+a,+int+b)+->+a+%2B+b,
++++(I1)+(double+d)+->+(int)+(d+*+2)
);|code-block|syntax|javascript|4335655|尽管这个更短，我也会考虑Eran's+answer也许它更易读和更容易理解(如果有更多的函数)。而且我也看不到这样一个构造的用例...|offset|length|4335656|它变得更短(不一定更好)：|4335657|List<Object>+test+=+Arrays.asList(
++++(I0)+(a,+b)+->+a+%2B+b,
++++(I1)+d+->+(int)+(d+*+2)
);|4335658|entityMap|0|LINK|mutability|MUTABLE|url|https://stackoverflow.com/a/47650202/85421^0|0|0|C|D|0|0|0|0^^$0|@$1|2|3|4|5|6|7|W|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|X|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|Y|8|@]|9|@$I|Z|J|10|1|11]]|A|$]]|$1|K|3|L|5|6|7|12|8|@]|9|@]|A|$]]|$1|M|3|N|5|D|7|13|8|@]|9|@]|A|$E|F]]|$1|O|3|-4|5|6|7|14|8|@]|9|@]|A|$]]]|P|$Q|$5|R|S|T|A|$U|V]]]]

You could cast to the respective Interface like:

<pre><code>List&lt;Object&gt; test = Arrays.asList(
 (I0) (int a, int b) -&gt; a + b,
 (I1) (double d) -&gt; (int) (d * 2)
);
</code></pre>

despite this being shorter, I would also consider <a href="https://stackoverflow.com/a/47650202/85421">Eran's answer</a> maybe it is more readable and easier to understand (if having more functions). And I also can't see the use case for such a construct... 

It gets even shorter (not necessarily better):

<pre><code>List&lt;Object&gt; test = Arrays.asList(
 (I0) (a, b) -&gt; a + b,
 (I1) d -&gt; (int) (d * 2)
);
</code></pre>

blocks|key|4336003|text|据我所知，您正在尝试这样做：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|4336004|public+static+void+main(String...+args){
++++List<Object>+lambdas+=+Arrays.asList(
++++++++++++(IntBinaryOperator)+(int+a,+int+b)+->+a+%2B+b,
++++++++++++(DoubleToIntFunction)+(double+d)+->+(int)(d+*+2)
++++);
++++for(int+i=0;i<args.length;i%2B%2B){
++++++++//+Apply+lambdas.get(i)+to+args[i]
++++}
}|code-block|syntax|javascript|4336005|然而，这个评论是一件非常重要的事情；你将如何实现它？|4336006|你可以在每一轮中检查类型：|4336007|++++for(int+i=0;i<args.length;i%2B%2B){
++++++++if(lambdas.get(i)+instanceof+IntBinaryOperator){
++++++++++++processedArgs[i]+=
++++++++++++++++++++((IntBinaryOperator)+lambdas.get(i)).applyAsInt(MAGIC_NUMBER,+Integer.parseInt(args[i]));
++++++++}else{
++++++++++++//+All+your+other+cases+(may+take+a+while)
++++++++}
++++}|4336008|验证每个可能的类型是一个巨大的痛苦，如果它是依赖于位置的，那么它无论如何只会运行一次，所以它是过度杀伤力。|4336009|我的建议取决于这是静态的(您的代码只在一组特定的参数上运行)还是动态的(它需要在所有类型的参数上运行)。对于静态代码，我只需应用lambdas而不使用循环：|4336010|public+static+void+main(String...+args){
++++processedArgs+=+new+int[args.length];
++++IntBinaryOperator+op1+=+(int+a,+int+b)+->+a+%2B+b;
++++DoubleToIntFunction+op2+=++(double+d)+->+(int)(d+*+2);

++++processedArgs[0]+=+op1.applyAsInt(MAGIC_NUMBER,+Integer.parseInt(args[0]));
++++processedArgs[1]+=+op2.applyAsInt(Double.parseDouble(args[1]));
}|4336011|对于动态解决方案，我建议切换到单个功能界面。我会使用最大要求，并在不需要的地方填充虚拟值：|4336012|public+static+void+main(String...+args){
++++processedArgs+=+new+int[args.length];
++++List<DoubleBinaryOperator>+ops+=+Arrays.asList(
++++++++++++(a,+b)+->+a+%2B+b,
++++++++++++(d,+ignore)+->+(d+*+2)
++++);
++++for(int+i=0;i<args.length;i%2B%2B){
++++++++processedArgs[i]+=+(int)ops.get(i).applyAsDouble(Double.parseDouble(args[i]),+MAGIC_NUMBER);
++++}
}|4336013|或者，最好是您可以简化您的lambda：|4336014|public+static+void+main(String...+args){
++++processedArgs+=+new+int[args.length];
++++List<DoubleToIntFunction>+ops+=+Arrays.asList(
++++++++++++(d)+->+(int)(d+%2B+MAGIC_NUMBER),
++++++++++++(d)+->+(int)(d+*+2)
++++);
++++for(int+i=0;i<args.length;i%2B%2B){
++++++++processedArgs[i]+=+ops.get(i).applyAsInt(Double.parseDouble(args[i]));
++++}
}|4336015|我觉得你的解决方案最终比这些解决方案都要简单。只是想帮你指明正确的方向。|4336016|entityMap^0|0|0|0|0|0|0|0|0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|14|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|15|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|16|8|@]|9|@]|A|$]]|$1|I|3|J|5|6|7|17|8|@]|9|@]|A|$]]|$1|K|3|L|5|D|7|18|8|@]|9|@]|A|$E|F]]|$1|M|3|N|5|6|7|19|8|@]|9|@]|A|$]]|$1|O|3|P|5|6|7|1A|8|@]|9|@]|A|$]]|$1|Q|3|R|5|D|7|1B|8|@]|9|@]|A|$E|F]]|$1|S|3|T|5|6|7|1C|8|@]|9|@]|A|$]]|$1|U|3|V|5|D|7|1D|8|@]|9|@]|A|$E|F]]|$1|W|3|X|5|6|7|1E|8|@]|9|@]|A|$]]|$1|Y|3|Z|5|D|7|1F|8|@]|9|@]|A|$E|F]]|$1|10|3|11|5|6|7|1G|8|@]|9|@]|A|$]]|$1|12|3|-4|5|6|7|1H|8|@]|9|@]|A|$]]]|13|$]]

From what I gather, you're trying to do something like this:

<pre><code>public static void main(String... args){
 List&lt;Object&gt; lambdas = Arrays.asList(
 (IntBinaryOperator) (int a, int b) -&gt; a + b,
 (DoubleToIntFunction) (double d) -&gt; (int)(d * 2)
 );
 for(int i=0;i&lt;args.length;i++){
 // Apply lambdas.get(i) to args[i]
 }
}
</code></pre>

That comment is a pretty big deal, though; how would you implement it?

You could check the type during each round:

<pre><code> for(int i=0;i&lt;args.length;i++){
 if(lambdas.get(i) instanceof IntBinaryOperator){
 processedArgs[i] =
 ((IntBinaryOperator) lambdas.get(i)).applyAsInt(MAGIC_NUMBER, Integer.parseInt(args[i]));
 }else{
 // All your other cases (may take a while)
 }
 }
</code></pre>

Validating each possible type is a huge pain, and if it's position-dependent, it's only going to run once anyway, so it's overkill.

My recommendation depends on if this is going to be static (your code runs only on one specific set of arguments ever) or dynamic (it needs to run on all kinds of arguments). For static code, I'd just apply the lambdas without a loop:

<pre><code>public static void main(String... args){
 processedArgs = new int[args.length];
 IntBinaryOperator op1 = (int a, int b) -&gt; a + b;
 DoubleToIntFunction op2 = (double d) -&gt; (int)(d * 2);

 processedArgs[0] = op1.applyAsInt(MAGIC_NUMBER, Integer.parseInt(args[0]));
 processedArgs[1] = op2.applyAsInt(Double.parseDouble(args[1]));
}
</code></pre>

For a dynamic solution, I'd recommend switching to a single functional interface. I would go with the maximum requirement and fill in dummy values where not needed:

<pre><code>public static void main(String... args){
 processedArgs = new int[args.length];
 List&lt;DoubleBinaryOperator&gt; ops = Arrays.asList(
 (a, b) -&gt; a + b,
 (d, ignore) -&gt; (d * 2)
 );
 for(int i=0;i&lt;args.length;i++){
 processedArgs[i] = (int)ops.get(i).applyAsDouble(Double.parseDouble(args[i]), MAGIC_NUMBER);
 }
}
</code></pre>

Or, preferably, if you can simplify your lambdas:

<pre><code>public static void main(String... args){
 processedArgs = new int[args.length];
 List&lt;DoubleToIntFunction&gt; ops = Arrays.asList(
 (d) -&gt; (int)(d + MAGIC_NUMBER),
 (d) -&gt; (int)(d * 2)
 );
 for(int i=0;i&lt;args.length;i++){
 processedArgs[i] = ops.get(i).applyAsInt(Double.parseDouble(args[i]));
 }
}
</code></pre>

I feel like your solution ultimately is less complicated than any of these. Just trying to help point you in the right direction.

blocks|key|4336045|text|你可以让你的接口使用vararg类型：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|4336046|public+class+NaryFunctionTest+{

++++interface+NaryFunction<R+extends+Number>+{
++++++++R+run(R...+args);
++++}

++++@Test
++++public+void+test()+{
++++++++NaryFunction<Integer>+f1+=+(Integer[]+o)+->+o[0]+%2B+o[1];
++++++++NaryFunction<Double>+f2+=+(Double[]+o)+->+o[0]+*2;
++++++++List<NaryFunction<?>>+test+=+Arrays.asList(
++++++++++++f1,
++++++++++++f2
++++++++);
++++}
}|code-block|syntax|javascript|4336047|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|J|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|H|$]]

You could make your interfaces use vararg typing:

<pre><code>public class NaryFunctionTest {

 interface NaryFunction&lt;R extends Number&gt; {
 R run(R... args);
 }

 @Test
 public void test() {
 NaryFunction&lt;Integer&gt; f1 = (Integer[] o) -&gt; o[0] + o[1];
 NaryFunction&lt;Double&gt; f2 = (Double[] o) -&gt; o[0] *2;
 List&lt;NaryFunction&lt;?&gt;&gt; test = Arrays.asList(
 f1,
 f2
 );
 }
}
</code></pre>

I'd like to create an array of lambda. The problem is that the lambda could be different from each other. Example:

<pre><code>private interface I0 {
 int interface0(int a, int b);
}

private interface I1 {
 int interface1(double d);
}
</code></pre>

Now, how can I declare a list which can contain both I0 and I1?

<pre><code>List&lt;Object&gt; test = Arrays.asList(
 (int a, int b) -&gt; a + b,
 (double d) -&gt; d * 2
);
</code></pre>

Obviously <code>Object</code> does not work.

Declare array of lambdas in Java

编译器

我想创建一个lambda数组。问题是lambda可能彼此不同。示例：private interface I0 {    int interface0(int a, int b);}private interface I1 {    int interface1(double d);}现在，我如何声明一个同时包含I0和I...

问在Java中声明lambdas数组
EN

社区

活动

资源

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问在Java中声明lambdas数组EN

社区

活动

资源

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问在Java中声明lambdas数组
EN