Java第五天：数组、方法与冒泡排序实战入门

“学Java的第五天”，这个标题本身就很有意思。你想想，第一天装环境，第二天Hello World，第三天变量和运算符，第四天if和for，到了第五天，很多人突然开始怀疑自己是不是脑子有问题：前面学的似乎全忘了，新东西又看不懂，遇到报错不知道从哪下手，甚至有人直接在这个节点放弃了。

但我想说的是，第五天恰恰是Java学习过程中第一个真正值得庆祝的节点。前四天你学的是“语法零件”，第五天开始，你终于要把这些零件拼装起来，去处理一组真实的数据、写一个真正能解决小问题的程序了。这篇文章就当是一个过来人陪你复盘这特殊的一天：这一天通常要学什么、会遇到哪些坑、以及网上一堆看起来很高深的“八股文”和“面试题”，到底和第五天的你有什么关系。

1. 第五天，正处在Java学习的哪个位置

1.1 前四天的进度，决定了第五天的难度

大多数自学Java的人，前四天的节奏大概是这样：第一天跟教学视频装JDK、配环境变量、装IDEA，基本在折腾里度过；第二天终于跑出“Hello World”，看到控制台把那行字打印出来，成就感爆棚；第三天开始接触变量、基本数据类型、运算符、Scanner输入；第四天学if、switch、for、while，做猜数字、九九乘法表之类的练习，这时候你已经能写几十行的程序了。

但到了第四天晚上，你大概率会发现一个问题：知识很碎。你会用if判断，会用for循环，知道int和double，但一旦要把20个学生的成绩存起来算平均分，你就卡住了，因为变量一次只能存一个值。你要写一个“输入两个数，交换后输出”的功能，主方法里堆了一大坨代码，改起来非常痛苦，因为你还不知道有“方法”这种东西。

第五天的核心任务，就是把前四天学过的变量、判断、循环、输入输出这些“零件”，通过两个重量级语法工具重新组织起来，这两个工具就是：数组 和 方法。顺便，你还会第一次听到“类”“对象”这两个在Java里绕不开的词，虽然这个阶段不用完全搞懂，但先混个脸熟非常重要。

1.2 第五天的学习任务，说白了就三件事

如果把程序比作一个厨房，前四天你学的是认识锅碗瓢盆和食材，第五天要学的是两件大事：

• 数组：相当于把散落一地的食材放进一个“货架”里，以后想拿哪一份，告诉人家货架编号和位置就行。
• 方法：相当于把“洗菜”“切菜”“炒菜”这些固定动作封装成一个个独立工序，要用的时候一喊名字，它自动执行。
• 类与对象初体验：Java是一门面向对象的语言，但第五天你只需要知道：以后写代码基本都是在“定义类”，然后在“类里面写方法”，主方法main就是一个特殊的入口。如果你能说出“类是模板，对象是根据模板造出来的具体东西”这句话，就已经超过很多人了。

再有就是Java的标识符命名规则。第五天你已经需要自己写一些稍微复杂的类和方法了，如果命名乱七八糟，后面Debug起来会非常痛苦。类名用大驼峰（StudentInfo），变量和方法名用小驼峰（studentName、getSum），常量全大写加下划线（MAX_VALUE）。这些规则现在养成习惯，比以后改毛病轻松十倍。

2. 第五天真正要啃下来的硬核知识点

2.1 数组：你第一次真正操作一组数据

数组是第五天的第一道坎，也是最容易让人产生“我是不是不适合学编程”念头的地方。但别慌，它只是一个“数据容器”。

声明数组的写法就三种，本质上都可以理解为“开一块连续的房间”：

java复制// 方式一：声明并分配空间，默认值是0
int[] scores = new int[5];

// 方式二：声明的同时直接赋值
int[] scores = {78, 92, 85, 64, 99};

// 方式三：先声明，再new，再逐个赋值
int[] scores = new int[5];
scores[0] = 78;
scores[1] = 92;

新手最容易踩的坑，就是下标越界。Java数组的下标从0开始，也就是说长度为5的数组，下标范围是0到4。很多人在第五天会写出 scores[5] = 100 这样的代码，然后看到经典的 ArrayIndexOutOfBoundsException，一脸懵。这里你只需要记住一句话：下标最大只能取到 length - 1。

