day06 java编程基础综合练习

/*
        练习99乘法表

        分析:
            第一行打印一个表达式,第n行打印n个表达式;需要使用循环嵌套完成,外层控制行,内层控制每一行表达式的个数;
            在内循环中,使用字符串拼接,完成表达式的输出;在内循环后换行;
         步骤:
            1:写外循环,从1循环到9
            2:写内循环,从1到外循环的变量i
            3:在内循环中,使用字符串拼接,完成表达式的输出;
            4:在内循环后换行;
 */
public class JiuJiuCFB {
    public static void main(String[] args) {
        cfb();
    }
    // ctrl+alt+m可以将选中的一片代码提取成一个方法
    public static void cfb() {
        //1:写外循环,从1循环到9
        for (int i = 1; i <=9 ; i++) {
            //2:写内循环,从1到外循环的变量i
            for (int j = 1; j <=i ; j++) {
              //3:在内循环中,使用字符串拼接,完成表达式的输出;   1*1=1
                System.out.print(j+"*"+i+"="+(j*i)+"\t");
            }
            //4:在内循环后换行;
            System.out.println();
        }
    }
}

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

    思路：
        1:定义两个数组，分别使用静态初始化完成数组元素的初始化
        2:定义一个方法，用于比较两个数组的内容是否相同
        3:比较两个数组的内容是否相同，按照下面的步骤实现就可以了
            首先比较数组长度，如果长度不相同，数组内容肯定不相同，返回false
            其次遍历，比较两个数组中的每一个元素，只要有元素不相同，返回false
            最后循环遍历结束后，返回true
        4:调用方法，用变量接收
        5:输出结果
 */
public class BiJiaoShuZu {
    public static void main(String[] args) {
        //定义两个数组，分别使用静态初始化完成数组元素的初始化
        int[] arr = {11, 22, 33, 44, 55};
        //int[] arr2 = {11, 22, 33, 44, 55};
        int[] arr2 = {11, 22, 33, 44, 5};


        //调用方法，用变量接收
        boolean flag = compare(arr,arr2);
        //输出结果
        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;
            }*/
            if(arr[x]==arr2[x]){
                //继续比较下一个
                continue;
            }else {
                //说明此时的x位置的两元素不相同,没有必要继续比了,可以直接得出结论,false
                return false;
            }
        }

        //最后循环遍历结束后，返回true
        return true;
    }
}

/*
    需求:
        打印出1--100之间缝7过案例中所有不能说的数字,且每6个数字换一行;
    分析:
        1:统计已经打印出来的数字的个数,
        2:判断这个个数,如果个数是6的倍数时则换行;
 */
public class Demo01 {
    public static void main(String[] args) {
        int count=0;
        //1:找出1--100之间不能说的数字
        for (int i = 1; i <=100 ; i++) {
            if(i%10==7||i/10%10==7||i%7==0){
                //证明这个数字i不能说
                System.out.print(i+"\t");//仅仅只输出数字,不考虑换行
                //统计已经打印的数字的个数
                count++;
                if (count % 6 == 0) {
                    System.out.println();
                }
            }

        }
    }
}

/*
    需求:
        自定义一个方法从数组中找出指定元素对应的所有索引,并返回;
    分析:
        由于元素对应的索引的个数不确定,我们只能设计返回值为数组类型,将来将找到的所有索引都存放到数组中,然后返回数组即可;
        由于开始的时候,长度和元素都不确定因此.只能先确定长度,再确定元素;
    步骤:
        1:先确定数组中有几个合法的索引;
        2:创建一个对应长度的整数数组;
        3:由于下面的步骤中要操作新数组,所以需要单独给新数组定义一个变量,表示索引;
        4:再次遍历老数组,找到其中合法的索引保存到新数组中;
 */
public class ArrayDemo01 {
    //自定义一个方法从数组中找出指定元素对应的所有索引,并返回;
    public static int[] getIndexs(double[] arr,double key){
        // 1:先确定数组中有几个合法的索引;
        int count = 0;
        for (int i = 0; i < arr.length; i++) {
            //使用数组arr中的每一个元素与key比较,但凡比较成功,则让数量+1
            if(arr[i]==key){
                count++;
            }
        }
        //在开发中,如果找不到数据,对于引用数据类型,我们可以返回null
        if(count==0){
            //说明key在数组中不存在,则返回null
            return null;
        }
        //但凡代码能执行到这里,就证明key在数组中存在了  count次
        //2:创建一个对应长度的整数数组;
        int[] arr2= new int[count];
        //3:由于下面的步骤中要操作新数组,所以需要单独给新数组定义一个变量,表示索引;
        int index = 0;
        //4:再次遍历老数组,找到其中合法的索引保存到新数组中;
        for (int i = 0; i < arr.length; i++) {
            if(arr[i]==key){
                //说明当前这个索引是我们要找的,则将当前这个索引i保存到数组arr2中的index位置'
                arr2[index] = i;
                index++;
            }
        }
        //返回arr2即可
        return arr2;
    }

