企业官网建设流程全解析

零基础学Java，最容易卡死的往往不是语法本身，而是“没有反馈”。看书的时候觉得全懂了，关掉页面打开IDEA，盯着空白的main方法半天敲不出一个字。我见过太多人栽在这一步：资料收藏了几十G，视频看了两三百集，动手写的代码加起来不超过一百行。所以我一直主张，零基础入门Java，目标不该是“把书写完”，而应该是“把题刷完”。这不是否定理论学习，而是说，只有通过训练题把每一个知识点变成手底下的肌肉记忆，你才算是真的会了。

这篇文章要聊的就是一套专门为零基础设计的Java基础编程500题综合练习。它不依赖任何框架，不牵扯Spring、MyBatis这些工程级概念，就是老老实实地把JavaSE阶段的核心语法、面向对象、常用API、集合、异常、IO、多线程、算法入门和综合性小项目拆成500道可执行的题目。这篇我不会把500道题全部平铺出来，那样反而没法刷。我会把题库的分层逻辑讲清楚，再从每个阶段挑出几道最有代表性的题做精讲，把考点、易错点和标准写法摊开揉碎，最后分享一套刷题节奏和避坑方法。无论你是刚摸电脑的在校生、准备转行的社会人，还是想巩固基础后去啃Java面试题的人，这套内容都值得你收藏起来，照着题目列表一天一天往下写。

1. 这套500题的核心设计思路：为什么“刷题”比“看书”更适合零基础

1.1 题库怎么分层：从语法到实战的闯关路线

我见过不少培训机构的课程大纲，也看过很多开源项目里的“Java学习路线图”，它们普遍存在一个问题：知识点归知识点，练习题归练习题，两者之间没有形成递进关系。学生上午学了if和for，下午的练习却是输出一个HelloWorld，难度断层，练了个寂寞。这套500题的编排思路完全不同，它把这500道题划分成五个相互衔接的阶段，每一阶段都瞄准一类明确的能力短板。

第一阶段是环境与基础语法，大约80题，覆盖JDK安装、环境变量配置、HelloWorld变式、变量与数据类型、运算符、Scanner键盘录入、分支和循环。这一阶段的训练目标是让手先“热”起来，能手不抖地写出完整程序，而不是对着IDE报错发呆。第二阶段是流程控制与数组，大约120题，重点放在循环嵌套、数组的初始化和遍历、排序入门、查找算法。这个阶段是从“能写代码”过渡到“能用代码解决逻辑问题”的关键期，九九乘法表变式、数组逆序、冒泡排序都在这里出现。

第三阶段是面向对象，大约90题，包含类与对象、构造方法、封装、继承、多态、接口、异常机制。这一阶段的训练目标是建立“用类组织代码”的思维方式，很多零基础学员在这里第一次感受到“面向对象”和“面向过程”的差异，容易卡壳，所以题库里设计了不少代码阅读题和改错题来辅助理解。第四阶段是常用API与集合，大约90题，涉及String、StringBuilder、包装类、ArrayList、HashSet、HashMap、日期时间处理。这个阶段开始贴近日常开发的常用工具箱，也是从“做题”走向“干活”的桥。最后是算法与综合实战，大约120题，包括递归、二分查找、各种排序的综合变体、二维数组规律题，以及几个贯穿前面所有知识点的综合小项目，比如学生成绩统计系统。

每一道题都挂了难度星级和知识点标签，一星题是基础题，二星题需要一点思路绕弯，三星题开始有综合性和面试题的影子。完整的500道题不可能在博客正文里逐一列出，所以我会在每个阶段里抽出最典型的题目做深度拆解，剩下的题目你拿着这个分层思路去找对应的训练资源，或者用这套方法自己出题，都能做到心里有数。

1.2 每一层的题目难度曲线和常见训练误区

这套题库的分层逻辑不是拍脑袋定的。先说难度曲线：前80题基本都是“照葫芦画瓢”型，题目描述里会直接告诉你用哪个语法点，比如“用for循环输出1到100之间所有3的倍数”，你只需要把语法用熟练；中间的题慢慢过渡到“方案设计”型，比如“统计一个字符串中每个字符出现的次数”，题目不告诉你必须用HashMap还是数组，你要自己选；最后的综合题则是“需求分析”型，给你一段模糊的描述，比如“做一个控制台版本的学生成绩管理系统”，你要自己拆解出需要哪些类、哪些方法、哪些数据结构，这个能力和实际工作的匹配度很高。

