Java06-3 Arrays：数组的工具类

构造方法是私有的，无法创建Arrays对象，可以使用的方法都是静态的

举例说明：
int[] arr = {1,2,3,4,5};

一、数组的拷贝
1.1 Arrays.copyOf(original, newLength);
     1.被拷贝的数组    2.新数组长度    3.返回值就是新数组
      int[] newArr = Arrays.copyOf(arr, arr.length);
      String str = Arrays.toString(newArr);
      System.out.println(str);     //[1, 2, 3, 4, 5]    
1.2 System.arraycopy(src, srcPos, dest, destPos, length);
      1.被拷贝的数组    源数组
      2.源数组中的某个下标，从此下标处开始拷贝
      3.新数组
      4.新数组中的某个下标，从此下标处开始放置拷贝过来的元素
      5.要拷贝的元素个数
      int[] test = new int[arr.length + 1];
      // arr： 2    3    ...    length-1
      // arr： 1    2
      System.arraycopy(arr, 2, test, 1, arr.length - 2);    //元素个数[2 arr.length-1] = arr.length-1 - 2 + 1
      System.out.println(Arrays.toString(test));    //[0, 3, 4, 5, 0, 0]
1.3
      arr = new int[]{10,20,1,3,4,6,100};
      newArr = Arrays.copyOfRange(arr, 2, 6);    //[1, 3, 4, 6]
      System.out.println(Arrays.toString(newArr));

//拷贝指定范围内的元素（左包含，右不包含）
public static int[] copyofRange(int[] array, int from, int to) {
    //1.数组长度不能为0；数组不能为null
    if(array == null) {
        return null;
    }
    //2.to要大于from；to和from需要在array的下标范围内；from和to不能为负数
    //判断from和to-1在array范围内
    //to > from并且from的最小值是0，所以to-1最小也是0，to最小值为0
    if(to <= from || from < 0 || to -1 >= array.length) {
        return null;
    }
    //创建新数组
    int[] newArr = new int[to - from];  //（[to - from]联系上多思考）
    /*
     *    array        from    from+1    to-1        
     *    newArr      0      1              length-1
     */
    for(int i = from; i < to; i++) {
        newArr[i - from] = array[i];
    }
    return newArr;
}

二、将数组转换为字符串的形式，打印时候方便
      String str = Arrays.toString(newArr);
      System.out.println(str);     //[1, 2, 3, 4, 5]    
    
三、数组排序（此处只针对升序)
      Arrays.sort(arr);
      System.out.println(Arrays.toString(arr));    //[1, 3, 4, 6, 10, 20, 100]
1.指定范围内的元素排序    (包含起始位置，不包含结束位置)
     Arrays.sort(arr,1,4);
     System.out.println(Arrays.toString(arr));    //[10, 1, 3, 20, 4, 6, 100]
2.二分查找（升序）
      int index = Arrays.binarySearch(arr, 4);
      System.out.println(index);    //[1, 3, 4, 6, 10, 20, 100]    index=2
3.指定范围内查找  （左包含，右不包含）
      index = Arrays.binarySearch(arr, 1, 4, 6);    //从1,2,3里面找6的下标
      System.out.println(index);    //index=3

eg1：升/降序的冒泡
public static void bubbleSort(int[] array, boolean isAsc) {
    if(array == null || array.length == 0 || array.length == 1) {
        return;
    }
    //升/降序的冒泡
    for(int i = 0; i < array.length; i++) {
        for(int j = 0; j < array.length - 1 - i; j++) {
            boolean condition = isAsc ? (array[j] > array[j + 1]) : (array[j] < array[j + 1]);
            if(condition) {
                int temp = array[j];
                array[j] = array[j + 1];
                array[j + 1] = temp;
            }
        }        
    }
}

eg2：查找有序数组中，是否存在某个元素
public static int binarySearch(int[] array, int key) {
    int left = 0;
    int right = array.length - 1;
    while(left <= right) {
        int mid = (left + right) / 2;
        if(array[mid] == key) {
            return mid;
        }else if(array[mid] < key) {
            left = mid + 1;
        }else {
            right = mid - 1;
        }
    }
    return -(left + 1);
}