1~5节. 编程训练习题课

疯狂练一练

每一题都有非常详细的注释, 如果大家有其他更简单的思路, 可以在评论区交流, 或者私信一起讨论.

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

package com.itheima.lxh_exercise;

public class Exercise {
    public static void main(String[] args) {
        //  声明两个变量, 并附初始值
        int a=6,b=3;
        // 使用打印输出的方式 调用方法
        System.out.println("最小值为: "+outMin(a,b));
    }
    /*
     * @Author LXHYouth
     * @Date 12:34 2024/3/8
     * @Param [a, b]
     * @return int
     * @Description 比较两个数的大小, 输出最小值
     **/
    public static int outMin(int a,int b){
        return a<b?a:b;
    }
}

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

package com.itheima.lxh_exercise;

/**
 * @className: ExerciseTwo
 * @author: LXHYouth
 * @date: 2024/3/8 14:28
 * @Version: 1.0
 * @description:
 */
public class ExerciseTwo {
    public static void main(String[] args) {
        // 初始化一个数组
        int[] arr={2, 1, 3, 5, 4};
        // 定义一个变量
        int a=3;
        System.out.println(existNumber(a,arr));
    }

    /*
     * @Author LXHYouth
     * @Date 14:28 2024/3/8
     * @Param [a, arr]
     * @return boolean
     * @Description 查看数组中是否含被传入的数值
     **/
    public static boolean existNumber(int a,int[] arr){
        // 循环遍历整个数组,
        for (int i = 0; i < arr.length; i++) {
            // 判断整数数组中某一个数是否存在
            if(a==arr[i]){
                // 含有相等的直接返回true, 结束方法
                return true;
            }
        }
        // 没有相等的返回 false
        return false;
    }
}

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

package com.itheima.lxh_exercise;

import java.util.Scanner;

/**
 * @className: ExerciseThree
 * @author: LXHYouth
 * @date: 2024/3/8 14:35
 * @Version: 1.0
 * @description:
 */
public class ExerciseThree {
    // 定义一个私有的静态的全局变量, 用来计数
    private static int count;
    public static void main(String[] args) {
        // 定义一个扫描器对象
        Scanner scanner = new Scanner(System.in);
        // 最大最小值
        int max=0,min=0;
        // 输入错误后进行循环输入
        while (true) {
            System.out.print("请输入最大范围值(正整数): ");
            // 定义最大最小范围
            max = scanner.nextInt();
            System.out.print("请输入最小范围值(正整数): ");
            min = scanner.nextInt();
            // 对输入数值的有效性进行判断
            if (min > max || min < 0 || max < 0) {
                System.out.print("输入错误,请重新输入.");
            }else {
                break;
            }
        }
        int[] arr=arrayList(max,min);
        System.out.println(min+"~"+max+"之间能被3整除的有:" );
        // 获取真正被存入数组中数据的个数
        for (int i = 0; i < count; i++) {
            System.out.print(arr[i]+" ");
            if((i+1)%5==0){
                System.out.println();
            }
        }
    }

    /*
     * @Author LXHYouth
     * @Date 16:28 2024/3/8
     * @Param [max, min]
     * @return int[]
     * @Description 传入范围的最大最小值, 以数组的形式返回范围内所有能被3整除的数值
     **/
    public static int[] arrayList(int max, int min) {
        int[] arr = new int[1000];
        for (int i = min; i <= max; i++) {
            if (i % 3 == 0) {
                // 全集变量记录存入数组的个数, 以便其他方法使用
                arr[count] = i;
                count++;
            }
        }
        // 返回数组
        return arr;
    }
}

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

package com.itheima.lxh_exercise;

/**
 * @className: ExerciseFour
 * @author: LXHYouth
 * @date: 2024/3/8 16:33
 * @Version: 1.0
 * @description:
 */
public class ExerciseFour {
    public static void main(String[] args) {
        int[] arr={1,3,3,5,7};
        System.out.println("是否为升序数列: "+ascendingOrderArr(arr));

    }