很多零基础学员刷题时有一个共性误区：前80题嫌简单，跳着做；中间80题发现卡住，就开始怀疑自己是不是太笨；最后直接放弃。说到底，这是没搞清楚手熟和脑熟之间的时间差。写代码的快感来自“能独立AC一道题”，但获得这种快感之前，你必须有大量看起来毫无挑战性的重复输入。这套题库把前两个阶段的题量压到了200道，就是想用足够的重复量把你的编码速度提起来，再慢慢加大思维难度。

还有一个训练误区是“只读不写”。我在答疑群里经常看到这样的对话：有人贴出一段代码问“为什么我运行不出结果”，下面有人回复“你少了分号”，然后提问者说“我眼神不好没看出来”，其实根子上是语句敲得太少，对语法结构没有形成条件反射。刷题必须自己把代码完整敲进编辑器，一个字符一个字符地敲，错了就看报错信息，改完再跑，这个过程本身就是最重要的学习。

2. 基础语法阶段的代表题精讲：把代码“手”感练出来

2.1 第一道必写的变式题：星号三角形与循环嵌套

第一阶段的题目里，最容易被低估的就是“用星号打印各种三角”。但凡有点基础的人会觉得这题毫无技术含量，但我带过的学员里，十个人有八个第一次写靠右对齐的直角三角形时会卡住。这道题练的不是数学，而是循环嵌套的节奏感：外层循环管行数，内层循环管每一行输出多少个字符。

直接给一个标准解法。输出一个五行、靠左对齐的直角三角形：

public class StarTriangle { public static void main(String[] args) { int rows = 5; for (int i = 1; i <= rows; i++) { for (int j = 1; j <= i; j++) { System.out.print("*"); } System.out.println(); } } }

这道题的易错点在于，内层循环的条件 j <= i 才是“行数等于星数”的核心，如果你写成 j <= rows，那每行都会输出五颗星，最后出来的就是矩形而不是三角。真正需要花心思的变式是把三角形靠到右边，这时候就需要在每行星号之前先输出空格：

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

这道题的精髓是“用循环控制输出的长度”，你在做九九乘法表、打印菱形、输出日历的时候都会用到完全相同的思路。如果你能不看答案，靠自己推出来靠右版本，那么恭喜你，你初步建立了“循环就是在重复做一件可变的事”的感觉。刷题时我建议你把这道题的变体尽量多写几个：倒三角、等腰三角、空心三角、菱形，每个变体都亲手敲一遍，这比抄十遍完整项目有效得多。

2.2 零基础必踩的坑：整数除法与类型转换

基础语法阶段有一道题看起来平平无奇，但我几乎每个月都会在答疑群里看到有人被它坑一次。题目是这样问的：声明 int a = 7，int b = 2，double result = a / b，请问result的值是多少？

很多人瞟一眼题目，心里想：7除以2等于3.5，double能存小数，所以result是3.5。但实际运行结果是3.0。原因在于，a / b 的两个操作数都是int，Java会先在int范围内做整除，得到3，再把3自动转成double赋给result，最终输出3.0。想让结果变成3.5，需要提前把其中一个数转成double，写法可以是(double) a / b，也可以是a * 1.0 / b。

这道题考察的是数据类型转换规则里的“隐式转换”，很多基础不好的人会认为double和int之间的转换是自动且无脑的，实际上在运算过程中，如果操作数都是int，结果就是int，只有当操作数里出现了浮点类型，整个表达式才会被提升为浮点运算。这个规则还衍生出另外一个经典题目：int total = 85，int count = 3，要计算平均成绩，很多人写成double avg = total / count;结果输出28.0，正确做法是把total或者count先转成double再除。

我在题库里故意把这类“看起来简单、做起来必错”的题放在一星难度，就是为了让零基础学员在早期就把这类认知误区炸出来。这种坑知道了价值不大，踩过一次后记住原理，以后写计算平均分、算百分比、算汇率再也不会失手。而且这种题是很好的“讲题素材”，你能给身边同学把这道题讲明白，说明这个知识点就真的内化了。