    public static void main(String[] args) {
        double[] arr = {1.1,2.2,2.2,2.2,1.1,5.5,6.6};
        int[] indexs = getIndexs(arr, 2.22);
        if(indexs!=null){
            for (int i = 0; i < indexs.length; i++) {
                System.out.print(indexs[i]+"   ");
            }
        }else {
            System.out.println("没找着...");
        }
    }
}

分析以下需求并实现
(1)定义方法public static boolean isSym(int[] arr)，判断数组中的元素值是否对称,对称返回true，不对称返回false；
(2)在main方法中，定义一个数组，并调用方法。
(3)打印结果：[1,2,3,4,3,2,1]是否对称：true

public class Test1 {
    public static void main(String[] args) {
        int[] arr = {1, 2, 3, 4, 3, 2, 1};
        //打印数组
        printArr(arr);
//        调用方法验证数组是否对称
        boolean duicheng = isSym(arr);
        System.out.println("是否对称：" + duicheng);
    }

    //验证数组是否对称
    public static boolean isSym(int[] arr) {
        for (int start = 0, end = arr.length - 1; start <= end; start++, end--) {
            if (arr[start] != arr[end]) {
                //只要有不相等的 就是不对称 
                return false;
            }
        }
        //for循环结束以后 要是没有不相等的 那就是对称的
        return true;
    }

    //打印数组
    public static void printArr(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.print("]");
    }
}

分析以下需求并实现
(1)定义一个长度为6的int类型数组，元素值使用随机数生成（范围为50-80）
(2)求出该数组中满足要求的元素和。
要求：求和的元素的个位和十位不能包含7,并且只能为偶数。

public class Test2 {
    public static void main(String[] args) {
        //动态生成数组
        int[] arr = new int[6];
        //创建随机数对象
        Random r = new Random();
        //调用方法 使用随机数把生成的随机数加入到数组中
        addArr(r, arr);
        //调用方法，求满足要求的元素的和
        int sum = sum_arr(arr);
        System.out.println("该数组中满足要求的元素的和为：" + sum);
    }

    public static void addArr(Random r, int[] arr) {
        for (int i = 0; i < arr.length; i++) {
            arr[i] = r.nextInt(31) + 50;
//            System.out.println(arr[i]);
        }
    }

    public static int sum_arr(int[] arr) {
        int sum = 0;
        for (int i = 0; i < arr.length; i++) {
            int ge = arr[i] % 10;
            int shi = arr[i] / 10;
            if (ge != 7 && shi != 7 && arr[i] % 2 == 0) {
                //如果满足条件 就计算sum
                sum += arr[i];
            } else {
                //如果不满足，那就直接跳过本次循环，进行下一次循环
                continue;
            }
        }
        //最终把sum返回
        return sum;
    }
}

分析以下需求并实现
(1) 定义方法public static int getCount(int[] arr,int num)，求出指定元素在数组中出现的次数.
(2)定义方法public static int getAllCount(int[] arr)，统计数组中出现次数为1的元素一共有多少个。
(推荐-遍历数组，然后调用第一个方法，求出数组中每个元素在数组中出现的次数，如果只出现了一次，就统计)
(3) 在main方法中定义数组，如int arr[]={1,3,4,5,0,0,6,6,0,5,4,7,6,7,0,5};。然后调用getAllCount方法，统计只出现一次的元素有多少个。
打印结果：数组中只出现一次的元素有2个/

public class Test3 {
    public static void main(String[] args) {
        int arr[] = {1, 3, 4, 5, 0, 0, 6, 6, 0, 5, 4, 7, 6, 7, 0, 5};
        Scanner sc = new Scanner(System.in);
        System.out.println("请输入一个数字用来查询：");
        int num = sc.nextInt();
        int cout = getCount(arr, num);
        System.out.println(num + "在arr数组中出现了" + cout + "次");

        int count_all = getAllCount(arr);
//        System.out.printf("数组中只出现一次的元素有%d个", count_all);
        //这两个打印效果一样，上面是格式化打印，作为了解
        System.out.println("数组中只出现一次的元素有" + count_all + "个");
    }

    public static int getCount(int[] arr, int num) {
        int count = 0;
        for (int i = 0; i < arr.length; i++) {
            if (arr[i] == num) {
                //每次满足相等 就计数一次
                count++;
            }
        }
        return count;
    }

    public static int getAllCount(int[] arr) {
        //定义变量，用来记录只出现过一次的元素的数量
        int count_all = 0;
        for (int i = 0; i < arr.length; i++) {
            //调用getCount方法，依次确认每个元素出现的次数
            int count = getCount(arr, arr[i]);
            //判断如果只出现一次，那就计数
            if (count == 1) {
                count_all++;
            } else {
                //如果不是出现一次，那就直接跳过本次循环
                continue;
            }
        }
        //返回只出现过一次的元素的数量
        return count_all;
    }
}