JavaSE基础——数组练习题

这里是一些数组的练习题，及其代码实现。

1、需求：数组元素求和：某部门5名员工的销售额分别是：16、26、36、6、100， 请计算出他们部门的总销售额。

    public static void main(String[] args) {
        // 需求：数组元素求和：某部门5名员工的销售额分别是：16、26、36、6、100，
        // 请计算出他们部门的总销售额。
        // 1、 把这些数据拿到程序中使用数组记住。
        int [] money = {16 , 26 , 36 , 6 , 100} ;

        //3、 定义一个求和变量累加数组的元素值
        int sum = 0 ;

        //2、遍历数组中的每个元素
        for (int i = 0; i < money.length; i++) {
            // i = 0 1 2 3 4
            sum += money[i];
        }

        //4、输出求和变量即可。
        System.out.println("他们部门的总销售额是：" + sum);
    }

2、需求：数组元素求最大值。

    public static void main(String[] args) {
        //需求：数组元素求最大值
        // 1、把颜值数据拿到程序中去，用数组装起来。
        int [] faceScores = {15 , 9000 , 10000 , 20000 , 9500 , -5 };
        //                    0      1     2       3       4     5

        // 2、定义一个变量用于记录最大值，这个变量建议默认存储第一个元素值作为参照。
        int max = faceScores[0] ;
        // 3、 遍历数组的元素，如果该元素大于变量存储的元素，则替换变量存储的值为该元素。
        for (int i = 1; i < faceScores.length; i++) {
            if (faceScores[i] > max) {
                max = faceScores[i];
            }
        }
        // 4、输出改数组元素的最大值。
        System.out.println("该数组元素的最大值为： " + max);
    }

3、需求：游戏后台随机生成1-20 之间的5个数（无论是否重复），然后大家来猜数字；猜中提示"运气不错，猜中了"，并输出该数据的第一次出现的位置，且输出全部五个数据，最终结束本游戏。

    public static void main(String[] args) {
        // 需求：游戏后台随机生成1-20 之间的5个数（无论是否重复），然后大家来猜数字；
        // 猜中提示"运气不错，猜中了"，并输出该数据的第一次出现的位置，且输出全部五个数据，最终结束本游戏。

        //1、定义一个动态初始化的数组，存储五个随机的1-20之间的数据
        int [] data = new int[5];
        //2、动态的生成5个1-20.
        Random r = new Random() ;
        for (int i = 0; i < data.length ; i++) {
            // i = 0 1 2 3 4
            data[i] = r.nextInt(20) + 1 ;// 1-20 间的随机数。
        }

        //3、使用一个死循环来让用户进行猜测。
        Scanner sc = new Scanner(System.in) ;
        OUT:
        while (true){
            System.out.println("请您输入一个1-20 之间的任意整数进行猜测： ");
            int guessData = sc.nextInt();

            //4、遍历数组中的每个数据，看是否有数据与猜测的数据相同，相同代表猜中了，给出提示
            for (int i = 0; i < data.length; i++) {
                if(data[i] == guessData ){
                    System.out.println("您运气不错！猜中了，您猜中的数据索引是：" + i);
                    break OUT; // 结束了整个死循环，代表游戏结束了！
                }
            }
            System.out.println("当前猜测的数据在数组中不存在，请重新猜测！ ");
        }

        //5、输出数组的全部元素，让用户看到自己确实是猜中了某个数据。
        for (int i = 0; i < data.length; i++) {
            System.out.print(data[i] + "\t");
        }
    }

4、需求：某公司开发部5名开发人员，要进行项目进展汇报演讲，现在采取随机排名后进行汇报。 请先依次录入5名员工的工号，然后展示出一组随机的排名顺序。

