java学习笔记9-简单案例

减肥计划if版

import java.util.Scanner;

/*需求：输入星期数，显示今天的减肥活动
    周一：跑步
    周二：游泳
    周三：慢走
    周四：动感单车
    周五：拳击
    周六：好好吃一顿
 */
public class jianfei0if {
    public static void main(String[] args) {

        //键盘录入一个星期数，用一个变量接收
        Scanner sc = new Scanner(System.in);

        System.out.println("输入一个星期数（1-7）");
        int week = sc.nextInt();

        //对星期数进行判断，用if语句实现
        if (week < 1 || week > 7) {
            System.out.println("输入错误");
        } else if (week == 1) {
            System.out.println("跑步");
        } else if (week == 2) {
            System.out.println("游泳");
        } else if (week == 3) {
            System.out.println("慢走");
        } else if (week == 4) {
            System.out.println("动感单车");
        } else if (week == 5) {
            System.out.println("拳击");
        } else if (week == 6) {
            System.out.println("爬山");
        } else {
            System.out.println("好好吃一顿");
        }
    }
}

减肥计划swit版

import java.util.Scanner;

public class jianfei0switch {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        System.out.println("请输入一个数（1-7）");
        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("输入有误");

        }
    }
}

逢七过

输出含七或七的倍数的数

/*需求：
输出含七或七的倍数的数
 */
public class feng7guo {
    public static void main(String[] args) {
        //获取1-100的数
        for (int i = 1; i <= 100; i++) {
            //if判断
            if (i % 10 == 7 || i / 10 % 10 == 7 || i % 7 == 0) {
                //输出
                System.out.println(i);
            }
        }
    }
}

输出不含七或七的倍数的数

    //输出不含七或七的倍数的数
public class feng7guo {
    public static void main(String[] args) {
        //获取1-100的数
        for (int i = 1; i <= 100; i++) {
            //if判断
            if (i % 10 != 7 && i / 10 % 10 != 7 && i % 7 != 0) {
                //输出
                System.out.println(i);
            }
        }
    }
}  

兔生兔

/*需求：
有一对兔子，从出生后第三个月起每个月都生一对兔子，小兔子长到第三个月后每个月又生一对兔子，假如兔子都不死，问二十个月的兔子对数为多少
 */
/*规律：
从第三个数据开始，每一个数据都是前两个数据之和
第一个第二个数据是已知的

用数组模拟：
arr[0] = 1;
arr[1] = 1;
arr[2] = arr[0] + arr[1];
arr[3] = arr[1] + arr[2];
 */
public class tuzi {
    public static void main(String[] args) {
        //定义一个数组，用动态初始化完成数组元素的初始化，长度为20
        int[] arr = new int[20];

        //以为第一个月第二个月是已知的所以
        arr[0] = 1;
        arr[1] = 1;

        //用循环实现每个月的兔子对数
        for (int x = 2; x < arr.length;x++){
            arr[x] = arr[x-2] + arr[x-1];
        }
        //输出数组中最后一个元素，就是第20个月的兔子对数
        System.out.println("20个月的兔子对数为："+arr[19]);
    }
}

百钱百鸡

/*鸡翁一值钱五，鸡母一值钱三，鸡雏三值钱1
百钱买百鸡，问鸡翁，鸡母，鸡雏各几何
 */
public class baiqianbaiji {
    public static void main(String[] args) {
        //第一层循环，表示鸡翁的范围，初始化表达式的变量定义为x=0，判断条件是x<=20
        for (int x = 0; x <= 20; x++) {
            //第二层循环，表示鸡母的范围，初始化表达式的变量自定义为y=0，判断条件是y<=33
            for (int y = 0; y <= 33; y++) {
                //这个时候，用于表示鸡雏的变量z=100-x-y
                int z = 100 - x - y;

                //判断表达式z%3==0和表达式5*x+3*y+z/3==100是否同时成立
                if (z % 3 == 0 && 5 * x + 3 * y + z / 3 == 100) {
                    System.out.println(x + "," + y + "," + z);
                }
            }
        }
    }
}

数组元素求和

/*
需求：有这样一个数组，元素是{68，27，95，88，171，996，51，210}.求出该数组中满足要求的元素和
 */
public class sunarr {
    public static void main(String[] args) {
        //定义一个数组，用静态初始化完成数组元素的初始化
        int[] arr = {68, 27, 95, 88, 171, 996, 51, 210};

        //定义一个求和变量，初始值是0
        int sum = 0;

        //遍历数组，获取到数组中的每一个元素
        for (int x = 0; x < arr.length; x++) {
            //判断该元素是否满足条件，如果满足就累加
            if (arr[x] % 10 != 7 && arr[x] / 10 % 10 != 7 && arr[x] % 2 == 0) {
                sum += arr[x];
            }
        }
        //输出求和变量的值
        System.out.println("sun:" + sum);

    }
}

数组内容相同

/*
需求：设计一个方法，比较两个数组是否相同
 */
public class shuzuxiangtong {
    public static void main(String[] args) {
        //定义一个数组，分别使用静态初始化
        int[] aar = {11, 22, 33, 44, 55};
        int[] aar2 = {11, 22, 33, 44, 55};

        //调用方法，用变量接受
        boolean flag = compare(aar,aar2);
        //输出结果
        System.out.println(flag);
    }

