一、循环流程控制

3种循环结构：

• for
• while
• do-while

1、for循环

适用于固定次数的循环

for循环四要素：初始化、循环条件、递增/递减、循环体

累加求和案例：

/**
 * @document: 累加求和
 * @Author:SmallG
 * @CreateTime:2023/7/20+18:46
 */

public class ForDemo1 {
    //计算从1到100的和
    public static void main(String[] args) {
        int sum = 0;
        for (int i = 1; i <= 100; i++) {
            sum +=i;
        }
        System.out.println(sum); //5050
    }
}

输出100以内所有13的倍数案例：

/**
 * @document: 输出100以内所有13的倍数
 * @Author:SmallG
 * @CreateTime:2023/7/20+18:52
 */

public class ForDemo2 {
    public static void main(String[] args) {
        for (int i = 0; i < 100; i++) {
            if (i % 13 == 0) {
                System.out.print(i + " ");
            }
        }
    }
}

break语句案例：

/**
 * @document:统计1到100的累加和，条件是当和大于等于4000时则终止计算
 * @Author:SmallG
 * @CreateTime:2023/7/20+18:57
 */

public class BreakDemo {
    public static void main(String[] args) {
        int sum = 0;
        for (int i = 1; i <= 100; i++) {
            sum += i;
            if (sum >= 4000) {
                break;
            }
        }
        System.out.println(sum);
    }
}

for循环与continue案例：

continue用于结束当前的一次循环

/**
 * @document: continue关键字
 * @Author:SmallG
 * @CreateTime:2023/7/21+10:18
 */

public class ForDemo05 {
    public static void main(String[] args) {
        //逢7过 遇到7或者7的倍数 就跳过 不输出
        for (int i = 1; i <= 100; i++) {
            if (i % 7 == 0 || i % 10 == 7 || i / 10 == 7) {
                continue;
            }
            System.out.print(i+" ");
        }
        System.out.println();
    }
}

for循环变量作用域案例：

/**
 * @document: for循环的作用域
 * @Author:SmallG
 * @CreateTime:2023/7/21+10:39
 */

public class ForDemo06 {
    public static void main(String[] args) {
        int i =0;
        for (;i<=3;i++){
            System.out.print(i+"-");
        }
        for (;i<=5;i++){
            System.out.print(i+"+");
        }
        System.out.println(i); // 0-1-2-3-4+5+6
    }
}

for省略循环条件

/**
 * @document: 省略循环条件
 * @Author:SmallG
 * @CreateTime:2023/7/21+11:03
 */

public class ForDemo07 {
    public static void main(String[] args) {
        for (int i = 0; ; i++) {
            System.out.print(i + " ");
            if (i == 10) {
                break;
            }
        }
        System.out.println();
        //循环省略增量
        for (int i=0;i<=10;){
            System.out.print(i+" ");
            i++;
        }
        System.out.println(6);
    }
}

for循环逗号表达式：

for循环中可以定义多个循环变量，实现复杂机制

注意：循环条件只能有一个

/**
 * @document: for循环逗号表达式
 * @Author:SmallG
 * @CreateTime:2023/7/21+11:25
 */

public class ForDemo08 {
    public static void main(String[] args) {
        for (int i = 1, j = 6; i <= 6; i+=2, j-=2) {
            System.out.println(i+" "+j);
            /*
            1 6
            3 4
            5 2
             */
        }
    }
}

for循环经典问题：猴子吃桃

有一只猴子第一天摘了若干桃子，当时吃了一半觉得不过瘾又多吃了一个

第二天醒来 又吃了前一天剩下的一半 觉得不过瘾 有多吃了一个

以后每一天都是吃了前一天剩下的一半 多一个

到第九天再吃的时候发现只剩下1个桃子

问 ：第一天一共摘了多少个桃子？

/**
 * @document: 猴子吃桃问题
 * @Author:SmallG
 * @CreateTime:2023/7/21+11:32
 */

public class EatPeaches {
    public static void main(String[] args) {
        int sum = 1;  //一共接收了多少个桃子
        for (int i = 0; i < 8; i++) {
            sum = (sum + 1) * 2;
        }
        System.out.println(sum);
    }
}

2、while循环

适用于不知道循环多少次的循环结构

摇骰子游戏：

摇到三个一样的就停止

/**
 * @document: 摇骰子游戏
 * @Author:SmallG
 * @CreateTime:2023/7/21+11:55
 */

public class WhileDemo01 {
    public static void main(String[] args) {
        int dice1 = 1;
        int dice2 = 2;
        int dice3 = 3;
        Random random = new Random();
        int i=0;
        while (dice1 != dice2 || dice2 != dice3) {
            dice1 = random.nextInt(6) + 1;
            dice2 = random.nextInt(6) + 1;
            dice3 = random.nextInt(6) + 1;
            System.out.println(dice1+" "+dice2+" "+ dice3);
            i++;
            System.out.println(i);
        }
    }
}

3、do...while循环

先执行循环体，再判断，循环体至少有一次。

