7. 数组筑基

自己实现ToString()方法

无返回值的

    /**
     * 无返回值的
     * @return
     */
    public static void myToString1(int[] array) {
        if (array == null) {
            System.out.println("null");
        }
        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 void main1(String[] args) {
        int[] array = {1,2,3,4,5};
        myToString(array);
    }

有返回值的

    /**
     * 有返回值的
     * @param array
     * @return
     */
    public static String myToString(int[] array) {
        if (array == null) {
            return null;
        }
        String ret = "[";
        for (int i = 0; i < array.length; i++) {
            ret += array[i];
           if (i != array.length-1) {
               ret += ", ";
           }
        }
        ret+="]";
        return ret;
    }
    public static void main(String[] args) {
        int[] array = {1,2,3,4,5};
        String ret = myToString(array);
        System.out.println(ret);
    }

别忘记考虑空数组的情况！！！

数组的拷贝

拷贝也就是英文当中的copy（抄）的意思，更加通俗来讲就是我们常用的Ctrl + C 和 Ctrl + v

    /**
     * 拷贝数组
     * @param args
     */
    public static void main(String[] args) {
        int[] array = {1,2,3,4,5};
//        int[] array = null;
        if (array != null) {
            int[] copy = new int[array.length];
            for (int i = 0; i < array.length; i++) {
                copy[i] = array[i];
            }
            System.out.println("array 数组："+Arrays.toString(array));
            System.out.println("copy 数组："+Arrays.toString(copy));
        }else {
            System.out.println("null");
        }
    }

拷贝Arrays.copyOf()(最常用)

当然Java当中也有专门为拷贝提供的工具类，这个工具类就是Arrays.copyOf()

    public static void main(String[] args) {
        int[] array = {1,2,3,4,5};
        int[] copy = Arrays.copyOf(array, array.length);
        System.out.println("array数组："+Arrays.toString(array));
        System.out.println("copy数组："+Arrays.toString(copy));
    }

拷贝时扩容

拷贝一部分的值Arrays.copyOfRange()

System.arraycopy()

      1、 是你要拷贝的数组
      2、 你要从这个数组的哪个下标开始拷贝
      3、 你要拷贝到那个数组
      4、 你要拷贝到这个数组的哪个位置开始
      5、 你要拷贝多大

    public static void main(String[] args) {
        int[] array = {1,2,3,4,5};
        int[] copy = new int[array.length];
        /**
         * 1、 是你要拷贝的数组
         * 2、 你要从这个数组的哪个下标开始拷贝
         * 3、 你要拷贝到那个数组
         * 4、 你要拷贝到这个数组的哪个位置开始
         * 5、 你要拷贝多大
         */
        System.arraycopy(array,0,copy,0,array.length);
        System.out.println("array数组："+Arrays.toString(array));
        System.out.println("copy数组："+Arrays.toString(copy));
    }

.clone()方法

    public static void main(String[] args) {
        int[] array = {1,2,3,4,5};
        int[] copy = array.clone();
        System.out.println("array数组："+Arrays.toString(array));
        System.out.println("copy数组："+Arrays.toString(copy));
    }

看似拷贝，实则撒也不是

    public static void main(String[] args) {
        int[] array = {1,2,3,4,5};
        int[] copy = array;
        System.out.println("array数组："+Arrays.toString(array));
        System.out.println("copy数组："+Arrays.toString(copy));
    }

这段代码仅仅只是将array数组的地址给到了copy数组，并没有产生新的对象，所以不能称为拷贝

深拷贝和浅拷贝

深拷贝

如果我们能够做到，修改拷贝之后的数组，不影响原来的数组，就说这个拷贝是深拷贝

    public static void main(String[] args) {
        int[] array = new int[]{1,2,3,4,5};
        int[] copy =new int[array.length];
        System.out.println("========拷贝前========");
        System.out.println("array数组："+Arrays.toString(array));
        System.out.println("copy数组："+Arrays.toString(copy));
        for (int i = 0; i < array.length; i++) {
            copy[i] = array[i];
        }
        copy[0] = 99;
        System.out.println("========拷贝后========");
        System.out.println("array数组："+Arrays.toString(array));
        System.out.println("copy数组："+Arrays.toString(copy));
    }

浅拷贝

如果我们能够做到，修改拷贝之后的数组，影响到了原来的数组，就说这个拷贝是浅拷贝

求数组中的平均值

    public static double avg(int[] array) {
        int sum = 0;
        for (int i = 0; i < array.length; i++) {
            sum += array[i];
        }
        return sum*1.0/array.length;
    }
    public static void main(String[] args) {
        int[] array = new int[]{1,2,3,4,5};
        double ret = avg(array);
        System.out.println(ret);
    }

查找数组中某个值的下标

方法一：

    public static int findKey(int[] array, int data) {
        for (int i = 0; i < array.length; i++) {
            if (array[i] == data) {
                return i;
            }
        }
        return -1;
    }
    public static void main(String[] args) {
        int[] array = new int[]{1,2,3,4,5};
        int ret = findKey(array,3);
        if (ret != -1) {
            System.out.println("找到了下标是"+ret);
        }else {
            System.out.println("没有找到");
        }
    }

方法二：

二分查找

前提：所给的数组必须是有序的

    /**
     * 二分查找
     * 前提：所给的数组必须是有序的
     * @param array
     * @param key
     * @return
     */
    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) {
                left = mid + 1;
            }else if (array[mid] == key) {
                return mid;
            }else {
                right = mid -1;
            }
        }
        return -1;
    }

    public static void main(String[] args) {
        int[] array = new int[]{1,2,3,4,5};
        int ret = binarySearch(array,4);
        System.out.println(ret);
    }

