Question

I ve recent come over the java @SafeVarargs annotation. 在贾瓦省,谁能发挥aria的作用,令我感到很混淆(肥皂中毒)。删除的类型?),因此,我很想知道:

在@SafeVarargs的意义上(最好以深入事例的形式解释)中, v的功能何在?
为什么这种说明留给方案人自行决定? 汇编者是否应该能够检查?
Is there some standard one must adhere to in order to ensure his function is indeed varags safe? If not, what are the best practices to ensure it?

Answer 1

(1) 在互联网上和StackOverflow上,有许多与普通和营利有关的特定问题的例子。基本上,如果你有不同类型的争论:

<T> void foo(T... args);

在 Java,脂肪是合成糖,在编造时经历一种简单的“再写”:一种蒸气参数:<代码> X...被转换成X[]的参数;每当有人呼吁采用这一加固方法时,汇编者收集了所有“可变的论据”,这些论点都包含在加固参数中,并创设了像new X[]{......(此处加插图)。 }。

当弹性体类型具体如<代码>时,便能很好地发挥作用。 String.... 哪类变量如<代码> T...,它也在上发挥作用。 T为这一呼吁的具体类型。例如,如果上述方法属于类别<代码>的一部分。 Foo<T>,并附有。 Foo<String> reference, 然后打电话foo,因为我们现在知道T:String。

然而,当<代码>T的“价值”是另一个类型参数时,它并不发挥作用。在 Java,不可能建立一系列类型的参数组成部分(<>代码>new T[]{......})。 So Java 相反使用new Object[]{>}(Object为的上限)。 T;如果上限有所不同,则不是<条码>(目标

因此,创建<代码>新目标[]而不是new T[]或无论什么都是错误的? 简而言之, Java的阵列在运行时间知道其部件类型。因此,通过阵列的物体在运行时将具有错误的成分类型。

也许最常用的救助办法,简单地说是为了在元素中注入活力,这并不是问题(不会对阵列的操作时间类型给予照顾),因此,这是安全的:

@SafeVarargs
final <T> void foo(T... args) {
    for (T x : args) {
        // do stuff with x
    }
}

然而,对于取决于所通过阵列的操作时间组成部分的任何东西,都不会安全。这里是不安全和失事的简单例子:

class UnSafeVarargs
{
  static <T> T[] asArray(T... args) {
    return args;
  }

  static <T> T[] arrayOfTwo(T a, T b) {
    return asArray(a, b);
  }

  public static void main(String[] args) {
    String[] bar = arrayOfTwo("hi", "mom");
  }
}

这里的问题是,我们取决于<代码>args的类型,即T[],以便作为予以退回。 T[]。但实际而言,争论的类型不是T[。

3) 如果贵国的方法有“<代码”的争论 T... (T为任何类型的参数),然后:

Safe: If your method only depends on the fact that the elements of the array are instances of T
Unsafe: If it depends on the fact that the array is an instance of T[]

视阵列的操作时间类型而定的物品包括:将其退回为T[],将其作为一个参数的论据通过T[],将阵列类型改为。



2) 上文提及的区别过于复杂,难以自动区分。

Answer 2


就最佳做法而言,考虑这一点。

If you have this:

public <T> void doSomething(A a, B b, T... manyTs) {
    // Your code here
}


为此:

public <T> void doSomething(A a, B b, T... manyTs) {
    doSomething(a, b, Arrays.asList(manyTs));
}

private <T> void doSomething(A a, B b, List<T> manyTs) {
    // Your code here
}

我发现,我通常只增加一些词句,使之更方便我打电话的人。我的内部实施几乎总是更方便地使用<代码>List<>。因此,在<代码>Arrays.asList()上,确保我没有办法引进肥皂污染,这是我所做的。

我只了解你第3号。新中学已经为上面第1和第2号提供了很大的答案,我没有足够声誉,只能把这一说法作为评论。 iii

Answer 3

@SafeVarargs用于表明,这些方法不会造成肥皂污染。

肥皂污染是我们在通用阵列中混合不同参数的类型。

For example:

public static <T> T[] unsafe(T... elements) {
    return elements; 
}

 Object [] listOfItems =  unsafe("some value", 34, new ArrayList<>());
 String stringValue = (String) listOfItems[0]; // some value
 String intValue = (String) listOfItems[1]; // ClassCastException

As you can see, such implementation could easily cause ClassCastException if we don t guess with the type.

友情链接