编程训练基础代码六

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

public class SmallerValue {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        System.out.println("请输入两个整数: ");
        int a=sc.nextInt();
        int b=sc.nextInt();
        System.out.println("较小值为" + rMin(a, b));

    }

    private static int rMin(int a, int b) {
        int min=a;
        if (min>b){
            min=b;
        }
        return min;
    }
}

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

package com.itheima.test;/**
 * @author walls1717
 * @since 2024/3/7
 **/

import java.util.Scanner;

/**
 *
 * @title: existsOr
 * @Author Tan
 * @Date: 2024/3/7 19:44
 * @Version 1.0
 */
public class existsOr {
    public static void main(String[] args) {
        Scanner sc=new Scanner(System.in);
        System.out.println("请输入一个整数");
        boolean b = exists1(sc.nextInt());
        if (b==true){
            System.out.println("存在");
        }else {
            System.out.println("不存在");
        }
    }

    private static boolean exists1(int nextInt) {
        int []array = {1, 2, 3, 4, 5};
        for (int i = 0; i < array.length; i++) {
            if (array[i]==nextInt){
                return true;
            }
        }
        return false;
    }
}

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

public class Demo03 {
    public static void main(String[] args) {
        //创建扫描器
        Scanner sc = new Scanner(System.in);
        System.out.println("请输入两个整数");
        int a=sc.nextInt();
        int b=sc.nextInt();
        extracted(a, b);

    }

    private static void extracted(int a, int b) {
        for (int i = 0; i < arrdo(a, b).length; i++) {
            System.out.print(arrdo(a, b)[i]+" ");
        }
    }

    private static int[] arrdo(int a, int b) {

        int count=0;
        for (int i = a,j=0; i <= b; i++){
            if (i%3==0  ){
                count++;
            }
        }
        int[] arr=new int[count];
        for (int i = a,j=0; i <= b; i++) {
            if (i%3==0  ){
                arr[j]=i;
                j++;
            }
        }
        return arr;
    }
}

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

public class Demo06 {
    public static void main(String[] args) {
        int[] arr={1,2,3,5,4};
        asc(arr);
    }

    private static boolean asc(int[] arr) {
        for (int i = 0; i < arr.length; i++) {
            for (int j = arr.length-1; j < 0; j--) {
                if (arr[i]>arr[j]){
                    return false;
                }
            }
        }
        return true;
    }
}

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

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

public class Demo05 {
    public static void main(String[] args) {
        Scanner sc =new Scanner(System.in);
        System.out.println("请输入一个整数");
        input(sc.nextInt());
    }

    private static void input(int nextInt) {
        for (int i = 0; i < nextInt; i++) {
            for (int j = 0; j <=i ; j++) {
                System.out.print("@");
            }
            System.out.println();
        }
    }
}

5、需求：兔子问题(斐波那契数列)。有一对兔子，从出生后第3个月起每个月都生一对兔子，小兔子长到第三个月后每个月又生一对兔子，假如兔子都不死，问第二十个月的兔子对数为多少？由此可见兔子对象的数据是：1 , 1 , 2 , 3 , 5 , 8 …

首先我们对其数据进行分析，可知从第三天开始，每天的兔子数量等于前两天之和，其次我们要知道递归的思想：
递归：在方法中调用方法本身的现象。注意事项：1.递归要有出口 2.递归次数不宜过多 3.递归所体现的思想，就是拆分合并的思想

public static void main(String[] args) {
        //定义一个方法去实现逻辑，传入月数并接收其返回值
        int sum = sumRabbit(20);
        //打印结果
        System.out.println("兔子的对数为：" + sum);
    }

    private static int sumRabbit(int i) {
        //判断传来的月数是不是第1个月或者两个月，如果是则返回1
        if (i == 1 || i == 2) {
            return 1;
        } else {
            //如果传来的月数不是1或者2，那么返回前两个月兔子数量的和；这里采用了递归的思想
            return sumRabbit(i - 1) + sumRabbit(i - 2);
        }
    }

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

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

public class Demo06 {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        System.out.println("请输入一个数字");
        double v = absoluteValue(sc.nextDouble());
        System.out.println(v);
    }

    private static double absoluteValue(double nextDouble) {
        return nextDouble>0?nextDouble:-nextDouble;
        /*if (nextDouble<0){
            return -nextDouble;
        }else {
            return nextDouble;
        }*/
    }
}

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

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

