Синтаксис Дженериков Java для массивов

Ответ - то, что массивы могут только содержать овеществленные типы. И классы generified не овеществлены. Таким образом, "тип" во время выполнения List< ArrayList> просто Список. Дженерики стираются во времени выполнения (Google "стена стирания" для больше).

Так это:

List<ArrayList>[] myArray

действительно средства:

List[] myArray

нет никакого безопасного с точки зрения типов способа объявить то, что Вы пытаетесь объявить. Обычно я рекомендовал бы использовать Список вместо массива в этом случае. Некоторые люди пошли, насколько предложить, чтобы массивы рассматривали как типы устаревшие теперь, когда у нас есть дженерики. Я не могу сказать, что я готов пойти, который далеко, но необходимо рассмотреть, является ли набор лучшей альтернативой каждый раз, когда Вы привлечены к массиву.

книжные Дженерики Java и Наборы Naftalin и Wadler являются превосходной ссылкой для вопросов, которые Вы могли бы иметь о дженериках. Или, конечно, эти дженерики FAQ Ваша каноническая ссылка онлайн.

Г-н Josh Bloch говорит:

"Предпочитают, чтобы списки выстроили, потому что массивы являются ковариантными, и дженерики являются инвариантными',

Вы могли, возможно, сделать:

List<List<ArrayList>> someListArray;

Это может дать некоторый хит производительности (даже noticable, я держал пари), но Вы получите лучшую безопасность типов во время компиляции.

, но я думаю, что вопрос должен быть больше вокруг, "почему" Вам нужно это?

List<ArrayList>[] someListArray;

дает Вам:

array of ( List of ArrayList )

, Но из-за ограничений в дженериках Java (ошибка 6229728 ) можно только на самом деле создать:

array of List

и бросок это:

List<ArrayList>[] someListArray = (List<ArrayList>[]) new List[5];

Списком является Список, способный к содержанию Списка объектов ArrayList [], массив таких Списков

Так, что Вы сказали, то, что Массив (Список объекта ArrayList) КОРРЕКТЕН.

Может Вы совместно использовать, каковы Ваши тесты были. Мои собственные тесты отличающиеся

import java.util.*;

public class TestList {
    public static void main(String ... args) {
        class MySpecialLinkedList extends LinkedList<ArrayList<Integer>> {
            MySpecialLinkedList() {

            }

            public void foo() {

            }


            public Object clone()
            {
                return super.clone();
            }
        }

        List<ArrayList<Integer>> [] someListArray = new MySpecialLinkedList[10];
        for (int i = 0; i < 10; ++i) {
            someListArray[i] = new LinkedList<ArrayList<Integer>>();
            for (int j = 0; j < 20; ++j) {
                someListArray[i].add(new ArrayList<Integer>());
                for (int k = 0; k < 30; ++k) {
                    someListArray[i].get(j).add(j);
                }
            }
        }
    }
}

Вы корректны в высказывании:

После запущения некоторых тестов, я решил, что объявление означает массив, где каждый элемент является объектом ArrayList.

Выполнение этого кода

List<ArrayList>[] myArray  = new ArrayList[2];

myArray[0] = new ArrayList<String>();
myArray[0].add("test 1");

myArray[1] = new ArrayList<String>();
myArray[1].add("test 2");

print myArray;

Приводит к этому результату:

{["test 1"], ["test 2"]}

Это кажется мне нет никакой причины не сделать это вместо этого:

List<ArrayList> myArray  = new ArrayList<ArrayList>();

После запущения некоторых дополнительных тестов я думаю, что у меня есть свой ответ.

List< ArrayList> [] действительно указывает массив, где каждым элементом является Список объектов ArrayList.

Компиляция кода как показано ниже показанного, почему мой первый тест позволил мне использовать массив, где каждым элементом является Список чего-либо. Используя типы возврата Списка [] и Списка в методах, которые заполняют массивы, не предоставил компилятору достаточно информации для запрещения присвоений. Но компилятор сделал предупреждения о проблемах о неоднозначности.

С точки зрения компилятора, метод, возвращая Список [] мог бы возвращать List< ArrayList> (который удовлетворяет объявление), или оно не могло бы. Точно так же метод, возвращая Список мог бы или не мог бы возвратить ArrayList.

Здесь был выход компилятора:

javac Generics2.java-xlint:unchecked

Generics2.java:12: warning: [unchecked] unchecked conversion
found   : java.util.List[]
required: java.util.List<java.util.ArrayList>[]
        someListArray = getArrayWhereEachElementIsALinkedListObject();
                                                                   ^
Generics2.java:16: warning: [unchecked] unchecked conversion
found   : java.util.List[]
required: java.util.List<java.util.ArrayList>[]
        someListArray= getArrayWhereEachElementIsAListOfLinkedListObjects();

Здесь мои тесты.

import java.util.ArrayList;
import java.util.List;
import java.util.LinkedList;


public class Generics2 {

    public static void main(String[] args) {

        List<ArrayList>[] someListArray;

        someListArray = getArrayWhereEachElementIsALinkedListObject();
        // Why does this satisfy the declaration?
        //someListArray[0] => LinkedList object holding Strings

        someListArray= getArrayWhereEachElementIsAListOfLinkedListObjects();
        //someListArray[0] => LinkedList object holding LinkedList objects

    }

    public static List[] getArrayWhereEachElementIsALinkedListObject() {
        List[] arrayOfLists = new LinkedList[2];
        arrayOfLists[0] = getStringLinkedListAsList();
        arrayOfLists[1] = getIntegerLinkedListAsList();
        return arrayOfLists;
    }

  public static List[] getArrayWhereEachElementIsAListOfLinkedListObjects() {

        List list1 = new LinkedList();
        list1.add(new LinkedList());

        List list2 = new LinkedList();
        list2.add(new LinkedList());

        List[] arrayOfListsOfLinkedLists = new LinkedList[2];
        arrayOfListsOfLinkedLists[0] = list1;
        arrayOfListsOfLinkedLists[1] = list2;
        return arrayOfListsOfLinkedLists;
    }

    public static List getStringLinkedListAsList() {
        List stringList= new LinkedList();
        stringList.add("one");
        stringList.add("two");
        return stringList;
    }


    public static List getIntegerLinkedListAsList() {
        List intList= new LinkedList();
        intList.add(new Integer(1));
        intList.add(new Integer(2));
        return intList;
    }

}