java练习

案例1：减肥计划

减肥计划：输入星期数，显示今天的减肥活动；
周一：跑步；周二：游泳；周三：慢走；周四：动感单车；周五：拳击；周六：爬山；周日：好好吃一顿

if结构实现

// idea_test-itiheima
import java.util.Scanner;
//在没有使用之前，这个导包操作是灰色的，表示是无用信息，可以删除。
public class Demo19 {
    public static void main(String[] args) {
        //键盘录入一个数字，表示星期数1-7
        System.out.println("请输入1-7之间的数（用于表示星期数）：");
        Scanner sc = new Scanner(System.in);
        int day = sc.nextInt();

        //利用if循环语句实现判断并输出相应的减肥活动
        //利用循环判断输入数字是否是1-7之间的数字
        if(day < 1 || day > 7){
            System.out.println("输入的数字有误");
        }else{
            if(day == 1){
                System.out.println("周一：跑步");
            }else if(day == 2){
                System.out.println("周二：游泳");
            }else if(day == 3){
                System.out.println("周三：慢走");
            }else if(day == 4){
                System.out.println("周四：动感单车");
            }else if(day == 5){
                System.out.println("周五：拳击");
            }else if(day == 6){
                System.out.println("周六：爬山");
            }else{
                System.out.println("周日：好好吃一顿");
            }
        }
    }
}

switch结构实现

import java.util.Scanner;
public class Demo19{
    public static void main(String[] args) {
        System.out.println("请输入1-7之前的数：");
        //输入一个数字，表示星期数
        Scanner sc = new Scanner(System.in);
        int week = sc.nextInt();
        //对输入的数字进行判断，输出对应星期的减肥计划
        switch (week){
            case 1:
                System.out.println("周一：跑步");
                break;
            case 2:
                System.out.println("周二：游泳");
                break;
            case 3:
                System.out.println("周三：慢走");
                break;
            case 4:
                System.out.println("周四：动感单车");
                break;
            case 5:
                System.out.println("周五：拳击");
                break;
            case 6:
                System.out.println("周六：爬山");
                break;
            case 7:
                System.out.println("周日：大吃一顿");
                break;
            default:
                System.out.println("输入的数据有误，请出入1-7之前的数");
        }
    }
}

案例2：逢七过

案例：逢7过案例。输出1-100之中满足包含7或者是7的倍数的数字。

public class Demo19{
    public static void main(String[] args) {
        int a = 0;//个位
        int b = 0;//十位
        int sum = 0;//输出个数
        for(int i = 1; i <= 100 ; i++){
            a = i % 10;
            b = i /10 % 10;
            if(i % 7 == 0 || a == 7 || b == 7){
                System.out.print(i + ", ");
                sum++;
            }
        }
        System.out.println();
        System.out.println("1-100之间符合逢7过的数字有："+ sum + "个");
    }
}

案例3：不死兔神

需求：有一对兔子，从出生后第3个月起每个月都生一对兔子，小兔子长到第三个月后每个月又生一对兔子，假如兔子都不死，问第二十个月的兔子对数为多少？

规律是：1 2 3 4 5 6 月份
兔子数：1 1 2 3 5 8

public class Demo19{
    public static void main(String[] args) {
        //用数组存放兔子的对数，用动态初始化定义
        int[] arr = new int[20];
        // 找规律得出 前两个月兔子数都是1，且和整体的规律无关；
        arr[0] = 1;
        arr[1] = 1;
        for(int i = 2;i<arr.length;i++){
            arr[i] = arr[i-1] + arr[i-2];
        }
        System.out.println("第二十个月的兔子数为：" + arr[19]);
    }
}

案例4：百钱买百鸡

需求：有100文钱，要买100只鸡，公鸡5文一只，母鸡3文一只，小鸡1文三只，问公鸡、母鸡、小鸡各几只？

