第九节 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]+"||");
}
}
}