为什么非要这么设计？因为这个货架的第1格叫“位置0”，第5格叫“位置4”，计算机的世界里从0开始数，是一种底层内存偏移量的习惯，你现在不需要深究，但必须适应。

数组最常见的操作就是遍历。求平均分、找最大值、统计及格人数，全都要靠for循环配合数组完成：

java复制public class ArrayDemo {
    public static void main(String[] args) {
        int[] scores = {78, 92, 85, 64, 99};

        int sum = 0;
        int max = scores[0];

        for (int i = 0; i < scores.length; i++) {
            sum += scores[i];
            if (scores[i] > max) {
                max = scores[i];
            }
        }

        System.out.println("总分：" + sum);
        System.out.println("平均分：" + (sum / scores.length));
        System.out.println("最高分：" + max);
    }
}

这段代码里有个细节值得注意：for 的循环条件是 i < scores.length，而不是 i <= scores.length。我见过太多初学者在刚开始写数组遍历时，因为多写了一个等于号，程序一运行就报越界异常。养成“遍历数组就用小于号”的肌肉记忆，能帮你省下大量调试时间。

如果你还有余力，把二维数组也看了。它本质上就是一个“表格”，int[][] matrix = new int[3][4] 可以理解成3行4列。遍历需要两层循环，外层管行，内层管列。这个阶段只要能在纸上画出表格、能把数据填进去再读出来，就算过关。

2.2 方法：把逻辑封装成“可复用的工序”

第二个核心知识点是方法。前四天你所有的代码都写在main方法里，一旦功能复杂，main方法就变成了一个巨大的垃圾场：变量互相纠缠、逻辑不分层、想复用一段计算只能复制粘贴。方法就是来解决这个问题的。

定义一个方法的标准结构：

java复制public static 返回值类型 方法名(参数类型 参数名) {
    // 方法体
    return 返回值;
}

一个最简单的加法方法，可以这样写：

java复制public class MethodDemo {
    public static void main(String[] args) {
        int result = add(3, 5);
        System.out.println("3 + 5 = " + result);
    }

    public static int add(int a, int b) {
        return a + b;
    }
}

这里面新手最不理解的往往是 public static 这两个关键词。在第五天你可以先记住一个结论：现阶段你自定义的方法都写成 public static，目的是能和main方法一样，不创建对象就能直接调用。 至于为什么Java要这么设计，到你学面向对象、类的实例化之后自然就明白了。现在没必要为这个卡住。

方法的参数传递也是一个高频困惑点。初学时你只需要掌握最核心的一条结论：如果参数是基本类型（int、double、boolean等），方法内部怎么改，都不会影响外面的变量，因为传进去的是“值拷贝”。 比如 add(3, 5)，3和5只是把值给了a和b，a和b在方法内部随便改，你外部的 result 根本不受影响。这个结论等以后你学到引用类型的时候会再遇到一次升级版，但基础打牢了，升级版不会太难。

第五天还值得了解一下方法重载。需求很简单：你想让add方法既能加两个int，又能加两个double，还能加三个int，怎么办？不用改方法名，只要参数列表不同，Java会根据你调用时传的参数自动匹配对应的方法：

java复制public static int add(int a, int b) { ... }
public static double add(double a, double b) { ... }
public static int add(int a, int b, int c) { ... }

这个知识点的意义，在于让你提前明白：Java里面方法名是可以重复的，只要参数列表不一样。以后面试被问“重载和重写的区别”，重载这部分你在第五天就已经实际用过了。

2.3 综合练习：冒泡排序，第五天的“期末考”

如果说第五天有什么必做的练习，我会毫不犹豫推荐：手写一个冒泡排序。因为排序这件事，完美地把数组、循环嵌套、中间变量交换、逻辑推演全部串起来了，而且它是面试题里出现频率极高的基础题，热词榜上的“冒泡排序java”常年挂着。

