通配符与泛型方法

Question

以下打印范围内所有元素的方法有什么实际区别吗？

public static void printA(Iterable<?> range)
{
    for (Object o : range)
    {
        System.out.println(o);
    }
}

public static <T> void printB(Iterable<T> range)
{
    for (T x : range)
    {
        System.out.println(x);
    }
}

显然，printB 涉及对 Object 的额外检查强制转换（请参见第 16 行），这对我来说似乎相当愚蠢 - 不都是 Object 吗？

public static void printA(java.lang.Iterable);
  Code:
   0:   aload_0
   1:   invokeinterface #18,  1; //InterfaceMethod java/lang/Iterable.iterator:()Ljava/util/Iterator;
   6:   astore_2
   7:   goto    24
   10:  aload_2
   11:  invokeinterface #24,  1; //InterfaceMethod java/util/Iterator.next:()Ljava/lang/Object;
   16:  astore_1
   17:  getstatic   #30; //Field java/lang/System.out:Ljava/io/PrintStream;
   20:  aload_1
   21:  invokevirtual   #36; //Method java/io/PrintStream.println:(Ljava/lang/Object;)V
   24:  aload_2
   25:  invokeinterface #42,  1; //InterfaceMethod java/util/Iterator.hasNext:()Z
   30:  ifne    10
   33:  return

public static void printB(java.lang.Iterable);
  Code:
   0:   aload_0
   1:   invokeinterface #18,  1; //InterfaceMethod java/lang/Iterable.iterator:()Ljava/util/Iterator;
   6:   astore_2
   7:   goto    27
   10:  aload_2
   11:  invokeinterface #24,  1; //InterfaceMethod java/util/Iterator.next:()Ljava/lang/Object;
   16:  checkcast   #3; //class java/lang/Object
   19:  astore_1
   20:  getstatic   #30; //Field java/lang/System.out:Ljava/io/PrintStream;
   23:  aload_1
   24:  invokevirtual   #36; //Method java/io/PrintStream.println:(Ljava/lang/Object;)V
   27:  aload_2
   28:  invokeinterface #42,  1; //InterfaceMethod java/util/Iterator.hasNext:()Z
   33:  ifne    10
   36:  return

Answer 1

在您的示例中，在签名的一个位置使用了泛型类型。在这种情况下，T 类型对于调用者 没有任何优势。在您的示例中，该类型对于方法的实现者也没有优势。

我发现通配符版本更容易让调用者理解，因为它明确表示“我根本不关心类型”。

在您的示例中，checkcast 确实是多余的。如果T 是有界的，就像T extends Number 一样，这将是必需的。然后需要检查Number，因为局部变量x 的类型为Number，但Iterator.next() 方法仍返回Object。似乎 Java 编译器不会费心优化演员表。 JIT 可能会在运行时这样做。

更新：

如果在多个地方使用泛型类型，例如在 cletus 的回答中，您别无选择，只能使用泛型类型T，否则编译器会发现参数类型/返回类型之间没有任何联系（任何两个通配符对于编译器来说是不同的）。

边界情况是签名仅在一个位置具有类型，但实现需要它是泛型类型而不是通配符。想想void swap(List<T> list, int a, int b) 方法。它需要从列表中取出元素并将它们放回原处。IIRC，Effective Java 建议使用带有通配符的公共方法，以及带有包含实际实现的类型的内部辅助方法。这样，用户获得了一个简单的 API，而实现者仍然具有类型安全性。

public void swap(List<?> list, int a, int b){
    swapHelper(list, a, b);
}
private <T> void swapHelper(List<T> list, int a, int b){
    ...
}

Answer 2

第二个更灵活。一个更好的例子是：它说明了类型。这对您是否有用取决于函数的作用。

当你想从方法中返回一些东西时，第二个显示了它的用处：

public static <T> List<T> reverse(List<T> list) {
  for (int i=0; i<n/2; i++) {
    T value = list.get(i);
    list.set(i, list.get(list.size() - i - 1));
    list.set(list.size() - i = 1, value);
  }
  return list;
}

复制数组可能是一个更好的例子，但重点仍然是你不能用List<?> 做上述事情。

Answer 3

不是真的。生成的字节码应该几乎相同。