前提

我们需要知道两点

（1）T指的是泛型类型，它只能是引用类型，何为引用类型？在java中除了基本数据类型（如byte、short、int、long、float、double、boolean、char）之外的所有类型都是引用类型。引用类型包括类（class）、接口（interface）、数组（array）等

 （2）我们asList返回值是一个List<T>类型，也就是说我们传递什么T最后返回的List中元素类型就是什么T类型，比如我们传递一个Integer 那么List中元素就是Integer，我们传递一个int [] 那么我们list中元素就是int[]，有的同志就要问了，为什么传递过去的事int [] 泛型T不会识别为int ，刚才我们说了泛型只能是引用类型，但是我们int是基本类型，不会识别为引用类型，所以我们参数接收的时候直接就将int [] 识别成了引用类型，所以我们返回的结果List<int[]>就是这种类型的。

实验

  public static void main(String[] args) {

        int[] a = {2,3,4,5};
        Integer[] b = {2,3,4,5};

        List listA = Arrays.asList(a);
        List listA1 = Arrays.asList(2,3,4,5);
        List listB = Arrays.asList(b);

        System.out.println(listA.size());
        System.out.println(listA1.size());
        System.out.println(listB.size());
      
         System.out.println("ListA元素类型："+listA.get(0).getClass());
                                        
        System.out.println("ListA元素："+Arrays.toString((int[]) listA.get(0)));

        System.out.println("ListA1元素类型："+listA1.get(0).getClass());

        System.out.println("ListB元素类型："+listB.get(0).getClass());
    }
 

 运行结果

我们可以看到我们传递过去的int [] array数组，接受参数确实将int [] 识别为了T，也就是说我们List中元素是int[] ,所以我们的元素个数是1。

对于我们传递过去的Arrays.asList(2,3,4,5);这个可变参数我们没有指定类型，但是java会自动装箱操作，将这个几个参数自动封装为Integer类型。

补充

上面都是一维数组，那么如果是二维数组又是什么情况呢？

我们以Arrays中的toArray方法为例

public Object[] toArray() {

return Arrays.copyOf(elementData, size);

}

@SuppressWarnings("unchecked")
    public <T> T[] toArray(T[] a) {
        if (a.length < size)
            // 新建一个运行时类型的数组，但是ArrayList数组的内容
            return (T[]) Arrays.copyOf(elementData, size, a.getClass());
            //调用System提供的arraycopy()方法实现数组之间的复制
        System.arraycopy(elementData, 0, a, 0, size);
        if (a.length > size)
            a[size] = null;
        return a;

class Solution {
    public int[][] reconstructQueue(int[][] people) {
        Arrays.sort(people,(a,b)->{
            if(a[0]==b[0]) return a[1]-b[1];
            return b[0]-a[0];
        });
         LinkedList<int[]> que = new LinkedList<>();
         for (int[] p : people) {
             que.add(p[1],p);
         }
         return que.toArray(new int[people.length][]);
    }
}

实际上我们传递过去的二维数组int[][] ,我们参数中泛型T识别的是int[] ,然后传递到源码中的a实际上就是我们int[] 类型的一维数组，这个可以这样理解：int[3][2] 实际上是 int[3] {int[2], int[2], int[2]}。

然后返回值直接就是T[] 就是int[3][]。

下面这个例子更加好理解一些。

List<int[]> res = new ArrayList<>();
res.add(new int[]{100});
int[][] a = res.toArray(new int[0][]);
System.out.println(a[0][0]);

//成功运行并输出
100

其他问题

2.asList()方法返回对象使用add（）方法抛出异常
先进行如下测试：

  public static void main(String[] args) {
        List<String> pets = Arrays.asList("tiger","mice");
        pets.add("lion");
    }
 

结果如下：

我们这里可以看到他抛出了一个异常，难道add方法不是List的基本用法吗？我们继续扒一下源码。

原来原来Arrays的asList方法使用的ArrayList类是一个内部定义的类，而不是java.util.ArrayList类。其部分源码如下：

private static class ArrayList<E> extends AbstractList<E>
        implements RandomAccess, java.io.Serializable
    {
        @java.io.Serial
        private static final long serialVersionUID = -2764017481108945198L;
        @SuppressWarnings("serial") // Conditionally serializable
        private final E[] a;

        ArrayList(E[] array) {
            a = Objects.requireNonNull(array);
        }
        
        ....
     }

​

我们可以看到这是一个静态内部类，存储数组元素的a变量是final类型的，由此判断，这个静态内部类是不能做任何内部元素的添加删除操作的！就跟String类一样，String对象存储字符数组的变量也是有final修饰符的。因为一旦增加数组元素，这个数组容量已经定好的容器就无法装载增加的元素了。

内部类里面并没有add,remove方法，我们可以看下这个类继承的AbstractList类里面对这些方法的实现：

public abstract class AbstractList<E> extends AbstractCollection<E> implements List<E> {  
    ........  
  
    public void add(int index, E element) {  
        throw new UnsupportedOperationException();  
    }  
  
    public E remove(int index) {  
        throw new UnsupportedOperationException();  
    }  
} 

找到异常的来源了，我们使用asList得到的对象add、remove方法直接就是抛出异常。那么我们如果要想对asList得到的对象使用add、remove方法，该怎么办呢？

List<String> pets = new ArrayList<String>(Arrays.asList("a", "b", "c")); 

可以将传入的参数转换为一个ArrayList对象返回。

3.通过Arrays.asList方法将数组转成集合后，使用set方法修改元素，为什么原来的数组的值也会改变？
测试：

public static void main(String[] args){
            String[] strings={"A","B","C"};
            List<String> stringList=Arrays.asList(strings);
            stringList.set(0,"G");
            System.out.println(stringList);
            System.out.println(strings[0]);
        }
 

结果：

​我们可以看到集合的值和原数组的第一个值都被修改了，为什么原数组也会被修改呢？

原因是静态内部类ArrayList的成员变量a使用了final，用于存储集合的数组引用始终被强制指向原有数组。

所以原数组也会被修改。

​那么怎么在不修改原数组的基础上修改集合呢？我们同样可以采取将传入的参数转换为一个ArrayList对象返回的方式。
参考链接：https://blog.csdn.net/qq_51634677/article/details/131223655