public class Demo12 {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        System.out.println("请输入两个整数 : ");
        int start=sc.nextInt();
        int end=sc.nextInt();
        printNumbersSkippingSevens(start,end);
    }

    private static void printNumbersSkippingSevens(int start, int end) {
        System.out.println("逢七必过的数字有: ");
        for (int i = start; i <=end; i++) {
if (containsSeven(i)||isMultipleOfSeven(i)){
    System.out.println(i);
}
        }
    }

    /**
     * 是七的倍数
     * @param i
     * @return
     */
    private static boolean isMultipleOfSeven(int i) {
        return i%7==0;
    }

    /**
     * 包含七
     * @param i
     * @return
     */
    private static boolean containsSeven(int i) {
        String numStr=Integer.toString(i);
        return numStr.contains("7");
    }
    方法二:
    private static void printNUm(int start, int end) {
        for (int i = start; i <= end; i++) {
            int ge = i % 10;
            int shi = i / 10 % 10;
            if (i %7==0||ge==7||shi==7) {
                System.out.println(i);
            }
        }
    }
}

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

public class Demo08 {
    public static void main(String[] args) {
        //定义一个小数数组
        double[] numbers = {1.0, 2.0, 3.5, 4.0, 5.0, 6.1, 7.0};
        System.out.println("准整数" + findNearIntegers(numbers));
    }

    private static int findNearIntegers(double[] numbers) {
        int count=0;
        for (int i = 0; i < numbers.length; i++) {
            /*if ((numbers[i]*10)%10==0){
                count++;
            }*/
            int n= (int) numbers[i];
            if (n==numbers[i]){
                count++;
            }
        }
        return count;
    }
}

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

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

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

public class Demo09 {
    public static void main(String[] args) {
        //自定义一个数组
        double[] numbers = {1.2, 2.5, 3.7, 4.6, 5.1};
        for (int i = 0; i <roundToNearestInt(numbers).length ; i++) {

            System.out.print(roundToNearestInt(numbers)[i]+" ");
        }
    }

    private static int[] roundToNearestInt(double[] numbers) {
        int[] arr=new int[numbers.length];
        for (int i = 0; i < numbers.length; i++) {
            if (numbers[i]*10%10<5){
                arr[i]=(int) numbers[i];
            }else {
                arr[i]=(int) numbers[i]+1;
            }
        }
return arr;
    }
}

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

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

public class Demo10 {
    public static void main(String[] args) {
        int[] arr={2, 1, 3, 5, 4};
        multiplication(arr);
    }

    private static void multiplication(int[] arr) {
        int sum=0;
        /*int power=1;
        for (int i = arr.length-1; i >= 0; i--) {
            sum+=arr[i]*power;
            power*=10;
        }*/
        for (int i = 0; i < arr.length; i++) {
            sum=sum*10+arr[i];
        }
        System.out.println(sum);
    }
}

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

public class Demo11 {
    public static void main(String[] args) {
        //定义一个初始数组
        int[] originalArray = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10};
        
        int[] newArray = rearrangeArray(originalArray);
        System.out.print("[ ");
        for (int num : newArray) {
            System.out.println(num);
            if (num==(newArray.length-1)){
                System.out.print(", ");
            }
        }
        /*for (int i = 0; i < newArray.length; i++) {
            System.out.print(newArray[i]);
            if (i < newArray.length - 1) {
                System.out.print(", ");
            }
        }*/
        System.out.println(" ]");
    }

    private static int[] rearrangeArray(int[] originalArray) {
        int left=0;
        int right=originalArray.length-1;
        //定义一个新数组, 用于存放排列好的数组
        int[] newarr=new int[originalArray.length];
        for (int i = 0; i < originalArray.length; i++) {
            if (originalArray[i]%2==0){
                newarr[left++]+=originalArray[i];
            }else {
                newarr[right--]+=originalArray[i];
            }
        }
        return newarr;
    }
}

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

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

