需求：

  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. public class DataManage {
    2.  /**
    3.   * 从键盘接收数据
    4.   * 
    5.   * @return 接收数据的数组
    6.   */
    7.  public int[] insertData() {
    8.      // 定义一个长度为10的数组
    9.      int[] a = new int[10];
    10.      Scanner sc = new Scanner(System.in);
    11.      // 少接收一个数据 为在指定位置处插入数据做准备
    12.      for (int i = 0; i < a.length - 1; i++) {
    13.          System.out.println("请输入第" + (i + 1) + "个数据：");
    14.          // 处理发生异常
    15.          try {
    16.              // nextInt方法用于从键盘接收整型数据
    17.              a[i] = sc.nextInt();
    18.          } catch (InputMismatchException e) {
    19.              System.out.println("输入的数据格式有误，不能有非数字！");
    20.              // 将有问题的键盘监听重新连接起来 阻止后面直接报错 用next()继续去接收数据
    21.              sc.next();
    22.              // 当输入错误时重新输入
    23.              i--;
    24.          }
    25.      }
    26.      return a;
    27.  }

显示所有数据：

  1. /**
  2.      * 显示数组中元素的内容
  3.      * 
  4.      * @param a      数组
  5.      * @param length 要显示的数组元素的个数
  6.      */
  7.     public void showData(int[] a, int length) {
  8.         // 将数组内容循环打印输出
  9.         for (int i = 0; i < length; i++) {
  10.             System.out.print(a[i] + "  ");
  11.         }
  12.         // 最后一个数据输出结束时需要换行
  13.         System.out.println();
  14.     }

在指定位置处插入数据：

  1. /**
  2.      * 从键盘接收一个数据，插入到数组的指定位置处
  3.      * 
  4.      * @param a 要插入数据的数组
  5.      * @param n 要插入的数据
  6.      * @param k 要插入的位置，从0开始
  7.      */
  8.     public void insertAtArray(int[] a, int n, int k) {
  9.         // 注意从最后一个数据开始移动 避免数据覆盖
  10.         // 如果数据溢出 将倒数第二个数据覆盖最后一个
  11.         for (int i = a.length - 1; i > k - 1; i--) {
  12.             a[i] = a[i - 1];
  13.         }
  14.         // 赋值操作
  15.         a[k - 1] = n;
  16.     }

查询是否能被3整除：

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

提示信息：

  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.     }

完整代码：

package array0806;
import java.util.InputMismatchException;
import java.util.Scanner;
/**
 * 从键盘接收整型数据存放到数组中，并对数组中的数据进行管理
 * (1)插入数据 insertData 
 * (2)显示所有数据 showData
 * (3)在指定位置处插入数据 insertAtArray
 * (4)查询是否能被3整除 divThree
 * 
 * @author yan
 *
 */
public class DataManage {
    /**
     * 从键盘接收数据
     * 
     * @return 接收数据的数组
     */
    public int[] insertData() {
        // 定义一个长度为10的数组
        int[] a = new int[10];
        Scanner sc = new Scanner(System.in);
        // 少接收一个数据 为在指定位置处插入数据做准备
        for (int i = 0; i < a.length - 1; i++) {
            System.out.println("请输入第" + (i + 1) + "个数据：");
            // 处理发生异常
            try {
                // nextInt方法用于从键盘接收整型数据
                a[i] = sc.nextInt();
            } catch (InputMismatchException e) {
                System.out.println("输入的数据格式有误，不能有非数字！");
                // 将有问题的键盘监听重新连接起来 阻止后面直接报错 用next()继续去接收数据
                sc.next();
                // 当输入错误时重新输入
                i--;
            }
        }
        return a;
    }
    /**
     * 显示数组中元素的内容
     * 
     * @param a      数组
     * @param length 要显示的数组元素的个数
     */
    public void showData(int[] a, int length) {
        // 将数组内容循环打印输出
        for (int i = 0; i < length; i++) {
            System.out.print(a[i] + "  ");
        }
        // 最后一个数据输出结束时需要换行
        System.out.println();
    }
    /**
     * 从键盘接收一个数据，插入到数组的指定位置处
     * 
     * @param a 要插入数据的数组
     * @param n 要插入的数据
     * @param k 要插入的位置，从0开始
     */
    public void insertAtArray(int[] a, int n, int k) {
        // 注意从最后一个数据开始移动 避免数据覆盖
        // 如果数据溢出 将倒数第二个数据覆盖最后一个
        for (int i = a.length - 1; i > k - 1; i--) {
            a[i] = a[i - 1];
        }
        // 赋值操作
        a[k - 1] = n;
    }
    /**
     * 输入数组中能被3整除的元素
     * 
     * @param a
     */
    public void divThree(int[] a) {
        String str = "";
        int count = 0;
        for (int n : a) {
            if (n % 3 == 0) {
                str = str + n + "  ";
                count++;
            }
        }
        if (count == 0) {
            System.out.println("数组中没有能被3整除的元素！");
        } else {
            System.out.println("数组中能被3整除的元素为：" + str);
        }
    }
    /**
     * 提示信息
     */
    public void notice() {
        System.out.println("**********************************");
        System.out.println("      1--插入数据");
        System.out.println("      2--显示所有数据");
        System.out.println("      3--在指定位置处插入数据");
        System.out.println("      4--查询能被3整除的数据");
        System.out.println("      0--退出");
        System.out.println("**********************************");
    }
    public static void main(String[] args) {
        DataManage dm = new DataManage();
        Scanner sc = new Scanner(System.in);
        int input = 0;
        int[] a = null;
        int n = 0, k = 0;// n表示要插入的数据，k表示插入的位置
        while (true) {
            // 循环提示
            dm.notice();
            // 进行提示
            System.out.println("请输入对应的数字进行操作");
            try {
                input = sc.nextInt();
            } catch (InputMismatchException e) {
                System.out.println("输入的数据格式有误，不能有非数字！");
                sc.next();
                continue;
            }
            // 针对0键单独处理退出程序
            if (input == 0) {
                System.out.println("退出程序！");
                break;
            }
            switch (input) {
            case 1: {
                // 插入数据
                a = dm.insertData();
                // 显示数据
                System.out.println("数组元素为：");
                dm.showData(a, a.length - 1);
                break;
            }
            case 2: {
                // 显示所有数据
                if (a != null) {
                    System.out.println("数组元素为：");
                    if (a[a.length - 1] == 0) {
                        // 如果数组的最后一个元素为0 说明还没有插入数据 因此不显示最后一个元素
                        dm.showData(a, a.length - 1);
                    } else {
                        dm.showData(a, a.length);
                    }
                } else {
                    System.out.println("还未在数组中插入数据，请重新选择操作！");
                }
                break;
            }
            case 3: {
                // 在指定位置处插入数据
                if (a != null) {
                    System.out.println("请输入要插入的数据：");
                    try {
                        n = sc.nextInt();
                        System.out.println("请输入要插入数据的位置：");
                        k = sc.nextInt();
                    } catch (InputMismatchException e) {
                        System.out.println("输入的数据格式有误，不能有非数字！");
                        sc.next();
                        break;
                    }
                    dm.insertAtArray(a, n, k);
                    dm.showData(a, a.length);
                } else {
                    System.out.println("还未在数组中插入数据，请重新选择操作！");
                }
                break;
            }
            case 4: {
                // 查询数组中能被3整除的元素
                if (a != null) {
                    dm.divThree(a);
                } else {
                    System.out.println("还未在数组中插入数据，请重新选择操作！");
                }
                break;
            }
            // 输入的菜单选项不合法
            default:
                System.out.println("输入无效！");
            }
        }
    }
}