Java基础day06- 嵌套循环与数组-CSDN博客

本文链接：https://blog.csdn.net/liang79096/article/details/137053547

1.小测

（1）赌数游戏

注意：1.随机数的选取由Math.random的调用(0-1)间的随机数*6+1 得到1-6的范围

2.利用swit case 将字符串当作常量留给 case 判断

package com.atguigu.exer;

import java.util.Scanner;

/*
一 赌数游戏：随机产生3个1-6的整数，如果三个数相等，那么称为“豹子”，
	如果三个数之和大于9，称为“大”，如果三个数之和小于等于9，称为“小”，
	用户从键盘输入押的是“豹子”、“大”、“小”，输入后程序判断是否猜对了
	提示：
		1.随机数  Math.random()产生 [0,1)范围内的小数
		2.押豹子只判断三个数是否一样
		  押大小只判断三个数的总和
		3.不需要循环
 */
public class DiceTest {
    public static void main(String[] args) {
        //随机产生3个1-6的整数，
        int num1 = (int)(Math.random() * 6 + 1);
        int num2 = (int)(Math.random() * 6 + 1);
        int num3 = (int)(Math.random() * 6 + 1);

        System.out.println(num1 + " " + num2 + " " + num3);

        //通过键盘输入：豹子，大，小
        Scanner s = new Scanner(System.in);//创建对象
        System.out.print("下注（豹子,大,小）：");
        String s2 = s.next();//调用方法-从键盘读取一个字符串

        //判断
        /*
        下面的内容后面讲
        if ("豹子".equals(s2)){ //字符串比较内容不要用== 用equals方法（后面讲）
            System.out.println("豹子");
        } else if ("大".equals(s2)) {
            System.out.println("大");
        } else if ("小".equals(s2)){
            System.out.println("小");
        }else{
            System.out.println("输入无效");
        }
         */
        boolean bo = false;//用来控制猜的对错（豹子 大  小）

        boolean bo2 = true;//如果猜的不是豹子 大 小 那么用来控制是否还输出："猜中了" : "猜错了

        switch (s2){
            case  "豹子":
                bo = num1 == num2 && num2 == num3;
                break;
            case "大":
                int sum = num1 + num2 + num3;
                bo = sum > 9;
                break;
            case "小":
                int sum2 = num1 + num2 + num3;
                bo = sum2 <= 9;
                break;
            default:
                bo2 = false; //不再输出："猜中了" : "猜错了
                System.out.println("输入内容无效");
                break;
        }
        if (bo2) {//判断是否输出："猜中了" : "猜错了
            System.out.println(bo ? "猜中了" : "猜错了");
        }
    }
}

（2）比大小

注意：多次输入且不了解具体输入次数故用while

package com.atguigu.exer2;

import java.util.Scanner;

/*
案例三： 猜大小 。从键盘输入1到100之间的数。如果大了就输出猜大了 如果小了就输出猜小了
        猜对了停止程序执行。
    补充：
        要猜的数是随机数：Math.random()得到的结果是[0,1)  要得到1到100的数
 */
public class GuessNumberTest {
    public static void main(String[] args) {
        //随机生成的一个数（要猜的数）
        int number = (int)(Math.random() * 100 + 1);
        System.out.println("number:" + number);

        //2.从键盘读取数据
        Scanner s = new Scanner(System.in);//创建一次对象就会在内存（堆）中占用一块内存

        while(true) {//不断的猜数
            //获取猜的值
            System.out.print("请输入猜的数(1到100):");
            int guessNumber = s.nextInt();

            //比较
            if (guessNumber < number){
                System.out.println("猜小了");
            } else if (guessNumber > number) {
                System.out.println("猜大了");
            } else{
                System.out.println("猜对了");
                break;
            }
        }
    }
}

（3）珠峰折叠

注意：单位换算

package com.atguigu.exer2;

/*
案例二：珠穆朗玛峰高8844.43米 一张纸的厚度0.1毫米 请问这张纸折叠多少次能超过珠穆朗玛峰的高度
 */
