是否可以解决“为可变参数参数创建 T 的通用数组”编译器警告？

Question

这是相关代码的简化版本，一个泛型类使用另一个具有泛型类型参数的类，并且需要将其中一个泛型类型传递给具有可变参数参数的方法：

class Assembler<X, Y> {
    void assemble(X container, Y... args) { ... }
}

class Component<T> {
    void useAssembler(T something) {

        Assembler<String, T> assembler = new Assembler<String, T>();

        //generates warning:
        // Type safety : A generic array of T is
        // created for a varargs parameter
        assembler.assemble("hello", something);
    }

}

是否有任何正确的方法可以将泛型参数传递给可变参数方法而不会遇到此警告？

当然是这样的

assembler.assemble("hello", new T[] { something });

不起作用，因为您无法创建通用数组。

Answer 1

在Java 6中，除了添加@SuppressWarnings("unchecked")，我不这么认为。

这个bug report 有更多信息，但归结为编译器不喜欢泛型类型的数组。

Answer 2

在 Java 7 中，使用 @SafeVarargs 注释方法声明

Answer 3

如果您追求流畅类型的界面，您可以尝试构建器模式。不像可变参数那样简洁，但它是类型安全的。

静态泛型类型方法可以在使用构建器时消除一些样板，同时保持类型安全。

建造者

public class ArgBuilder<T> implements Iterable<T> {

    private final List<T> args = new ArrayList<T>();

    public ArgBuilder<T> and(T arg) {
        args.add(arg);
        return this;
    }

    @Override
    public Iterator<T> iterator() {
        return args.iterator();
    }

    public static <T> ArgBuilder<T> with(T firstArgument) {
        return new ArgBuilder<T>().and(firstArgument);
    }
}

使用它

import static com.example.ArgBuilder.*;

public class VarargsTest {

    public static void main(String[] args) {
        doSomething(new ArgBuilder<String>().and("foo").and("bar").and("baz"));
        // or
        doSomething(with("foo").and("bar").and("baz"));
    }

    static void doSomething(Iterable<String> args) {
        for (String arg : args) {
            System.out.println(arg);
        }
    }
}

Answer 4

在可变参数方法调用中将参数显式转换为 Object 将使编译器满意，而无需诉诸 @SuppressWarnings。

public static <T> List<T> list( final T... items )
{
    return Arrays.asList( items );
}

// This will produce a warning.
list( "1", 2, new BigDecimal( "3.5" ) )

// This will not produce a warning.
list( (Object) "1", (Object) 2, (Object) new BigDecimal( "3.5" ) )

// This will not produce a warning either. Casting just the first parameter to 
// Object appears to be sufficient.
list( (Object) "1", 2, new BigDecimal( "3.5" ) )

我认为这里的问题是编译器需要弄清楚要创建什么具体类型的数组。如果方法不是通用的，编译器可以使用方法中的类型信息。如果该方法是通用的，它会尝试根据调用时使用的参数来确定数组类型。如果参数类型是同质的，那么这项任务很容易。如果它们有所不同，我认为编译器会尝试过于聪明并创建一个联合类型的泛型数组。然后它觉得有必要警告你。一个更简单的解决方案是在无法更好地缩小类型范围时创建 Object[]。上述解决方案正是这样做的。

为了更好地理解这一点，与下面的 list2 方法相比，尝试对上面的 list 方法的调用。

public static List<Object> list2( final Object... items )
{
    return Arrays.asList( items );
}

Answer 5

这是一个很容易解决的问题：使用List<T>！

应避免引用类型的数组。

在当前版本的 Java (1.7) 中，您可以使用 @SafeVargs 标记方法，这将删除来自调用者的警告。不过要小心，如果没有遗留数组，你仍然会更好。

List.of() 提供了一种相对简洁的方式来编写（不可修改的）List，直到 Java 获得适当的文字表示。

另请参阅Improved Compiler Warnings and Errors When Using Non-Reifiable Formal Parameters with Varargs Methods 技术说明。

Answer 6

自 Java 7 起，您可以将 @SafeVarargs 添加到方法中，并且不必在客户端代码上进行注释。

class Assembler<X, Y> {

    @SafeVarargs
    final void assemble(X container, Y... args) {
        //has to be final...
    }
}

Answer 7

您可以重载方法。 这并不能解决您的问题，但可以最大限度地减少警告的数量（是的，这是一个 hack！）

class Assembler<X, Y> {
  void assemble(X container, Y a1) { ... }
  void assemble(X container, Y a1, Y a2) { ... }
  void assemble(X container, Y a1, Y a2, Y a3) { ... }
  void assemble(X container, Y a1, Y a2, Y a3, Y a4) { ... }
  void assemble(X container, Y... args) { ... }
}

Answer 8

当使用泛型类型的数组时，我不得不传递对泛型类型的引用。有了它，我实际上可以使用 java.lang.reflect.Array 编写通用代码。

http://java.sun.com/javase/6/docs/api/java/lang/reflect/Array.html