数组（如果失眠了就拿出来看看）

数组所有操作实现，供自己闲时手机复习使用！

public class Demo {
    public static void main(String[] args) {
        int[] array1 = {19,45,38,29,2,100,190};



//        System.out.println(binarySearch2(array1, 0, array1.length, 3));
//        int[] array2 = new int[array1.length];
//        copyArray(array1, array2);
//        toString(array1);
    }
    


    /*数组拷贝*/
    public static void copyArray(int[] array1, int[] array2) {
        for (int i = 0; i < array1.length; i++) {
            array2[i] = array1[i];
        }
        toString(array2);
    }

    /*数组转字符串*/
    public static void toString(int[] array) {
        System.out.print("[");
        for (int i = 0; i < array.length; i++) {
            System.out.print(array[i]);
            if (i != array.length - 1) {
                System.out.print(", ");
            }
        }
        System.out.println("]");
    }

    /*求数组中最大元素*/
    public static int maxOfArray(int[] array) {
        int max = array[0];
        for (int i = 0; i < array.length; i++) {
            if (max < array[i]) {
                max = array[i];
            }
        }
        return max;
    }

    /*求数组中最小元素*/
    public static int minOfArray(int[] array) {
        int min = array[0];
        for (int i = 0; i < array.length; i++) {
            if (min > array[i]) {
                min = array[i];
            }
        }
        return min;
    }

    /*求数组元素平均值*/
    public static double avgOfArray(int[] array) {
        double avg = 0.0;
        int sum = 0;
        for (int i = 0; i < array.length; i++) {
            sum += array[i];
        }
        avg = (double) sum / (double) array.length;
        return avg;
    }

    /*数组的逆置*/
    public static void reverseArray(int[] array) {
        int i = 0;
        int j = array.length - 1;
        while (i < j) {
            int tmp = array[i];
            array[i] = array[j];
            array[j] = tmp;
            i++;
            j--;
        }
    }

    
    
    
    /*数组中的二分查找（非递归）*/
    public static int binarySearch(int[] array, int key) {
        int left = 0;
        int right = array.length - 1;
        int mid = left + right / 2;
        while (left <= right) {
            if (array[mid] < key) {
                left = mid + 1;
            } else if (array[mid] > key) {
                right = mid - 1;
            } else {
                return mid;
            }
        }
        return -1;
    }

    /*数组的二分查找（递归）*/
    public static int binarySearch2(int[] array, int left, int right, int key) {
        if (right < left) {
            return -1;
        }
        int mid = (left + right) / 2;
        if (left < right) {
            if (array[mid] < key) {
                return binarySearch2(array, mid + 1, right, key);
            } else if (array[mid] > key) {
                return binarySearch2(array, left, mid - 1, key);
            } else {
                return mid;
            }
        }
        return -1;
    }

    /*将数组中偶数放在奇数前面*/
    public static void fun1(int[] array) {
        int i = 0;
        int j = array.length - 1;
        while (i != j) {
            while (i < j && array[i] % 2 != 0) {
                i++;
            }
            while (i < j && array[j] % 2 == 0) {
                j--;
            }
            if (i != j) {
                int tmp = array[i];
                array[i] = array[j];
                array[j] = tmp;
            }
        }
    }

    
    
    /*对数组进行冒泡排序（粗略版本） Arrays.sort*/
    public static void bubbleSort(int[] array) {
        //趟数
        for (int i = 0; i < array.length - 1; i++) {
            //每一趟的次数
            for (int j = 0; j < array.length - 1 - i; j++) {
                if (array[j] > array[j + 1]) {
                    int max = array[j];
                    array[j] = array[j + 1];
                    array[j + 1] = max;
                }
            }
        }
    }
    
    

    /*对数组进行冒泡排序（优化版本）*/
    public static void bubbleSort1(int[] array){
        boolean flag = true;
        int count = 0;
        //趟数
        for (int i = 0; i < array.length - 1; i++) {
            for(int j = 0; j < array.length - 1 - i;j++){
                count++;
                if (array[j] > array[j + 1]) {
                    int max = array[j];
                    array[j] = array[j + 1];
                    array[j + 1] = max;
                    flag = false;
                }
            }
            if(flag){
                break;
            }
        }
        System.out.println(count);
    }
}

数组的拷贝操作(共有四种方式):

1.for();通过遍历赋值;

2.System.arraycopy();底层是C++实现的native方法,速度较快;int[ ]ret = Arrays.copyOf();

3.Arrays.copyOf();会返回新的对象,底层是System.arraycopy();

4.clone();会返回新的对象,int[ ]array2 = array.clone();

需要注意的是:

1.对于简单/基本类型进行拷贝,深拷贝(将地址和值一起拿走了);

2.对于引用类型进行拷贝,浅拷贝(没有把引用指向的对象一起拿走,仅仅只是拷贝了一份引用而已,还是指向了原来的对象)