Java数组-方法练习题

1、定义一个方法，该方法能够找出两个小数中的较小值并返回。

public class Demo1 {
    public static void main(String[] args) {
        System.out.println(getMinNumber(1.1, 2.1));
        System.out.println(getMinNumber(2.1, 1.1));
    }

    //参数列表 double a,double b
    //返回值类型 double
    public static double getMinNumber(double a, double b) {
        //找出两个小数中的较小值并返回
        //表达式 ? 正确值 : 错误值
        return a < b ? a : b;
    }
}

2、定义一个方法判断整数数组中某一个数是否存在，并将结果返回

public class Demo2 {
    public static void main(String[] args) {
        System.out.println(isExists(new int[]{2, 4, 6, 8, 0}, 3));//false
        System.out.println(isExists(new int[]{2, 4, 6, 8, 0}, 4));//true
    }

    //参数列表: int[] arr, int num   [1 2 3 4 5]    3
    //返回值类型: boolean
    public static boolean isExists(int[] arr, int num) {
        //1. 数组遍历
        for (int i = 0; i < arr.length; i++) {
            if (arr[i] == num) {
                //数在数组中的
                return true;
            }
        }
        //当for循环结束了, 还没有返回true 数不在数组中的
        return false;
    }
}

3、定义一个方法统计指定范围（例如100~200）之间能被3整除的数，并将数放入一个数组中返回

public class Demo3 {


    public static void main(String[] args) {
        int[] array = getArray(100, 200);
        System.out.println(array);//[I@776ec8df
        System.out.println(Arrays.toString(array));//[102,105.....198]
    }


    //参数int min,int max
    //返回int[]
    public static int[] getArray(int min, int max) {
        //1. 遍历一遍,找出所有满足条件的数的个数
        //1-1 声明计数器
        int count = 0;
        //1-2 使用for遍历数组
        for (int i = min; i <= max; i++) {
            //判断i是否可以整除3
            if (i % 3 == 0) {
                count++;
            }
        }

        //2. 准备数组
        int[] arr = new int[count];

        //3. 将满足条件的数据放入数组
        //3-1 再来声明一个递增计数器,表示数组中正在填充数据的索引
        int index = 0;
        for (int i = min; i <= max; i++) {
            //判断i是否可以整除3
            if (i % 3 == 0) {
                arr[index++] = i;
            }
        }

        //4. 返回
        return arr;
    }
}

4、定义一个方法，接收一个整型数组，判定数组中的元素是否是升序排列，并将结果返回

public class Demo4 {
    public static void main(String[] args) {
        System.out.println(isAsc(new int[]{1, 3, 5, 7, 9}));
        System.out.println(isAsc(new int[]{1, 5, 3, 7, 9}));
    }

    //以后一旦使用到了索引+1  千万注意索引越界
    //参数 int[] arr
    //返回值 boolean
    public static boolean isAsc(int[] arr) {
        for (int i = 0; i < arr.length - 1; i++) {
            if (arr[i] >= arr[i + 1]) {
                return false;//一旦发现有一个前面元素大于后面的元素, 此时数组就已经判断为非升序
            }
        }

        //当上面的循环执行完毕,依旧没有返回false; 代表数组中的每个元素都满足后边大于前边
        return true;
    }
}

5、设计一个方法，可以接收1个整数n(比如4)来代表行数，然后使用方法打印出下面的图形状

打印效果如下:
@
@@
@@@
@@@@

public class Demo5 {
    public static void main(String[] args) {
        print(4);
    }

    //参数 int num
    //返回值 void
    public static void print(int num) {
        //外层for控制行
        for (int i = 1; i <= num; i++) {
            //内存for控制列
            for (int j = 0; j < i; j++) {
                System.out.print("@");
            }
            //换行
            System.out.println();
        }
    }
}

6、数字是有绝对值的，非负数的绝对值是它本身，负数的绝对值是它本身取反。

​ 请定义一个方法，方法能够得到小数类型数字的绝对值并返回。请定义方法并测试。

public class Demo6 {
    public static void main(String[] args) {
        System.out.println(getAbs(1.1));
        System.out.println(getAbs(-1.1));
    }

    //参数 double num
    //返回值 double
    public static double getAbs(double num) {
        if (num >= 0) {
            //>=0 非负数
            return num;
        } else {
            //<0 负数
            return num * -1;
        }
    }

}

7、定义一个方法，接收两个整数作为数值范围，然后在控制台打印出范围内之间的满足逢七必过的数

​ 逢七必过规则(数字包含7或者是7的倍数)

public class Demo7 {

    public static void main(String[] args) {
        print(10, 20);
    }

