Java基础（1）---数组

1. 概念

    数组是有序的元素序列，相同类型的有限的元素的集合。数组的元素存储在一个连续性的内存空间中，并通过索引访问。

     一些零散的知识点：

　　1）HashMap底层采用数组+树/链表结构，是通过元素hashcode的值和数组大小去计算数组下标，然后将元素放到相对应的数组元素里面（链表/树）。通过索引查询数组的时间复杂度为O(1)。

　  2）针对数组，JDK1.8提供了一些并行方法，比如parallelXX；还提供了Spliterator（可分割迭代器）

3.使用范例

    public static void main(String[] args){
        Integer[] a = new Integer[5];//创建数组
        a[0] = 1; a[1] = 2;a[2] = 6;a[3] = 4;a[4] = 7;//设置
//        a[7] = 1;//数组越界，运行时异常
        System.out.println("a数组打印：" + Arrays.toString(a));
        Arrays.parallelPrefix(a, (pre, local) -> pre + local);//当前的元素与前一个元素（有计算过后，那么取计算过后的值）进行操作
        System.out.println("a数组，parallelPrefix操作结果：" + Arrays.toString(a));
        Arrays.sort(a);//null对象会导致排序异常
        Arrays.parallelSort(a);//并行排序，支持大数据量，具体看源码分析
        System.out.println("a数组parallelSort:" + Arrays.toString(a));
        int i = Arrays.binarySearch(a, 9);//有序数组的二分法查找，返回数组下标
        System.out.println("a数组二分法查找9，返回值：" + i);
        int[] c = new int[10];
        Arrays.fill(c, 11);//填充所有数组元素，值为11
        System.out.println("c数组 fill：" + Arrays.toString(c));
        List<Integer> list = Arrays.stream(a)//数组支持流操作
                .distinct()
                .collect(Collectors.toList());//去重
        System.out.println("a数组stream操作去重转list：" + list.toString());
        Integer[] b = Arrays.copyOf(a,8);//数组无法进行扩容，只能通过创建新的数组，将旧的数组复制到新的数组中
        b[6] = 10;b[7] = 9;
        System.out.println("数组扩容，生成新数组b：" + Arrays.toString(b));
        Arrays.setAll(a, x -> x * 10);//函数式编程，对每个元素做赋值操作
        System.out.println("a数组setAll:" + Arrays.toString(a));
        Spliterator<Integer> spliteraror1 = Arrays.spliterator(a);//平行迭代器
        Spliterator<Integer> spliteraror2 = spliteraror1.trySplit();//平行迭代器，将迭代器再切割
        spliteraror1.forEachRemaining( item -> System.out.println("a数组spliteraror1:" + item));
        spliteraror2.forEachRemaining(item -> System.out.println("a数组spliteraror2：" + item));
    }

4.源码分析，针对parallelSort方法

   //排序算法是一种并行排序合并，它将数组分解为子数组，这些子数组本身被排序，然后再进行合并。当子数组长度达到最小粒度时，使用适当的方法对子数组进行排序。
　　//如果指定数组的长度小于最小粒度，则使用适当的方法对其排序。该算法需要一个不大于原始数组大小的工作空间。用于执行任何并行任务。 
   //递归调用方法，分解数组到最小粒度，再进行排序。然后将结果从下往上合并排序。
   //虽然是这么理解，不过还是不懂算法具体实现~~ 详见ArraysParallelSortHelpers
　　public static void parallelSort(int[] a) {
        int n = a.length, p, g;
        if (n <= MIN_ARRAY_SORT_GRAN ||
            (p = ForkJoinPool.getCommonPoolParallelism()) == 1)//如果单核或者数组长度小于2的13次数或者是单核处理器，则采用双枢轴快速排序算法
            DualPivotQuicksort.sort(a, 0, n - 1, null, 0, 0);
        else//否则采用平行排序算法
            new ArraysParallelSortHelpers.FJInt.Sorter
                (null, a, new int[n], 0, n, 0,
                 ((g = n / (p << 2)) <= MIN_ARRAY_SORT_GRAN) ?
                 MIN_ARRAY_SORT_GRAN : g).invoke();
    }