数组的理解

数组

定义：数组可以存放多个同一类型的数据。 数组也是一种数据类型， 是引用类型，数组在赋值前要初始化容量，数组在初始化时，会有一个默认值，0或者null，数组下标不能越界。

数组的特性

• 数组一旦被创建，长度不能被改变。
• 数组中的每一个下标不能存储重复的值，会被覆盖
• 数组的下标默认从0开始，
• 数组中最后一个元素为 length-1
• 数组中可以时基本数据类型，也可以时引用数据类型

数组遍历

1、通过for循环遍历数组中的每一个值

	/**
     * @return void
     * @Author xw
     * @Description 测试for循环
     * @Date 13:12 2021/8/31
     * @Param []
     **/
    private static void testFor() {
        int[] array = new int[]{1, 2, 3, 45, 5};
        for (int i = 0; i < array.length; i++) {
            System.out.println(array[i]);
        }
    }

2、使用while循环遍历

	/**
     * @return void
     * @Author xw
     * @Description 测试while循环
     * @Date 13:13 2021/8/31
     * @Param []
     **/
    private static void testWhile() {
        int[] array = new int[]{1, 2, 3, 45, 5};
        int i = 0;
        while (i < array.length) {
            System.out.println(array[i]);
            i++;
        }
    }

数组中元素的查找

	/**
     * @return void
     * @Author xw
     * @Description 测试寻找数组中的一个值
     * @Date 13:14 2021/8/31
     * @Param []
     **/
    private static void findOne() {
        int[] array = new int[]{1, 2, 3, 45, 5};
        int i = 0;
        int tableIndex = -1;
        while (i < array.length) {
            if (45 == array[i]) {
                tableIndex = i;
                System.out.println(tableIndex);
            }
            i++;
        }
    }

数组中元素的极值

1、查找数组中的最大值

	/**
     * @return void
     * @Author xw
     * @Description 最大值
     * @Date 13:20 2021/8/31
     * @Param []
     **/
    private static void test02() {
        int[] array = new int[]{1, 2, 3, 45, 5};
        int maxIndex = 0;
        int i = 1;
        while (i < array.length) {
            if (array[i] > array[maxIndex]) {
                maxIndex = i;
            }
            i++;
        }
        System.out.println("maxIndex = " + maxIndex);
    }

2、查找数组中的最小值

	/**
     * @return void
     * @Author xw
     * @Description 找出最小值
     * @Date 14:23 2021/8/31
     * @Param []
     **/
    private static void findLow() {
        int[] array = new int[]{3, 1, 2, 45, 5};
        int minIndex = 0;
        for (int i = 0; i < array.length; i++) {
            if (array[i] < array[minIndex]) {
                minIndex = i;
                break;
            }
        }
        System.out.println(array[minIndex]);
    }

数组中值的交换

	/**
     * @return void
     * @Author xw
     * @Description 交换变量的值
     * @Date 13:29 2021/8/31
     * @Param []
     **/
    public static void test03() {
        int[] array = new int[]{1, 2, 3, 45, 5};
        // 使用临时变量保存值
        int temp = array[0];
        array[0] = array[1];
        array[1] = temp;
        System.out.println("array = " + Arrays.toString(array));
    }

数组的扩容

1、数组的扩容，可以声明一个更大的数组，将旧数组的的值，拷贝到新数组中，将引用指向新的数组

	/**
     * @return void
     * @Author xw
     * @Description 数组的扩容
     * @Date 13:42 2021/8/31
     * @Param []
     **/
    private static void test05() {
        int[] array = new int[]{1, 2, 3};

        int[] temp = new int[6];
        for (int i = 0; i < array.length; i++) {
            temp[i] = array[i];
        }
        // 更改数组的指向
        array = temp;
        for (int i = 0; i < array.length; i++) {
            if (temp[i] == 0) {
                temp[i] = 5;
            }
            System.out.println(temp[i]);
            System.out.println("====================");
            System.out.println(array[i]);
        }
    }

数组的反转

1、数组的反转，就是将数组中最后一个元素，替换成第一个元素

	/**
     * @return void
     * @Author xw
     * @Description 数组的反转
     * @Date 13:51 2021/8/31
     * @Param []
     **/
    private static void test06() {
        int[] array = new int[]{2, 3, 4};
        int[] temp = new int[array.length];

        for (int i = array.length - 1; i >= 0; i--) {
            temp[i] = array[array.length - 1 - i];
        }
        // 更改指向
        array = temp;

        for (int i = 0; i < array.length; i++) {
            System.out.println(temp[i]);
        }
    }

2、折半反序
上面操作，需要创建新的数组，还需要依次遍历每一个，换种操作，可以折半操作，将数组进行分半，将最后面的赋值给第一个，提高了效率。

	/**
     * <简述> 数组的反转
     * <详细描述>
     * @author xw
     * @return void
     */
    private static void test02() {
        int[] array = {1, 2, 3, 4, 5};

        for (int i = 0; i < array.length / 2; i++) {
            int temp = array[i];
            array[i] = array[array.length - 1 - i];
            array[array.length - 1 - i] = temp;
        }

        for (int i = 0; i < array.length; i++) {
            System.out.println(array[i]);
        }
    }

常用算法

冒泡排序

	/**
     * @return void
     * @Author xw
     * @Description 冒泡排序
     * @Date 13:40 2021/8/31
     * @Param []
     **/
    private static void test04() {
        int[] array = new int[]{5, 3, 46, 45, 5};
        for (int i = 0; i < array.length - 1; i++) {   // 外层控制比较次数
            for (int j = 0; j < array.length - i - 1; j++) {  // 内存控制两个数比较大小
                int temp = 0;
                if (array[j + 1] < array[j]) {
                    temp = array[j + 1];
                    array[j + 1] = array[j];
                    array[j] = temp;
                }
            }
        }
        System.out.println(Arrays.toString(array));
    }

二分查找法

	/**
     * @return void
     * @Author xw
     * @Description 二分查找法
     * @Date 18:10 2021/8/31
     * @Param []
     **/
    public static void binarySearch() {
        // 定义一个有序的数组
        int[] nums = {1, 3, 5, 8, 12, 35, 54, 456};
        // 定义要查找的数值
        int targetNum = 8;
        // 目标
        int res = -1;
        // 左指针
        int left = 0;
        // 右指针
        int right = nums.length - 1;
        //
        while (left <= right) {
            int mid = (left + right) / 2;
            if (nums[mid] == targetNum) {
                res = mid;
                break;
            } else if (nums[left] < targetNum) {
                left = mid + 1;
            } else if (nums[right] > targetNum) {
                right = mid - 1;
            }
        }

        System.out.println(res);
    }