    /*
     * @Author LXHYouth
     * @Date 16:44 2024/3/8
     * @Param [arr]
     * @return boolean
     * @Description 传入一个数组, 返回是否为升序数列
     **/
    public static boolean ascendingOrderArr(int[] arr){
        // 循环只能到索引减1的位置, arr[i+1]会超出最大索引
        for (int i = 0; i < arr.length-1; i++) {
            if(arr[i]>arr[i+1]){
                return false;
            }
        }
        return true;
    }
}

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

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

package com.itheima.lxh_exercise;

import java.util.Scanner;

/**
 * @className: ExerciseFive
 * @author: LXHYouth
 * @date: 2024/3/8 16:47
 * @Version: 1.0
 * @description:
 */
public class ExerciseFive {
    public static void main(String[] args) {
        // 创建一个扫描器对象
        Scanner scanner = new Scanner(System.in);
        System.out.print("请输入打印的行数: ");
        // 调用打印方法
        printChar(scanner.nextInt());

    }
    public static void printChar(int number){
        for (int i = 0; i < number; i++) {
            for (int j = 0; j < i+1; j++) {
                System.out.print("@");
            }
            System.out.println();
        }
    }
}

5.1 这道不死神兔题：如果一开始有一对兔子，它们每月生育一对兔子，小兔在出生后一个月又开始生育且繁殖情况与最初的那对兔子一样，那么一年后有多少对兔子？

实质就是斐波那契数列（黄金分割数列）

//待解决(正在解决中, 正在作图看看怎么才能更好的表达清楚)

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

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

package com.itheima.lxh_exercise;

import java.util.Scanner;

/**
 * @className: ExerciseSix
 * @author: LXHYouth
 * @date: 2024/3/8 16:58
 * @Version: 1.0
 * @description:
 */
public class ExerciseSix {
    public static void main(String[] args) {
        // 创建一个扫描器对象
        Scanner scanner = new Scanner(System.in);
        System.out.print("请输入一个数: ");
        double number= scanner.nextDouble();
        System.out.println("这个数的绝对值为: "+absoluteValue(number));

    }

    /*
     * @Author LXHYouth
     * @Date 17:10 2024/3/8
     * @Param [number]
     * @return double
     * @Description 输入一个数, 返回其绝对值
     **/
    public static double absoluteValue(double number){
        // 只有小于零的一种情况数值的绝对值不是本身
        if(number<0){
            number=-number;
        }
        return number;
    }
}

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

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

package com.itheima.lxh_exercise;

import java.util.Scanner;

/**
 * @className: ExerciseSeven
 * @author: LXHYouth
 * @date: 2024/3/8 17:13
 * @Version: 1.0
 * @description:
 */
public class ExerciseSeven {
    public static void main(String[] args) {
        // 创建扫描器对象
        Scanner scanner = new Scanner(System.in);
        // 最大最小值
        int max=0,min=0;
        // 输入错误后进行循环输入
        while (true) {
            System.out.print("请输入最大范围值(正整数): ");
            // 定义最大最小范围
            max = scanner.nextInt();
            System.out.print("请输入最小范围值(正整数): ");
            min = scanner.nextInt();
            // 对输入数值的有效性进行判断
            if (min > max) {
                System.out.print("输入错误,请重新输入.");
            }else {
                break;
            }
        }
        // 调用方法
         takeOutSeven(max,min);
    }

    /*
     * @Author LXHYouth
     * @Date 18:25 2024/3/8
     * @Param [max, min]
     * @return void
     * @Description 传入最大最小范围, 剔除所有数字中包含7或者是7的倍数的
     **/
    public static void takeOutSeven(int max,int min){
        // 用于计数
        int count=0;
        // 遍历范围内所有数
        for (int i = min; i <= max; i++) {
            // 创建判断语句, 用于判断外层是否跳过
            boolean judge=false;
            // 不是7倍数, 但是有可能含有7数字的特殊情况
            if(i%7!=0){
                // 避免i被赋值而出现变化, 使用临时变量代替
                int temp=i;
                // 判断数值所有位数上的数字, 当每一位上都没含数字7时, 最高位除以10等于0时跳出循环
                while (temp>0) {
                    if (temp%10%7!=0){
                        temp /=10;
                    }else{
                        // 当有一位上的数是7, 令值位true
                        judge=true;
                        // 结束内层循环
                        break;
                    }
                }
                // 判断是否跳出外层循环
                if(judge){
                    // 当judge为true时, 说明当前数, 某位上含有数字7,就不输出
                    // 跳过本次循环, 对下一个数进行判断
                    continue;
                }
                System.out.print(i+" ");
                // 每输出一个计数加一
                count++;
                // 输入五个数, 控制换行
                if (count%5==0){
                    System.out.println();
                }

            }
        }
    }
}

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

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