public class ZFTest {
    public static void main(String[] args) {
        int zf = 8844430;//珠穆朗玛峰高
        double paper = 0.1;//纸的厚度
        int count = 0;//折叠的次数

        while(paper < zf){ //如果纸的厚度小于珠峰的高度就需要不断的折叠
            paper *= 2;//每调用一次 纸折叠一次
            count++;
        }

        System.out.println("count:" +count);
    }

2.嵌套中break；与continue的作用对象

注意：break结束的是包含它的那层循环的当前循环

continue 结束的是包含它的那层循环的当次循环

package com.atguigu.java;

/*
    在嵌套循环中
        break : break结束的是包含它的那层循环当前循环
        continue ：结束的是包含它的那层循环的当次循环

    结束指定的那层循环：
        1.给那层循环起名字
        2.在brak的后面跟上循环的名字
 */
public class BreakContinueTest {

    public static void main(String[] args) {

        for (int i = 1; i <= 3 ; i++) {
            for (int j = 1; j <=3 ; j++) {
                if (j == 2){
                    //break;//break结束的是包含它的那层循环的当前循环
                    continue;//结束的是包含它的那层循环的当次循环
                }
                System.out.println("i=" + i + " j=" + j);
            }
        }

        System.out.println("==================================");

        //结束外层循环
        lable : for (int i = 1; i <= 3 ; i++) { // 给循环起名字:   名字：for(;;)
            for (int j = 1; j <=3 ; j++) {
                if (j == 2){
                    break lable;//结束指定的循环 : break 循环的名字;
                }
                System.out.println("i=" + i + " j=" + j);
            }
        }

        System.out.println("程序结束");

    }

}

3.嵌套循环本体及小练习

注意循环结束时输出位置，别让输出语句在循环内进行

外圈循环表示列内圈表示行

同可用i-- 但不常用

package com.atguigu.java;

/*
    嵌套循环 ： 在一个循环a中 在 写一个循环b。 a叫作外层循环 b叫作内层循环。

    说明：
        1.外层循环控制行 内层循环控制列
        2.循环的次数 = 外层循环的次数 * 内层循环的次数
        3.外层循环一次 内层循环一轮
 */
public class ForForTest {
    public static void main(String[] args) {

        /*
            *****
         */
        for (int i = 1; i <= 5; i++) {
            System.out.print("*");
        }
        System.out.println();//换行
        System.out.println("=======================================");

        /*
             *****
             *****
             *****
             *****
             *****
         */
        for(int j = 1; j <= 5; j++) { //外层循环控制行 内层循环控制列

            for (int i = 1; i <= 5; i++) {//外层循环一次 内层循环一轮
                System.out.print("*");
            }
            System.out.println();
            
        }

        System.out.println();//换行
        System.out.println("=======================================");

        /*
                        行i          列j
             *          1           1
             **         2           2
             ***        3           3
             ****       4           4
             *****      5           5
         */
        for (int i = 1; i <= 5 ; i++) { //控制行
            for (int j = 1; j <= i; j++) {//控制列
                System.out.print("*");
            }
            System.out.println();
        }

        System.out.println();//换行
        System.out.println("=======================================");

        /*                  行 i             列j
             *****          1               5
             ****           2               4
             ***            3               3
             **             4               2
             *              5               1
         */
        for (int i = 1; i <= 5 ; i++) {//控制行（控制轮）
            for (int j = 1; j <= 6 - i; j++) {
                System.out.print("*");
            }
            System.out.println();
        }

        System.out.println();//换行
        System.out.println("=======================================");

         /*
                           行i     列(空格)k      列j
             ----*          1         4          1
             ---* *         2         3          2
             --* * *        3         2          3
             -* * * *       4         1          4
             * * * * *      5         0          5
         */
        for (int i = 1; i <= 5 ; i++) {

            /*
                输出 空格
             */
            for (int k = 0; k < 5 - i; k++) {
                System.out.print(" ");
            }
            /*
                输出 *
             */
            for (int j = 1; j <= i ; j++) {
                System.out.print("* ");
            }

            System.out.println();
            
        }
        System.out.println();//换行
        System.out.println("=======================================");

         /*
                           行i     列(空格)k      列j
             ----*          1         4          1
             ---* *         2         3          2
             --* * *        3         2          3
             -* * * *       4         1          4
             * * * * *      5         0          5
             -* * * *       1         1         4
             --* * *        2         2         3
             ---* *         3         3         2
             ----*          4         4         1
         */
        for (int i = 1; i <= 5 ; i++) {
            for (int k = 0; k < 5 - i; k++) {
                System.out.print(" ");
            }
            for (int j = 1; j <= i ; j++) {
                System.out.print("* ");
            }
            System.out.println();
        }

        for (int i = 1; i <= 4 ; i++) {
            for (int k = 1; k <= i ; k++) {
                System.out.print("-");
            }
            for (int j = 1; j <= 5 - i; j++) {
                System.out.print("* ");
            }
            System.out.println();
        }
    }
}

4.练习：九九乘法表

值得注意的是：最后输入” “时会因为乘积从一位变两位而错位

但输入"\t"则不会

package com.atguigu.java;

/*
    九九乘法表
 */
public class JiuJiuTest {