猜数字游戏：

/**
 * @document: 猜数字游戏 do..while循环
 * @Author:SmallG
 * @CreateTime:2023/7/21+14:05
 */

public class DoWhileDemo01 {
    public static void main(String[] args) {
        //程序随机生成一个100以内的正整数
        //先执行循环体 然后判断条件
        Scanner scanner = new Scanner(System.in);
        //产生一个随机数字
        Random random = new Random();
        //产生一个1到100之间的数字
        int num = random.nextInt(100) + 1;
        System.out.println("开始猜猜吧！");
        int guess;
        do {
            //接收键盘的输入
            guess = scanner.nextInt();
            //比较
            if (guess>num){
                System.out.println("猜大了");
            }else if (guess<num){
                System.out.println("猜小了");
            }else{
                System.out.println("猜中了");
            }
        }while (guess != num); // 当猜的数字不等于num的时候继续进行循环
    }
}

4、while与do...while的区别

while结构，先执行判断条件，符合条件的才能进入循环体，do...while先循环一次，再执行判断条件

“当”循环实例：

/**
 * @document: "当"循环 优先采用while循环
 * @Author:SmallG
 * @CreateTime:2023/7/21+14:20
 */

public class WhileDemo02 {
    public static void main(String[] args) {
        double total = 10000; //存款本金
        //当本金超过12000时停止循环
        while (total < 12000) {
            total += total * 0.03;
        }
        System.out.println(total);
    }
}

“直到”循环实例：

/**
 * @document: "直到"循环 优先采用do...while循环
 * @Author:SmallG
 * @CreateTime:2023/7/21+14:29
 */

public class DoWhileDemo02 {
    public static void main(String[] args) {
        //输入密码直到密码输入正确
        Scanner scanner = new Scanner(System.in);
        String password ;
        do {
            System.out.println("请输入密码：");
            password = scanner.next();
        }while (!"123456".equals(password));
        System.out.println("密码输入成功!");
    }
}

5、嵌套循环

打印直角三角形：

/**
 * @document: 打印直角三角形
 * @Author:SmallG
 * @CreateTime:2023/7/21+14:40
 */

public class ForDemo09 {
    public static void main(String[] args) {
        //1层1个，2层2个，3层3个，4层4个，5层5个
        for (int i = 1; i <= 5; i++) {
            //外层循环负责一共打印几行
            for (int j = 0; j < i; j++) {
                //内层循环负责每行打印多少个
                System.out.print("*");
            }
            System.out.println();
        }
    }
}

打印五层等腰三角形：

/**
 * @document: 打印等腰三角形（金字塔）
 * @Author:SmallG
 * @CreateTime:2023/7/21+14:47
 */

public class ForDemo10 {
    public static void main(String[] args) {
        //外层循环用于控制打印几行
        for (int i = 1; i <= 5; i++) {
            for (int k = 5 - i; k > 0; k--) {
                System.out.print(" ");
            }
            for (int j = 1; j <= 2 * i - 1; j++) {
                System.out.print("*");
            }
            System.out.println();
        }
    }
}

实例：有1分，2分，5分的硬币若干，从中拿取一部分，组成十元钱，有多少种组合方式?

/**
 * @document: 有1分，2分，5分的硬币若干，从中拿取一部分，组成十元钱，有多少种组合方式?
 * @Author:SmallG
 * @CreateTime:2023/7/21+15:16
 */

public class ForDemo11 {
    public static void main(String[] args) {
        //计数器用于存储方法的个数
        int count = 0;
            for (int i = 1000; i >= 0; i--) {
                for (int j = 0; j<= 500;j++) {
                    for (int k = 0; k <= 200; k++) {
                        if (i + j * 2 + k * 5 == 1000) {
                            count++;
                        }
                    }
                }
            }
        System.out.println(count);
    }
}

二、数组

1、基本类型数组

（1）创建基本类型数组

语法：数据类型[] 数组名 = new 数据类型[数组长度]；

例如：int[] arr = new int[100];

/**
 * @document: 创建数组 数组的定义
 * @Author:SmallG
 * @CreateTime:2023/7/21+15:49
 */

public class ArrayDemo01 {
    public static void main(String[] args) {
        //创建一个数组长度为10的整型数组
        int[] arr = new int[10];
        //通过索引（下标）访问数组中的元素
        //索引从0开始  最大到数组的长度-1
        System.out.println(arr[0]); // 0 int类型的数组默认值为0
        arr[0] = 5;
        System.out.println(arr[0]);

        int x = arr[1];
        System.out.println(x); // 0

        arr[2] += 10; // arr[2] = arr[2] + 10;
        System.out.println(arr[2]);
    }
}

（2）静态初始化数组

/**
 * @document: 静态初始化数组
 * @Author:SmallG
 * @CreateTime:2023/7/21+16:23
 */

public class ArrayDemo02 {
    public static void main(String[] args) {
        int[] numbers = {10, 15, 16, 19, 20}; //静态初始化数组 适合于少量数据
        System.out.println(numbers[0]); //访问数组与其他没有区别
        System.out.println(numbers[4]);
    }
}