先理解排序思路。假设数组 {5, 1, 4, 2, 8}，冒泡排序的核心思想是：每一轮都从前往后两两比较，如果前面的数比后面的大，就交换位置。这样一轮下来，最大的数就像气泡一样“冒”到了最后面。

第一轮比较过程：

• 5和1比较，5 > 1，交换，数组变成 1, 5, 4, 2, 8
• 5和4比较，5 > 4，交换，数组变成 1, 4, 5, 2, 8
• 5和2比较，5 > 2，交换，数组变成 1, 4, 2, 5, 8
• 5和8比较，5 < 8，不交换，数组保持 1, 4, 2, 5, 8

第一轮结束，最大值8已经沉到末尾。第二轮只需要比较前4个数，第二轮结束后，第二大数5会沉到倒数第二的位置。所以外层循环要走 n-1 轮，每一轮内层比较的次数会逐轮递减。

完整代码：

java复制public class BubbleSort {
    public static void main(String[] args) {
        int[] arr = {5, 1, 4, 2, 8};

        for (int i = 0; i < arr.length - 1; i++) {
            boolean swapped = false;  // 优化：如果这一轮没有交换，说明已经有序
            for (int j = 0; j < arr.length - 1 - i; j++) {
                if (arr[j] > arr[j + 1]) {
                    int temp = arr[j];
                    arr[j] = arr[j + 1];
                    arr[j + 1] = temp;
                    swapped = true;
                }
            }
            if (!swapped) {
                break;
            }
        }

        for (int num : arr) {
            System.out.print(num + " ");
        }
    }
}

这个代码里的几个关键点，面试时经常会被追问：

• 外层 i < arr.length - 1：n个数最多只需要n-1轮排序。
• 内层 j < arr.length - 1 - i：每完成一轮，最大的数已经归位，后面就不需要再比较了，所以减去i。
• swapped 这个布尔变量是优化手段：如果某一轮从头到尾没有发生交换，说明数组已经有序，直接跳出循环，可以减少无意义的比较。

你可以观察一下排序过程，用一个表格记录每一轮结束后的状态：

冒泡排序的时间复杂度，第五天你只需要知道结论：最坏情况是O(n²)，也就是说数据越乱，比较次数越多；最好情况是数组已经有序，在swapped优化下可以达到O(n)。后面的算法课里你会反复和各种排序算法打交道，但冒泡排序永远是你第一个能完整讲清楚“为什么”的算法，这个底子很重要。

2.4 第五天该掌握的其他常用知识

除了数组和方法，第五天还免不了遇到一些基础细节，比如String类。Java里的字符串不是基本类型，它是一个类，用双引号括起来。目前你只需要会三件事：声明字符串、用 + 拼接、用 equals 比较内容是否相同。特别注意，字符串比较内容不能用 ==，这个坑等以后学面向对象时会专门讲，但提前遇到是好事。

还有输入输出。前四天你已经用过 Scanner，到了第五天，试着把输入、数组、方法、循环组合起来，做一个“输入5个成绩，输出平均分和最高分”的小程序。不要小看这种组合练习，它才是第五天真正的学习方式：把零散的知识点像搭积木一样组装成能解决实际问题的程序。

3. 第五天最容易踩的坑：报错现场还原

3.1 环境变量那些事：明明装好了，怎么又说找不到命令

第五天你已经不是第一天装环境了，但大概率还会遇到环境问题。最常见的是在命令行输入 java -version，提示 'java' 不是内部或外部命令。这个问题的根源，99%的情况下是 JAVA_HOME 或 PATH 没有配置正确。

在Windows上，建议这样配：

• 新建系统变量 JAVA_HOME，值填JDK的安装路径，比如 C:\Program Files\Java\jdk-17。
• 编辑系统变量 Path，新增一行 %JAVA_HOME%\bin。

配完之后一定要做两件事：点确定关闭所有环境变量窗口，然后再重新打开一个新的命令行窗口。很多人配完了直接用旧窗口测试，发现还是报错，其实只是因为环境变量没有刷新，不是配置错了。这个坑很不起眼，但能卡住你半小时。

3.2 那些你早晚会背下来的报错信息

第五天的报错，翻来覆去就那几种：