public static void main(String[] args) {
        // 需求：某公司开发部5名开发人员，要进行项目进展汇报演讲，现在采取随机排名后进行汇报。
        // 请先依次录入5名员工的工号，然后展示出一组随机的排名顺序。
        //1、动态初始化一个数组，存储5个工号。
        int [] codes = new int [5];

        //2、定义一个循环 循环五次，依次录入一个工号存入对应的位置
        Scanner sc = new Scanner(System.in);
        for (int i = 0; i < codes.length; i++) {
            // i =  0 1 2 3 4
            // 正式录入工号
            System.out.println("请您输入第" + (i + 1 ) + "个员工的工号： ");
            int code = sc.nextInt() ;
            // 存入到数组中去：
            codes[i] = code;
        }

        //3、遍历数组中的每个元素，然后随机一个索引出来，让该元素与随机索引位置处的元素值进行交换（重点）
        // codes = 22 33 35 13 88
        Random r = new Random();
        for (int i = 0; i < codes.length; i++) {
            //当前遍历的元素值：codes[i]
            // 随机一个索引位置出来:codes[index]
            int index = r.nextInt(codes.length);

            //定义一个临时变量存储index位置的值
            int temp = codes[index] ;
            codes[index] = codes[i] ;
            codes[i] = temp;
        }

        //4、遍历数组元素输出随机排名的结果
        for (int i = 0; i < codes.length; i++) {
            System.out.print(codes[i] + "\t");
        }
    }

5、冒泡排序 ： 每次从数组中找出最大值放在数组的后面去。(重点)

    public static void main(String[] args) {
        // 冒泡排序 ： 每次从数组中找出最大值放在数组的后面去。(重点)
        // 1、定义一个数组，存储一些数据啊
        int [] arr = {5 , 2 , 3 , 1} ;
        //             0   1   2   3 索引

        // 2、定义一个循环控制比较的轮数
        for (int i = 0; i < arr.length - 1 ; i++) {
            // i = 0 比较的次数3次  j = 0 1 2
            // i = 1 比较的次数2次  j = 0 1
            // i = 2 比较的次数1次  j = 0
            // 3、定义一个循环控制每轮比较的次数，占位
            for (int j = 0; j < arr.length - i - 1 ; j++) {
                // 判断j当前位置的元素值 是否大于后一个位置元素值，若较大 则交换位置
                if (arr[j] > arr[j + 1]){
                    int temp = arr[j + 1 ] ;
                    arr[j + 1] = arr[j];
                    arr[j] = temp ;
                }
            }
        }
        // 遍历数组内容输出
        for (int i = 0; i < arr.length; i++) {
            System.out.print(arr[i] + "\t");
        }
    }

 6、输入5位同学的成绩，找出最高分，最低分（排序）

这里我使用了两种办法找最高分与最低分：

第一种是先遍历数组，找出输入成绩数组的最高分和最低分，然后使用分支语句if语句判断出最高分和最低分；

第二种办法是将成绩从小到大排序后，取数组的第一个元素为最小值，最后一个元素为最大值。

 public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        //1、输入5位同学成绩分数
        double [] scores = new double[5];
        for (int i = 0; i < scores.length; i++) {
            System.out.println("请输入第"+ (i+1) +"名同学的成绩");
            scores[i] = sc.nextDouble();
        }

        //2、找出最高分和最低分
        //第一种办法
        /*double max = scores[0];
        double min = scores[0];
        for (int i = 0; i < scores.length; i++) {
            if (scores[i] > max){
                max = scores[i];
            }
            if (scores[i] < min){
                min = scores[i];
            }
        }
        System.out.println("最高分为：" + max);
        System.out.println("最低分为：" + min);*/

        //3、排序
        for (int i = 0; i < scores.length-1; i++) {
            for (int j = 0; j < scores.length-1-i; j++) {
                if (scores[j] > scores[j+1]) {
                    double temp = scores[j+1];
                    scores[j+1] = scores[j];
                    scores[j] = temp;
                }
            }
        }

        //4、打印出来
        for (int i=0;i<scores.length;i++){
            System.out.print(scores[i]+"\t");
        }
        System.out.println("");

        //2、找出最高分最低分
        //排序后的数组的第一个数为最低分，最后一个数为最高分
        double max = scores[scores.length-1];
        double min = scores[0];
        System.out.println("最高分为：" + max);
        System.out.println("最低分为：" + min);

    }

