需求分析

需求：定义一个类，对数组中的数据进行管理（增删改查）。
方法：

  1. 插入数据：public int[] insertData() {}
  2. 显示所有数据 public void showData(int[] a, int length) {}
  3. 在指定位置处插入数据 public void insertAtArray(int[] a,int n,int k) {}
  4. 查询能被3整除的数据 public void divThree(int[] a) {}

方法实现

接收数据并添加进数组中

  1. /**
  2.      * 从键盘接收数据，并审核数据，将数据添加进数组中
  3.      * @return
  4.      */
  5.     public int[] insertData(){
  6.         int[] arr = new int[10];
  7.         //新增数组元素来自于键盘输入，所以需要引入Scanner类
  8.         //Scanner用于监听跟键盘操作相关的内容
  9.         //因为Scanner类，不是我们在同一个包中创建的类，是在Java JDK的类库中保存的类，所以使用的时候需要进行导入
  10.         Scanner sc = new Scanner(System.in);//从程序外部进入的数据称之为输入性数据
  11.         //为插入数据提前做准备，长度为10的数组只能暂时先接收九个数据
  12.         for(int i=0;i<arr.length-1;i++) {
  13.             System.out.println("请输入第" + (i+1)+ "个数据");
  14.             //System.out.println(sc.next());//next()方法无法识别是否是整型数据
  15.             //nextInt()方法用于从键盘接收整型数据
  16.             try{
  17.                 //异常捕获，将有可能发生异常的代码放进来
  18.                 arr[i] = sc.nextInt();
  19.             } catch(Exception e){
  20.                 //通过catch语句捕获可能会发生的异常，即输入非数字的时候，执行catch代码块中的内容
  21.                 System.out.println("输入的数据类型有误，不能是非数字");
  22.                 //将有问题的键盘监听重新连接起来，使用next()继续去接收数据
  23.                 sc.next();
  24.                 //为了重新输入数据，所以针对以循环做一次重新开始
  25.                 i--;
  26.             }
  27.         }
  28.         //返回创建并新增元素的数组
  29.         return arr;
  30.     }

数组元素的显示

  1.     /**
  2.      * 显示数组中元素的内容
  3.      * @param a 数组名
  4.      * @param length 要显示的数组元素的个数
  5.      */
  6.     public void showData(int[] a, int length) {
  7.         for (int i = 0; i < length; i++) {
  8.             System.out.print(a[i] + " ");
  9.         }
  10.         //使用空内容打印，使得打印内容换行
  11.         System.out.println();
  12.     }

在指定位置处插入数据

  1.     /**
  2.      * 从键盘接收一个数据，插入到数组的指定位置处
  3.      * @param a 要插入数据的数组
  4.      * @param n 要插入的数据
  5.      * @param k 要插入的位置，从0开始
  6.      */
  7.     public void insertAtArray(int[] a, int n, int k) {
  8.         // 注意从最后一个数据开始移动，避免数据覆盖
  9.         for (int i = a.length - 1; i > k; i--) {
  10.             a[i] = a[i - 1];
  11.         }
  12.         a[k] = n;
  13.     }
  14.     public static void main(String[] args) {
  15.         DataManger dm = new DataManger();
  16.         int[] a = dm.insertData();
  17.         dm.showData(a, a.length-1);//输出全部数据
  18.         Scanner sc = new Scanner(System.in);//其实此处也要处理一下非整数输入的问题
  19.         System.out.println("请输入要插入的数据：");
  20.         int n = sc.nextInt();
  21.         System.out.println("请输入要插入的位置：");
  22.         int k = sc.nextInt();
  23.         dm.insertAtArray(a, n, k);
  24.         dm.showData(a, a.length);
  25.     }

能被3整除的方法

  1.     /**
  2.      * 输出数组中能被3整除的元素
  3.      * @param a
  4.      */
  5.     public void divThree(int[] a){
  6.         String str = "";//用于保存能被3整除的数据
  7.         int count = 0;//用于保存能被3整除的数组元素的个数
  8.         for (int n : a) {
  9.             if(n % 3 == 0) {
  10.                 str = str + n + " ";
  11.                 count++;
  12.             }
  13.         }
  14.         if(count == 0) {
  15.             System.out.println("数组中没有能被3整除的元素！");
  16.         } else {
  17.             System.out.println("数组中能被3整除的元素为：" + str);
  18.         } 
  19.     }