2.3 数组与流程控制的入门综合题：回文数判断

进入数组和流程控制阶段后，有一道题很能检验综合能力：判断一个整数是否是回文数。回文数就是正着读和倒着读都一样的数，比如121、12321、1221。题目会限定“不使用字符串，用数学方式拆解”。

核心思路是不断对数字取余和整除，把整个数字反转过来，再和原数比较。参考代码：

public class PalindromeNumber { public static void main(String[] args) { int num = 12321; int original = num; int reversed = 0; while (num > 0) { int digit = num % 10; reversed = reversed * 10 + digit; num /= 10; } if (original == reversed) { System.out.println(original + " 是回文数"); } else { System.out.println(original + " 不是回文数"); } } }

这段代码里最容易写错的是reversed = reversed * 10 + digit这一行。很多初学者的第一反应是直接赋值reversed = digit，那样每一轮循环都会用最新一位覆盖前面的结果，最后reversed只是最后一位数字，判断必然失败。如果你自己推演这个过程，用12321走一遍流程：第一轮digit=1，reversed=1；第二轮digit=2，reversed=12；第三轮digit=3，reversed=123，这样逐位累加，反转才成立。

这道题的价值在于它同时考了三件事：while循环的终止条件、取余和整除的应用、变量临时保存原值的必要性。理解了这道题，后面再遇到“统计数字的位数”“把数字的各位相加”“把二进制转换成十进制”都会觉得顺理成章。刷题到这一阶段时，建议你不要只满足于代码能跑通，最好在纸上把每次循环的变量变化写出来，这一步对建立调试思维非常关键。

3. 面向对象思想怎么练：核心题目与易错点拆解

3.1 用“学生类设计”理解封装与对象数组

第三阶段是零基础学员从“写代码”走向“搭结构”的分水岭。面向对象阶段第一道必做的典型题是：设计一个Student类，包含姓名、年龄、分数三个属性，要求属性私有化，提供构造方法、getter/setter方法、以及一个显示信息的方法，然后在main方法中创建三名学生，存入对象数组，最后输出平均分和最高分。

这道题覆盖的知识点非常密集。属性私有化体现封装，构造方法负责对象初始化，getter/setter提供受控访问，对象数组则要求你把“类是模板”这件事真正落到内存层面来理解。这里给出一个可运行的完整参考：

class Student { private String name; private int age; private double score; public Student(String name, int age, double score) { this.name = name; this.age = age; this.score = score; } public String getName() { return name; } public double getScore() { return score; } public void showInfo() { System.out.println(name + "，年龄：" + age + "，分数：" + score); } } public class StudentManager { public static void main(String[] args) { Student[] students = new Student[3]; students[0] = new Student("小明", 18, 88.5); students[1] = new Student("小红", 19, 92.0); students[2] = new Student("小刚", 18, 76.5); double total = 0; Student best = students[0]; for (Student s : students) { s.showInfo(); total += s.getScore(); if (s.getScore() > best.getScore()) { best = s; } } System.out.println("平均分：" + total / students.length); System.out.println("最高分学生：" + best.getName()); } }

零基础的人第一次接触这段代码，最容易懵的地方是对象数组。int[]存整数，Student[]存的是引用，数组空间里放的并不是学生对象本身，而是对象在堆内存中的地址。这个可以类比作通讯录：数组里存的是“联系人的电话号码”，而不是把整个人塞进手机。如果这道题你写得通顺，说明你已经能把类当数据类型用了，后面的ArrayList、HashMap接收自定义类型时也会顺畅得多。

3.2 让static真正“活”起来：静态计数器那道题

第三阶段的题里，有一道题专门破除对static的误解：设计一个User类，每次创建对象时自动给一个静态计数器加一，最后在main方法中创建三个对象，输出计数器的值。参考实现：

class User { static int count = 0; public User() { count++; } } public class StaticTest { public static void main(String[] args) { new User(); new User(); new User(); System.out.println("已创建用户对象：" + User.count + " 个"); } }

这个题目想让你看到两件事。第一，static修饰的变量属于类，不依赖具体对象，所有实例共享这同一份内存，所以创建三个对象后count的值是3，而不是每个对象各自持有一份1。第二，构造方法也是普通方法，它同样可以操作静态变量，这个特性在写工具类、全局配置、连接池的时候特别有用。很多人在后面学框架时会遇到“静态代码块”和“类加载机制”，如果此时能真理解这题，后面就不会觉得那是天书。