7、输入一个字符串，看看里面有多少个’A’或’a’字符

方法一：使用遍历字符串，使用字符串的charAt方法选择字符串里的每个元素进行寻找A或a的个数。

public static void main(String[] args) {
        //1、输入一个字符串
        Scanner sc = new Scanner(System.in);
        System.out.println("请输入字符串：");
        String index = sc.next();

        //2、遍历字符串的长度
        //num1代表A的数量；num2代表a的数量。
        int num1 = 0;
        int num2 = 0;
        //直接遍历字符串的长度，使用字符串的charAt方法选择字符串里的每个元素进行判断是否是A或a。
        for (int i = 0; i < index.length(); i++) {
            if (index.charAt(i) == 'A'){
                //这里等等后也可以接A的ASCII数65（下面a同理）
                num1 += 1;
            }
            if ( index.charAt(i) == 'a'){
                num2 += 1;
            }
        }

        System.out.println("这个字符串里有" + num1 +"个A字母");
        System.out.println("这个字符串里有" + num2 +"个a字母");
    }

方法二：将字符串转换成该字符串所有字符组成的数组，再通过遍历数组寻找A和a。

 Scanner sc = new Scanner(System.in);
        System.out.println("输入一个字符串");
        String input = sc.next();

        //通过字符串获取该字符串所有字符组成的char数组
        char[] array = input.toCharArray();

        //遍历
        int num = 0;//计数有多少个A或a
        for (int i = 0; i < array.length; i++) {
            if (array[i] == 'A' || array[i] == 'a'){
                num++;
            }
        }
        System.out.println("这个字符串里有"+ num +"个A或a字母");

8、已知一个顺序从小到大的整型数组{12,23,34,45,56,67,78,89}， 用户输入一个数字，把它放入到正确的位置中，其他元素也要保留。

public static void main(String[] args) {
        //1、定义数组
        int [] array = {12,23,34,45,56,67,78,89};
        //2、用户输入数字
        Scanner sc = new Scanner(System.in);
        System.out.println("请输入一个任意正整数：");
        int num = sc.nextInt();
        //3、定义这个数字的索引变量
        int index = 0;
        //4、遍历数组，找到这个要加入的数字的位置
        for (int i = 0; i < array.length; i++) {
            if (num > array[i]){
                index = i + 1 ;
            }
        }

        //5、定义一个新的数组，将输入的数字加入进去
        int [] newArray = new int[array.length+1];//新数组长度为旧数组长度加1.//11

        //6、遍历新数组，把输入数字加进去，且原来数组其他元素保留
        //给输入数字赋值
        newArray[index] = num;
        for (int i = 0; i < newArray.length; i++) {
                //输入数字前的数字
            if (i < index){
                newArray[i] = array[i];
                //输入数字后的数字
            }else if (i > index){
                newArray[i] = array[i-1];
            }
        }


            //第二种写法
        //5、需要把这个数字加进去。定义一个新的数组接它
        /*int newArray [] = new int[array.length+1];
        newArray[index] = num;
        for (int i = 0; i < index; i++) {
            newArray[i] = array[i];
        }
        for (int i = index ; i < array.length; i++) {
            newArray[i+1] = array[i];
        }*/


        //7、打印新数组
        System.out.print("[");
        for (int i=0;i<newArray.length;i++){
            System.out.print(newArray[i]+"  ");
        }
        System.out.print("]");

    }

9、输入任意一个字符串，如：“abDEe23dJfd343dPOddfe4CdD5ccv!23rr”。 取出该字符串中所有的字母。顺序不能改变！

方法1：使用遍历字符串取字符串里所有的字母