package com.itheima.lxh_exercise;

/**
 * @className: TranslateEight
 * @author: LXHYouth
 * @date: 2024/3/8 20:43
 * @Version: 1.0
 * @description:
 */
public class ExerciseEight {
    public static void main(String[] args) {
        double[] arr={3.342,3.01,54,43.75,33.0};
        System.out.println(quasiInteger(arr));
    }

    /*
     * @Author LXHYouth
     * @Date 10:53 2024/3/10
     * @Param [arr]
     * @return int
     * @Description 接收浮点数组寻找数组中的准整数个数, 并返回个数
     **/
    public static int quasiInteger(double[] arr){
        // 用于记录准整数个数
        int count=0;
        // 遍历所有的数
        for (int i = 0; i < arr.length; i++) {
            // 去掉小数位
            int temp=(int)arr[i];
            // 判断如果相等就为在准整数
            if(temp==arr[i]){
                count++;
            }
        }
        return count;
    }
}

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

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

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

package com.itheima.lxh_exercise;
import java.util.Scanner;
/**
 * @className: ExerciseNight
 * @author: LXHYouth
 * @date: 2024/3/10 10:56
 * @Version: 1.0
 * @description:
 */

public class ExerciseNight {
    public static void main(String[] args) {
        // 创建一个扫描器对象
        Scanner sacnner = new Scanner(System.in);
        System.out.print("请输入一个正数: ");
        // 接受输入的正数
        double number=sacnner.nextDouble();
        System.out.print("四舍五入后为: ");
        // 调用四舍五入的方法
        System.out.println(roundingOff(number));


    }
    /*
     * @Author LXHYouth
     * @Date 13:32 2024/3/10
     * @Param [number]
     * @return int
     * @Description 对一个数进行四舍五入操作, 这里使用的是获取小数位与0.5进行比较
     *              方法二: 把数乘10强转成int型, 然后对10取余,
     *                     余数就是十分位(小数位第一位), 然后对5比较进行四舍五入
     **/
    public static int roundingOff(double number){
        // 获取整数的小数位
        double temp=number-(int)number;
        // 判断小数位是四舍还是五入
        if (temp<0.5){
            return (int)number;
        }
        return ((int)number+1);
    }

}

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

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

思路一:

package com.itheima.lxh_exercise;
public class ExerciseTen {
    public static void main(String[] args) {
        // 初始化数组
        int[] arr={2, 1, 3, 5, 4};
        System.out.println("数组表示的值为: "+sumIntoNumbers(arr));
    }
    /*
     * @Author LXHYouth
     * @Date 14:18 2024/3/10
     * @Param [arr]
     * @return int
     * @Description 素组中存储的值合成一个多位数
     **/
    public static int sumIntoNumbers(int[] arr){
        int number=0;
        int multiplier=1;
        // 根据题意从数组的最大索引位置开始到最小索引位置，依次表示整数的个位、十位、百位。。。
        for (int i = arr.length-1; i >=0 ; i--) {
            number+=arr[i]*multiplier;
            multiplier*=10;
        }
        return number;
    }
}

思路二:

package com.itheima.lxh_exercise;