public class Demo19{
    public static void main(String[] args) {
        //分别定义公鸡、母鸡、小鸡的个数
        int i ;//公鸡个数
        int j ;//母鸡个数
        int k ;//小鸡个数

        //循环是根据鸡的个数，判断条件是所需100文
        // 因为公鸡5文一只，所以100文只可以买20只
        for(i=0 ; i <= 20 ; i++){
            //因为母鸡3文一只，所以100文最多可以买33只
            for(j = 0;j <= 33; j ++){
                k = 100 - i - j ;
                if(k%3 == 0 && 5*i + 3*j + k/3 == 100 ){
                    System.out.println("公鸡、母鸡、小鸡的个数分别是："+i+","+j+","+k);
                    //输出结果是：0 25 75 =》25*3 75，75/3 25，75+25=100
                    //           4 18 78 =》4*5 20,18*3 54,78/3 26,20+54+26=100
                    //           8 11 81 =》8*5 40，11*3 33,81/3 27，40+33+27=100
                    //           12 4 84 =》12*5 60,4*3 12,84/3 28,60+12+28=100
                }
            }
        }
    }
}

案例5：数组元素求和

需求：有这样一个数组，元素是{68，27，95，88，171，996，51，210}。求出该数组中满足要求的元素和。要求是：求和的元素个位和十位都不能是7，并且只能是偶数。

public class Demo19{
    public static void main(String[] args) {
        // 定义数组
        int[] arr = {68,27,95,88,171,996,51,210};
        // 定义求和变量
        int sum = 0;
        // 利用循环依次执行如下判断
        for(int i = 0; i < arr.length ; i++){
            // 求数组元素个位和十位的数字
            int a = 0;
            int b = 0;
            a = arr[i] % 10;//个位
            b = arr[i] / 10;//十位
            // 数字只能是偶数 且 个位十位不能是7
            if(a != 7 && b != 7 && arr[i] % 2 ==0 ){
                sum += arr[i];
            }
        }
        // 输出数组元素求和的结果
        System.out.println("符合要求数字之和为：" + sum);//结果为1362
    }
}

案例6：数组内容相同

需求：设计方法用于比较两个数组的内容是否相同

public class Demo19{
    public static void main(String[] args) {
        // 静态初始化的方式定义两个数组
        int[] arr1 = {1,2,3};
        int[] arr2 = {1,2};

        // 调用方法
        boolean out = compareArray(arr1,arr2);
        //输出结果
        System.out.println("两数组内容是否相同："+ out );
    }
    //定义方法实现需求
    public static boolean compareArray(int[] arr1,int[] arr2){
        // 判断数组的长度是否一致
        if(arr1.length != arr2.length){
            return false;
        }
        // 利用循环比较两个数组的元素是否相等
        for(int i = 0; i<arr1.length;i++){
            if(arr1[i] != arr2[i]){
                return false;
            }
        }
        return true;
    }
}

案例7：查找

需求：已知一个数组arr = {19,28,37,46,50}，键盘录入一个数据，查找该数据在数组中的索引，并在控制台输出找到的索引值。

import java.util.Scanner;
public class Demo19{
    public static void main(String[] args) {
        //定义一个数组
        int[] arr = {19,28,37,46,50};
        //键盘录入一个数据，导包、创建对象、接收数据
        System.out.println("请输入一个数:");
        Scanner sc = new Scanner(System.in);
        int x = sc.nextInt();
        //定义方法前
        /*//利用循环遍历数组实现键盘录入数据与数组中数据的比较，
        // 定义索引接收值
       int index = -1;
        for(int i = 0;i <arr.length;i++){
            if(arr[i] == x){
                index = i;
            }
        }

        //比较会有两种情况：在数组中，输出对应索引值；不在数组中，返回-1。
        System.out.println("index：" + index);*/
        System.out.println("index:" + findIndex(arr,x));
    }
    // 定义方法实现：查找指定的数据在数组中的索引
    public static int findIndex(int[] arr,int x){
        int index = -1;
        for(int i = 0;i<arr.length;i++){
            if(x == arr[i]){
                index = i;
                break;
            }
        }
        return index;
    }
}

案例8：反转

需求：已知一个数组arr = {19,28,37,46,50}；用程序实现把数组中的元素值交换；交换后的数组arr={50,46,37,28,19}；并在控制台输出交换后的数组元素。
自己的思路