public static void main(String[] args) {
        //1、输入字符串
        //直接输入
//        String index = "abDEe23dJfd343dPOddfe4CdD5ccv!23rr";
        //使用Scanner输入器输入
        Scanner sc = new Scanner(System.in);
        System.out.println("请输入字符串：");
        String index = sc.next();

        //2、遍历字符串，取出所有字母
        //定义一个空的字符串去接取出的字符串中的字母
        String result = "";
        for (int i = 0; i < index.length(); i++) {
            if ((index.charAt(i) >= 'A' && index.charAt(i) <= 'Z' )||( index.charAt(i) >= 'a' && index.charAt(i) <= 'z')){
                result += index.charAt(i);
            }
        }
        System.out.println(result);
    }

方法二：将字符串转换成字符型的数组 ，然后遍历数组

String input = "abDEr23djfd343dPOddfe4CdD5ccv!23rr";
        Scanner sc = new Scanner(System.in);
        System.out.println("输入一个字符串");
        String input = sc.next();
        //将字符串生成一个char数组array。
        char array [] = input.toCharArray();

        //新的字符串来接结果
        String result = "";

        for (int i = 0; i < array.length; i++) {
            if ((array[i] >= 65 && array[i] <= 90) || (array[i] >= 97 && array[i] <= 122)){
                result += array[i];
            }
        }
        System.out.println(result);

10、已知一个整型数组{-9，13，-5，7，8，2，12}，用户输入一个数字， 判断该数字是否在数组中，如果在请把该数字删除（长度减少1）。

    public static void main(String[] args) {
        //1、输入一个整型数组
        int [] array = {-9,13,-5,7,8,2,12};

        //2、用户输入一个数字
        Scanner sc = new Scanner(System.in);
        System.out.println("请输入一个数字：");
        int num = sc.nextInt();

        //3、判断这个数字是否在数组里
        //定义这个数字的索引
        int index = -1;
        for (int i = 0; i < array.length; i++) {
            if (num == array[i]){
                index = i;
                break;
            }
        }
        //如果index不等于，则说明有数字在数组里
        if (index != -1){
            //4、定义一个新的数组（长度为旧数组长度-1）
            int [] newArray = new int[array.length-1];
            for (int i = 0; i < newArray.length; i++) {
               if (i<index){
                   newArray[i] = array[i];
               }else if (i>=index){
                   newArray[i] = array[i+1];
               }
            }
            //5、打印新的数组
            System.out.println("删除输入数字后，新数组为：");
            System.out.print("[");
            for (int i=0;i<newArray.length;i++){
                System.out.print(newArray[i]+"  ");
            }
            System.out.print("]");
        }else{
            System.out.println("这个数不在数组里");
        }
    }

11、输入一个字符串，把当中的大写字母变小写，小写字母变大写。

public static void main(String[] args) {
        //1、输入一个字符串
        Scanner sc = new Scanner(System.in);
        System.out.println("请输入一个字符串：");
        String input = sc.next();

        //2、将字符串转换成数组
        char [] array = input.toCharArray();

        //3、遍历数组
        //使用一个新的字符串来接
        String result = "";
        for (int i = 0; i < array.length; i++) {
            if (array[i] >= 'A' && array[i] <= 'Z'){
                array[i] += 32;
            }else if (array[i] >= 'a' && array[i] <= 'z'){
                array[i] -= 32;
            }
            result += array[i];
        }

        //4、打印结果
        System.out.println(result);
    }

12、输入一个字符串，判断里面有多少个连续的ab？

    public static void main(String[] args) {
        //1、输入一个字符串
        Scanner sc = new Scanner(System.in);
        System.out.println("请输入一个字符串：");
        String input = sc.next();

        //2、将字符串转换成数组
        char [] array = input.toCharArray();

        //3、遍历数组
        //定义一个变量接有几个连续的ab
        int num = 0;
        //遍历到数组长度减1是因为避免输入最后一个字母为a时，发生数组越界现象。（不需要遍历最后一个元素）
        for (int i = 0; i < array.length-1; i++) {
            if (array[i] == 'a' && array[i+1] == 'b'){
                num += 1;
            }
        }

        //4、打印结果
        System.out.println("连续的ab个数为：" + num);
    }

