Java数组2[Mac+JDK8--＞逆序，数组内部元素奇偶排列，判断升序，二分查找，拷贝，冒泡排序与优化]

缺少Jdk8的朋友点这里[Win+Mac+Linux]提取码：Rvsj

举栗子

/**
     * 数组拷贝共有 4 种方式
     * for
     * Arrays.copyOf(src)
     * System.arraycopy(src, srcPos, dst, dstPos, len);
     * arr.clone(src);克隆产副本，是Object的克隆方法
     * 1.System.arraycopy()速度最快，属于与natve方法[C,C++代码实现]
     * 2.以上4种全是浅拷贝：牵一发动全身
     *
     * @param arr
     * @return
     */
    public static int[] my_copyArray(int[] arr) {
     
        int[] arr_d = new int[arr.length];
        for (int i = 0; i < arr.length; i++) {
     
            arr_d[i] = arr[i];
        }
        return arr_d;
    }

    public static int my_arrayMax(int[] arr) {
     
        int max = arr[0];
        for (int val : arr) {
     
            if (max < val) {
     
                max = val;
            }
        }
        return max;
    }

    /**
     * 二分查找
     *
     * @param arr 要查找的有序序列
     * @param key 在序列中想查找的数字
     * @return
     */
    public static int count = 0;

    public static int my_binarSearch(int[] arr, int key) {
     
        int left = 0;
        int right = arr.length - 1;
        int mid;
        while (left <= right) {
     
            ++count;
            mid = (left + right) >>> 2;
            if (arr[mid] < key) {
     
                left = mid + 1;
            } else if (arr[mid] > key) {
     
                right = mid - 1;
            } else {
     
                return mid;
            }
        }
        return -1;
    }

    /**
     * Arrays工具类中常见方法类介绍
     * fill
     * sort
     * toString
     * binarySearch
     *
     * @param
     */

    //判断某个数组是否升序
    public static boolean my_isUP1(int[] arr) {
     
        int[] ret = Arrays.copyOf(arr, arr.length);
        Arrays.sort(ret);
        if (Arrays.equals(ret, arr)) {
     
            return true;
        } else {
     
            return false;
        }
    }

    public static boolean my_isUP2(int[] arr) {
     
        for (int i = 0; i < arr.length; i++) {
     
            if (arr[i] > arr[i + 1]) {
     
                return false;
            }
        }
        return true;
    }

    public static void my_bubbleSort(int[] arr) {
     
        int tmp, flag;
        for (int i = 0; i < arr.length; i++) {
     
            flag = 1;
            for (int j = 0; j < i - 1; j++) {
     
                if (arr[j] > arr[j + 1]) {
     
                    tmp = arr[j];
                    arr[j] = arr[j + 1];
                    arr[j + 1] = tmp;
                    flag = 0;
                }
                if (flag == 1) {
     
                    break;
                }
            }
        }
    }

    public static int[] my_reverse_1(int[] arr) {
     
        int[] tmp = new int[arr.length];
        for (int i = 0; i < arr.length; i++) {
     
            tmp[i] = arr[arr.length - 1 - i];
        }
        return tmp;
    }

    public static void my_reverse_2(int[] arr) {
     
        int left = 0;
        int right = arr.length - 1;
        int tmp;
        while (left < right) {
     
            tmp = arr[left];
            arr[left] = arr[right];
            arr[right] = tmp;
            ++left;
            --right;
        }
    }

    public static void my_move(int[] arr) {
     
        int left = 0;
        int right = arr.length - 1;
        int tmp;
        while (left < right) {
     
            while ((left < right) && (arr[left] % 2 == 0)) {
     
                ++left;
            }
            while ((left < right) && (arr[right] % 2 == 1)) {
     
                --right;
            }
            if (left<right) {
     
                tmp = arr[left];
                arr[left] = arr[right];
                arr[right] = tmp;
            }
        }
    }

总结

1. 数组的拷贝有四种：
   src：源数组；dst：目标数组
   srcPos：源起始下标；dstPos：目标起始下标
   len：需要目标数组拷贝多少源数组的长度
2. 1⃣️利用for循环自己编写一个函数

public static int[] my_copyArray(int[] arr) {
     
        int[] arr_d = new int[arr.length];
        for (int i = 0; i < arr.length; i++) {
     
            arr_d[i] = arr[i];
        }
        return arr_d;
    }

2⃣️Arrays.copyOf(src)
3⃣️System.arraycopy(src, srcPos, dst, dstPos, len);
4⃣️arr.clone(src);克隆产副本，是Object的克隆方法
以上四种方法全是浅拷贝

3. 二分查找函数[my_binarySearch]会编写，冒泡排序[bubbleSort]会优化
4. Arrays函数类方法常用：
   1⃣️fill填充

/*
src：初始下标
fromIndex：起始下标
toIndex：终止下标
val：被填充的数据
*/
Arrays.fill(src, val);
Arrays.fill(src, fromIndex, toIndex, val);

2⃣️sort排序

//参数直接传入数组名称
Arrays.sort(int[] arr);//无返回值

3⃣️toString

//将数组转换为字符串打印
System.out.println(Arrays.toString(int[] arr))

4⃣️binarySearch

//Java自带的二分查找函数int[] arr：数组名；int key：要查找的数值
Arrays.binarySearch(int[] arr, int key);

4. 数组逆序掌握[my_reverse函数]，函数内部元素的升降序[my_isUP]
5. 数组内部奇数偶数以前以后[my_move]：偶数在前奇数在后的排列方式重新整合数组内部元素