public class Demo19{
        public static void main(String[] args) {
            // 定义一个数组
            int[] arr = {1,28,37,46,50};
            //通过循环实现数组元素前后的交换
            int tep = 0;
            if(arr.length % 2 ==0){
                for(int i = 0;i< arr.length/2;i++){
                    //数组长度是偶数6，则arr.length/2是3
                    int index = arr.length-(i+1);
                    tep = arr[i]; //tep = arr[0] = 1
                    arr[i] = arr[index];//arr[0] = arr[5-(0+1)]=arr[4]
                    arr[index] = tep;
                }
            }else{
                for(int i = 0;i<= arr.length/2;i++){
                    //数组长度是偶数5，则arr.length/2是2
                    int index = arr.length-(i+1);
                    tep = arr[i]; //tep = arr[0] = 1
                    arr[i] = arr[index];//arr[0] = arr[5-(0+1)]=arr[4]
                    arr[index] = tep;
                }
            }
            System.out.print("{");
            for(int i = 0;i<arr.length;i++){
                System.out.print(arr[i]);
                System.out.print(", ");
            }
            System.out.println("}");

        }
}

视频的思路

public class Demo19{
    public static void main(String[] args){
        //静态初始化一个数组
        int[] arr = {1,28,37,46,50,2};
        //定义两个索引值，循环实现将数组前后反转
        // 定义一个中间变量tep
        for(int start = 0,end = arr.length-1; start<=end; start++,end--){
            int tep = 0;
            tep = arr[start];
            arr[start] = arr[end];
            arr[end] = tep;
        }
        printArray(arr);
    }
    //定义方法实现数组的输出
    public static void printArray(int[] arr){
        System.out.print("[");
        for(int i = 0;i<arr.length;i++){
            if(i == arr.length-1){
                System.out.print(arr[i]);
            }else{
                System.out.print(arr[i] + ", ");
            }
        }
        System.out.println("]");
    }
}

两者的区别是：
①前者首先对数组长度的奇偶进行判别，对for循环条件判断语句进行区分，循环语句写了两个；
②后者首先在循环里设置了两个变量用于分别表示正向第某个start，反向第某个end，条件判断语句使用start<=end实现，减少了代码量。

案例9：评委打分

需求：在编程竞赛中，有6个评委为参赛的选手打分，分数为0-100的整数分。选手的最后得分为：去掉一个最高分和一个最低分后的四个评委的平均分。
自己的思路

public class Demo19{
    public static void main(String[] args){
        //静态方法定义一个数组，存放评委打出的6个分数
        int[] arr = {50,42,86,96,20};
        //定义方法实现去掉一个最高分、一个最低分后的四个评委的平均分。
        System.out.println("最终得分是：" + score(arr));
    }
    public static int score(int[] arr){
        //定义选手总分
        int sum = 0;
        //定义选手最高分和最低分
        int max = arr[0],min = arr[0];
        //循环实现排除最高分和最低分
        for(int i = 1;i<arr.length;i++){
            if(arr[i] > max){
                max = arr[i];
            }else if(arr[i] < min){
                min = arr[i];
            }
        }
        //找到小于max，大于min的元素
        for(int i = 0;i<arr.length;i++){
            if(arr[i] >min && arr[i] < max){
                sum += arr[i];
            }
        }
        return sum/(arr.length-2);
    }
}

视频中思路

public class Demo19{
    public static void main(String[] args){
        //动态定义一个数组
        int[] arr = new int[6];
        //键盘输入评委分数，利用循环输入
        Scanner sc = new Scanner(System.in);
        for(int i = 0;i<arr.length;i++){
            System.out.println("请输入第" + (i+1)+"个评委打出分数：");
            arr[i] = sc.nextInt();
        }
        //按照计算公式计算平均分
        int avg = (sum(arr)-getMax(arr)-getMin(arr))/(arr.length-2);
        System.out.println("最终评分是：" + avg);
        
    }
    //方法定义求数组最大值
    public static int getMax(int[] arr){
        int max = arr[0];
        for(int i = 1;i<arr.length;i++){
            if(max < arr[i]){
                max = arr[i];
            }
        }
        return max;
    }
    //方法定义求数组最小值
    public static int getMin(int[] arr){
        int min = arr[0];
        for(int i = 1;i<arr.length;i++){
            if(min > arr[i]){
                min = arr[i];
            }
        }
        return min;
    }
    //方法定义求数组元素之和
    public static int sum(int[] arr){
        int sum = 0;
        for(int i = 0 ; i<arr.length;i++){
            sum += arr[i];
        }
        return sum;
    }

}