public class Demo12 {
    public static void main(String[] args) {
        //获取扫描器
        Scanner sc = new Scanner(System.in);
        //键入数组
        int[] arr = {19, 28, 37, 46, 50};
        System.out.println("请录入一个数据");
        System.out.println("该数据为"+quaryIndex(arr, sc.nextInt()));
    }
    /**
     * 在数组中查找索引,并判断是否存在
     *
     * @param arr
     * @param num
     * @return
     */
    private static int quaryIndex(int[] arr, int num) {
        if (num!=arr[arr.length-1]&&num<0){
            return -1;
        }
        //遍历数组查找与输入的数字匹配的索引
        for (int i = 0; i < arr.length; i++) {
            if (num==arr[i]){
                return i;
            }
        }
        return -1;
    }
}

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

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

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

实现提示：

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

答:
package com.itheima.test;/**
 * @author walls1717
 * @since 2024/3/4
 **/

import javax.swing.text.View;
import java.util.Scanner;

/**
 * @title: ExaminationManagementSystem
 * @Author Tan
 * @Date: 2024/3/4 8:57
 * @Version 1.0
 */
public class ExaminationManagementSystem {
    public static void main(String[] args) {
        //定义成绩数组
        int[] scores = {10, 20, 30, 40, 50, 60, 70, 80};
        //获取扫描器
        Scanner sc = new Scanner(System.in);

        while (true) {
            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("---------------------");
            int input = sc.nextInt();//管理系统编号录入
            switch (input) {
                case 1:
                    System.out.println("学生成绩为: ");
                    viewScore(scores);
                    System.out.println();
                    break;
                case 2:
                    System.out.println("最高分为: " + viewMaxScore(scores));
                    break;
                case 3:
                    System.out.println("最低分为: " + viewMinScore(scores));
                    break;
                case 4:
                    System.out.println("平均分为: " + viewAvgScore(scores));
                    break;
                case 5:
                    System.out.println("不及格人数为: " + viewnoPass(scores));
                    break;
                case 6:
                    System.out.println("感谢您的使用, 再见");
                    System.exit(0);
                    break;
            }
        }
    }

    /**
     * 求平均数
     * @param scores
     * @return
     */
    private static double viewAvgScore(int[] scores) {
        int sum=scores[0];
        for (int i = 0; i < scores.length; i++) {
            sum+=scores[i];
        }
        return sum/scores.length*1.0;
    }

    /**
     * 不及格人数
     * @param scores
     * @return
     */
    private static int viewnoPass(int[] scores) {
      int   noPass=0;
        for (int i = 0; i < scores.length; i++) {
            if (scores[i]<60){
                noPass++;
            }
        }
        return noPass;
    }

    /**
     * 查看最低分
     * @param arr
     * @return
     */
    private static int viewMinScore(int[] arr) {
        int min = arr[0];//最低分
        for (int i = 0; i < arr.length; i++) {
            if (arr[i] < min) {
                min = arr[i];
            }
        }
        return min;
    }

    /**
     * 查看最高分
     *
     * @param arr
     */
    private static int viewMaxScore(int[] arr) {
        int max=arr[0];
        for (int i = 0; i < arr.length; i++) {
            if (arr[i] > max) {
                max = arr[i];
            }
        }
        return max;
    }

    /**
     * 查看成绩
     *
     * @param arr
     */
    private static void viewScore(int[] arr) {
        System.out.print("[ ");
        for (int i = 0; i < arr.length; i++) {
            if ((arr.length - 1) == i) {
                System.out.print(arr[i]);
            } else {
                System.out.print(arr[i] + ", ");
            }
        }
        System.out.print(" ]");
    }
}

拔高题

1、定义一个方法，在键盘上接收10个整数，然后对10个整数进行按照从小到大的顺序放入一个数组中返回

public class Demo01 {
    public static void main(String[] args) {
        System.out.println("请在键盘上输入十个整数");
        int[] sortedArr = sort(inputNumber()); // 对输入的数组进行排序
        arrWrite(sortedArr);//打印输出10个排列好的数组
    }

    private static int[] sort(int[] arr) {
        // 冒泡排序算法
        for (int i = 0; i < arr.length - 1; i++) {
            for (int j = 0; j < arr.length - i - 1; j++) {
                if (arr[j]>arr[j+1]){
                    // 交换 arr[j] 和 arr[j + 1]
                    int temp=arr[j];
                    arr[j]=arr[j+1];
                    arr[j+1]=temp;
                }
            }
        }
        return arr;
    }

