6数组基础概念

1、数组声明，内存空间存储关系

//声明一个变量就是内存空间划出一块合适的空间
//声明数组时，是在内存空间划出一串连续的空间

2、什么是数组

数组的本质是内存中的一串连续的空间

数组是用来存储固定长度的一个整体

举个例子：

我们可以声明一个装苹果的盒子，这个盒子可以装绿苹果、红苹果等第，但是只能装苹果

3、如何使用数组

3、1基本的使用

//        第一步声明一个数组
        int[] nums;
//也可以用下面这个，但下面这个是C语言的写法，虽然不算错，但是会有个warning
//声明数组时，不要指定数组的长度，数组的长度是在分配空间的时候给的
        int nums1[];
//第二步给数组分配空间
//此时new后面的int[]一定要把长度写上，否则会报错
//分配空间后，Java会给每个元素都赋上默认值
//整型数组的默认值是0，浮点型默认值是0.0，布尔型默认值是false，
//char型默认值转为int后是0的单字符，所有引用类型的默认值是null
        nums = new int[2];
//第三步赋值
//如果赋值多了，会抛出一个异常ArrayIndexOutOfBoundsException,即越界异常
        nums[0] = 1;
        nums[1] = 2;
//第四步就可以直接使用数组
        nums[0] *= 10;
//输出数组
        System.out.println(Arrays.toString(nums));

3、2一边声明一边赋值

此时，这一块代码必须全部写在同一行，不能换行写，不能先声明，再换行

//一边声明一边赋值
//        法一
        int[] nums = {1, , 2};
//        法二
//        此时不能在实例化后面的int中写长度
        int[] nums1 = new int[]{1, 2};

3、3数组的简单应用

 Scanner input = new Scanner(System.in);
        int[] nums = new int[5];
        String[] names = new String[]{"A", "B", "C", "D", "E"};
        for (int i = 0; i < nums.length; i++) {
            System.out.println("请输入" + names[i] + "学生成绩：");
            nums[i] = input.nextInt();
        }
        double sum = 0.0;
        for (int i = 0; i < nums.length; i++) {
            System.out.println(names[i] + "成绩为：" + nums);
            sum += nums[i];
        }
        System.out.println("班级总成绩为：" + (int) sum);
        System.out.println("班级平均成绩为：" + sum / names.length);

4、找最大值

public static void main(String[] args) {
        Scanner input = new Scanner(System.in);
        System.out.println("需要对比几个数？");
        int[] nums = new int[input.nextInt()];
//        录入值
        for (int i = 0; i < nums.length; i++) {
            System.out.println("请录入第" + (i + 1) + "个数字");
            nums[i] = input.nextInt();
        }
        int iMax = nums[0];
        for (int i = 0; i < nums.length; i++) {
            if (nums[i] > iMax) {
                iMax = nums[i];
            }
        }
        System.out.println("当前最大值为：" + iMax);
    }

5、添加一个数，保持原本排序规则不改变

5、1通过两个数组，将一个数字移动到另外一个数组

int[] nums = {99, 85, 82, 63, 60};
System.out.println("原数组为：");
//        输出原数组
System.out.println(Arrays.toString(nums));
Scanner input = new Scanner(System.in);
System.out.println("请输入一个要插入的数：");
int num = input.nextInt();
int[] newNums = new int[nums.length];
int flag = nums.length;
for (int i = 0; i < nums.length; i++) {
    if (num > nums[i]) {
        flag = i;
        //                当找到了位置，就不能再继续比较了，如果继续比较，后面肯定是比他大的
        break;
    }
}
for (int i = 0; i < newNums.length; i++) {
    if (i < flag) {
        newNums[i] = nums[i];
    } else if (i == flag) {
        newNums[i] = num;
    } else {
        newNums[i] = nums[i - 1];
    }
}
System.out.println("插入的坐标为：" + flag);
System.out.println("输出排序后的数组");
//        输出新数组
System.out.println(Arrays.toString(newNums));

5、2一个数组，默认最后一位空出来，将自身逐个移动

        int[] nums = new int[6];
        nums[0] = 99;
        nums[1] = 85;
        nums[2] = 82;
        nums[3] = 63;
        nums[4] = 60;

        System.out.println(Arrays.toString(nums));

        System.out.println();
        Scanner input = new Scanner(System.in);
        System.out.println("请输入一个要插入的数字：");
        int num = input.nextInt();

//        给予一个默认值，默认比所有的数字都小，那么我们应该放在队尾
        int flag = nums.length - 1;

//        寻找需要插入的位置，应该要插入首次比它小的那个数的位置
        for (int i = 0; i < nums.length; i++) {
            if (num > nums[i]) {
                flag = i;
                break;
            }
        }
//        默认从数组的最后一位(总长度-1)
//        每次循环一次自减1，直到遇到我们需要插入的位置结束循环
//        i>flag 只有当i比需要插入的位置大的时候才操作，如果相同就应该结束
        for (int i = nums.length-1; i >flag; i--) {
//            将前一位赋值给后面一位
            nums[i]=nums[i-1];
        }
//        将需要插入的数，插入到当前位置
        nums[flag]=num;

//        打印位置
        System.out.println("插入位置为："+flag);
        System.out.println(Arrays.toString(nums));

5、3只使用一次循环，完成队列插入

    public static void main(String[] args) {
        int[] a = {99, 85, 82, 63, 60};
// 数组的长度不可变，故要插入一个数必须重新定义一个长度为6的数组
        int[] b = new int[6];
// 将数组a的值赋给数组b的前五项
        for (int i = 0; i < a.length; i++) {
            b[i] = a[i];
        }
// 输出未插入前的数组b
        System.out.println(Arrays.toString(b));
// 控制台输入一个数字
        Scanner sc = new Scanner(System.in);
        System.out.println("请输入一个数：");
        int num = sc.nextInt();
// 标志符
        boolean isInsert = false;
        for (int i = b.length - 2; i >= 0; i--) {
            // 输入值大于当前数组值时，将b[i]值赋给b[i+1]进行覆盖，相当于从当前位置向后移动一位
            if (num > b[i]) {
                b[i + 1] = b[i];
            } else {
                //若不大于，则插入，因为数组有序，故找到后直接break
                // 考虑一种特殊情况，就是插入的数比原数组都小，故需要在b[0]插入，利用标识符isInsert来判断
                b[i + 1] = num;
                isInsert = true;
                break;
            }
        }
        if (isInsert == false) {
            b[0] = num;
        }
        System.out.println(Arrays.toString(b));
    }

6、数组扩容

        Scanner input = new Scanner(System.in);
        int[] nums = new int[8];
        int iCount = 0;
        for (; ; ) {
            System.out.println("请录入一个数字，录入负数会结束录入：");
            int num = input.nextInt();
            //比较这个数是否是负数，如果是负数，打破循环
            if (num < 0) {
                break;
            } else {
                if ((iCount + 1) > nums.length) {
                    //数组扩容
                    int[] newNums = new int[(int) (nums.length * 1 - 5)];
                    for (int i = 0; i < nums.length; i++) {
                        newNums[i] = nums[i];
                    }
                    nums = newNums;
                }
                //iCount相当于现在我们的数组真实有效的长度
                nums[iCount++] = num;
            }
        }
        int[] newNums = new int[iCount];
        for (int i = 0; i < newNums.length; i++) {
            newNums[i] = nums[i];
        }
        nums = newNums;
        for (int i = 0; i < nums.length; i++) {
            System.out.println(nums[i] + "\t");
        }