这个题的经典变式是：在静态方法里能不能访问实例变量？答案是不能，因为静态方法不依赖对象，而实例变量必须依附对象存在，在一个没有this的上下文里无法确定要访问哪个对象的属性。这类判断题不要死记答案，你应该亲手敲一遍，看看编译器报什么错，再把原因用自己的话解释出来，这才算是吃透了。多态阶段还会出现一个经典判断题：父类引用指向子类对象，调用同名方法时输出什么？这类阅读题在Java面试题里也是高频出现，我建议你把它们当作“代码模拟器”，先猜输出，再实际跑一遍验证。

3.3 继承与多态的经典判断题：父类引用指向子类对象

面向对象阶段有一种题我特别推荐，就是“看代码说输出”。比如：

class Animal { public void speak() { System.out.println("动物在叫"); } } class Dog extends Animal { @Override public void speak() { System.out.println("狗在汪汪叫"); } } public class PolyTest { public static void main(String[] args) { Animal a = new Dog(); a.speak(); } }

输出结果是“狗在汪汪叫”。原因在于，Java的方法调用是动态绑定的，虽然a的声明类型是Animal，但堆里真正创建的对象是Dog，运行时JVM会根据实际对象类型去调用Dog重写后的方法。初学者常见的错误推理是“a是Animal类型的变量，就应该调Animal的方法”，这个想法是典型的面向过程思维残余。

这道题还有个延伸问法：如果Dog里有一个独有方法shakeTail()，直接用a.shakeTail()能调用吗？不能，因为编译时编译器只看a的声明类型Animal，Animal里没有这个方法，直接编译报错。必须把a强转成Dog才能调用，或者用一个真正的Dog变量来接收。先跑一遍再背结论，多态里的“编译看左边，运行看右边”才不会变成一句没有感觉的口诀。刷完这些面向对象题之后，建议你把每一道题的主类和附类都改成不同名字再跑一遍，看看改了什么破坏了什么，这种折腾比再多写十道简单题都有用。

4. 异常、集合、IO、多线程四类题的实操解析

4.1 自定义异常：把不合法的业务数据拦在门外

从异常阶段开始，题目的实用性明显上来了。有一道题是训练自定义异常的：设计一个年龄校验功能，当年龄小于0或大于150时，抛出异常并提示非法信息，而不是让程序带着脏数据继续跑。

直接看一个基于运行时异常的实现：

class AgeException extends RuntimeException { public AgeException(String message) { super(message); } } class Person { private int age; public void setAge(int age) { if (age < 0 || age > 150) { throw new AgeException("年龄不合法：" + age); } this.age = age; } } public class ExceptionTest { public static void main(String[] args) { Person p = new Person(); p.setAge(200); } }

运行后程序会在执行到p.setAge(200)这一行时抛出AgeException，栈信息里会明确告诉你异常发生的位置。这道题的价值不在于“会写一个异常类”，而在于理解“异常是用来表达程序状态异常的手段”。什么是业务规则？年龄有上限就是业务规则。如果这段代码没有校验，脏数据会顺着方法调用链一直传下去，最后在某个深不见底的地方才爆出神秘问题，排查成本极高。自定义异常不是炫技，而是把错误拦截在离源头最近的位置。

初学阶段很多人混淆throw和throws。简单说，throw是“主动抛出异常对象”，throws是“声明此方法可能抛出某种异常，交由调用者处理”。这个题也可以用受检查异常去写，也就是让AgeException继承Exception而不是RuntimeException，这时main方法必须用try-catch包裹或者继续抛出才能编译通过。两种写法都建议练一遍，练完后你对异常机制的理解就比只背概念要稳固得多。这个知识点同样频繁出现在Java八股文和面试题的基础部分，是不可跳过的一环。

4.2 集合去重排序：一道题吃透Set与List的配合

集合阶段有一道高频训练题：从键盘录入若干个整数，去掉重复值，按升序输出。这个题有无数种实现方式，但我想重点讲的是用TreeSet一步到位的做法，因为它在考察你对集合特性的熟悉程度：

