2022-07-16 第三组 高严 学习记录 java04

一、今日重点

【√代表掌握了，-代表产生困惑但已解决，×代表没解决】

• 员工管理系统【√】
• 有一个数组，键盘输入一个下标，获取指定下标位置的数字，输入的这个数是否合法【√】
• 输入一个数，数是从后往前加，倒序输入【√】
• 倒序输入数组数值，扩容后数组仍倒序【√】
• 向数组中插入数据【√】

二、思路与注意事项

• 员工管理系统

思路就是利用switch case和while死循环来，反复跳转。
创建两个一样长的数组，来保存员工姓名和工号，通过工号自增，来定位姓名。

1. 其中添加功能需要考虑数组扩容的问题，一旦下标越界就要给数组进行扩容，我选择在添加成功以后进行判断，如果需要就进行扩容。
2. 查询功能，先拿着工号去数组中找，如果找到就拿该工号对应的下标在存放姓名的数组中找姓名。找到之后输出。如果不存在就提示，重新进行查找。
3. 修改功能实际上是两个操作，修改之前先根据工号查询，看看这个人在不在我们的数组里，如果在就执行修改的操作，如果不在显示当前用户不存在。
4. 删除功能，涉及到了数组元素的移位，同时也需要先查找，存在才能够删除，创建一个新的数组将需要删除的元素后边的元素分别向前移一位。

• 有一个数组，键盘输入一个下标，获取指定下标位置的数字，输入的这个数是否合法

需要判断几种情况：
1.输入的是一个负值
2.输入的是一个正值，越界了
3.正确的情况

• 输入一个数，数是从后往前加，倒序输入

第一次输入的值给arr[arr.length - 1 - 0]
第二次输入的值给arr[arr.length - 1 - 1]
第三次输入的值给arr[arr.length - 1 - 2]
数组的最大下标 = 数组的长度 - 1

• 向数组中插入数据

1.因为数组已满，需要扩容
2.找到要插入的数据的位置
3.插入位置后面的数据需要向后移位
定义一个临时变量，存储原来index位置的元素
int temp = arr[index];
把要插入的数存到了指定的位置
arr[index] = num;
原来位置的后面的那个数向后移一位
arr[index + 2] = arr[index + 1];
arr[index + 1] = temp;
要插入的位置的原始数据保存起来
int temp = arr[index];
把要插入的数据放到指定位置
arr[index] = num;
判断要移位的数据的个数

三、练习汇总

• 员工管理系统

import java.util.Scanner;

public class Ch01 {