    //定义一个方法，用于比较两个数组的内容是否相同
    /*
    两个明确：
        返回值类型：boolean
        参数：int[] arr,int arr2
     */
    public static boolean compare(int[] arr, int[] arr2) {
        //首先比较数组的长度，如果长度不相同，数组内容肯定不相同，返回false
        if (arr.length != arr2.length) {
            return false;
        }
        //其次遍历，比较两个数组中的每一个元素，只要有元素不相同，返回false
        for (int x = 0; x < arr.length; x++) {
            if (arr[x] != arr2[x]) {
                return false;
            }
        }
        return true;
    }
}

查找

/*
需求：找数组中的索引值
 */
public class zhachao {
    public static void main(String[] args) {
        //定义一个数组，分别使用静态初始化
        int[] arr = {1, 8, 6, 9, 51, 24, 36, 95, 78};

        //键盘录入要查找的数据，用一个变量接收
        Scanner sc = new Scanner(System.in);

        System.out.println("输入要查找的数据");
        int number = sc.nextInt();
        
        //输出索引变量
        int index = getIndex(arr,number);
        System.out.println("index:" + index);
    }

    //查找指定的数据在数组中的索引
    //定义一个方法遍历查找数组元素
    /*
    两个明确：
        返回值类型：int
        参数：int[] arr ,int number
     */
    public static int getIndex(int[] arr, int number) {
        //定义一个索引变量，初始值为-1
        int index = -1;

        //遍历数组，获取到数组中的每一个元素
        for (int x = 0; x < arr.length; x++) {
            //拿键盘录入的数组和数组中的每一个元素进行比较，如果值相同，就把该值对应的索引赋给index变量
            if (arr[x] == number) {
                index = x;
                break;
            }
        }
        //返回索引
        return index;
    }
}

反转

/*
需求：
已知数组，用程序把数组中元素交换
 */
public class fanzhuan {
    public static void main(String[] args) {
        //定义一个数组，分别使用静态初始化
        int[] arr = {51, 99, 65, 35, 45,};
        
		//反转数组
        reverse(arr);
        //遍历数组
        printArray(arr);

    }
    //定义一个方法调换数组元素
    /*
    两个明确
        返回值类型：void
        参数：int[] arr
     */
    public static void reverse(int[] arr) {
        //循环遍历数组，这一次初始化语句定义两个索引变量，判断条件是开始索引小于等于结束索引
        for (int start = 0, end = arr.length - 1; start <= end; start++, end--) {
            //变量交换
            int temp = arr[start];
            arr[start] = arr[end];
            arr[end] = temp;
        }
    }
	//定义一个方法打印数组输出[a,b]格式
    /*
    两个明确
        返回值类型：void
        参数：int[] arr
     */
        public static void printArray ( int[] arr){
            System.out.print("[");

            for (int x = 0; x < arr.length; x++) {
                if (x == arr.length - 1) {
                    System.out.print(arr[x]);
                } else {
                    System.out.print(arr[x] + ",");
                }
            }
            System.out.print("]");
        }
    }

评委打分

import java.util.Scanner;

/*
需求：6个评委打分，分数为0-100的整数分，选手的最后的分为：去掉一个最高分，去掉一个最低分，剩下的平均值
 */
public class pingweidafen {
    public static void main(String[] args) {
        //定义一个数组，用动态初始化完成数组元素的初始化，长度为6
        int[] arr = new int[6];

        //键盘录入评委分数
        Scanner sc = new Scanner(System.in);
        for (int x = 0; x < arr.length; x++) {
            System.out.println("请输入第" + (x + 1) + "个评委打分");
            arr[x] = sc.nextInt();
        }
        
        //定义方法实现获取数组中的最高分（最大值）调用方法
        int max = getMax(arr);
        //定义方法实现获取数组中的最低分（最小值）调用方法
        int min = getMin(arr);
        //定义方法实现获取数组中的所有元素和（数组元素和）调用方法
        int sum = getSum(arr);

        //按照规则出分
        int avg = (sum - max - min) / (arr.length - 2);

        //输出
        System.out.println("最终得分为：" + avg);
    }
    
    //定义一个方法求数组元素之和

    /*
     两个明确：
         返回值类型：int
         参数：int[] arr
      */
    public static int getSum(int[] arr) {
        int sum = 0;
        for (int x = 0; x < arr.length; x++) {
            sum += arr[x];
        }
        return sum;
    }
	//定义一个方法求最小值
    /*
       两个明确：
           返回值类型：int
           参数：int[] arr
        */
    public static int getMin(int[] arr) {
        int min = arr[0];

        for (int x = 1; x < arr.length; x++) {
            if (arr[x] < min) {
                min = arr[x];
            }
        }
        return min;
    }
	//定义一个方法求最大值
    /*
       两个明确：
           返回值类型：int
           参数：int[] arr
        */
    public static int getMax(int[] arr) {
        int max = arr[0];

        for (int x = 1; x < arr.length; x++) {
            if (arr[x] > max) {
                max = arr[x];
            }
        }
        return max;
    }
}