（3）数组的遍历

/**
 * @document: 数组的遍历
 * @Author:SmallG
 * @CreateTime:2023/7/21+16:30
 */

public class ArrayDemo03 {
    public static void main(String[] args) {
        //数组的静态初始化
        int[] arr = {15, 3, 9, 12, 6, 11};
        //查看数组的长度
        System.out.println("数组的长度为：" + arr.length);
        //查看数组的所有元素
        for (int i = 0; i < arr.length; i++) {
            System.out.print(arr[i] + " ");
        }
        System.out.println();
        //求数组中所有元素的和
        int sum = 0;
        for (int i = 0; i < arr.length; i++) {
            sum += arr[i];
        }
        System.out.println("数组中所有元素的和为：" + sum); //56
    }
}

斐波那契数列案例：

接收键盘的输入n，打印前n个斐波那契数列，计算前n个数字的和

/**
 * @document:斐波那契数列
 * @Author:SmallG
 * @CreateTime:2023/7/21+16:42
 */

public class ArrayDemo04 {
    public static void main(String[] args) {
        //接收键盘的输入
        Scanner scanner = new Scanner(System.in);
        System.out.print("请输入数列的长度：");
        int n = scanner.nextInt();
        int[] arr = new int[n];
        arr[1] = 1; // arr[0] 默认为0 不用赋值
        //创建数列
        for (int i = 2; i < n; i++) {
            arr[i] = arr[i - 1] + arr[i - 2];
        }
        //打印数列并计算前n个和
        int sum = 0;
        for (int i = 0; i < n; i++) {
            sum += arr[i];
            System.out.print(arr[i] + " ");
        }
        System.out.println();
        System.out.println(sum);
    }
}

2、二维数组

数组永远是连续的内存空间，在保存数据的时候挨个保存。

/**
 * @document: 二维数组
 * @Author:SmallG
 * @CreateTime:2023/7/21+17:29
 */

public class MatrixDemo01 {
    public static void main(String[] args) {
        //声明一个二维数组
        int[][] matrix = new int[3][3];
        //给第一行第一列赋值
        matrix[0][0] = 11;
        System.out.println(matrix[0][0]);


        int[][] matrix2 = {
                {1, 2, 3},
                {4, 5, 6},
                {7, 8, 9},
                {1, 12, 33, 4}
        };
        //二维数组的遍历
        for (int i = 0; i < matrix2.length; i++) {
            for (int j = 0; j < matrix2[i].length; j++) {
                System.out.print(matrix2[i][j]+" ");
            }
            System.out.println();
        }
    }
}

三、练习

1、打印九九乘法表

/**
 * @document: 打印九九乘法表
 * @Author:SmallG
 * @CreateTime:2023/7/21+17:44
 */

public class HomeWork01 {
    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();
        }
    }
}

2、矩阵对角线之和（二维数组）

/**
 * @document: 求矩阵对角线元素之和
 * @Author:SmallG
 * @CreateTime:2023/7/21+17:54 
 * 假设一个5*5矩阵，矩阵每一行元素均为1 2 3 4 5
 */

public class HomeWork02 {
    public static void main(String[] args) {
        //创建矩阵数组
        int[][] arr = {
                {1, 2, 3, 4, 5},
                {1, 2, 3, 4, 5},
                {1, 2, 3, 4, 5},
                {1, 2, 3, 4, 5},
                {1, 2, 3, 4, 5}
        };
        //遍历数组进行相加
        int sum = 0;
        for (int i = 0; i < arr.length; i++) {
            for (int j = 0; j < arr[i].length; j++) {
                if (i == j) {
                    sum += arr[i][j];
                } else if (i + j == 4 && i != j) {
                    sum += arr[i][j];
                }
            }
        }
        System.out.println(sum);
    }
}

3、打印杨辉三角形（二维数组）

/**
 * @document: 打印杨辉三角形
 * @Author:SmallG
 * @CreateTime:2023/7/21+18:08
 */

public class HomeWork03 {
    public static void main(String[] args) {
        //创建数组
        int[][] yang = new int[10][10];
        for (int i = 0; i < 10; i++) {
            yang[i][0] = 1;
            yang[i][i] = 1;
        }
        for (int i = 2; i < 10; i++) {
            for (int j = 1; j <= i; j++) {
                yang[i][j] = yang[i - 1][j - 1] + yang[i - 1][j];
            }
        }
        for (int i = 0; i < 10; i++) {
            for (int k = 10 - i; k > 0; k--) {
                System.out.print("  ");
            }
            for (int j = 0; j <= i; j++) {
                if (yang[i][j] < 10) {
                    System.out.print(yang[i][j] + "   ");
                } else if (yang[i][j] < 100 && yang[i][j] > 9) {
                    System.out.print(yang[i][j]+"  ");
                }else{
                    System.out.print(yang[i][j] + " ");
                }
            }
            System.out.println();
        }
    }
}