提示信息方法

  1. /**
  2.      * 提示信息
  3. */
  4.     public void notice() {
  5.         System.out.println("********************************************");
  6.         System.out.println("                1--插入数据");
  7.         System.out.println("                2--显示所有数据");
  8.         System.out.println("                3--在指定位置处插入数据");
  9.         System.out.println("                4--查询能被3整除的数据");
  10.         System.out.println("                0--退出");
  11.         System.out.println("********************************************");
  12.     }

主方法中的实现

  1. /**
  2.      * 在主方法中实现程序流程的控制，专注于业务逻辑的实现
  3.      * 将主要功能封装在一个个的方法中，然后在主方法中调用这些方法
  4.      * @param args
  5.      */
  6.     public static void main(String[] args) {
  7.         DataManager dm = new DataManager();
  8.         Scanner sc = new Scanner(System.in);
  9.         // 将输入数据提取出来
  10.         //将input创建在循环外是为了减少系统内存的消耗，若建立在循环内部，那么每次循环都会不断的建立销毁，造成不必要的浪费
  11.         int input;
  12.         //如果一个引用类型数据的值为null，此时若调用它的属性或者方法，则会发生空指针异常，这是因为这些属性或者方法都指向一个空的内存地址，无法得到有用的信息
  13.         int[] a = null;//先定义数组为一个空数组
  14.         int n=0,k=0;//n表示要插入的数据，k表示插入位置
  15.         //为了多次提示和不间断的使用服务，需要设计一个循环来控制服务一直运转，并且可以手动停止
  16.         while(true) {
  17.             // 循环提示
  18.             dm.notice();
  19.             // 进行提示
  20.             System.out.println("请输入对应的数字进行操作：");
  21.             try {
  22.                 input = sc.nextInt();
  23.             } catch(Exception e) {//当使用try-catch捕获异常时，即使程序发送错误，代码依旧往下执行
  24.                 System.out.println("输入的数据格式有误，不能有非数字！");
  25.                 sc.next();
  26.                 /*continue的作用是为了当输入错误时，结束本次循环，不会再去执行下面的代码，如果继续执行下面的代码，关于input的
  27.                  * 操作则会报错，因为在上面并没有对input进行初始化赋值
  28.                  */
  29.                 continue;
  30.             }
  31.             // 针对0单独处理，退出程序（退出循环）
  32.             if (input == 0) {
  33.                 System.out.println("退出程序！");
  34.                 //break结束while循环
  35.                 break;
  36.             }
  37.             // 通过switch语句根据操作数进行操作的选择
  38.             switch(input) {
  39.                 case 1 :{
  40.                     //插入数据，并接收得到的数据
  41.                     a = dm.insertData();
  42.                     //显示数据
  43.                     System.out.println("数组元素为：");
  44.                     dm.showData(a, a.length);
  45.                     break;
  46.                 }
  47.                 case 2 : {
  48.                     //显示数组元素
  49.                     //需要判断数组是否已经赋值
  50.                     if(a != null) {
  51.                         System.out.println("数组元素为：");
  52.                         dm.showData(a, a.length);
  53.                     }else {
  54.                         System.out.println("还未在数组中插入数据，请重新选择操作！");
  55.                     }
  56.                 }
  57.                 case 3 : {
  58.                     //在指定位置处插入数据
  59.                     //需要判断数组是否已经赋值
  60.                     if(a != null){
  61.                         System.out.println("请输入要插入的数据：");
  62.                         try{
  63.                             n=sc.nextInt();
  64.                             System.out.println("请输入要插入数据的位置：");
  65.                             k=sc.nextInt();
  66.                         }catch(Exception e){
  67.                             System.out.println("输入的数据格式有误，不能有非数字！");
  68.                             sc.next();
  69.                             break;
  70.                         }
  71.                         while(true) {
  72.                             if(k < 0 || k > a.length) {
  73.                                 System.out.println("插入的位置错误，请输入0-9之间的数字");
  74.                                 k = sc.nextInt();
  75.                             }else {break;}
  76.                         }
  77.                         dm.insertAtArray(a, n, k);
  78.                         System.out.println("新增数据后，数组元素为：");
  79.                         dm.showData(a, a.length);
  80.                     }else{
  81.                         System.out.println("还未在数组中插入数据，请重新选择操作！");
  82.                     }
  83.                     break;
  84.                 }
  85.                 case 4 : {
  86.                     //查询数组中能被3整除的元素
  87.                     if(a!=null){
  88.                         dm.divThree(a);
  89.                     }else{
  90.                         System.out.println("还未在数组中插入数据，请重新选择操作！");
  91.                     }
  92.                 }
  93.                 default: {
  94.                     System.out.println("输入的数字有误，请输入对应的数字进行操作!");
  95.                 }
  96.             }
  97.         }
  98.     }
  99. }