Java中的数组

1.在Java中数组是一个对象。
测试代码如下：

public class TestArray {
    public static void main(String[] args) {
        TestArray testArray = new TestArray();
        testArray.testSuperClass();
    }

    /*
    * 在Java中数组是一个对象
    * ==> [代表了数组的维度，一个[表示一维，两个[表示二维。可以简单的说数组的类名由若干个'['和数组元素类型的内部名称组成。
    * */
    private void testSuperClass(){
        int[] array = new int[3];
        System.out.println(array.getClass().getSuperclass());
        System.out.println(array.getClass().getName());
        /*上面一段输出
            class java.lang.Object
            [I
        */

        int[][] douArray = new int[2][2];
        System.out.println(douArray.getClass().getSuperclass());
        System.out.println(douArray.getClass().getName());
        /*上面一段输出
            class java.lang.Object
            [[I
        */

    }
}

2.分配给数组的空间是连续的（与链表作对比）
数组的使用：

		int a[] = new int[2];    //默认为0,如果是引用数据类型就为null =》其实分配空间和赋值是一起进行的
        int b[] = new int[] {1,2,3,4,5};    
        int c[] = {1,2,3,4,5};

3.数组的性能
在java中，数组是一种效率相对较高的存储和随机访问对象引用序列的方式。
虽然数组没有list和set使用方便，但是它具有一定的速度的优势。
下面是测试代码（jdk1.8）：

public class TestArray2 {

    public static void main(String[] args) {
        int times = 100000;  //相加次数

        int sum1 = 0;
        int sum2 = 0;
        int size = 10;

        int[] arr = {1,1,1,1,1,1,1,1,1,1};
        long start = System.currentTimeMillis();
        for (int i = 0; i < times; i++) {
            sum1 += arr[i % size];
        }
        System.out.println(sum1+"数组累加花费时间 : " + (System.currentTimeMillis() - start));


        List<Integer> list = new ArrayList<>();
        for (int i = 0; i < size; i++) {
            list.add(i, 1);
        }

        long start1 = System.currentTimeMillis();
        for (int i = 0; i < times; i++) {
            sum2 += list.get(i % size);
        }
        System.out.println(sum2+"list累加花费时间 : " + (System.currentTimeMillis() - start1));

    }
}

相加次数是10万次
数组累加花费时间 : 2
list累加花费时间 : 3

相加次数是100万次
数组累加花费时间 : 6
list累加花费时间 : 7

相加次数是1000万次
数组累加花费时间 : 32
list累加花费时间 : 38

相加次数是1亿次
数组累加花费时间 : 336
累加花费时间 : 367

相加次数是10亿次
数组累加花费时间 : 2850
累加花费时间 : 3488

上面我们可以看出，数据量越大，优势就会越明显。但是优势似乎没有想象中的大。。。

5.List通过数组实现扩容（具体见List章节）
6.数组复制误区
我们看一段代码，如下：

public class TestArrayCopy {

    public static void main(String[] args) {
        Person student = new Person("Jack");

        Person[] classA = new Person[]{student};
        Person[] classB = Arrays.copyOf(classA, classA.length);

        System.out.println(classA[0].toString());
        System.out.println(classB[0].toString());

        classA[0].setName("Rose");
        
        System.out.println(classA[0].toString());
        System.out.println(classB[0].toString());
    }
}

class Person {
    private String name;

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public Person(String name) {
        this.name = name;
    }

    @Override
    public String toString() {
        return "Person{" +
                "name='" + name + '\'' +
                '}';
    }
}

输出：
Person{name=‘Jack’}
Person{name=‘Jack’}
Person{name=‘Rose’}
Person{name=‘Rose’}
这是由于浅拷贝引起的问题，在一处改变了某个对象，导致所有指向该对象的都发生了改变。
结论：通过Arrays.copyOf()方法产生的数组是一个浅拷贝。

7.数组转换成List
测试代码：

public class TestArray2List {

    public static void main(String[] args) {
        int[] arr1 = new int[]{1,2,3,4,5};
        List list = Arrays.asList(arr1);
        System.out.println("list长度:"+list.size());

        Integer[] arr2  = new Integer[]{1,2,3,4,5};
        List<Integer> list2 = Arrays.asList(arr2);
        System.out.println("list2长度:"+list2.size());
    }
}

输出：
list长度:1
list2长度:5

为什么会不同？这里引用（https://www.cnblogs.com/chenssy/p/3466092.html）的说法：

public static <T> List<T> asList(T... a) {
        return new ArrayList<T>(a);
    }

这个参数:T…a，这个参数是一个泛型的变长参数，我们知道基本数据类型是不可能泛型化的，也是就说8个基本数据类型是不可作为泛型参数的，但是为什么编译器没有报错呢？这是因为在java中，数组会当做一个对象来处理，它是可以泛型的，所以我们的程序是把一个int型的数组作为了T的类型，所以在转换之后List中就只会存在一个类型为int数组的元素了。
所以我们这样的程序System.out.println(datas.equals(list.get(0)));输出结果肯定是true

继续测试，如果我们在下面加一行代码：

public class TestArray2List {

    public static void main(String[] args) {
        int[] arr1 = new int[]{1,2,3,4,5};
        List list = Arrays.asList(arr1);
        System.out.println("list长度:"+list.size());

        Integer[] arr2  = new Integer[]{1,2,3,4,5};
        List<Integer> list2 = Arrays.asList(arr2);
        System.out.println("list2长度:"+list2.size());

        list2.add(6);
    }
}

输出：
list长度:1
list2长度:5
Exception in thread “main” java.lang.UnsupportedOperationException
at java.util.AbstractList.add(AbstractList.java:148)
at java.util.AbstractList.add(AbstractList.java:108)
at test.TestArray.TestArray2List.main(TestArray2List.java:38)
意味着add方法不可用！！！
还是上面的那段代码：

    public static <T> List<T> asList(T... a) {
        return new ArrayList<>(a);
    }

这里是直接返回一个ArrayList对象返回，但是注意这个ArrayList并不是java.util.ArrayList,而是Arrays工具类的一个内部类。

    private static class ArrayList<E> extends AbstractList<E>
        implements RandomAccess, java.io.Serializable
    {
        private static final long serialVersionUID = -2764017481108945198L;
        private final E[] a;

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

。。。
    }

但是这个内部类并没有提供add()方法，那么只能调用父类的：

    public boolean add(E e) {
        add(size(), e);
        return true;
    }
    
    public void add(int index, E element) {
        throw new UnsupportedOperationException();
    }

这里父类仅仅只是提供了方法，方法的具体实现却没有，所以具体的实现需要子类自己来提供，但是非常遗憾
这个内部类ArrayList并没有提供add的实现方法。

在内部类ArrayList中，它主要提供了如下几个方法：
1、size：元素数量
2、toArray：转换为数组，实现了数组的浅拷贝。
3、get：获得指定元素。
4、contains：是否包含某元素。

图示如下：

结论：asList返回的是一个长度不可变的列表。数组是多长，转换成的列表是多长，我们是无法通过add、remove来增加或者减少其长度的。