相关疑难解决方法(0)

我创建了一个带有类型参数的方法,使用这些类型参数返回泛型类型,并获取Function也取决于类型参数的参数.当我使用lambdas作为参数时,编译器强制我指定方法的类型参数,这感觉不对.

我正在设计一个实用程序类,其中包含使用的方法Stream.flatMap.它将每种集合条目映射到包含键和值元素的FlatEntry,并且可以使用构建器在多个级别上执行此操作.受影响的方法是flatEntryMapperBuilder.这是代码:

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, …

我正在使用lambda在下面的Java程序中实现一个功能接口.当lambda作为参数传递给泛型方法时,编译器会标记"不兼容类型"错误,因为它推断lambda实现了Func <Shape>接口,该接口让编译器将lambda参数("thing")解释为当lambda尝试将其传递给需要Round类型参数的方法(testRound)时,为Shape类型.这个错误对我有意义.

但是等效方法引用不会引发错误消息.我一直误以为lambda和可以替换lambda的方法引用是可以互换的.在这里,事实并非如此.

public class Main
{
    public static void main(String... args)
    {
        methodB(thing -> Main.testRound(thing)); // incompatible types
        methodB(Main::testRound);                // no problem here
    }

    static <T extends Shape> void methodB(Func<T> function)
    {
    }

    static boolean testRound(Round thing)
    {
        return true;
    }
}

interface Func<T>
{
    boolean test(T ob);
}

class Shape
{
}

class Round extends Shape
{
}

当lambda失败时,为什么方法引用成功？

UPDATE

Vince Emigh在下面找到了我已经标记为接受的答案.虽然这不是我的问题的一部分,但是有四种方法可以解决这样一个事实:Func<Shape>如果一个人真的被使用lambdas ,那么lambda只被推断为类型:

// Use a type witness.

Main.<Round>methodB(thing -> testRound(thing));

// Make the lambda's argument …