    /**
     * 排列数组
     */
    private static void arrWrite(int[] arr) {
        System.out.print("[ ");
        for (int i : arr) {
            System.out.print(i);
            if (i != arr[arr.length-1]) {
                System.out.print(", ");
            }
        }
        System.out.println(" ]");
    }

    /**
     * 获取十个数组内容
     * @return
     */
    private static int[] inputNumber() {
        Scanner sc = new Scanner(System.in);
        int[] arr = new int[10];
        for (int i = 0; i < arr.length; i++) {
            System.out.println("请输入第" + (i + 1) + "个数字: ");
            arr[i] = sc.nextInt();
        }
        return arr;
    }
}

2、定义一个方法，接收一个数组，然后将数组中的最大值与第一个元素交换，最小值与最后一个元素交换，然后将数组返回

public class Demo02 {
    public static void main(String[] args) {
        //假定 一个数组
        int[] inputArray = {3, 5, 1, 2, 4};
        int[] modified=swapArray(inputArray);//接受数组
        printArray(modified);

    }
    private static void printArray(int[] arr) {
        if (arr == null) {
            System.out.println("Array is null.");
            return;
        }
        System.out.print("[");
        for (int i = 0; i < arr.length; i++) {
            System.out.print(arr[i]);
            if (i < arr.length - 1) {
                System.out.print(", ");
            }
        }
        System.out.println("]");
    }
    /**
     * 将数组中的最大值与第一个元素
     * 交换，最小值与最后一个元素交换
     * @param arr
     * @return
     */
    private static int[] swapArray(int[] arr) {
        //定义最大值和最小值
        int maxArr=arr[0];
        int minArr=arr[0];
        //定义最大和最小索引
        int minIndex=0;
        int maxIndex=0;
        // 遍历数组，找到最大值和最小值及其索引
        for (int i = 0; i < arr.length; i++) {
            if (arr[i]>maxArr){
                maxArr=arr[i];
                maxIndex=i;
            }
            if (arr[i]<minArr){
                minArr=arr[i];
                minIndex=i;
            }
        }
        // 交换最大值和第一个元素
        int temp=arr[0];
        arr[0]=maxArr;
        arr[maxIndex]=temp;
        // 交换最小值与最后一个元素
        temp=arr[arr.length-1];
        arr[arr.length-1]=minArr;
        arr[minIndex]=temp;
        return arr;
    }
}

3、定义一个方法，接收两个整数，计算并返回两个整数的最大公约数

public class Demo03 {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        System.out.println("请输入两个整数");
        System.out.print("第一个整数: ");
        int a= sc.nextInt();
        System.out.print("第二个整数: ");
        int b=sc.nextInt();
        System.out.println("最大公约数是: " + greatestCommonDivisor(a,b));
        sc.close();//关闭扫描器
    }
    private static int greatestCommonDivisor(int num1, int num2) {
        // 使用欧几里得算法计算最大公约数
        while (num2!=0){
            int temp=num2;
            num2=num1%num2;
            num1=temp;
        }
        return num1;
    }
}

4、定义一个方法，接收一个整数数组，请判断数组中是否存在连续三个元素都是奇数的情况：如果存在，请返回 true ；否则，返回 false

public class Demo04 {
    public static void main(String[] args) {
        //假定有一个数组
        int[] array = {1, 3, 5, 2, 7, 9, 4, 11, 13};
        boolean flag = hasConsecutiveOdds(array);
        System.out.println("数组中是否存在连续三个奇数: " + flag);
    }

    /**
     * 遍历数组查询数组是否存在三个连续奇数
     *
     * @param arr
     * @return
     */
    private static boolean hasConsecutiveOdds(int[] arr) {
        if (arr == null || arr.length < 3) {
            //数组元素为空或者不满足三个元素
            return false;
        }
        for (int i = 0; i < arr.length - 2; i++) {
            if (odds(arr[i]) && odds(arr[i + 1]) && odds(arr[i + 2])) {
                return true;
            }
        }
        return false;
    }

    /**
     * 判断此数是否是奇数
     *
     * @param num
     * @return
     */
    private static boolean odds(int num) {
        return num % 2 != 0;
    }
}