不能在不指定类型参数的情况下使用带有 lambda 参数的 Java 8 方法 [英] Cannot use Java 8 method with lambda arguments without specifying type arguments
问题描述
我创建了一个带有类型参数的方法，使用这些类型参数返回一个泛型类型，并采用同样依赖于类型参数的 Function 参数.当我使用 lambdas 作为参数时，编译器强制我指定方法的类型参数，感觉不对.
I made a method with type arguments, returning a generic type using these type arguments, and taking Function arguments which also depends on the type arguments. When I use lambdas as arguments, the compiler forces me to specify the type arguments of the method, which feels wrong.
我正在设计一个实用程序类，其中包含与 Stream.flatMap 一起使用的方法.它将各种集合条目映射到包含键和值元素的 FlatEntry，并且可以使用构建器在多个级别上执行此操作.受影响的方法是 flatEntryMapperBuilder.代码如下:
I am designing a utility class with methods to use with Stream.flatMap. It maps every kind of collection entry to a FlatEntry which contains a key and value element, and can do this on multiple levels with a builder. The affected method is flatEntryMapperBuilder. Here is the code:
import java.util.function.Function;
import java.util.stream.Stream;
public class GdkStreams
{
public static <T, K, V> Function<T, Stream<FlatEntry<K, V>>> flatEntryMapper(Function<T, K> keyMapper,
Function<T, Stream<V>> valueMapper)
{
return input -> {
K key = keyMapper.apply(input);
return valueMapper.apply(input).map(value -> new FlatEntry<>(key, value));
};
}
public static <T, K, V> FlatEntryMapperBuilder<T, K, V> flatEntryMapperBuilder(Function<T, K> keyMapper,
Function<T, Stream<V>> valueMapper)
{
return new FlatEntryMapperBuilder<>(keyMapper, valueMapper);
}
public static class FlatEntryMapperBuilder<T, K, V>
{
private Function<T, K> keyMapper;
private Function<T, Stream<V>> valueMapper;
private FlatEntryMapperBuilder (Function<T, K> keyMapper, Function<T, Stream<V>> valueMapper)
{
this.keyMapper = keyMapper;
this.valueMapper = valueMapper;
}
public Function<T, Stream<FlatEntry<K, V>>> build()
{
return flatEntryMapper(keyMapper, valueMapper);
}
public <K2, V2> FlatEntryMapperBuilder<T, K, FlatEntry<K2, V2>> chain(Function<V, K2> keyMapper2,
Function<V, Stream<V2>> valueMapper2)
{
return new FlatEntryMapperBuilder<>(keyMapper,
valueMapper.andThen(stream -> stream.flatMap(flatEntryMapper(keyMapper2,
valueMapper2))));
}
}
public static class FlatEntry<K, V>
{
public final K key;
public final V value;
public FlatEntry (K key, V value)
{
this.key = key;
this.value = value;
}
}
}
问题在于它的使用.说我有:
The problem comes with its usage. Say I have:
Map<String, Set<String>> level1Map;
我可以通过执行以下操作将子集中的每个元素映射到 FlatEntry:
I can map every element in the sub Sets to a FlatEntry by doing:
level1Map.entrySet().stream().flatMap(GdkStreams.flatEntryMapper(Entry::getKey, entry -> entry.getValue().stream()));
而且它工作得很好.但是当我尝试这样做时:
And it works just fine. But when I try to do this:
level1Map.entrySet()
.stream()
.flatMap(GdkStreams.flatEntryMapperBuilder(Entry::getKey, entry -> entry.getValue().stream()).build());
Eclipse (Mars 4.5.0) 编译器中断:
The eclipse (Mars 4.5.0) compiler breaks with:
- The type Map.Entry does not define getKey(Object) that is applicable here
- The method getValue() is undefined for the type Object
- Type mismatch: cannot convert from GdkStreams.FlatEntryMapperBuilder<Object,Object,Object> to
<unknown>
和 javac (1.8.0_51) 中断:
And javac (1.8.0_51) breaks with:
MainTest.java:50: error: incompatible types: cannot infer type-variable(s) T,K#1,V#1
.flatMap(GdkStreams.flatEntryMapperBuilder(Entry::getKey, entry -> entry.getValue().stream()).build());
^
(argument mismatch; invalid method reference
method getKey in interface Entry<K#2,V#2> cannot be applied to given types
required: no arguments
found: Object
reason: actual and formal argument lists differ in length)
where T,K#1,V#1,K#2,V#2 are type-variables:
T extends Object declared in method <T,K#1,V#1>flatEntryMapperBuilder(Function<T,K#1>,Function<T,Stream<V#1>>)
K#1 extends Object declared in method <T,K#1,V#1>flatEntryMapperBuilder(Function<T,K#1>,Function<T,Stream<V#1>>)
V#1 extends Object declared in method <T,K#1,V#1>flatEntryMapperBuilder(Function<T,K#1>,Function<T,Stream<V#1>>)
K#2 extends Object declared in interface Entry
V#2 extends Object declared in interface Entry
MainTest.java:50: error: invalid method reference
.flatMap(GdkStreams.flatEntryMapperBuilder(Entry::getKey, entry -> entry.getValue().stream()).build());
^
non-static method getKey() cannot be referenced from a static context
where K is a type-variable:
K extends Object declared in interface Entry
2 errors
如果我用 entry 替换 ，javac 彻底改变了它的输出:Entry::getKey ->entry.getKey()
If I replace Entry::getKey by entry -> entry.getKey(), javac changes its output drastically:
MainTest.java:51: error: cannot find symbol
.flatMap(GdkStreams.flatEntryMapperBuilder(entry -> entry.getKey(), entry -> entry.getValue().stream()).build());
^
symbol: method getKey()
location: variable entry of type Object
MainTest.java:51: error: cannot find symbol
.flatMap(GdkStreams.flatEntryMapperBuilder(entry -> entry.getKey(), entry -> entry.getValue().stream()).build());
^
symbol: method getValue()
location: variable entry of type Object
2 errors
它通过指定类型参数编译得很好，这正是我所期望的:
It compiles fine by specifying type parameters, which is what I expected:
level1Map.entrySet()
.stream()
.flatMap(GdkStreams.<Entry<String, Set<String>>, String, String> flatEntryMapperBuilder(Entry::getKey,
entry -> entry.getValue()
.stream())
.build());
或指定参数类型参数之一:
or specifying one of the arguments type parameters:
Function<Entry<String, Set<String>>, String> keyGetter = Entry::getKey;
level1Map.entrySet()
.stream()
.flatMap(GdkStreams.flatEntryMapperBuilder(keyGetter, entry -> entry.getValue().stream()).build());
但这很笨拙！现在想象一下，使用链式方法(这是我的目标用法)在映射中编写所有具有 2 个级别的类型参数是多么笨拙:
But this is clumsy! Imagine now how clumsy it would be to write all type parameters with 2 levels in the map, using the chain method (which is my target usage):
Map<String, Map<String, Set<String>>> level2Map;
我已经阅读了许多关于 lambda 和泛型类型推断的其他问题，但没有一个能回答我的具体情况.
I have read many other questions about lambdas and generics type inference but none is answering my particular case.
我错过了什么吗?我可以更正我的 API 以使其使用不那么笨拙，还是我总是坚持指定类型参数?谢谢！
Am I missing something? Can I correct my API so that its usage is less clumsy, or am I stuck with always specifying type arguments? Thanks!
推荐答案
Holger 在评论区给出了我认为最好的答案:
Holger had the best answer in the comment section in my opinion:
这是 Java 8 类型推断的一个已知限制:它不适用于像 genericFactoryMethod().build() 这样的链式方法调用.
This is a known limitation of Java 8’s type inference: it doesn’t work with chained method invocations like
genericFactoryMethod().build().
谢谢！关于我的 API，我将在将它们用作参数之前指定函数，如下所示:
Thanks! About my API, I will specify the functions before using them as arguments, like this:
Function<Entry<String, Set<String>>, String> keyMapper = Entry::getKey;
Function<Entry<String, Set<String>>, Stream<String>> valueMapper = entry -> entry.getValue().stream();
感谢 Holger 的评论(再次感谢！)，我重新设计了 API.它保留原始元素而不是键，以及扁平化的值.
I redesigned the API thanks to Holger's comments (thanks again!). It keeps the original element instead of a key, along with the flattened value.
public static <T, R> Function<? super T, Stream<FlatEntry<T, R>>> flatEntryMapper(Function<? super T, ? extends Stream<? extends R>> mapper)
{
return element -> mapper.apply(element).map(value -> new FlatEntry<>(element, value));
}
public static class FlatEntry<E, V>
{
/** The original stream element */
public final E element;
/** The flattened value */
public final V value;
private FlatEntry (E element, V value)
{
this.element = element;
this.value = value;
}
}
它是可链接的，从级别 2 开始，映射器必须处理 FlatEntry.用法类似于一个简单的flatMap:
It is chainable, starting with level 2 the mapper has to process a FlatEntry. The usage is similar to a simple flatMap:
Map<String, Map<String, Map<String, Set<String>>>> level3Map;
// gives a stream of all the flattened values
level3Map.entrySet()
.stream()
.flatMap(entry -> entry.getValue().entrySet().stream())
.flatMap(entry -> entry.getValue().entrySet().stream())
.flatMap(entry -> entry.getValue().stream());
// gives a stream of FlatEntries with flattened values and all their original elements in nested FlatEntries
level3Map.entrySet()
.stream()
.flatMap(GdkStreams.flatEntryMapper(entry -> entry.getValue().entrySet().stream()))
.flatMap(GdkStreams.flatEntryMapper(flatEntry -> flatEntry.value.getValue().entrySet().stream()))
.flatMap(GdkStreams.flatEntryMapper(flatEntry -> flatEntry.value.getValue().stream()));
这篇关于不能在不指定类型参数的情况下使用带有 lambda 参数的 Java 8 方法的文章就介绍到这了，希望我们推荐的答案对大家有所帮助，也希望大家多多支持IT屋！
