当一个方法具有泛型参数而其他方法具有泛型 lambda 时的 Java 不明确方法

Question

考虑以下几点：

    public void run() {
        run(o -> {});
    }

    //replace CharSequence with whatever except Object
    public <E extends CharSequence> void run(E e) {
    }
    public <E extends CharSequence> void run(Consumer<E> e){
    }

编译器会抱怨java reference to run is ambiguous，即使传递的参数显然是一个 lambda，而这两个方法中只有一个是 lambda

问题是为什么会这样？它是一个错误吗？应该用什么替换签名以实现相同的行为？

额外： IntelliJ 说（Main 类无关紧要）：

Ambiguous method call. Both
run(CharSequence) in Main and
run(Consumer<CharSequence>) in Main match

注意： 用除java.lang.Object 之外的任何东西替换CharSequence 都会产生同样的问题！

另请注意： 即使两个泛型不同并且彼此不相关也没关系！只要他们不是java.lang.Object。

所以，这不会编译 ether：

    public void run() {
        run(o -> {});
    }
    public <E extends ArrayList> void run(E e) {
    }
    public <E extends String> void run(Consumer<E> e){
    }

Answer 1

也不能将 CharSequence 声明为 lambda

看看吧。

interface WeirdCharSequence extends CharSequence {
  default int length() { return 0; }
  default char charAt(int index) { return 0; }
  default CharSequence subSequence(int start, int end) { return null; }

  void accept(CharSequence i); 
}

证明可以

WeirdCharSequence charSequence = o -> {};
run(charSequence);

o -> {} 可能意味着很多东西，并且没有足够的上下文来弄清楚 lambda 究竟代表什么。您始终可以通过显式声明所需的类型来帮助编译器。

this.<CharSequence>run(o -> {});

或

Consumer<CharSequence> consumer = o -> {};
run(consumer);

或（个人不太喜欢）

run((Consumer<CharSequence>)o -> {});

可能是编译器将E 视为既是Consumer<CharSequence> 又是CharSequence 的类型。

class ReallyWeirdCharSequence implements Consumer<CharSequence>, CharSequence {
  public void accept(CharSequence i) { }
  public int length() { return 0; }
  public char charAt(int index) { return 0; }
  public CharSequence subSequence(int start, int end) { return null; }
} 

Answer 2

经过一番调查，我意识到这是java语言的一个bug。

试试你自己：

    public void run() {
        run(o -> {});
    }
    public <E extends Class> void run(E e) {
    }
    public void run(Consumer e) {
    }

或者：

    public void run() {
        run(o -> {});
    }
    public <E extends Class> void run(E e) {
    }
    public <E extends Integer> void run(Consumer<E> e) {
    }

即使两个函数的参数彼此不相关。不知何故，java编译器认为它们是。

总之，使用泛型参数创建方法将使该方法作为接受 lambda 表达式的方法有效。

Answer 3

现在猜一猜，但一切都有一个 toString 方法，通过让编译器为您隐式调用它来隐式地将事物转换为字符串是很常见的。 String 当然是 CharSequence 的继承者。所以编译器可能会抱怨它无法在以下两者之间做出决定：

run((CharSequence)(o -> {}).toString());

和

run((Consumer<CharSequence>)(o -> {}));