Java中的二分查找Arrays.binarySearch()

当然Java中也提供了二分查找

具体还有很多不一样参数的，大家可以下来自己看看，阿漓就不一一介绍了

这时候估计就有很多想问问题的小明了，我们经常使用的数据并不总是排好序的，那么这个时候怎么办？
别急！Java当中也有排序的函数

排序函数Arrays.sort()

    public static void main(String[] args) {
        int[] array = {2,5,1,4,3};
        Arrays.sort(array);
        System.out.println(Arrays.toString(array));
    }

冒泡排序

    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 tmp = array[j];
                    array[j] = array[j+1];
                    array[j+1] = tmp;
                }
            }
        }
    }

    public static void main(String[] args) {
        int[] array = {10,5,3,7,6};
        bubbleSort(array);
        System.out.println(Arrays.toString(array));
    }

优化代码

    public static void bubbleSort(int[] array) {
        for (int i = 0; i < array.length - 1; i++) {
            boolean flg = false;
            for (int j = 0; j < array.length - 1 - i; j++) {
                if (array[j] > array[j+1]) {
                    int tmp = array[j];
                    array[j] = array[j+1];
                    array[j+1] = tmp;
                    flg = true;
                }
            }
            // 进入的条件是循环一遍后未发生交换
            if (flg == false) {
                return;
            }
        }
    }

    public static void main(String[] args) {
        int[] array = {10,5,3,7,6};
        bubbleSort(array);
        System.out.println(Arrays.toString(array));
    }

数组的逆置

第一个与最后一个交换，第二个与倒数第二个交换

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

    public static void main(String[] args) {
        int[] array = {10,5,7,6};
        reverse(array);
        System.out.println(Arrays.toString(array));
    }

Arrays.fill() 填充数组

Arrays.fill() 还可以添加其他的参数，大家可以下来查一查一些好玩的函数

二维数组

二维数组的定义方式

    public static void main(String[] args) {
        int[][] array1 = {{1,2,3},{4,5,6}};
        int[][] array2 = new int[2][3];
        int[][] array3 = new int[][]{{1,2,3},{4,5,6}};
    }

二维数组的三种遍历方式

    public static void main(String[] args) {
        int[][] array = {{1,2,3},{4,5,6}};
        System.out.println("=========for=========");
        for (int i = 0; i < array.length; i++) {
            for (int j = 0; j < array[i].length; j++) {
                System.out.print(array[i][j]+" ");
            }
            System.out.println();
        }
        System.out.println("==========foreach===========");
        for (int[] tmp:array) {
            for (int x:tmp) {
                System.out.print(x+" ");
            }
            System.out.println();
        }
        System.out.println("==========Arrays.deepToString()=========");
        System.out.println(Arrays.deepToString(array));
    }

定义并遍历一个第一行有3个0第二行有5个0的二维数组

    public static void main(String[] args) {
        int[][] array = new int[2][];
        array[0] = new int[3];
        array[1] = new int[5];
        System.out.println(Arrays.deepToString(array));
    }

今天的分享就到此结束啦！本篇文章参与了国庆活动希望各位友友能多多支持，点点赞，您的点赞是对我莫大的支持！

2022年10月3日18:01:59