import java.util.Scanner; import java.util.TreeSet; public class SetSortTest { public static void main(String[] args) { Scanner sc = new Scanner(System.in); TreeSet<Integer> set = new TreeSet<>(); System.out.println("请输入整数，按0结束："); while (true) { int num = sc.nextInt(); if (num == 0) { break; } set.add(num); } for (Integer n : set) { System.out.print(n + " "); } sc.close(); } }

TreeSet的底层是红黑树，它天然具备两个能力：元素不重复，遍历时按自然顺序升序输出。所以整道题的算法逻辑被集合特性直接承接了，你需要写的代码就是“添加元素”和“遍历输出”。如果你的第一反应是用ArrayList存数字，然后用HashSet去重再用Collections.sort排序，那也是一种正确做法，但代码更啰嗦。两种做法我都建议写一遍，对比之后才能真正理解“数据结构的选择决定代码的复杂度”。

这个题还有一个隐藏考点：输入终止条件的设置。用0作为结束标志本身没什么问题，但在实际编码中，Scanner的nextInt遇到非数字输入会抛InputMismatchException，所以如果要更健壮，应该用hasNextInt做判断或者用字符串读入再解析。我在题库里保留了这个小粗糙点，就是为了让学员在跑通程序后自己发现流程设计的漏洞，再动手去修，这个过程比题目本身还珍贵。

4.3 文件复制：IO流的经典练习与内存思维

IO阶段的代表题是文件复制。实现把a.txt内容复制到b.txt，这是理解字节流最典型的练习。很多初学者第一次写文件复制，会下意识地“先读完再写”：把文件内容全部读到一个大数组里，然后一次性写出。对于小文件这没毛病，但一旦文件有几百MB，程序就会内存溢出。正确的思路是“边读边写”，用一个固定大小的缓冲数组反复搬运数据。

直接看标准实现：

import java.io.FileInputStream; import java.io.FileOutputStream; import java.io.IOException; public class FileCopy { public static void main(String[] args) { try (FileInputStream in = new FileInputStream("a.txt"); FileOutputStream out = new FileOutputStream("b.txt")) { byte[] buffer = new byte[1024]; int len; while ((len = in.read(buffer)) != -1) { out.write(buffer, 0, len); } System.out.println("复制完成"); } catch (IOException e) { e.printStackTrace(); } } }

这里用到了try-with-resources，JDK7以后的新特性，好处是流会自动关闭，不再需要手写finally块。代码里最关键的是len = in.read(buffer)，read方法返回的是实际读到的字节数，最后一次读取时可能不够1024个字节，所以写出的长度必须用len限定，而不是把整个buffer都写出去。如果直接用out.write(buffer)，最后一次会把缓冲区内残留的旧数据也写进目标文件，文件最后面就会出现乱码。很多零基础学员在菜鸟教程上抄下来代码能跑，却不知道这个细节，遇到文件末尾多出一串脏字符时彻底懵住。

我建议你在“边读边写”的基础上再写一个版本：统计复制耗时，比较1KB缓冲和4KB缓冲这个差别，感受一下缓冲大小对性能的影响。IO题在基础阶段看起来不起眼，但它练的是对系统资源和内存边界的感知力，这种感知力在以后处理大文件、做网络传输时非常有用。

4.4 生产者与消费者：多线程最少要学会的一道题

多线程阶段有一道绕不开的经典题目：生产者消费者问题。这道题的完整写法有很多种变体，初学者最容易理解的方式是用BlockingQueue，它能自动处理线程间的阻塞与唤醒：

import java.util.concurrent.ArrayBlockingQueue; public class ProducerConsumer { public static void main(String[] args) { ArrayBlockingQueue<Integer> queue = new ArrayBlockingQueue<>(5); Thread producer = new Thread(() -> { for (int i = 1; i <= 10; i++) { try { queue.put(i); System.out.println("生产者放入：" + i); } catch (InterruptedException e) { e.printStackTrace(); } } }); Thread consumer = new Thread(() -> { while (true) { try { Integer value = queue.take(); System.out.println("消费者取出：" + value); if (value == 10) { break; } } catch (InterruptedException e) { e.printStackTrace(); } } }); producer.start(); consumer.start(); } }

