Java 进阶之路（五）：循环控制与数组的初探

于 2025-05-15 09:00:00 发布
阅读量1.1k 收藏 20
点赞数 24
文章标签： java 算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/dongxiaod1/article/details/147953146
版权

Java 进阶之路（五）：循环控制与数组的初探

学习 Java 编程，循环控制和数组是绕不开的基础知识。它们就像是编程世界里的“工具箱”，掌握了它们，才能更灵活地处理各种数据和逻辑。今天，我们就来深入了解一下 Java 中的 break、continue 语句以及数组的基本概念和常用操作。

🎯 控制循环的利器：break 与 continue

在编写循环时，我们有时候需要在特定条件下提前结束循环，或者跳过循环体中的某些语句。这时，break 和 continue 就派上用场了。

  • 🚪 break：跳出循环

    break 语句的作用是立即终止当前循环。当程序执行到 break 时，循环会立即停止，然后继续执行循环后面的代码。看下面的例子，当 num 等于 4 时，循环就会中断：

    for(int num=1;num<=9;num++){
    if(num==4){ // 在某种特定条件下，提前结束循环
        break; // 跳出循环
    }
    System.out.println(num+"*9="+num*9);
}
/*
   输出结果：
   num=1  1*9=9
   num=2  2*9=18
   num=3  3*9=27
   num=4  循环在此处中断
*/

  • ⏭️ continue：跳过本次循环

    与 break 不同，continue 语句不会终止整个循环，而是跳过当前循环体中剩余的语句，直接进入下一次循环的判断。下面的例子演示了如何跳过能被 3 整除的乘法表项：

    // 输出9的乘法表，跳过能被3整除的
for(int num=1;num<=9;num++){
    if(num%3==0){
        continue; // 跳过循环体中剩余语句而进入下一次循环
    }
    System.out.println(num+"*9="+num*9);
}
/*
   输出结果：
   num=1  1*9=9
   num=2  2*9=18
   num=3  跳过
   num=4  4*9=36
   num=5  5*9=45
   num=6  跳过
   num=7  7*9=63
   num=8  8*9=72
   num=9  跳过
*/

    如果我们想要输出所有不能被 3 整除的乘法表项，也可以换一种写法，这样更直观：

    // 输出9的乘法表，只要不能被3整除的
for(int num=1;num<=9;num++){
    if(num%3!=0){
        System.out.println(num+"*9="+num*9);
    }
}

🔄 嵌套循环：构建多维结构

当我们需要处理多行多列的数据，或者构建更复杂的逻辑结构时，嵌套循环就显得非常有用。简单来说，就是在一个循环体内再嵌套另一个或多个循环。

  • 🖼️ 多行多列的常见场景

    嵌套循环常常用于处理二维数据或打印类似表格、矩阵的结构。通常情况下，外层循环控制“行”，内层循环控制“列”。

  • 🚶 执行规则：外层一次，内层所有次

    嵌套循环的执行顺序是：外层循环每执行一次，内层循环就会完整地执行完所有次。

  • 💡 建议：保持简洁

    虽然可以多层嵌套，但为了代码的可读性和维护性，建议嵌套层数越少越好。能用一层解决的问题，尽量不用两层；能用两层解决的，尽量不用三层。

  • 🚪 break 的作用范围

    需要注意的是，break 默认只能跳出离它最近的那一层循环。

    下面是一个经典的嵌套循环例子，用来打印九九乘法表：

    public class MultiTable {
    public static void main(String[] args) {
        for(int num=1;num<=9;num++){ // 控制行
            for(int i=1;i<=num;i++){   // 控制列
                System.out.print(i+"*"+num+"="+i*num+"\t"); // \t 是水平制表符，用于对齐
            }
            System.out.println(); // 换行
        }
        /*
          执行过程示意:
            num=1
              i=1  1*1=1
              i=2  false
              换行
            num=2
              i=1  1*2=2
              i=2  2*2=4
              i=3  false
              换行
            num=3
              i=1  1*3=3
              i=2  2*3=6
              i=3  3*3=9
              i=4  false
              换行
            ...
         */
    }
}

📦 数组：同类型数据的集合

