第九节 java数组的介绍，数组定义，数组排序，Arrays类静态方法使用,以及源码解析

/**
 * Created by Administrator on 2017/12/3.

 *  数组的基本操作
 */
public class base06 {
    public static void main(String[] args) {
        String [] a;//定义一个数组，但是还未初始化（分配内存）
        String [] b=new String[6];//定义一个指定大小的数组，数组下标从0开始
        //b[6]="a";//ArrayIndexOutOfBoundsException  数组越界

        String [] c={"1","2","4"};//定义并且初始化数组

        int [] intArray=new int[100];
        for (int i=0;i<100;i++){
            intArray[i]=i;
        }
        //根据数据的下标，向数组添加元素


        for (int i=0;i<intArray.length;i++){
            System.out.println(intArray[i]);
        }
        //循环输出数组，length为数组的属性，代表数组的长度


        //Arrays.copyOf 将数组拷贝带新数组中，第二个参数为拷贝的长度
        int [] copyArray= Arrays.copyOf(intArray,intArray.length);
        //此时将打印intArray数组中所有的数
        printArray(copyArray);

        /**
         * 此时只打印 0-4 这5个数，因为指定了拷贝长度
         *
         * 源码来看：新建了一个指定长度的数组，然后调用System.arraycopy进行拷贝
         * public static int[] copyOf(int[] original, int newLength) {
         *      int[] copy = new int[newLength];
         *       System.arraycopy(original, 0, copy, 0,
         *       Math.min(original.length, newLength));
         *      return copy;
         *   }
         */
        int [] copyArray1= Arrays.copyOf(intArray,5);
        printArray(copyArray1);


        /**
         * 定义一个int类型的数组，大小为100
         * 循环向数组中添加最大值为100的整数
         */
        int [] intArraySort=new int[10];
        Random rd=new Random();
        for (int i=0;i<10;i++){
            intArraySort[i]=rd.nextInt(100);
        }

        /**
         * 第一次打印为向数组中添加的数
         * 第二次打印为排序好数组
         *
         * 源码：调用Arrays的静态方法进行排序，排序算法为：快速排序，后续会讲解
         *     public static void sort(int[] a) {
         *      DualPivotQuicksort.sort(a);
         *      }
         */
        printArray(intArraySort);//60||68||36||79||39||75||54||59||86||70||
        Arrays.sort(intArraySort);
        printArray(intArraySort);//36||39||54||59||60||68||70||75||79||86||

        /**
         * [3, 8, 21, 29, 47, 54, 56, 81, 94, 96]
         * 返回一个这种形式的数组
         *如下源码可知，就是利用StringBuilder进行的循环拼接
             * public static String toString(int[] a) {
             *if (a == null)
             *return "null";
             *int iMax = a.length - 1;
             *if (iMax == -1)
             *return "[]";

             *StringBuilder b = new StringBuilder();
             *b.append('[');
             *for (int i = 0; ; i++) {
             *b.append(a[i]);
             *if (i == iMax)
             *return b.append(']').toString();
             *b.append(", ");
         *}
         *}
         */
        System.out.println(Arrays.toString(intArraySort));

        /**
         * Arrays.binarySearch 方法是针对有序数组进行二分法查找，如果找到则返回对应下标，否则返回负数
         * 查看源码发现：典型的二分法计算，先查找中间值，比较中间值和目标值的大小
         *
             * private static int binarySearch0(int[] a, int fromIndex, int toIndex,
         *    int key) {
         *    int low = fromIndex;
         *    int high = toIndex - 1;

         *    while (low <= high) {
         *    int mid = (low + high) >>> 1;
         *    int midVal = a[mid];

         *    if (midVal < key)
         *    low = mid + 1;
         *    else if (midVal > key)
         *   high = mid - 1;
         *   else
         *   return mid; // key found
         *   }
         *   return -(low + 1);  // key not found.
         *   }
         *
         */
        int [] aArray={10,7,1,2,4,9,8,10};
        System.out.println(Arrays.binarySearch(aArray,7));//结果：-6
        Arrays.sort(aArray);
        System.out.println(Arrays.binarySearch(aArray,7));//结果：3  返回下标


        /**
         * 判断两个数组是否相等
         * 查看源码发现如下：1.首先判断数组内存地址是否相等，如果相等，那么a和a2指向的为同一个数组，则相等
         * 2.如果其中一个数组为null,或者数组长度不相等，则不相等
         * 3.循环对比数组中的每一个值进行判断
             * public static boolean equals(int[] a, int[] a2) {
         *     if (a==a2)
         *     return true;
         *    if (a==null || a2==null)
         *    return false;

         *    int length = a.length;
         *     if (a2.length != length)
         *    return false;

         *    for (int i=0; i<length; i++)
         *   if (a[i] != a2[i])
         *    return false;

         *     return true;
         *    }
         */
        System.out.println(Arrays.equals(aArray,intArraySort));





    }

    /**
     *打印数组方法
     */
    public static void printArray(int [] args) {
        System.out.println();
        for (int i=0;i<args.length;i++){
            System.out.print(args[i]+"||");
        }
    }
}