BlockingQueue的put方法在队列满时会阻塞等待空位，take方法在队列空时会阻塞等待数据，它把生产者消费者问题里最麻烦的等待、唤醒、锁机制都给封装掉了。初学者先跑通这个版本，体会到“两个线程通过一个中间容器协作”的模型，再回头去啃synchronized、wait、notify手写版本的代码，就会轻松很多。面试环节里问生产者消费者，主要考察两个点：一是能不能画出线程之间协作的模型，二是wait和notify的使用姿势是否正确，比如必须在同步代码块里调用，并且要用while循环而不是if来防止虚假唤醒。

多线程的坑在于并发问题的复现往往是概率性的，第一次跑没事，第二次就卡住或者数据错乱。如果刷题时遇到这种情况，不必焦虑，这正是多线程的常态。建议你给生产者线程加上sleep模拟耗时，再反复运行观察输出顺序，你对“线程调度是抢占式的”这句话就有了亲身体验。

5. 算法入门与综合实战题：从会做题到能干活

5.1 冒泡排序与选择排序：排序题背后的稳定性思维

进入算法阶段，排序是绝对的主角。题库里最基础的排序题是：给定数组 {5, 2, 9, 1, 7, 6}，用冒泡排序升序输出。冒泡排序的核心思想是反复交换相邻的逆序元素，每一轮都会把当前最大值像气泡一样推到末尾：

public class BubbleSort { public static void main(String[] args) { int[] arr = {5, 2, 9, 1, 7, 6}; for (int i = 0; i < arr.length - 1; i++) { 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; } } } for (int num : arr) { System.out.print(num + " "); } } }

这道题初学者会在内层循环边界上栽跟头。如果j的终止条件写成 arr.length - 1，那么j最大会取到arr.length-2，只用访问arr[j+1]不超过数组边界，好像没错，但每轮都会多比较已经就位的元素，效率变低。写成 arr.length - 1 - i，是为了让每轮冒泡的范围逐渐收缩，i越大，待排序区间越短，这是冒泡排序的优化点。另一个常考点是冒泡排序的稳定性：当两个元素相等时，冒泡不会交换它们的位置，所以相等元素的相对顺序保持不变，这也让它成为稳定的排序算法。相比之下，选择排序每一轮找到最小值后直接和当前位置交换，可能会破坏相等元素的相对顺序，因此是不稳定的。面试里问“稳定和不稳定有什么区别”，其实问的就是这一段代码细节。

如果你只想背下一套排序代码打天下，那至少要把冒泡和快速排序吃透。但基础训练阶段我不会直接上快排，因为快排的分治思想需要建立在数组区间概念之上，等二分查找练好再上手更合适。

5.2 二分查找：区间的“不变量”为什么重要

二分查找是算法题库里承上启下的题目。场景描述很简单：给定一个升序数组和一个目标值，如果能找到目标值就返回下标，否则返回-1。直接看标准实现：

public class BinarySearch { public static int search(int[] arr, int target) { int low = 0; int high = arr.length - 1; while (low <= high) { int mid = low + (high - low) / 2; if (arr[mid] == target) { return mid; } else if (arr[mid] < target) { low = mid + 1; } else { high = mid - 1; } } return -1; } }

这里的核心是“不变量”：在循环开始前，我们确信target只可能存在于[low, high]这个闭区间内。每次循环的中值如果小于target，说明target只可能在中值右边，low就更新为mid+1；如果中值大于target，说明target只可能在中值左边，high更新为mid-1。只要维护好这个区间不变量，循环条件和边界更新就不会写错。很多初学者二分查找写得晕，是因为他们不把这个区间约束当回事，mid找到一个比目标大的值之后，还是稀里糊涂地把high设成mid，结果死循环。

另外有个实现细节值得单独说一下：为什么很多教材里写mid = (low + high) / 2，而这里写成low + (high - low) / 2？因为当数组长度很大时，low和high相加可能超过int上限，导致溢出。写成减法形式避免了这个风险，很多Java面试题会把这种“看着奇怪实际优雅”的写法当成考察点。二分查找理解透之后，可以顺带练一道变体题：在一个有序数组中找到第一个大于等于目标值的元素下标，这是很多业务场景里真正会用到的能力。

5.3 用二维数组打印杨辉三角：蓝桥杯入门风格题