13、 双色球由6个红球和1个蓝球组成，6个红球是随机的1-33（不能重复）， 蓝球是1-16（号码可以和红球重复）。根据用户的注数要求，生成号码。

 public static void main(String[] args) {
        //随机输出一组双色球
        Random r = new Random();
        //1、用一个七位数组，接七个球的号码
        int array [] = new int[7];

        //2、使用一个for循环，生成六个红球号码且不重复
        //第一种方法(较麻烦，不好理解)
//        for (int i = 0; i < array.length-1; i++) {
//            while (true){
//                int data = r.nextInt(33)+1;
//                //定义一个标记位。默认data是没有重复的。
//                Boolean flag = true;
//                for (int j = 0; j < i; j++) {
//                    if (array[j] == data){
//                        //说明重复不能用
//                        flag = false;
//                        break;
//                        //中断死循环，重新输入随机数。
//                    }
//                }
//                if (flag){
//                    //data这个数据之前没有出现过，可以使用
//                    array[i] = data;
//                    break;
//                }
//            }
//        }
        //第二种方法（好理解）：
        for (int i = 0; i < array.length - 1; i++) {
            array[i] = r.nextInt(33)+1;
            for (int j = 0; j < i; j++) {
                if (array[i] == array[j]){
                    i--;
                    break;
                }
            }
        }
        //生成最后一位的蓝球号码（1-16）
        array[array.length-1] = r.nextInt(16)+1;
        //输出生成的
/*        System.out.print("[");
        for (int i = 0; i < array.length; i++) {
            System.out.print(array[i] + "\t");
        }
        System.out.print("]");*/


        //用户输入一组双色球数字
        Scanner sc = new Scanner(System.in);
        int guessnumber [] = new int[7];

        System.out.println("请输入您要买的注数：");
        int num = sc.nextInt();

        for (int i = 0; i < num; i++) {
            System.out.println("请输入您第" + (i+1) + "注的猜测");
            for (int j = 0; j < guessnumber.length - 1; j++) {
                System.out.println("输入第"+(i+1)+"个红球猜测的号码（1-33）：");
                guessnumber[i] = sc.nextInt();
            }
            System.out.println("请输入蓝球猜测的号码（1-16）：");
            guessnumber[guessnumber.length-1] = sc.nextInt();
        }

    }

14、公牛与母牛（大家都可以尝试写一下，感受一下代码的魅力哈哈哈哈）

通常由两个人玩，一方出数字，一方猜。出数字的人要想好一个没有重复数字的4个数，不能让猜的人知道。 猜的人就可以开始猜。每猜一个数字，出数者就要根据这个数字给出几A几B，其中A前面的数字表示数字正确 且位置正确的数的个数，而B前的数字表示数字正确而位置不对的数的个数。 如正确答案为 5234，而猜的人猜 5346，则是 1A2B，其中有一个5的位置对了，记为1A，而3和4这两个数字对了，而位置没对，因此记为 2B，合起来就是 1A2B。 接着猜的人再根据出题者的几A几B继续猜，直到猜中（即 4A0B）为止。

第一种办法（此方法比较麻烦，个人觉得第二种方法好理解）：

