数组转集合问题Arrays.asList()

数组转集合问题Arrays.asList()

1. 源码：

Arrays.class
public static <T> List<T> asList(T... a) {
	//ArrayList为静态内部类
    return new Arrays.ArrayList(a);
}

//内部类
Arrays.ArrayList.class
private static class ArrayList<E> extends AbstractList<E> implements RandomAccess, Serializable {
    private static final long serialVersionUID = -2764017481108945198L;
    private final E[] a;

	//浅拷贝，只是将数据的地址值赋值给ArrayList的属性a
    ArrayList(E[] array) {
        this.a = (Object[])Objects.requireNonNull(array);
    }
    ...
    ...
}

AbstractList.class
public void add(int index, E element) {
    throw new UnsupportedOperationException();
}

public E remove(int index) {
    throw new UnsupportedOperationException();
}

2. 结论：

1. Arrays.asList(arr) 转为的实例化对象为Arrays中的静态内部类ArrayList，该类没有重写add() 、remove() 、clear()方法，不能对List增删，只能查改；
2. Arrays.ArrayList内部类继承了AbstractList抽象类，AbstractList抽象类又实现了List接口，利用多态性，通过List接口接收asList()方法的返回结果，方法调用时，如果Arrays.ArrayList内部类进行了方法重写，则调用该重写方法，否则实际调用的是AbstractList重写List中的方法；
3. 操作转换后的集合，数组也会变化，Arrays中的内部类ArrayList存放的也是数组，转换时进行的浅拷贝，只是将数组的地址值赋值给ArrayList内部类中的属性a；
4. 方法参数arr数组如果使用基本数据类型，则会把它看作是一个整体保存在List底层数组中。

3. 验证代码：

@Test
public void test1(){
    String[] arr = {"小轩","小刘","小王"};
    List<String> asList = Arrays.asList(arr);
	
    //asList.add("aaa"); // 异常：java.lang.UnsupportedOperationException

    //修改集合，数组也会变化，Arrays中的内部类ArrayList存放的也是数据，而且是浅拷贝，只是将数组的地址值赋值给ArrayList中的属性a
    String oldValue = asList.set(1, "123");
    System.out.println("oldvalue:" + oldValue + "，asList:" + asList);
    System.out.println("改变集合影响对应的数组：" + Arrays.toString(arr));

    arr[2] = "中国";
    System.out.println("改变数组影响转换成的集合：" + asList);
    System.out.println(Arrays.toString(arr));


    int[] myArray = {1, 2, 3};
    List myList = Arrays.asList(myArray);
    System.out.println(myList.size());//1
    System.out.println(myList.get(0));
    //System.out.println(myList.get(1));//报错：ArrayIndexOutOfBoundsException
    int[] array = (int[]) myList.get(0);
    System.out.println(array[0]);//1

    //实现转换后能进行增删改查，并且不影响原数组
    String[] arr1 = {"小轩","小刘","小王"};
    ArrayList<String> arrayList = new ArrayList<>(arr1.length);
    Collections.addAll(arrayList, arr1);
    arrayList.add("小王八");

}

基础知识点：一二维数组

public class ArrayTest {

    @Test
    public void test(){
        /**
         * 1.初始化的三种方式
         * 2.长度在数组初始化之后就确定了，不能再改变
         * 3.一维数组元素的默认初始化值：
         * 数组元素是整型：0  浮点型：0.0 char：0或'\u0000'，而非'0'， '0'对应48 boolean型：false  引用数据类型：null
         */
        int[] arr = new int[]{1,2,4};
        int[] arr2 = new int[2];
        //类型推断
        String[] arr3 = {"小轩","小刘"};

        //错误 java.lang.ArrayIndexOutOfBoundsException
        //arr[4] = 5;

        arr2[0] = 11;
        arr2[1] = 22;
        for (int i = 0; i < arr.length; i++) {
            System.out.println(arr[i]);
        }


        /**
         *  1.二维数组初始化的四种方式；
         *  2.一维数组的元素又是一维数组，才构成二维数组；
         *  3.内层一维数组的长度不需要一致；
         *  4.二维数组外层元素为地址值（默认为null），内层默认为初始化值
         */
        int[][] arr4 = new int[3][];
        arr4[0] = arr;
        //System.out.println("外层：" + arr4[1] + "、内层: " + arr4[1][1]); //外层为null ，内层报错

        int[][] arr5 = new int[3][2];
        System.out.println("外层：" + arr5[1] + "、内层: " + arr5[1][1]); //外层为地址值，内层为默认值

        String[][] arr6 = new String[][]{{"小轩"},arr3};

        String[][] arr7 = {{"A","B","C"},arr3};

        System.out.println(Arrays.toString(arr6));

        //获取数组长度
        String[] strs = new String[5];
        strs[1] = "1";
        strs[2] = "2";
        System.out.println(strs.length); // 5
    }
}