public class ExerciseTenOther {
    public static void main(String[] args){
        // 初始化一个数组
        int[] arr={2, 1, 3, 5, 4};
        System.out.println(sumIntoNumbers(arr));

    }
    /**
     * @Author LXHYouth
     * @Date 19:58 2024/3/12
     * @Param [arr]
     * @return int
     * @Description 把数组存储的数据组建成一个数字
     **/
    public static int sumIntoNumbers(int[] arr){
        int sum=0;
        // 数组从索引 0到arr.length-1, 对应着数的最高位到最低位
        // sum=sum*10+arr[i];
        // 可以使用把数组遍历出来的数, 在最右端添加一个零(也就是乘个10), 然后加上遍历出来数
        // 如sum=sum*10+arr[0]=2 ->sum=2*10+arr[1]=21
        //  sum=21*10+arr[2]=213  继续往下推就可以得到数
        for(int i=0;i<arr.length;i++){
            sum=sum*10+arr[i];
        }
        // 返回最后的得到的值
        return sum;
    }
}

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

package com.itheima.lxh_exercise;

import java.util.Arrays;

/**
 * @className: ExerciseEleven
 * @author: LXHYouth
 * @date: 2024/3/10 15:02
 * @Version: 1.0
 * @description:
 */

/*
11、定义一个数组其中包含多个数字。用自己的方式最终实现，奇数放在数组的左边，偶数放在数组的右边。(可以创建其他数组，不必须在原数组中改变)
 */
public class ExerciseEleven {
    public static void main(String[] args){
        // 初始化一个数组
        int[] arr={23,54,23,55,43,78,436,79};
        // 使用数组中的方法直接打印
        System.out.println(Arrays.toString(distinguish(arr)));
    }
    /**
     * @Author LXHYouth
     * @Date 20:19 2024/3/12
     * @Param [arr]
     * @return int[]
     * @Description  重新排列数组实现奇数放数组左边, 偶数放数组右边
     **/
    public static int[] distinguish(int[] arr){
        // 定义左索引
        int indexL=0;
        // 定义右索引, 使用右边开始存, 索引则为最大索引
        int indexR=arr.length-1;

        // 创建一个新数组用来存储判断后的值
        int[] newArr=new int[arr.length];
        // 判断数据是奇数还是偶数, 然后存入数组
        for (int i = 0; i < arr.length; i++) {
            if(arr[i]%2==0){
                newArr[indexR]=arr[i];
                // 存入后像前移
                indexR--;
            }else{
                newArr[indexL]=arr[i];
                indexL++;
            }
        }
        return newArr;
    }

}

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

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

package com.itheima.lxh_exercise;

import java.util.Scanner;

/**
 * @className: ExerciseTwelve
 * @author: LXHYouth
 * @date: 2024/3/10 16:15
 * @Version: 1.0
 * @description:
 */

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

   并在控制台输出找到的索引值。如果没有查找到，则输出-1
 */