public static void main(String[] args) {


        Scanner sc = new Scanner(System.in);
        Random r = new Random();
        //1、随机生成四个没有重复的数，用一个数组接
        //随机生成的数组
        int array [] = new int[4];
        for (int i = 0; i < array.length; i++) {
            array[i] = r.nextInt(10);
            for (int j = 0; j < i; j++) {
                if (array[i] == array[j]){
                    i--;
                    break;
                }
            }
        }
        //输出看一下
        System.out.println("随机数：" + array[0] + array[1] + array[2] + array[3]);

        //循环：
        Boolean flag = false;//标志位，初始值为false。
        for (int i = 0; i < 7; i++) {
            //2、输入猜测数字
            System.out.println("请输入猜测的第"+ (i+1) +"数字(4个(1-10)的数字)");
            int num = sc.nextInt();

            //输入数字有效性进行验证
            if (num >= 1000 && num <= 9999){
                //先把输入的四位数放到数组里
                int input [] = new int[4];//1234
                for (int j = input.length-1; j >= 0; j--) {
                    input[j] = num % 10;
                    num /= 10;
                }
                //判断输入是否有重复数字,如果有，重新输入
                Boolean repeatOrNot = false;
                for (int j = 0; j < input.length; j++) {
                    for (int y = 0; y < j; y++) {
                        if (input[j] == input[y]){
                            repeatOrNot = true;
                            break;
                        }
                    }
                }
                if (repeatOrNot == true){
                    System.out.println("无效输入，只能输入四位均不相同的正整数数字");
                }else{
                    //如果没有重复，开始比较array数组和input数组
                    //3、将两个数组进行对比，给出几个A几个B
                    int a = 0;
                    int b = 0;
                    for (int k = 0; k < array.length; k++) {
                        for (int l = 0; l < input.length; l++) {
                            if (array[k] == input[l] && k == l){
                                a += 1;
                            }
                            else if (array[k] == input[l] && k != l){
                                b += 1;
                            }
                        }
                    }
                    //4、输出几A几B
                    System.out.println(a + "A" + b + "B");
                    if (a == 4 && b == 0){
                        flag = true;
                        break;
                    }
                }
            }else{
                System.out.println("无效输入，只能输入四位均不相同的正整数数字");
                i--;
            }
        }
        if (flag == true){
            System.out.println("恭喜你，猜对了");
        }else{
            System.out.println("机会使用完毕，正确答案是：" + array[0]+ array[1]+ array[2]+ array[3]);
        }
    }

第二种办法：

    public static void main(String[] args) {
        Random r = new Random();
        //1、生成随机的4个数（不重复），使用数组接
        int [] array = new int[4];
        //2、遍历数组，往数组里加数字
        for (int i = 0; i < array.length; i++) {
            array[i] = r.nextInt(10);
            //让数字不重复
            for (int j = 0; j < i; j++) {
                if (array[i] == array[j]){
                    i--;
                    break;
                }
            }
        }
        //3、打印出来随机生成的数看一下
        for (int i = 0; i < array.length; i++) {
            System.out.print(array[i] + "\t");
        }

        Scanner sc = new Scanner(System.in);
        //死循环，只有猜中时才退出
        while (true){
            //4、用户输入猜测的四个数字
            int [] userArray = new int[4];
            for (int i = 0; i < userArray.length; i++) {
                System.out.println("请输入您猜测的第" + (i+1) +"个数字(0-9)(不能重复)");
                userArray[i] = sc.nextInt();
            }
            System.out.println("您本次猜测的四个数字为：" + userArray[0] + userArray[1] + userArray[2] + userArray[3]);
            //5、判断猜测结果
            int a = 0;
            int b = 0;
            //遍历两个数组，比较两个数组里的元素是否相同，位置是否相同
            for (int i = 0; i < array.length; i++) {
                for (int j = 0; j < userArray.length; j++) {
                    if (array[i] == userArray[j] && i == j){
                        a++;
                    }else if (array[i] == userArray[j] && i != j){
                        b++;
                    }
                }
            }
            //输出几A几B
            System.out.println(a + "A" + b + "B");
            if (a == 4 && b == 0){
                System.out.println("恭喜，猜对了。正确的答案为：" + array[0] + array[1] + array[2] + array[3]);
                break;
            }else{
                System.out.println("请重新输入猜测的数字");
            }
        }
    }