数组是一种非常重要的数据结构，它可以用来存储一组相同数据类型的数据。

  • 引用数据类型

    在 Java 中，数组是一种引用数据类型，这意味着数组变量存储的是数组对象在内存中的地址，而不是直接存储数据本身。

  • 相同数据类型的集合

    数组的最大特点就是它只能存储同一种数据类型的数据。例如，一个整型数组只能存储整数，一个字符串数组只能存储字符串。

  • 定义：创建数组并指定容量

    定义数组时，我们需要指定数组的类型和长度（可以容纳多少个元素）。数组中的元素会根据其数据类型被赋予默认值。

    // 声明整型数组a，包含5个元素，每个元素都是int类型，默认值为0
int[] a = new int[5];
// 声明浮点型数组d，包含10个元素，每个元素都是double类型，默认值为0.0
double[] d = new double[10];
// 声明布尔型数组b，包含26个元素，每个元素都是boolean类型，默认值为false
boolean[] b = new boolean[26];

    默认值一览：

    • byte, short, int, long, char: 0
    • float, double: 0.0
    • boolean: false
    • 引用类型 (如 String): null

  • 初始化：为数组元素赋值

    数组初始化就是为数组中的元素赋予初始值。有几种不同的方式：

    int[] arr1 = new int[3]; // 默认初始化为0,0,0
int[] arr2 = {2,5,8}; // 直接指定初始值
int[] arr3 = new int[]{2,5,8}; // 使用 new 关键字并指定初始值
int[] arr4;
// arr4 = {2,5,8}; // 编译错误，此方式只能在声明同时初始化
arr4 = new int[]{2,5,8}; // 正确，分开声明和初始化时需要 new

  • 访问：获取或修改数组中的数据

    我们可以通过数组的长度属性和下标来访问数组中的元素。

    • 获取数组长度：使用 数组名.length 可以获取数组的元素个数。

      int[] arr = new int[3];
System.out.println("数组的长度:" + arr.length); // 输出 3

    • 通过下标访问元素：数组的下标从 0 开始，最大到 数组长度 - 1。

      int[] arr = new int[3];
System.out.println("数组的长度:" + arr.length); // 3
System.out.println("数组第1个元素为:" + arr[0]); // 输出 0 (默认值)
arr[0] = 100; // 给第1个元素赋值为100
arr[1] = 200; // 给第2个元素赋值为200
arr[2] = 300; // 给第3个元素赋值为300
// arr[3] = 400; // 运行时会发生数组下标越界异常 ArrayIndexOutOfBoundsException
System.out.println(arr[2]); // 输出 300
System.out.println(arr[arr.length-1]); // 输出最后一个元素的值，也是 300

    • ⚠️ ArrayIndexOutOfBoundsException：数组下标越界异常

      访问数组元素时，如果使用的下标超出了合法的范围（0 到 数组长度 - 1），就会在程序运行时抛出 ArrayIndexOutOfBoundsException 异常。

  • 🔄 遍历/迭代：逐一处理数组元素

    遍历数组是指从头到尾依次访问数组中的每一个元素。通常使用 for 循环来完成。

    int[] arr = new int[10];
for(int i=0;i<arr.length;i++){ // 遍历arr数组
    arr[i] = (int)(Math.random()*100); // 给每个元素赋值为0到99的随机数
    System.out.println(arr[i]); // 输出每个元素的值
}

    示例：找出数组中的最大值

    public class MaxOfArray {
    public static void main(String[] args) {
        int[] arr = new int[10];
        for(int i=0;i<arr.length;i++){
            arr[i] = (int)(Math.random()*100);
            System.out.println(arr[i]);
        }

        // 假设:int[] arr = {12,56,89,8};
        int max = arr[0]; // 假设第1个元素为最大值
        for(int i=1;i<arr.length;i++){ // 遍历剩余元素
            if(arr[i]>max){   // 若剩余元素大于max
                max = arr[i]; // 将max修改为较大的
            }
        }
        System.out.println("最大值为:" + max);
    }
}

  • 📋 复制：创建数组的副本

    有时候我们需要复制一个数组，可以使用 System.arraycopy() 或 Arrays.copyOf() 方法。

    • System.arraycopy()：灵活性好，可以指定源数组、源起始下标、目标数组、目标起始下标和要复制的元素个数。

      int[] a = {10,20,30,40,50};
