数组的Java泛型语法_Java_Generics_Syntax_Types

数组的Java泛型语法

java generics syntax types

数组的Java泛型语法,java,generics,syntax,types,Java,Generics,Syntax,Types,以下声明指定了什么数据结构 List<ArrayList>[] myArray; 在运行一些测试之后，我确定它接受一个数组，其中每个元素都是LinkedList对象，并且没有指定LinkedList对象包含的内容因此List指定了List必须包含的内容，但是List[]指定了List必须如何实现我错过什么了吗这是我的测试 import java.util.ArrayList; import java.util.List; import java.util.LinkedLis

以下声明指定了什么数据结构

 List<ArrayList>[] myArray;

在运行一些测试之后，我确定它接受一个数组，其中每个元素都是

LinkedList

对象，并且没有指定LinkedList对象包含的内容

因此

List

指定了

List

必须包含的内容，但是

List[]

指定了

List

必须如何实现

我错过什么了吗

这是我的测试

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


public class Generics1 {

    public static void main(String[] args) {

        List<ArrayList>[] someListArray;

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

        someListArray= getArrayWhereEachElementIsAListOfArrayListObjects();
        //someListArray[0] => ArrayList object holding ArrayList objects

    }

    public static List[] getArrayWhereEachElementIsAnArrayListObject() {
        List[] arrayOfLists = new ArrayList[2];
        arrayOfLists[0] = getStringList();
        arrayOfLists[1] = getIntegerList();
        return arrayOfLists;
    }

  public static List[] getArrayWhereEachElementIsAListOfArrayListObjects() {   

        List list1 = new ArrayList();
        list1.add(getArrayList());

        List list2 = new ArrayList();
        list2.add(getArrayList());

        List[] arrayOfListsOfArrayLists = new ArrayList[2];
        arrayOfListsOfArrayLists[0] = list1;
        arrayOfListsOfArrayLists[1] = list2;
        return arrayOfListsOfArrayLists;
    }

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


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

    public static ArrayList getArrayList() {
        ArrayList arrayList = new ArrayList() ;
        return arrayList;
    }
}

import java.util.ArrayList；
导入java.util.List；
导入java.util.LinkedList；
公共类泛型1{
公共静态void main（字符串[]args）{
列表数组；
someListArray=getArrayWhereEachElementIsAnArrayListObject（）；
//为什么这符合宣言？
//someListArray[0]=>包含字符串的ArrayList对象
someListArray=GetArrayWhere ArrayListObject（）的每个HeleMetismalistOf；
//someListArray[0]=>保存ArrayList对象的ArrayList对象
}
公共静态列表[]getArrayWhereEachElementIsAnArrayListObject（）{
列表[]arrayOfLists=新的ArrayList[2]；
arrayOfLists[0]=getStringList（）；
arrayOfLists[1]=getIntegerList（）；
返回阵列飞行；
}
公共静态列表[]GetArrayWhere ArrayListOfArrayListObjects（）的每个HeleElementalistOfArrayListObjects（{
List list1=新的ArrayList（）；
添加（getArrayList（））；
List list2=新的ArrayList（）；
添加（getArrayList（））；
列表[]ArrayOflistsOfArrayList=新建ArrayList[2]；
ArrayOflistsOfArrayList[0]=list1；
ArrayOflistsOfArrayList[1]=list2；
返回ArrayFlistSoFarrayList；
}
公共静态列表getStringList（）{
List stringList=新建ArrayList（）；
字符串列表。添加（“一”）；
添加（“两个”）；
返回字符串列表；
}
公共静态列表getIntegerList（）{
List intList=new ArrayList（）；
添加（新的整数（1））；
添加（新的整数（2））；
返回intList；
}
公共静态ArrayList getArrayList（）{
ArrayList ArrayList=新的ArrayList（）；
返回数组列表；
}
}

乔什·布洛赫先生说：

“更喜欢列表而不是数组，因为数组是协变的，泛型是协变的不变量'

你或许可以：

List<List<ArrayList>> someListArray;

列出someListArray；

这可能会对性能造成一些影响（我敢打赌，这甚至不会引起注意），但在编译时您将获得更好的类型安全性