public class ExerciseTwelve {
    public static void main(String[] args){
        // 初始化一个数组
        int[] arr ={19, 28, 37, 46, 50};
        // 创建一个扫描器对象
        Scanner scanner = new Scanner(System.in);
        System.out.print("请输入一个整数: ");
        // 存储键盘输入的值
        int number= scanner.nextInt();
        // 方法返回的索引值
        int index=find(arr, number);
        if(index==-1){
            System.out.println("你输入的数不存在!");
        }else {
            System.out.println("你输入的数在数组中的索引为: "+index);
        }
    }
    /**
     * @Author LXHYouth
     * @Date 20:25 2024/3/12
     * @Param [arr, number]
     * @return int
     * @Description     查找数组中是否存在键盘输入值
     **/
    public static int find(int[] arr,int number){
        for (int i = 0; i < arr.length; i++) {
            // 如果发现数组中有相等的数值就返回当时索引
            if(arr[i]==number){
                return i;
            }
        }
        //  如果没有找到相等值就返回-1
        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.a_class;

import java.util.Scanner;

public class Demo8 {
    public static void main(String[] args) {
        // 创建一个数组存储学生成绩
        int[] studentScoresArr = {10, 20, 30, 40, 50, 60, 70, 80};
        // 定义一个变量存储操作数
        int inputNumber = 0;
        // 创建一个扫描器对象
        Scanner scanner = new Scanner(System.in);
        // 使用死循环, 是键盘可以一直输入
        while (inputNumber != 6) {
            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("-----------------------");
            // 接收键盘输入的操作数
            inputNumber = scanner.nextInt();
            // 判断输入的操作数, 应调用哪个方法
            switch (inputNumber) {
                case 1:
                    scores(studentScoresArr);
                    break;
                case 2:
                    maxScore(studentScoresArr);
                    break;
                case 3:
                    minScore(studentScoresArr);
                    break;
                case 4:
                    avgScore(studentScoresArr);
                    break;
                case 5:
                    fluck(studentScoresArr);
                    break;
                case 6:
                    // 输入6时打印感谢语, 使用return退出程序
                    System.out.println("感谢你的使用, 再见!");
                    return ;
                default:
                    System.out.println("输入错误请重新输入:");
            }
        }
    }

    /*
     * @Author LXHYouth
     * @Date 20:17 2024/3/7
     * @Param [arr]
     * @return void
     * @Description 打印学生成绩
     **/
    public static void scores(int[] arr) {
        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("]");
    }

    /*
     * @Author LXHYouth
     * @Date 20:18 2024/3/7
     * @Param [arr]
     * @return void
     * @Description 获取最高分
     **/
    public static void maxScore(int[] arr) {
        int  max=Integer.MIN_VALUE;
        for (int i = 0; i < arr.length; i++) {
            max=max>arr[i]?max:arr[i];
        }
        System.out.println("最高分为: "+max);
    }

    /*
     * @Author LXHYouth
     * @Date 20:18 2024/3/7
     * @Param [arr]
     * @return void
     * @Description 获取最低分
     **/
    public static void minScore(int[] arr) {
        int  min=Integer.MAX_VALUE;
        for (int i = 0; i < arr.length; i++) {
            min=min<arr[i]?min:arr[i];
        }
        System.out.println("最低分为: "+min);
    }

    /*
     * @Author LXHYouth
     * @Date 20:18 2024/3/7
     * @Param [arr]
     * @return void
     * @Description 获取全班平均成绩
     **/
    public static void avgScore(int[] arr) {
        double sum=0;
        for (int i = 0; i < arr.length; i++) {
            sum+=arr[i];
        }
        System.out.println("平均分为: "+(sum/arr.length));
    }

    /*
     * @Author LXHYouth
     * @Date 20:19 2024/3/7
     * @Param [arr]
     * @return void
     * @Description 获取班级不及格人数
     **/
    public static void fluck(int[] arr) {
        int count=0;
        for (int i = 0; i < arr.length; i++) {
            if(arr[i]<60){
                count++;
            }
        }
        System.out.println("不及格人数有:"+count);
    }

}

拔高题

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

练习冒泡

package com.itheima.lxh_exercise;

import java.util.Arrays;
import java.util.Scanner;

/**
 * @className: RaiseOne
 * @author: LXHYouth
 * @date: 2024/3/10 17:30
 * @Version: 1.0
 * @description:   使用的方法为冒泡排序
 */

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

public class RaiseOne {
    public static void main(String[] args){
        // 创建一个计数器
        int count=0;
        // 创建一个接收数据的数组
        int[] arr=new int[10];
        // 创建一个扫描器对象
        Scanner scanner = new Scanner(System.in);
        System.out.print("请输入10个整数(以空格隔开): ");
        // 使用while循环控制输入次数, 然后存储到数组
        while(count<10){
            arr[count]= scanner.nextInt();
            count++;
        }
        // 这里是使用了Arrays.toString(), 直接可以对数组进行打印,
        // 代替一下for循环(主打一个偷懒)
        System.out.println(Arrays.toString(arrangeInOrder(arr)));

    }
    // 创建一个方法对数组进行从小到大的排列
    public static int[] arrangeInOrder(int[] arr){
        // for循环控制需要调换数值的次数
        for (int i = 0; i < arr.length-1; i++) {
            // 对于循环次数, 外层循环每循环一次说明又有一个数已经排好序了, 然后内层循环就可以少进行i次比
            for (int j = 0; j <arr.length-1-i ; j++) {
                // 如果碰到数组的前一个, 比后一个大就进行调换
                if (arr[j]>arr[j+1]){
                    int temp=arr[j];
                    arr[j]=arr[j+1];
                    arr[j+1]=temp;
                }

            }
        }
            return arr;
    }
}

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

package com.itheima.lxh_exercise;

import java.util.Arrays;

/**
 * @className: RaiseTwo
 * @author: LXHYouth
 * @date: 2024/3/10 20:27
 * @Version: 1.0
 * @description:
 */

/*
2、定义一个方法，接收一个数组，然后将数组中的最大值与第一个元素交换，最小值与最后一个元素交换，然后将数组返回
 */
public class RaiseTwo {
    public static void main(String[] args) {
        // 初始化一个数组
        int[] arr={3,6,2,6,8,2,4,43,211,8};
        // 打印输入整理后的数组
        System.out.println(Arrays.toString(findTheBestValue(arr)));
    }
    public static int[] findTheBestValue(int[] arr){
        // 初始化最大值最小值
        int min=Integer.MAX_VALUE;
        int max=Integer.MIN_VALUE;
        // 找到传入数组中的最大最小值
        for(int i=0;i<arr.length;i++){
            min=min<arr[i]?min:arr[i];
            max=max>arr[i]?max:arr[i];
        }
        // 判断最大最小值的位置, 然后与第一个和最后一个元素进行交换
        for(int i=0;i<arr.length;i++){
            if(arr[i]==max){
                int temp=arr[i];
                arr[i]=arr[0];
                arr[0]=temp;
            }
            if(arr[i]==min){
                int temp =arr[i];
                arr[i]=arr[arr.length-1];
                arr[arr.length-1]=temp;
            }
        }
        //
        return arr;
    }
}

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

package com.itheima.lxh_exercise;

import java.util.Scanner;

/**
 * @className: RaiseThree
 * @author: LXHYouth
 * @date: 2024/3/10 20:58
 * @Version: 1.0
 * @description:
 */
/*
3、定义一个方法，接收两个整数，计算并返回两个整数的最大公约数
 */
public class RaiseThree {
    public static void main(String[] args){
        // 创建一个扫描器对象
        Scanner scanner = new Scanner(System.in);
        System.out.print("请输入两个整数(以空格隔开): ");
        int number1=scanner.nextInt();
        int number2=scanner.nextInt();
        System.out.println(number1+"和"+number2+"的最大公约数为: "+greatestCommonDivisor(number1,number2));

    }
    public static int greatestCommonDivisor(int number1,int number2){
        // 定义一个条件变量
        int condition=(number1<number2?number1:number2);
        // 定义一个变量存放最大公约数
        int max=0;
        for(int i=1;i<=condition;i++){
            if(number1%i==0&&number2%i==0){
                max=i;
            }
        }
        return max;
    }

}

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

package com.itheima.lxh_exercise;

/**
 * @className: RaiseFive
 * @author: LXHYouth
 * @date: 2024/3/10 21:55
 * @Version: 1.0
 * @description:
 */
/*
定义一个方法，接收一个整数数组，请判断数组中是否存在连续三个元素都是奇数的情况：如果存在，请返回 `true` ；否则，返回 `false`
 */
public class RaiseFive {
    public static void main(String[] args){
        // 定义了多个数组进行测验
//        int[] arr={2,4,4,5,6,8};
        int[] arr={2,-3,4,5,-7,9};
//        int[] arr={2,2,3,5,8,9};
//        int[] arr={2,2,3,5,8,9};
        System.out.println(oddContinuous(arr));
    }

    /**
     * @Author LXHYouth
     * @Date 20:50 2024/3/12
     * @Param [arr]
     * @return boolean
     * @Description     判断数组中是否存在连续三个元素都是奇数, 存在返回true, 不存在返回false
     **/
    public static boolean oddContinuous(int[] arr){
        // 用于计数连续存在了几个奇数
        int count=0;
        // 遍历数组进行判断
        for (int i = 0; i < arr.length; i++) {
            // 如果发现是奇数count加1
            if(arr[i]%2!=0){
                count++;
                // 当count为3时, 说明符合要求, 结束程序返回true
                if (count==3){
                    return true;
                }
            }else{
                // 当出现偶数时, 重置计数器, 又开始从零计算
                count=0;
            }
        }
        // count一直没有到3, 说明不满足题意,返回false
        return false;
    }
}