int[] b = new int[6]; // 0,0,0,0,0,0
// a: 源数组
// 1: 源数组的起始下标
// b: 目标数组
// 0: 目标数组的起始下标
// 4: 要复制的元素个数
System.arraycopy(a,1,b,0,4); // 将a中下标1开始的4个元素复制到b中下标0开始的位置
for(int i=0;i<b.length;i++){
    System.out.println(b[i]); // 输出 b 数组元素
}

    • Arrays.copyOf()：灵活性相对较差，只能从源数组的开头开始复制，并指定目标数组的长度。

      import java.util.Arrays;

int[] a = {10,20,30,40,50};
// a: 源数组
// b: 目标数组
// 6: 目标数组的长度
// -- 若目标数组长度 > 源数组长度，则末尾补默认值
// -- 若目标数组长度 < 源数组长度，则将末尾的截掉
int[] b = Arrays.copyOf(a,6);
for(int i=0;i<b.length;i++){
    System.out.println(b[i]); // 输出 b 数组元素
}

  • ➕ 数组扩容：动态调整数组大小

    数组一旦创建，其长度就固定了，不能直接改变。但我们可以通过创建一个更大的新数组，并将原数组的数据复制过去来实现“扩容”的效果。

    import java.util.Arrays;

int[] a = {10,20,30,40,50};
// 数组的扩容 (创建了一个更大的新的数组，并将数据复制进去了)
a = Arrays.copyOf(a,a.length+1);
for(int i=0;i<a.length;i++){
    System.out.println(a[i]); // 输出扩容后的 a 数组元素
}

    示例：将最大值添加到数组末尾

    package day06;
import java.util.Arrays;
import java.util.Random; // 导入 Random 类

// 求数组元素的最大值，并将其存储到数组最后一个元素的下一个位置
public class MaxOfArray {
    public static void main(String[] args) {
        Random rand = new Random(); // 创建随机数对象
        int[] arr = new int[10];
        for(int i=0;i<arr.length;i++){
            arr[i] = rand.nextInt(100); // 生成0到99的随机整数
            System.out.println(arr[i]);
        }

        int max = arr[0]; // 假设第1个元素为最大值
        for(int i=1;i<arr.length;i++){ // 遍历剩余元素
            if(arr[i]>max){   // 若剩余元素大于max
                max = arr[i]; // 将max修改为较大的
            }
        }
        System.out.println("最大值为:" + max);

        arr = Arrays.copyOf(arr,arr.length+1); // 扩容
        arr[arr.length-1] = max; // 将最大值max赋值到最后一个元素上
        System.out.println("扩容后数组:");
        for(int i=0;i<arr.length;i++){
            System.out.println(arr[i]);
        }
    }
}

  • ⬆️ 排序：整理数组元素顺序

    Java 的 Arrays 类提供了便捷的排序方法 sort()，可以对数组进行升序排列。

    package day05;
import java.util.Arrays;
import java.util.Random; // 导入 Random 类

// 数组的演示
public class ArraySort {
    public static void main(String[] args) {
        Random rand = new Random(); // 随机数对象
        int[] arr = new int[10];
        for(int i=0;i<arr.length;i++){
            arr[i] = rand.nextInt(100); // 0到99的随机整数
            System.out.println(arr[i]);
        }

        Arrays.sort(arr); // 对arr数组做升序排列

        System.out.println("排序后:");
        for(int i=0;i<arr.length;i++){
            System.out.println(arr[i]);
        }

        System.out.println("倒着输出:");
        for(int i=arr.length-1;i>=0;i--){ // 数据还是升序的，只是倒着展示
            System.out.println(arr[i]);
        }
        System.out.println("第1个元素为:" + arr[0]);
    }
}

小结

  1. 嵌套循环的应用场景有哪些
  2. 数组的应用场景有哪些
  3. 数组的初始化方式有哪些
  4. 冒泡排序算法、选择排序算法、快速排序算法的实现
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值