heap pollution for simple parameter

Question

I have following function:

public static <T> List<T> list(T... xs) {
    final List<T> lst = new ArrayList<T>();
    for (final T x : xs) {
        lst.add(x);
    }

    return lst;
}

Its usage is simple:

   List<Integer> ints = list(1, 2, 3, 4)

Compiler gives me following warning for this list

"TypeSafety: potential heap pollution for via varargs parameter

I tried to find what it means but all explanastions I found were for functions of parameters that are themselves parametrized e.g.

f(List<T>... xss).

While I have function of generic non parametrized parameter.

Please explain me what is the potential problem with my function because I can not find any.

Note that this can be substituted with `new ArrayList<>(Arrays.asList(1, 2, 3, 4))`. Or, if you're using Guava, `Lists.newArrayList(1, 2, 3, 4)`. — shmosel, Feb 06 '20 at 21:00

Vasiliy Vlasov · Accepted Answer · 2017-06-07T21:46:27.630

Varargs in Java is a syntatic sugar. T... xs is the same as T[] xs. Therefore actually you have a function with parametrized parameter (the array).

Back to your question. Let's consider the situation, when you pass List<String> as generic type to the method. Then you have an array of elements of List<String> as an argument to your method. Two important issues arise because of this and lead to possible flaw in the code.

Arrays are covariant and it means that the compilator will allow this assignment: Object[] arr = xs
Because of generic erasure during compile time the array contains raw List elements and, unfortunately, there is no way in Java to guarantee, that the element you put in the array is exactly List<String>. So if you put List<Integer> java.lang.ArrayStoreException will not be thrown at runtime.

This alltogether leads to a situation when you may produce heap polution. Please, see the following example:

public static <T> List<T> list(T... xs) {
    final List<T> lst = new ArrayList<T>();
    for (final T x : xs) {
        lst.add(x);
    }
    Object[] arr = xs; //arrays are covariant, we can do this
    arr[0] = Arrays.asList(4); //<--------heap pollution
    return lst;
}
public static void main(String[] args) {
    List[] arr = { Arrays.asList("one"), Arrays.asList("two"), Arrays.asList("three") };
    List<List<String>> l = list(arr);
    for (List list : arr) {
        System.out.println(list.get(0));
    }
}

Output:

4
two
three

Here is a really good one explanation on the topic: http://www.angelikalanger.com/GenericsFAQ/FAQSections/ProgrammingIdioms.html#FAQ300

Official Java Guide: https://docs.oracle.com/javase/8/docs/technotes/guides/language/non-reifiable-varargs.html

Can you show my usage of list function that breaks this code? — Trismegistos, Jun 07 '17 at 11:11
`Object [] arr = { "one", "two", 3 }; String [] brokenArr = (String []) arr; List strings = list(brokenArr);` — Vasiliy Vlasov, Jun 07 '17 at 11:24
@VasiliyVlasov Casting `Object[]` to `String[]` throws a `ClassCastException`. — Jorn Vernee, Jun 07 '17 at 11:26
So basically I would have to Provide e.g. array of strings with some object which is not subtype of String. I don't think it is possible in correct code. — Trismegistos, Jun 07 '17 at 14:18
@Trismegistos My fault, both the example in the previous comment and the above answer were bad. I edited the answer so I hope it will help you to understand the problem. Thanks. — Vasiliy Vlasov, Jun 07 '17 at 21:35

score 3 · Answer 2 · answered Jun 07 '17 at 21:45

@VasiliyVlasov's answer nicely explains the reason for the warning. But in the context of your question, the list() method is indeed safe because it doesn't do any unsafe operations. The warning only says there's a "potential problem" because the compiler can't be sure the method you're calling is implemented safely. To avoid the warning, you can vouch for the safety of your method by marking it with @SafeVarargs. See the Javadoc and the JLS for more details.

heap pollution for simple parameter

2 Answers2