• ArrayIndexOutOfBoundsException：数组下标越界。最常见的场景是循环条件写成了 i <= scores.length，或者试图访问 scores[length]。解决办法就是检查下标，确保在0到length-1之间。
• NullPointerException：空指针异常，新手阶段偶尔会出现。通常是你声明了一个数组或对象，但没有new就直接用它了。记住了，变量只有经过初始化，才真正“有东西”。
• Compilation failure: 源发行版17需要目标发行版17：这个报错在热词榜上长期存在，原因通常是IDE的Project SDK和Modules语言级别不一致。解决路径是：在IDEA里打开 File -> Project Structure -> Project Settings -> Project，把SDK和语言级别选成一致；然后在 Settings -> Build, Execution, Deployment -> Java Compiler 里把目标字节码版本也改成一致。对于第五天的你来说，这个报错不是代码问题，全是IDE配置问题，不用慌。
• java.lang.OutOfMemoryError: Insufficient memory：热词榜里也出现了。学习阶段遇到它，大概率是因为写了死循环，不断创建对象或持续拼接字符串。排查思路是：先看有没有 while(true) 或递归没有出口。第五天的代码量一般不会真的把内存撑爆，真遇到先怀疑自己的循环逻辑。

3.3 一个晚间崩溃场景：为什么输出结果和我想的不一样

第五天的你写代码，经常会遇到一种情况：代码编译通过、运行不报错，但输出结果就是不对。这比报错还让人崩溃。最常见的原因是 赋值 = 和相等判断 == 搞混，比如在if条件里写了 if (score = 100)，程序直接编译报错，这还好；如果是 if (score == 100) 写成了 if (score = 100)，有些场景下甚至能编译通过，但逻辑完全错了，尤其涉及布尔类型时很难发现。

另一个典型的坑是浮点数精度问题。用 double 做运算，比如 0.1 + 0.2，输出结果往往不是0.3，而是0.30000000000000004。这不是Java的bug，是二进制浮点数表示本身的精度限制。现阶段你只需要知道：比较两个浮点数是否相等，绝对不要用 ==，而是看它们的差是否小于一个很小的数，比如0.0001。 这个知识点等你以后做金额相关项目时会天天遇到，早了解早省心。

还有中文符号问题。新手写代码，中文输入法没切干净，括号写成全角 （），分号写成中文 ；，编译器直接报“非法字符”或者一堆莫名其妙的错误。排查方法很简单：把报错行号附近的代码全部删掉重打一遍，注意切换到英文输入法，基本能解决。

4. 把第五天的题包成面试题，是什么样子

4.1 那些网上流传的“八股文”，其实第五天就开始埋种子了

很多学Java的人刷面试题时会感叹，怎么全是“八股文”。但如果你把搜索热词里的“java面试题”“java基础面试题”“java八股文”拿出来看看，会发现一个事实：大量高频面试题，考察的就是第五天打下的基础。

我整理了一张表，把第五天学的东西和日后面试题的对应关系列出来，你会发现很多题现在就能答一半：

这些题现在看到答案可能会觉得“我好像知道，但说不完整”。这很正常。第五天你不需要背答案，但你应该开始养成一种习惯：学任何一个知识点，多想一层“它为什么这么设计”“它和以前学的有什么区别”。 比如你学了数组，就去问自己：“数组的length是属性，String的length()是方法，为什么不一样？”这种追问习惯，会把网上的八股文真正变成你的内功。

4.2 热词里的那些“大词”，第五天要不要碰

搜索热词里还有一批名字看起来很吓人的东西，比如“lambda函数 java”“java completablefuture”“java枚举类型的使用”“qwen embedding 调用示例 java langchain4j”“springboot apikey 安全对接”。如果你是在第五天刷到这些，我的建议非常明确：看一眼，记住名字，然后关掉，别继续往下查。

这不是在打击你，而是因为学习路径是有顺序的。第五天的你，连类和对象都还没建立完整概念，去看Lambda和CompletableFuture，就像刚学会加减法就去看微积分，除了打击自信心，没有任何帮助。Java的知识体系是一个巨大的树状结构：基础语法是根，面向对象是主干，集合、异常、IO是枝干，框架和并发是树冠，一些高级特性和AI调用示例是树冠上的果实。一棵树不可能倒着长。你需要在合适的阶段做合适的事，才能让后续每一步都走得扎实。