    //参数 int min,int max
    //返回 void
    public static void print(int min, int max) {
        //判断, 如果不是两位整数,直接返回
        if ((min < 10 || min > 99) || (max < 10 || max > 99)) {
            return;//结束
        }

        //根据min--max做一个循环,找到里面所有的数
        for (int i = min; i <= max; i++) {
            //i: 一个范围内的数
            //求i的个位和十位
            int ge = i % 10;
            int shi = i / 10 % 10;

            if (ge == 7 || shi == 7 || i % 7 == 0) {
                continue;//跳过本次  继续下次
            }

            System.out.println(i);
        }
    }
}

8、定义一个方法，接收一个小数数组(小数点后只有1位)，然后找出数组中准整数有几个返回

​ 准整数指的是小数点之后全是0的小数

public class Demo8 {
    public static void main(String[] args) {
        System.out.println(count(new double[]{1.1, 1.2, 1.0, 2.0, 3.1}));
    }

    //[1.1, 1.2, 1.0, 2.0, 3.1]
    //参数 double[] arr
    //返回值 int
    public static int count(double[] arr){
        //1. 定义一个计数器
        int count = 0;

        //2. 循环遍历数组
        for (int i = 0; i < arr.length; i++) {
            if (((int)(arr[i] * 10)) % 10 == 0) {
                count++;
            }
        }
        return count;
    }
}

9、请定义一个方法，对正数的小数进行四舍五入的操作(不考虑负数情况)。

​ 四舍五入之后的结果是一个int整数类型并返回。

提示：四舍五入的操作关键是十分位(小数第一位)，如何获取十分位？

public class Demo9 {
    public static void main(String[] args) {
        System.out.println(getNum(10.51));//11
        System.out.println(getNum(10.21));//10
    }

    //参数列表 double num
    //返回值 int
    public static int getNum(double num) {
        //1. 获取每个小数的十分位(小数 * 10 取各位数)
        int shifenwei = ((int) (num * 10)) % 10;

        //2. 根据十分位的值,确定返回值
        if (shifenwei >= 5) {
            return (int)num + 1;
        } else {
            return (int)num;
        }
    }
}

10、现有一个整数数组，数组中的每个元素都是[0-9]之间的数字，从数组的最大索引位置开始到最小索引位置，依次表示整数的个位、十位、百位。。。依次类推。请编写程序计算，这个数组所表示的整数值。例如：

数组：{2, 1, 3, 5, 4}
表示的整数为：21354 // 注：是整数类型的两万一千三百五十四，不是字符串拼起来的。

public class Demo10 {
    public static void main(String[] args) {
        System.out.println(getNum(new int[]{2, 1, 3, 5, 4}));
        System.out.println(getNum(new int[]{8, 2, 1, 3, 5, 4}));
        System.out.println(getNum(new int[]{1, 3, 5, 4}));
    }

    //参数 int[]  arr
    //返回值 int
    public static int getNum(int[] arr) {
        //{2, 1, 3, 5, 4}---->21354
        // 2 * 10 * 10 * 10 * 10    4
        // 1 * 10 * 10 * 10         3
        // 3 * 10 * 10              2
        // 5 * 10                   1
        // 4
        //变量 累加
        int sum = 0;

        //i 0 1 2 3
        for (int i = 0; i < arr.length; i++) {
            //arr[i]  * 10 * 10
            sum += mul(arr[i], arr.length - 1 - i);
        }
        return sum;
    }
    //求num*n次10的结果
    public static int mul(int num, int times) {
        for (int i = 0; i < times; i++) {
            num = num * 10;
        }
        return num;
    }
}

11、定义一个数组其中包含多个数字。用自己的方式最终实现，奇数放在数组的左边，偶数放在数组的右边。(可以创建其他数组，不必须在原数组中改变)

public class Demo11 {

    public static void main(String[] args) {
        int[] newArr = getArr(new int[]{1, 2, 3, 4, 5, 6, 7, 8, 9, 0});
        System.out.println(Arrays.toString(newArr));
    }

    //参数 int[] arr
    //返回 int[]
    public static int[] getArr(int[] arr) {
        //1. 创建一个新数组(类型和长度)
        int[] newArr = new int[arr.length];

        //2.定义两个指针,分别指向新数组的首尾位置
//        int left = 0;
//        int right = arr.length - 1;
        int left = 0, right = arr.length - 1;

        //3. 遍历原有数组, 分析每个元素是奇数还是偶数
        for (int i = 0; i < arr.length; i++) {
            if (arr[i] % 2 == 0) {
                //偶数
                newArr[right] = arr[i];
                right--;//指针向左移动
            } else {
                //奇数
                newArr[left] = arr[i];
                left++;//指针向右移动
            }
        }

        //4. 将新数组返回
        return newArr;
    }
}

12、已知一个数组 arr = {19, 28, 37, 46, 50}; 键盘录入一个数据，查找该数据在数组中第一次出现的索引。