    public static void main(String[] args) {

        Scanner sc = new Scanner(System.in);
        int [] nos = new int[2];
        String [] names = new String[2];
        int no = 1001;
        int i = 0;
        while(true){
            System.out.println("欢迎使用员工管理系统");
            System.out.println("请选择功能：1.添加员工  2.查询员工  3.修改员工  4.删除员工");
            String flag = sc.next();
            switch (flag) {
                case "1":

                    System.out.println("请输入员工姓名：");
                    String name = sc.next();
//                nos[0] = no;
//                names[0] = name;
//                no++;
//                nos[1] = no;
//                names[1] = name;
                    nos[i] = no;
                    names[i] = name;
                    System.out.println("添加成功：员工的工号为：" + nos[i] + "，姓名：" + names[i]);
                    i++;
                    no++;
                    if(i >= nos.length){
                        int [] newNos = new int[nos.length + 1];
                        String [] newNames = new String[names.length + 1];
                        for (int j = 0; j < nos.length; j++) {
                            newNos[j] = nos[j];
                            newNames[j] = names[j];
                        }
                        nos = newNos;
                        names = newNames;
                    }
                    break;
                case "2":
                    System.out.println("请选择功能：1、根据工号查询  2、查询所有");
                    String n = sc.next();
                    switch (n) {
                        case "1":
                            System.out.println("请输入要查询的员工号：");
                            int s = sc.nextInt();
//                            boolean b = false;
                            int index = -1;
                            for (int j = 0; j < nos.length; j++) {
                                if(nos[j] == s){
                                    // 找到了
//                                    System.out.println("工号：" + s + "，姓名：" + names[j]);
//                                    b = true;
                                    index = j;
                                    break;
                                }
//                                else {
//                                    System.out.println("工号：" + s + "不存在！");
//                                }
                            }
                            if(index!= -1) {
                                System.out.println("工号：" + s + "，姓名：" + names[index]);
                            }else {
                                System.out.println("工号：" + s + "不存在！");
                            }
                            break;
                        case "2":
                            for (int j = 0; j < nos.length; j++) {
                                if(nos[j] != 0){
                                    System.out.println("工号：" + nos[j] + "，姓名：" + names[j]);
                                }
                            }
                            break;
                        default:
                    }

                    break;

                case "3":
                    System.out.println("请输入要修改的工号：");
                    int x = sc.nextInt();
                    int index = -1;
                    for (int j = 0; j < nos.length; j++) {
                        if(nos[j] == x){
                            index = j;
                            break;
                        }
                    }
                    if(index!= -1) {
                        System.out.println("工号：" + x + "，姓名：" + names[index]);
                        System.out.println("请输入新的姓名：");
                        String newName = sc.next();
                        names[index] = newName;
                        System.out.println("修改成功！工号：" + x + "，姓名：" + names[index]);
                    }else {
                        System.out.println("工号：" + x + "不存在！");
                    }
                    break;
                case "4":
                    /*
                        分析需求：
                        删除nos = 0,names = null
                        nos=0 names=null
                        移位
                        1,2,3,4,5
                        3删除掉
                        1,2,0,4,5
                        1,2,4,5,0

                        思路：
                        1,2,3,4,5
                        1,2,0,4,5
                        新建一个数组
                        把我现在的数组中的数据重新放进新的数组，不包括0
                        int [] arr = {1,2,3,4,5}
                        int [] arr = {1,2,0,4,5}

                        int [] newArr = new int[arr.length];
                     */
                    /*
                        删除：输入工号，是不是也得先查询
                     */
                    System.out.println("请输入要查询的员工号：");
                    int s = sc.nextInt();
                    // 先要去工号的数组中找，如果工号存在，拿到工号对应的下标
                    // 我还要拿着这个下标去姓名的数组中找姓名
                    int y = -1;
                    for (int j = 0; j < nos.length; j++) {
                        if(nos[j] == s){
                            y = j;
                            break;
                        }
                    }
                    if(y!= -1) {
                        System.out.println("工号：" + s + "，姓名：" + names[y]);
                        // 找到了，就删除
                        nos[y] = 0;
                        names[y] = null;

                        int [] newNos = new int[nos.length - 1];
                        String [] newNames = new String[names.length - 1];

                        for (int j = 0; j < nos.length - 1; j++) {
                           if(nos[j] == 0){
                               newNos[j] = nos[j + 1];
                               nos[j + 1] = 0;
                           }else {
                               newNos[j] = nos[j];
                           }
                           if(names[j] == null){
                               newNames[j] = names[j + 1];
                               names[j + 1] = null;
                           }else {
                               newNames[j] = names[j];
                           }
                        }
                        nos = newNos;
                        names = newNames;
                        System.out.println("工号：" + s + "删除成功！");
                    }else {
                        System.out.println("工号：" + s + "不存在！");
                    }
                    break;
                default:
            }
        }

    }
}

• 有一个数组，键盘输入一个下标，获取指定下标位置的数字，输入的这个数是否合法

import java.util.Scanner;

public class Ch01 {

    public static void main(String[] args) {

        Scanner sc = new Scanner(System.in);
        /*
            有一个数组
         */
        int [] arr = new int[]{4,58,69,14,22,-1};
        /*
            键盘输入一个下标，获取指定下标位置的数字
         */
        System.out.println("请输入一个下标：");
        int index = sc.nextInt();
        /*
            输入的这个数是否合法？
            需要判断几种情况？
            1.输入的是一个负值
            2.输入的是一个正值，越界了
            3.正确的情况
         */
        if(index >= 0 && index <= arr.length - 1){
            // 合法的情况
            System.out.println("对应位置的值是：" + arr[index]);
        } else {
            // 条件 <0 || >5
            // 越界
            System.out.println("你输入的数据有误，无法获取...");
        }
    }
}

• 输入一个数，数是从后往前加，倒序输入

import java.util.Scanner;

public class Ch02 {