5. 给同在第5天的你：几条实操建议

5.1 安排一天练习时，可以参考这个节奏

第五天如果完全由你自己安排，我建议用“上午数组、下午方法、晚上综合”的节奏来推进：

• 上午：跟着教程把数组语法过一遍，然后独立完成“输入5个成绩，求平均分和最高分”“把一个数组倒序输出”两个练习。不要看视频里的答案，自己先写，写不出来再看。
• 下午：学方法定义和调用，自己封装一个求最大值的方法、一个判断奇偶数的方法，并在main里调用验证。
• 晚上：手写冒泡排序。先用纸笔推演一遍排序过程，再对照你的推演结果写代码，最后运行验证。一定要做到“不看任何参考能独立写出来”，不然第二天就会忘。

一个非常朴素的判断标准：如果你能在不打开笔记的情况下，完整写出一个冒泡排序，并且能说清楚每一行代码的作用，说明第五天过关了。

5.2 准备一个“报错日记”，比收藏一堆教程更管用

我在带过不少新手之后发现，很多人遇到报错的第一反应是截图扔到群里问人，这其实是在浪费自己的成长机会。学编程最重要的一项能力是“debug”，而debug能力是可以刻意练习的。

我的建议是：从第五天开始，建一个自己的笔记，每天记录三件事：

• 今天遇到了什么报错，报错信息原文是什么。
• 我是怎么排查的，通过什么线索定位到了哪一行代码。
• 如果再遇到同类问题，我的第一排查动作应该是什么。

比如你记录了“ArrayIndexOutOfBoundsException，排查线索是循环条件多写了一个等号，第一排查动作是检查循环条件里的下标边界”，三个星期后你会有一份完全属于自己的“排错手册”。这份手册的价值，远比你收藏的100个教学视频要高，因为这些都是你亲自踩过的坑，记忆深刻，而且面试时被问到“你遇到印象最深的bug是什么”，你能立刻讲出一个真实、完整、有思考深度的故事。

5.3 关于“学了就忘”的焦虑，我给你吃颗定心丸

第五天最大的心理危机，往往不是知识难，而是“觉得前面学的全忘了”。我明确告诉你，这百分之百正常。编程学习本身就不是一条直线，它更像螺旋上升：你每往前走一层，都会发现旧知识有新的理解，同时也确实会遗忘一些细节。遗忘不是失败，它是记忆在筛选真正重要的东西。

应对办法是“循环复习法”：当天学的东西，睡前花15分钟合上书，在脑子里过一遍今天写的代码的骨架；每隔3天，把之前写的某个练习重新写一遍，看看能不能不看答案写出来；每个周末，把本周学过的东西组合成一个综合小练习，比如做一个“学生成绩管理”的简易版本，练到输入成绩、求平均分、找最高最低分、按分数排序，全都能用数组和方法搞定。

我跟你讲，第一次做这种综合练习时，你可能会发现自己连Scanner都要查一下，这太正常了。但坚持三周之后，你会惊讶于自己的变化：代码写得越来越顺，以前看不懂的报错，现在瞄一眼就知道是什么问题。那时候你再回头看第五天，会觉得今天这些焦虑，都只是成长的阵痛。

最后再说点我自己的体会。当年我学到第五天，卡在“为什么 int[] scores = new int[5] 之后，访问 scores[5] 会报错”这件事上，查了很久才彻底明白下标从0开始的道理。这个点现在看来有点傻，但它让我养成了一个习惯：程序出问题之前，先问自己“数据从哪里来、存在哪里、边界是什么”。学Java不是比谁记得多，而是比谁能在代码里准确表达“现实逻辑”。第五天的你，不需要现在就懂集合框架，也完全不用怕那些名字吓人的高级特性，你只需要把数组、方法和冒泡排序这三件事做到“合上书能独立写、闭上眼能讲清楚”，后面的路，会比想象中顺畅很多。