综合阶段的二维数组题里，杨辉三角是最有代表性的。题目要求打印前10行杨辉三角，格式自行设计。杨辉三角的规律是：每行首尾都是1，中间每个数是它左上方和正上方两个数之和。参考实现：

public class YangHuiTriangle { public static void main(String[] args) { int rows = 10; int[][] triangle = new int[rows][]; for (int i = 0; i < rows; i++) { triangle[i] = new int[i + 1]; triangle[i][0] = 1; triangle[i][i] = 1; for (int j = 1; j < i; j++) { triangle[i][j] = triangle[i - 1][j - 1] + triangle[i - 1][j]; } } for (int i = 0; i < rows; i++) { for (int k = 0; k < rows - i; k++) { System.out.print(" "); } for (int j = 0; j < triangle[i].length; j++) { System.out.print(triangle[i][j] + " "); } System.out.println(); } } }

这道题的关键在于创建不规则二维数组：第一行长度是1，第二行长度是2，第i行长度是i+1。Java的二维数组本质上是一维数组的数组，每一行可以各自指定长度，这个灵活的“锯齿数组”特性是很多教材不会仔细讲的。等号右侧new int[i + 1]就是按行变长的具体用法，跑通这个程序后，你对二维数组内存布局的理解就深入了一层。这种题目在蓝桥杯等比赛的入门阶段也很常见，数字规律题本质上就是在考察你用代码对规律建模的能力。

5.4 学生成绩统计小系统：串起前面所有知识

综合实战阶段，最接近“真实工作”的题是一个控制台版本的学生成绩统计系统。需求描述很简单：通过键盘循环录入学生姓名和成绩，录入0时停止；程序最后统计总人数、平均分、最高分和不及格人数，并按成绩从高到低输出全部学生信息。

这道题需要自己设计数据结构。我的推荐方案是：创建一个Student类存储姓名和成绩，用ArrayList保存学生对象，然后通过Collections.sort加Comparator实现按成绩降序排序。核心代码片段：

import java.util.ArrayList; import java.util.Collections; import java.util.Comparator; import java.util.Scanner; class Student { String name; double score; Student(String name, double score) { this.name = name; this.score = score; } } public class ScoreSystem { public static void main(String[] args) { Scanner sc = new Scanner(System.in); ArrayList<Student> list = new ArrayList<>(); while (true) { System.out.print("请输入姓名："); String name = sc.nextLine(); if (name.equals("0")) { break; } System.out.print("请输入成绩："); double score = Double.parseDouble(sc.nextLine()); list.add(new Student(name, score)); } Collections.sort(list, (s1, s2) -> Double.compare(s2.score, s1.score)); double total = 0; int failCount = 0; for (Student s : list) { total += s.score; if (s.score < 60) { failCount++; } } System.out.println("总人数：" + list.size()); System.out.println("平均分：" + total / list.size()); System.out.println("不及格人数：" + failCount); for (Student s : list) { System.out.println(s.name + "：" + s.score); } } }

这个项目同时用到了类设计、ArrayList泛型、Scanner、字符串比较、集合排序、Lambda表达式、增强for循环和统计逻辑。如果你能基本不看参考独立写出这个程序，零基础到精通的过度阶段，就算是走完了一大半。评分排序用Lambda表达式对初学者可以稍后理解，先用匿名内部类实现Comparator也是可以的，重要的是跑通完整的输入输出闭环。做完这个系统，你会明显感觉到“写代码”和“写程序”的区别——前者在练习语法，后者在解决一个小问题。

6. 刷题过程中的常见问题与排查技巧实录

6.1 初学者最高频的五个“低效刷题”行为

我接触过大量零基础刷题者，总结下来有五个行为会让刷题效率断崖式下降。

第一个是只看题解不写代码。阅读代码和编写代码用的是不同的脑区，你可以把题解看懂一百遍，合上屏幕依然写不出来。第二个是代码一报错就慌，第一反应是贴到群里问别人，而不是读报错信息。Java的编译器报错其实已经非常友好，它会明确指出哪一行哪个token有问题，你只需要从上往下逐条看，修复第一个报错后重新编译，很多时候后面的报错会自动消失。第三个是复制粘贴自己的旧代码，改个变量名就当新题写过。刷题的意义在于让大脑建立连接，不是让剪贴板建立连接。第四个是题目做不出来就直接看答案，缺少独立思考时间。我给自己带的人定过一个规矩：一星题独立思考20分钟，二星题30分钟，三星题45分钟，到时间还卡住才能看题解。这个时间不要太长也不要太短，太短没有思考深度，太长容易挫败。