    public static void main(String[] args) {

        for (int i = 1; i <= 9 ; i++) {
            for (int j = 1; j <= i ; j++) {
                System.out.print(j + "*" + i + "=" + i*j + " ");
            }
            System.out.println();
        }

    }
}

5 练习：输出2-100的质数

注意：输出时确定输出语句位置

去掉偶数可以有效减少运行次数

建议：理解并多练几遍

package com.atguigu.java;

/*
    输出100以内的质数（素数）

    质数：只能被1和自身整除的数。 2是最小的质数 除2以外质数都是奇数
 */
public class PrimeNumberTest {
    public static void main(String[] args) {

        //1.遍历100以内的数
        for (int i = 2; i <= 100; i++) {//遍历100以内的数
            //该变量的作用用来说明当前i的值是否是质数。
            boolean flag = true;//假设每一个数都是质数。

            //判断奇偶
            /*
                1.先判断奇偶
                    偶数：一定不是质数（直接打标记）
                    奇数：不一定是质数
                        需要再次判断（1.是质数就不会修改标记  2.不是质数会修改标记）
                2.通过标记判断是否是质数
             */
            //i != 2 && i % 2 == 0  是偶数但不能是2
            if (i != 2 && i % 2 == 0){//偶数 - 一定不是质数
                flag = false;
            }else {
                //2.用来判断i的值是否为质数
                for (int j = 2; j <= i - 1; j++) {//遍历每个数(n)的 : 2 到 n-1
                    //判断和n这个数中的 2 到 n-1 是否能够整除。如果有一个数可以被整除那就不是质数
                    if (i % j == 0) {
                        //不是质数 ---修改标记
                        flag = false;//如果该值不是质数那么就将标记改为false 并且终止判断
                        break;
                    }
                }
            }

            //3.输出
            if (flag){//通过变量flag判断是否为质数
                System.out.println(i + "是质数");
            }else{
                //System.out.println(i + "不是质数");
            }

        }

    }
}

6. 数组及输入练习

声明数组有两种方法

注意声明类型

长度和遍历

package com.atguigu.java2;

/*
    数组：可以用来存储多个相同类型的数据的容器

    说明：
        1.数组是引用数据类型。数组中的数据可以是基本数据类型也可以是引用数据类型（取决于是一个什么类型的数组）。
        2.数组中的数据被称为元素。
        3.数组一旦初始化完成数组的长度不可变。

    数组的分类： 一维数组，二维数组,......多维数组。
 */
public class ArrayTest {
    public static void main(String[] args) {

        //1.声明数组
        //格式： 数据类型[] 数组名;
        //      数据类型  数组名[];
        int[] scores;//数组中的元素是int类型 -- 建议使用此写法
        String names[];//数组中的元素是String类型。

        //2.静态初始化：用静态数据（编译时可以确定）对数组进行初始化。静态数据的个数就是数组的长度。
        //方式一：数组的声明和初始化可以分开写。
        scores = new int[]{5,2,4,1,9};//每个元素之间用逗号分隔开。该数组的长度为5
        names = new String[]{"小龙哥","小饭老师","小泽老师"};//该数组的长度为3
        //方式二 : 数组的声明和初始化不能分开。
        int[] ids = {1,6,3,9,10};//可以理解成是方式一的简写

        //3.获取数组中的元素：要通过数组的下角标获取数组中的元素。
        //下角标（索引,下标）：数组中的每个元素都有一个编号该编号就是下角标。
        //      注意：下角标的范围是0到（数组的长度-1）
        String name = names[1];//取值
        System.out.println(name);
        names[1] = "大海哥";//赋值
        System.out.println(names[1]);//直接输出数组中的内容


        //4.获取数组的长度 : 数组名.length
        int len = names.length;//数组的长度
        System.out.println(len);
        System.out.println(scores.length);

        System.out.println("===================================");

        //5.遍历数组中所有的元素
        int[] sid = {10,5,3,8,10,9};
        for (int i = 0; i < sid.length; i++) {//在这i的值当成索引值。索引是从0开始。
            System.out.println(sid[i]);
        }

        //注意：一旦索引值不在合理范围内（0 到 数组的长度-1）就会报错。
        //ArrayIndexOutOfBoundsException : 下角标越界
        //System.out.println(sid[-1]);//sid的索引范围是0~5


    }
}

7.数组的动态初始化及默认类型

先输入长度后数组

package com.atguigu.java2;


public class ArrayTest2 {
    public static void main(String[] args) {
        //声明数组
        String[] names;

        //动态初始化：通过指定数组的长度初始化数组但是数组中只有默认值。初始化完成后再给数组中的元素进行赋值。
        names = new String[3];//3指的是数组的长度。数组中现在只有默认值。

        //给数组中的元素赋值
        names[0] = "a";
        names[1] = "b";
        names[2] = "c";

        //遍历数组中的元素 (快捷方式: 数组名.fori)
        for (int i = 0; i < names.length; i++) {
            System.out.println(names[i]);
        }

        System.out.println("=======================================");
        /*
            数组中元素的默认值：
                基本数据类型：
                    整型默认值：0
                    浮点型默认值:0.0
                    布尔类型默认值: false
                    字符类型默认值: \u0000

                引用数据类型：null
         */
        //整型默认值：0
        byte[] n1 = new byte[2];
        short[] n2 = new short[2];
        int[] n3 = new int[2];
        long[] n4 = new long[2];
        System.out.println(n1[0] + " " + n2[0] + " " + n3[0] + " " + n4[0]);

        //浮点型默认值:0.0
        float[] f1 = new float[2];
        double[] d1 = new double[2];
        System.out.println(f1[0] + " " + d1[0]);

        //布尔类型默认值: false
        boolean[] bo = new boolean[2];
        System.out.println(bo[0]);

        //字符类型默认值: \u0000
        char[] c = new char[2];
        System.out.println("-" + c[0] + "-");

        String[] s = new String[2];
        System.out.println(s[0]);
    }
}

8.一堆数组的内存及硬件图

注意动态数组定义的是地址

故赋予的也是地址

package com.atguigu.java2;

/*
    一维数组的内存
 */
public class ArrayTest3 {
    public static void main(String[] args) {

        String[] s = new String[3];
        s[0] = "小龙哥";
        s[2] = "圆圆";

        String[] s2 = s;
        s2[1] = "强哥";

        for (int i = 0; i < s.length; i++) {
            System.out.println(s[i]);
        }
        System.out.println("============================");
        for (int i = 0; i < s2.length; i++) {
            System.out.println(s2[i]);
        }
    }
}