​ 并在控制台输出找到的索引值。如果没有查找到，则输出-1

public class Demo12 {
    public static void main(String[] args) {
        findIndex();
    }

    //参数列表
    //返回值void
    public static void findIndex(){
        //0. 创建键盘对象
        Scanner scanner = new Scanner(System.in);

        //1. 定义数组
        int[] arr = {19, 28, 37, 19, 50};

        //2. 键盘录入一个数据
        System.out.println("请输入要查找的元素");
        int target = scanner.nextInt();//19

        //3. 遍历数组,获取每个元素,跟目标元素进行比对,
        for (int i = 0; i < arr.length; i++) {
            if (arr[i] == target) {
                //如果比对中了, 直接输出当前元素的索引值;
                System.out.println(i);
                return;
                //break: 结束循环  跳出循环,但是依旧会执行循环后面的代码
                //return: 结束程序
            }
        }

        //当for循环走完之后,依旧没有找到,此时输出-1
        System.out.println(-1);

    }

}

13、能够合理的设计方法参数和返回值, 并调用方法

需求描述：模拟一个简单的考试管理系统, 已知成绩为 10, 20, 30, 40, 50, 60, 70, 80

• 程序运行后, 展示一个菜单, 根据用户输入的选择, 程序响应不同的业务逻辑
• 程序需要一直运行, 直到用户输入 6 的时候, 程序结束
  

实现提示：

• 将需要操作的多个成绩, 存入一个数组中
• 使用输出语句构建出菜单
• 利用 switch 或者是 if 语句, 区分出用户输入的 1 2 3 4 5 6
• 1 ~ 5 每一个都是一段独立的功能, 所以定义5个方法, 分别实现业务功能
• 在用户输入 1 ~ 5 的时候, 调用对应的方法

/*
    System.out.println("--------------------------");
    System.out.println("欢迎来到黑马考试管理系统");
    System.out.println("1. 查看成绩");
    System.out.println("2. 查看最高分");
    System.out.println("3. 查看最低分");
    System.out.println("4. 查看平均分");
    System.out.println("5. 查看不及格人数");
    System.out.println("6. 退出");
    System.out.println("--------------------------");
*/
public class Demo13 {
    public static void main(String[] args) {
        scoreSystem();
    }

    //参数 无
    //返回值 void
    public static void scoreSystem() {
        //0. 定义键盘对象
        Scanner scanner = new Scanner(System.in);

        //1. 定义数组
        int[] scores = new int[]{10, 20, 30, 40, 50, 60, 70, 80};

        //死循环
        outer:
        while (true) {
            //2. 输出菜单提示
            System.out.println("--------------------------");
            System.out.println("欢迎来到黑马考试管理系统");
            System.out.println("1. 查看成绩");
            System.out.println("2. 查看最高分");
            System.out.println("3. 查看最低分");
            System.out.println("4. 查看平均分");
            System.out.println("5. 查看不及格人数");
            System.out.println("6. 退出");
            System.out.println("--------------------------");

            //3. 从键盘输入想要做的事情
            int flag = scanner.nextInt();

            //4. 使用switch判断要执行的分支
            switch (flag) {
                case 1:
                    //查看成绩
                    System.out.println(Arrays.toString(scores));
                    break;
                case 2:
                    //查看最高分
                    int max = getMaxScore(scores);
                    System.out.println("最高分为:" + max);
                    break;
                case 3:
                    //查看最低分
                    int min = getMinScore(scores);
                    System.out.println("最低分为:" + min);
                    break;
                case 4:
                    //查看平均分
                    double avg = getAvgScore(scores);
                    System.out.println("平均分为:" + avg);
                    break;
                case 5:
                    //查看不及格人数
                    int count = getCount(scores);
                    System.out.println("不及格人数为:" + count);
                    break;
                case 6:
                    //退出
                    break outer;
                default:
                    System.out.println("您输入有误");
            }
        }
    }

    //查看不及格人数
    public static int getCount(int[] scores) {
        int count = 0;
        for (int i = 0; i < scores.length; i++) {
            if (scores[i] < 60) {
                count++;
            }
        }
        return count;
    }

    //查看平均分
    public static double getAvgScore(int[] scores) {
        //总分
        int sum = 0;
        for (int i = 0; i < scores.length; i++) {
            sum += scores[i];
        }
        return sum * 1.0 / scores.length;
    }

    //查看最低分
    public static int getMinScore(int[] scores) {
        int min = scores[0];

        for (int i = 0; i < scores.length; i++) {
            if (min > scores[i]) {
                min = scores[i];
            }
        }
        return min;
    }

    //获取最高分
    public static int getMaxScore(int[] scores) {
        int max = scores[0];

        for (int i = 0; i < scores.length; i++) {
            if (max < scores[i]) {
                max = scores[i];
            }
        }
        return max;
    }
}