    public static void main(String[] args) {

        // 准备一个键盘
        Scanner sc = new Scanner(System.in);
        int [] arr = new int[5];
        /*
            输入一个数，数是从后往前加
            倒序输入
            第一次输入的值给arr[arr.length - 1 - 0]
            第二次输入的值给arr[arr.length - 1 - 1]
            第三次输入的值给arr[arr.length - 1 - 2]
            数组的最大下标 = 数组的长度 - 1
         */

        for (int i = 0; i < arr.length; i++) {
            System.out.println("请输入第" + (i+1) +"个数：");
            // 输入
            int num = sc.nextInt();
            arr[arr.length - 1 - i] = num;
        }
        for (int i : arr) {
            System.out.println(i);
        }
    }
}

• 倒序输入数组数值，扩容后数组仍倒序

import java.util.Arrays;
import java.util.Scanner;

public class Ch03 {

    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        int [] arr = new int[2];
        int i = 0;
        main:while(true){
            System.out.println("请输入数据：");
            int num = sc.nextInt();
            arr[arr.length - 1 - i] = num;
            i++;
            if(i >= arr.length) {
                int [] newArr = new int[arr.length * 2];
                for (int j = 0; j < arr.length; j++) {
                    newArr[newArr.length - 1 - j] = arr[arr.length - 1 - j];
                }
                arr = newArr;
            }
            System.out.println("是否继续添加：1、是   2、否");
            String flag = sc.next();
            switch (flag){
                case "1":
                    continue;
                case "2":
                    System.out.println("当前数组为：" + Arrays.toString(arr));
                    break main;
//                    System.exit(-1);
            }
        }
    }
}

• 向数组中插入数据

import java.util.Arrays;
import java.util.Scanner;

public class Ch04 {

    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        int [] arr = new int[]{1,2,3,4,5};
        // 扩容
        int [] newArr = new int[arr.length * 2];

        for (int j = 0; j < arr.length; j++) {
            newArr[j] = arr[j];
        }
        arr = newArr;
        main:while(true){
            System.out.println("请输入要插入数据的下标：");
            int index = sc.nextInt();
            System.out.println("请输入要插入的数据：");
            int num = sc.nextInt();
        /*
            1.因为数组已满，需要扩容
            2.找到要插入的数据的位置
            3.插入位置后面的数据需要向后移位
         */
            // 定义一个临时变量，存储原来index位置的元素
//        int temp = arr[index];
//        // 把要插入的数存到了指定的位置
//        arr[index] = num;
//        // 原来位置的后面的那个数向后移一位
//        arr[index + 2] = arr[index + 1];
//        arr[index + 1] = temp;
            // 要插入的位置的原始数据保存起来
            int temp = arr[index];
            // 把要插入的数据放到指定位置
            arr[index] = num;
            //判断要移位的数据的个数
            for (int i = 1; i < arr.length - index; i++) {
                arr[arr.length - i] = arr[arr.length - 1 - i];
            }
            arr[index + 1] = temp;
            System.out.println("现在数组为：" + Arrays.toString(arr));
            System.out.println("是否继续添加：1、是   2、否");
            String flag = sc.next();
            switch (flag){
                case "1":
                    continue;
                case "2":
                    System.out.println("当前数组为：" + Arrays.toString(arr));
                    break main;
//                    System.exit(-1);
            }
        }

    }
}

四、学习总结

1. 今天是之前学习JAVA内容的小阶段性总结，主要呈现方式是练习题，讲解了昨天的作业员工管理系统，比起我昨天自己写出来的东西，代码可读性高了很多，简明扼要，很顺利的就能看明白原理，而我写的不必要的循环产生了冗余。增删改查，一向是写代码的重点，其中的查更是重中之重。考虑到了数组扩容问题，并且增添了美观度，给用户带来了好的体验，让我对昨天的作业产生了更深度的理解，终于可以说是掌握了这个知识点。让我体会到了使用Switch care的便利。
2. 倒序输入较为简单，比较容易理解，判断数组下标是否合法的问题，需要考虑到几种情况，锻炼了需求分析能力。
3. 插入数组，需要考虑到元素位移问题。
4. 今天的知识基本上掌握，至少可以说上是理解了，再接再厉，继续加油呀。