Java desmarcado: criação de matriz genérica desmarcada para parâmetro varargs

Eu configurei o Netbeans para mostrar avisos não verificados em meu código Java, mas não consigo entender o erro nas seguintes linhas:

private List<String> cocNumbers;
private List<String> vatNumbers;
private List<String> ibans;
private List<String> banks;
...
List<List<String>> combinations = Utils.createCombinations(cocNumbers, vatNumbers, ibans);

Dá:

[unchecked] unchecked generic array creation for varargs parameter of type List<String>[]

Fonte do método:

/**
 * Returns a list of all possible combinations of the entered array of lists.
 *
 * Example: [["A", "B"], ["0", "1", "2"]]
 * Returns: [["A", "0"], ["A", "1"], ["A", "2"], ["B", "0"], ["B", "1"], ["B", "2"]]
 *
 * @param <T> The type parameter
 * @param elements An array of lists
 * @return All possible combinations of the entered lists
 */
public static <T> List<List<T>> createCombinations(List<T>... elements) {
    List<List<T>> returnLists = new ArrayList<>();

    int[] indices = new int[elements.length];
    for (int i = 0; i < indices.length; i++) {
        indices[i] = 0;
    }

    returnLists.add(generateCombination(indices, elements));
    while (returnLists.size() < countCombinations(elements)) {
        gotoNextIndex(indices, elements);
        returnLists.add(generateCombination(indices, elements));
    }

    return returnLists;
}

O que exatamente está dando errado e como eu poderia corrigir, já que suponho que deixar avisos não verificados no código não é uma boa ideia?

Esqueci de mencionar, mas estou usando Java 7.

Edit : Também vejo agora que o método tem o seguinte:

[unchecked] Possible heap pollution from parameterized vararg type List<T>
  where T is a type-variable:
    T extends Object declared in method <T>createCombinations(List<T>...)

Como janoh.janoh mencionado acima, varargs em Java é apenas um açúcar sintático para arrays mais a criação implícita de um array no site de chamada. assim

List<List<String>> combinations =
    Utils.createCombinations(cocNumbers, vatNumbers, ibans);

é na verdade

List<List<String>> combinations =
    Utils.createCombinations(new List<String>[]{cocNumbers, vatNumbers, ibans});

Mas como você deve saber, new List<String>[]não é permitido em Java, por razões que foram abordadas em muitas outras questões, mas principalmente tem a ver com o fato de que os arrays conhecem seu tipo de componente em tempo de execução e verificam em tempo de execução se os elementos adicionados correspondem ao seu componente tipo, mas esta verificação não é possível para tipos parametrizados.

De qualquer forma, em vez de falhar, o compilador ainda cria o array. Ele faz algo semelhante a isto:

List<List<String>> combinations =
    Utils.createCombinations((List<String>[])new List<?>[]{cocNumbers, vatNumbers, ibans});

Isso é potencialmente inseguro, mas não necessariamente inseguro. A maioria dos métodos varargs simplesmente itera sobre os elementos varargs e os lê. Nesse caso, ele não se preocupa com o tipo de tempo de execução do array. Este é o caso do seu método. Como você está no Java 7, deve adicionar a @SafeVarargsanotação ao seu método e não receberá mais este aviso. Essa anotação basicamente diz que esse método só se preocupa com os tipos dos elementos, não com o tipo da matriz.

No entanto, existem alguns métodos varargs que usam o tipo de tempo de execução da matriz. Nesse caso, é potencialmente inseguro. É por isso que o aviso está lá.

Porque o compilador java usa uma criação de array implícita para varargs, e o java não permite a criação de um array genérico (porque o argumento de tipo não é reificável).

O código abaixo está correto (essas operações são permitidas com matrizes), portanto, é necessário um aviso não verificado:

public static <T> List<List<T>> createCombinations(List<T> ... lists) {
    ((Object[]) lists)[0] = new ArrayList<Integer>();
    // place your code here
}

Veja uma explicação abrangente aqui