第五个是做完就算，不回顾不重构。一道题第一次能跑通不说明你掌握了，三天后再让你写一遍，能独立写出来才算数。这也是为什么我强烈建议整理错题集：每道卡住过的题，都记下卡住的知识点，隔一周重新写一遍，写不出来就回头看笔记，直到能流畅写出来为止。

6.2 编译错误与逻辑错误速查表

刷题遇到问题是常态，关键是排查方法要高效。我整理了一张高频错误速查表，基本覆盖新手刷前100题时会遇到的大部分问题。

排查逻辑错误的顺序建议是：先确认程序有没有按预期顺序执行，可以在关键位置加System.out.println打印中间值；确认变量值的变化符合预期，再检查边界条件；最后考虑是不是对题目理解有偏差。比如回文数判断结果不对，打印每一轮reversed的值，立刻就能看出反转是否成功。这种“用输出做断点”的土办法，在刚刚接触编程的阶段比任何调试器都顺手。

6.3 三个月刷完500题的节奏模板与验收方式

最后给一份可抄的节奏模板。假设你每天能投入一到两小时，三个月刷完这套500题是可行的。第一个月集中火力在前两个阶段：第一周每天10道基础题，目标是手指跟上键盘，把环境配置、变量、运算符、分支循环全部过一遍；第二三周每天8道题，集中在循环嵌套、数组和简单算法，这个阶段容易烦躁，因为题目开始需要思考了，但恰恰不能跳；第四周做一次阶段自测，随机抽取50道题里的10道，限时半小时，检验前面是不是真的会了。

第二个月进入面向对象和集合API阶段，每天4到6道题。这不代表题量减少是变轻松，而是面向对象的题通常代码量更大、思考维度更多，一天写6道已经是高质量输出。这个阶段要特别注意的是，每做完一道题，自己把类图或者对象关系口头讲一遍，讲不清楚就回头重练。第三个月搞定异常、IO、多线程和综合实战，每天1道综合题加3道小题，最后两周集中做学生成绩统计系统这类综合项目题。周末不强制刷题，用来整理错题和复习本周没写出来的题。

三个月的终点，不是做完全部题目就结束，而是有一套验收标准。标准之一，随机从任一阶段抽题，你能在限定时间内独立写出来；标准之二，把你写过的某一类题的解法思路，给零基础的朋友讲明白，他能听懂；标准之三，把做过的综合项目换个需求描述，比如把“按成绩排序”改成“按姓名排序”，把存储结构从ArrayList换成数组，看能不能快速适配。这三条都通过，你再去面对Java面试题，会发现那些经常被问的基础概念题，你已经在写代码的过程中亲手经历过了，只需要再用语言组织一遍就行。

7. 最后分享一点个人体会

这套500题综合练习的思路，是我在带过几批零基础学员、又看过无数自学帖之后逐渐形成的。我印象最深的是一个起初连环境变量都不会配的同学，按这个节奏一天不落地写了两个多月，到第三个学期竟然能在社团里帮别人改代码。问他最大的变化是什么，他说：“以前看视频觉得老师写得都对，现在自己能感觉到哪里会报错，哪里容易踩坑了。”这就是刷题和看书的本质区别——它会让你获得对代码的“手感”和“直觉”。

所谓零基础入门到精通，并不是什么玄学。说白了就是把一个又一个看似独立的知识点，在一次次写错、改错、跑通的过程中连成网络。今天你因为整数除法丢小数困惑过，明天看到平均分统计题就会想到转型；今天你在二分查找里纠结边界条件，明天看源码里的while循环就多了一分敏感。这些连接会在你写完几百道题之后自己长出来。

最后一个小建议：这篇内容适合收藏，但收藏之后一定要从最简单的第一道题开始。不要总想着等到“准备好”再动手，编程从来不是准备好了才开始的，而是开始了才会慢慢准备好。每天哪怕只写五道题，一百天后你会感谢今天沉下心敲键盘的自己。