但我认为问题应该更多地围绕着“为什么”你需要这个

List<ArrayList>[] someListArray;

但由于Java泛型（bug）的限制，您实际上只能创建：

array of List

并投下：

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

List[]someListArray=（List[]）新列表[5]；

你说得对：

在运行一些测试之后，我确定声明意味着一个数组，其中每个元素都是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;

在我看来，没有理由不这样做：

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

List myArray=new ArrayList（）；

列表是一个能够容纳ArrayList对象的列表 List[]是此类列表的数组

所以，您所说的是数组（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);
                }
            }
        }
    }
}

import java.util.*；
公共类测试列表{
公共静态void main（字符串…参数）{
类MySpecialLinkedList扩展了LinkedList{
MySpecialLinkedList（）{
}
公共图书馆{
}
公共对象克隆（）
{
返回super.clone（）；
}
}
List[]someListArray=新建MySpecialLinkedList[10]；
对于（int i=0；i<10；++i）{
someListArray[i]=新的LinkedList（）；
对于（int j=0；j<20；++j）{
someListArray[i].add（新建ArrayList（））；
对于（int k=0；k<30；++k）{
someListArray[i].get（j）.add（j）；
}
}
}
}
}

在运行了一些附加测试之后，我想我已经找到了答案

List[]确实指定了一个数组，其中每个元素都是ArrayList对象的列表

如下所示编译代码揭示了为什么我的第一个测试允许我使用一个数组，其中每个元素都是一个任何内容的列表。在填充数组的方法中使用返回类型List[]和List并没有向编译器提供足够的信息来禁止赋值。但是编译器确实发出了关于歧义性的警告

从编译器的角度来看，返回列表[]的方法可能返回列表（满足声明），也可能不返回。类似地，返回列表的方法可能返回也可能不返回ArrayList

以下是编译器输出：

javac Generics2.java-Xlint：未选中

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(); java:12:警告：[未选中]未选中的转换找到：java.util.List[] 必需：java.util.List[] someListArray=getArrayWhereEachElementIsALinkedListObject（）； ^ java:16:警告：[未选中]未选中的转换找到：java.util.List[] 必需：java.util.List[] someListArray=GetArrayWhere每个链接ListObjects（）的ElementistisAlistOfLink；这是我的测试

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


public class Generics1 {

    public static void main(String[] args) {

        List<ArrayList>[] someListArray;

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

        someListArray= getArrayWhereEachElementIsAListOfArrayListObjects();
        //someListArray[0] => ArrayList object holding ArrayList objects

    }

    public static List[] getArrayWhereEachElementIsAnArrayListObject() {
        List[] arrayOfLists = new ArrayList[2];
        arrayOfLists[0] = getStringList();
        arrayOfLists[1] = getIntegerList();
        return arrayOfLists;
    }

  public static List[] getArrayWhereEachElementIsAListOfArrayListObjects() {   

        List list1 = new ArrayList();
        list1.add(getArrayList());

        List list2 = new ArrayList();
        list2.add(getArrayList());

        List[] arrayOfListsOfArrayLists = new ArrayList[2];
        arrayOfListsOfArrayLists[0] = list1;
        arrayOfListsOfArrayLists[1] = list2;
        return arrayOfListsOfArrayLists;
    }

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


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

    public static ArrayList getArrayList() {
        ArrayList arrayList = new ArrayList() ;
        return arrayList;
    }
}

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; } } 导入java.util.ArrayList；导入java.util.List；导入java.util.LinkedList；公共类泛型2{ 公共静态void main（字符串[]args）{ 列表数组； someListArray=getArrayWhereEachElementIsALinkedListObject（）； //为什么这符合宣言？ //someListArray[0]=>包含字符串的LinkedList对象 someListArray=GetArrayWhere每个链接ListObjects（）的ElementistisAlistOfLink； //someListArray[0]=>包含LinkedList对象的LinkedList对象 } 公共静态列表[]GetArrayWhere每个ChelementisAlinkedListObject（）{ 列表[]arrayOfLists=新链接列表[2]； arrayOfLists[0]=ge 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; } }

List<ArrayList>[] myArray

List[] myArray