企业官网建设流程全解析

1. 一起把 Java 运算符这块硬骨头啃下来

聊到 Java 语法，很多自学的小伙伴进度很容易卡在运算符这一章。说实话，运算符在教科书里的篇幅不算长，但信息密度极高，而且它不像循环、数组那样能直观看出“学完能干嘛”。很多人要么囫囵吞枣记了一堆符号，要么觉得“不就是加减乘除嘛”，结果一到写代码就翻车——尤其是++、%、==和=混在一起的时候，报错都找不到地方。

这篇博文就专门围绕 Java 运算符练习展开。我会把算术、赋值、比较、逻辑、三元、位运算这六大类运算符逐一拆开讲，每一类都配上实际练习和踩坑记录。不管你是在校学生、转行自学，还是正在准备 Java 面试的开发者，这篇文章都值得花半小时慢慢看——尤其是那些“一看就懂、一写就错”的细节，我会尽量讲透。

先说清楚这篇文章解决什么问题：它帮你建立一套运算符的“判断框架”——看到一段表达式，知道先算哪、再算哪，知道结果是 int 还是 boolean，知道为什么这个写法会编译报错。配合文中的练习代码和常见面试题，你会在写完大量练习题之后，形成肌肉记忆。

2. 运算符整体思路：先建框架，再扣细节

2.1 学运算符的正确姿势：不是背符号，而是建“计算模型”

我第一次学运算符的时候，习惯性地拿了一张表去背优先级——加减乘除、移位、比较、逻辑、赋值，背得滚瓜烂熟，但做题还是错。后来才发现，问题出在方法上：运算符不是孤立的知识点，它背后是一套“表达式求值”的完整流程。你看到一个表达式，脑子里要同时跑三件事：

1. 操作数是什么类型：int？double？boolean？String？类型决定了很多运算的行为。
2. 运算符的优先级和结合性：先算什么、后算什么。
3. 运算结果的类型：是数值？是布尔？会不会有精度损失？会不会溢出？

把这三件事练成本能反应，运算符才算真正过关。举个例子，System.out.println(10 + 20 + "30");你觉得输出是什么？很多人脱口而出“60”，实际输出是"3030"——因为从左往右算，10 + 20先得到30（int），再和字符串"30"拼接，变成字符串"3030"。这就是“类型参与运算”的典型坑。

所以我在练习时，给自己的要求是：每写一个表达式，先口头预测结果，再敲代码验证。预测错了，就把错因记下来——这个习惯帮我避开了大量低级失误。

2.2 练习题的行业价值：为什么面试官爱考运算符

有些同学觉得，现在开发都用框架、写业务，谁还天天算表达式？确实，日常 CRUD 很少让你手写复杂的位运算，但运算符是面试官检验基础扎实程度的“探针”——它能快速暴露你三方面的问题：

• 基础不牢：说不出i++和++i的区别，说明底层执行逻辑没理清。
• 粗心大意：if (a = b)这种把比较写成赋值的错误，在真实项目里能造成严重的逻辑 BUG。
• 不会排查问题：遇到结果不对，不知道通过拆解表达式、单独打印中间值来定位。

更实际一点，运算符在真实开发里随处都在：判断用户权限要用逻辑运算符；金额计算要注意浮点精度；分页页码计算要用到除法和取余；状态位标记用位运算可以大幅节省内存。这些不是“面试八股”，是实打实的工作技能。

2.3 本章练习的整体规划：从简单到综合，分四层递进

我给自己安排的运算符练习分四个阶段，你也可以照这个节奏走：

• 第一层：单类运算符专项练习。比如单独练算术、单独练逻辑，每个类别 10 道题，确保基本用法烂熟。
• 第二层：混合表达式求值。把多类运算符揉在一起，重点练优先级和类型转换。
• 第三层：易错题专项。单独整理==与equals、&与&&、i++与++i这类对比题，反复做。
• 第四层：场景应用题。把运算符放进真实的小需求里，比如判断闰年、计算水仙花数、交换两个变量。这一步能让你感觉到“运算符真的有用”。

我当时每天固定练 30 分钟，大概两周就把四层全部过完了。进度不快，但稳——比一天刷 100 道题然后全忘掉强得多。

3. 六大运算符逐一拆解：原理、实操、避坑

3.1 算术运算符：加减乘除之外的“隐藏陷阱”

算术运算符大家小学就认识：+ - * / %。但在 Java 里，它们的行为和数学有几点明显不同，必须单独拎出来说。

整数除法是向下取整，不是四舍五入。这是新手踩得最狠的坑。7 / 2的结果不是 3.5，而是 3——两个整数相除，结果还是整数，小数部分直接丢掉。想做精确除法，至少要把其中一个操作数转成浮点型：7 / 2.0或(double) 7 / 2。我当时在做一个求平均分的练习，sum / count写成了整数除法，结果全班平均分出来是 88 而不是 88.5，查了半天才发现问题。

取余运算符%要理解“余数”的含义。a % b的结果是a / b的余数，符号跟随被除数。7 % 3是 1，-7 % 3是 -1，7 % -3是 1。这在处理“循环队列”或“分页”时特别有用。比如你要把一个索引限制在 0~7 的范围内，直接index % 8就能循环，不需要写 if 判断。

自增自减++和--：前后位置的区别是执行顺序，不是结果值。很多资料说“i++是先赋值后自增，++i是先自增后赋值”，这句话其实有点误导。更准确的理解是：i++这个表达式的值是自增前的值，++i表达式的值是自增后的值，但无论哪种写法，变量i最终都会自增 1。看这个例子：

int i = 5; int a = i++; // a = 5，i = 6 int b = ++i; // b = 7，i = 7

难点在于复合表达式里，比如int result = i++ + ++i;这种题。这类题目在实际开发中很少写，但面试爱考，因为它能检验你对“表达式的值”和“变量的当前值”这两个概念的区分是否清晰。遇到这种题，我的建议是先在纸上拆成多行普通代码，再代入求值，不要在脑子里硬跑。

字符参与算术运算时，会先转成 ASCII 码。'A' + 1的结果是 66（char 自动提升为 int），而不是"B"。这在处理字符加密、统计大小写字母时经常用到。

注意：String类型的+是字符串拼接，不是算术加法。只要表达式里出现字符串，+就变成拼接符。这是 Java 里极少数“运算符重载”的例子——仅限+，其他运算符不支持字符串操作。

3.2 赋值运算符：不只是“等于”，它还带着类型转换

赋值运算符=是编程里最容易和“相等比较”混淆的符号。在 Java 中，=表示“把右边的值存入左边的变量”，而==才表示相等判断。这个区别第一次写if (a = 1)报错或者逻辑错乱时，你会记得特别牢。

赋值运算符有一组复合形式：+=、-=、*=、/=、%=。它们等价于先运算再赋值，但有个细节值得注意——复合赋值自带强制类型转换。看这个经典题：

short s = 1; s = s + 1; // 编译报错：int 不能直接赋给 short s += 1; // 编译通过：相当于 s = (short)(s + 1);

为什么s += 1能过？因为s + 1的结果是 int，直接赋给 short 会损失精度，必须强转。但+=帮编译器做了这个隐式转换。这个细节很多人学了几年 Java 都没注意过，但它体现了语言设计者对“易用性和安全性”的权衡。

赋值运算符还有一个特征是右结合，也就是支持链式赋值：a = b = c = 10;会先把10赋给c，然后把c的值赋给b，最后赋给a。规则是“从右往左执行”，但实际效果是三个变量都变成 10。这个写法在初始化多个变量时很简洁，但别在复杂表达式里这么干，可读性差。

3.3 比较运算符：结果永远是 boolean，别拿来当数值用

比较运算符包括>、<、>=、<=、==、!=，它们的结果只有true或false，是布尔值。这点一定要刻在脑子里——它和 C 语言不一样，C 里比较结果为 1 或 0，可以参与算术运算，但 Java 里boolean不能自动转成 int，也不能参与算术运算。

==的坑最多，因为它在不同场景下含义不同：

• 基本类型比较的是值：5 == 5.0是true，因为比较前 5 会转成 5.0。
• 引用类型比较的是“是否指向同一个对象”："abc" == "abc"可能是true也可能是false，取决于字符串是否来自常量池。两个new String("abc")用==比较，结果一定是false。

所以我一直建议：判断两个对象的内容是否相等，永远用equals()，不要用==。==只在判断基本数据类型时才是你直觉里“等于”的意思。

浮点数的相等比较也是重灾区。0.1 + 0.2 == 0.3的结果是false，因为浮点数在内存里是近似存储的。你算金融相关的金额，千万不要用 double 做精确比较，正确做法是BigDecimal，或者设定一个极小误差范围（如Math.abs(a - b) < 1e-6）来近似判断相等。

3.4 逻辑运算符：短路与死活用得好，代码性能差一倍

逻辑运算符有三组：&&（短路与）、||（短路或）、!（逻辑非），以及非短路的&和|。日常开发中用得最多的是前三者，它们有短路特性：左边已经能决定整个表达式的真假时，右边就不再执行。这个特性不仅是性能优化，更是防 NPE（空指针）的关键。

String name = null; if (name != null && name.length() > 0) { // 不会抛空指针，因为 name != null 为 false，右边不执行 }

如果把&&换成&，这个代码就会抛 NullPointerException——因为&不具备短路能力，左右两边都会执行。同理，||和|的区别也是是否短路。

逻辑非!看着简单，但多重否定容易把人绕晕。!true是false，!(a > b)等价于a <= b。我练逻辑运算符时，总结了三条经验：

• 写条件的时候尽量正向表达，少用“双重否定”。if (!(num < 0))不如if (num >= 0)直观。
• 判断一个数是否在区间内，用&&连起来：x >= 10 && x <= 100。不要写成10 <= x <= 100，Java 不支持这种链式比较，编译直接报错。
• 警惕短路改变程序状态：if (n++ > 5 || m++ > 3)这种表达式里，如果前半段已经为 true，m++就不会执行，变量 m 的值不会被修改。这种“副作用依赖短路”的写法，是日常 bug 的高发区，尽量别这么写。

3.5 三元运算符：Java 里唯一的“三目运算”

三元运算符条件 ? 表达式1 : 表达式2是唯一一个有三个操作数的运算符。它在“二选一赋值”场景非常简洁：

int max = a > b ? a : b;

等价于：

int max; if (a > b) { max = a; } else { max = b; }

但三元运算符有个类型统一问题，容易踩坑。当两个分支的类型不同时，结果类型会进行“类型提升”。比如：

int a = 5; double b = 3.0; Object result = true ? a : b; // 结果是 Double，不是 Integer

因为 Java 会自动把两个分支统一成公共类型 double。这个行为在面试题里经常出现，出题人就是想看你有没有意识到“条件表达式的结果类型不是固定的”。

还有一个踩坑点：三元运算符可以作为if-else的简写，但别在条件复杂或分支是多个语句时强行用三元，可读性会急剧下降。比如return a != null ? a.length() > 0 ? "yes" : "no" : "unknown";这种嵌套三元的写法，虽然合法，但维护起来想骂人。我的原则是：只用三元做简单二选一，超过两层就改成 if。

3.6 位运算符：日常少用，但懂了就不慌

位运算符包括&（按位与）、|（按位或）、^（按位异或）、~（按位取反）、<<（左移）、>>（右移）、>>>（无符号右移）。它们操作的是整数在内存里的二进制位。

位运算是很多 Java 面试题喜欢拔高的点，因为它在算法题、底层框架里特别常见。比如 HashMap 计算桶下标就用到了hash & (n - 1)；权限系统中用|组合权限、用&判断是否拥有权限；状态码压缩用位标记。

我自己练习位运算时，发现最有价值的是一个“交换两个变量”的技巧：

a = a ^ b; b = a ^ b; a = a ^ b;

这个操作不借助第三个变量就能交换 a 和 b。原理是异或的自反性：a ^ b ^ b会变回 a。不过说实话，真实开发里没人这么写，因为它不如用一个临时变量来得直观，而且可读性差。但面试官问到这个技巧时，你如果能解释清楚原理，说明你对位运算的掌握是真的到位。

移位运算同样容易出错。左移<<是乘 2 的幂（a << 1等于a * 2），右移>>是除 2 的幂（带符号位），>>>是无符号右移（高位补 0）。-8 >> 1结果是 -4，-8 >>> 1结果是 2147483644——因为无符号右移把符号位也一起移了，负数直接变成一个很大的正数。

4. 实操过程与核心环节实现：手写一整套运算符练习

4.1 练习环境准备：别在 IDE 里干瞪眼，先搭一个“表达式演算台”

我用的是 IntelliJ IDEA 社区版，新建一个 Java 项目，建一个OperatorPractice类，里面写一堆testXxx()方法，每个方法对应一个运算符专题。

public class OperatorPractice { public static void main(String[] args) { testArithmetic(); testAssignment(); testComparison(); testLogical(); testTernary(); testBitwise(); } public static void testArithmetic() { System.out.println("===== 算术运算符 ====="); System.out.println("7 / 2 = " + (7 / 2)); System.out.println("7 / 2.0 = " + (7 / 2.0)); System.out.println("7 % 3 = " + (7 % 3)); System.out.println("10 + 20 + \"30\" = " + (10 + 20 + "30")); int i = 5; System.out.println("i++ 表达式的值 = " + (i++)); System.out.println("执行 i++ 后 i = " + i); System.out.println("++i 表达式的值 = " + (++i)); System.out.println("执行 ++i 后 i = " + i); } }

这些打印语句就是你的“演算台”。先用手算出预期结果，再跑程序对答案。别小看这个流程——它逼着你在输出前经历一次完整的“类型推断 + 优先级推演”，这正是考试和面试最需要的底层能力。

4.2 核心练习一：运算符优先级与类型提升的计算题

我整理过一批典型的综合题，直接拿来当练习模板。先遮住答案，自己在纸上算，最后用程序验证。

第一题：

int a = 3; int b = 5; int result = a++ * 2 + --b;

拆解过程：a++表达式的值是 3，之后 a 变成 4；--b表达式的值是 4，同时 b 变成 4。所以result = 3 * 2 + 4 = 10。这一题的核心考点是：表达式的值（用当前值代入计算）和自增自减的副作用（改变变量本身）是两条线，别混在一起。

第二题：

int x = 10; int y = 3; System.out.println(x % y == 1 ? x / y : x * y);

先算x % y，结果是 1，于是1 == 1为true，走x / y分支，输出10 / 3 = 3（整数除法）。这题把取余、比较、三元、除法全部串起来了，是一道典型的“综合小题”。

第三题（经典陷阱题）：

int n = 5; boolean flag = (n > 3) && (n++ < 10); System.out.println(flag); System.out.println(n);

n > 3为true，需要继续算右边；n++ < 10中，表达式的值是5 < 10为true，同时 n 变成 6。所以 flag 是 true，n 是 6。如果把&&改成||，左边为 true 就直接短路，n++ < 10不执行，n 还是 5。我当初就差在这——没有意识到逻辑运算会改变变量值。

第四题（类型提升）：

char ch = 'A'; int num = 10; System.out.println(ch + num); System.out.println((char) (ch + 1));

第一行输出 75，因为 char 提升为 int 参与加法；第二行输出 B，因为强转回 char 后把数字 66 解释成了字符编码。这题的价值在于让你理解“char 在算术运算中就是数值，只有在显示时才是字符”。

4.3 核心练习二：用运算符解决实际问题

光做题不够，把运算符嵌进真实逻辑里，你的理解深度会完全不一样。这里分享三个我自己练过的场景题。

场景一：判断闰年

闰年的规则：能被 400 整除，或者能被 4 整除但不能被 100 整除。

int year = 2024; boolean isLeap = (year % 400 == 0) || (year % 4 == 0 && year % 100 != 0); System.out.println(isLeap);

这道题把逻辑优先级用到了极致。口诀是“整除 400 直接闰；整除 4 且不整除 100 闰；其余不闰”。注意&&和||的优先级：&&的优先级高于||，所以这里不加括号也能算对，但为了可读性，建议显式加括号。

场景二：交换两个变量

用临时变量的写法是工作里最稳妥的：

int temp = a; a = b; b = temp;

用位运算的写法是纯炫技，原理是异或自反性。我建议两种都会，但使用场景要知道——临时变量法优先，位运算法只用来理解异或特性。

场景三：判断一个数是奇数还是偶数

if (num % 2 == 0) { System.out.println("偶数"); } else { System.out.println("奇数"); }

这里有个细节：num % 2 == 1判断奇数是有坑的。当 num 是负数时，-3 % 2的结果是 -1，不等于 1，但 -3 确实是奇数。所以正确写法是num % 2 != 0判断奇数。这个细节很多人刷题踩过，但从来不知道原因——根源就在取余运算的符号跟随被除数。

4.4 核心练习三：一道接近面试难度的综合题

我再放一道综合度比较高的题，你试试不看答案能不能做对：

int i = 2; i = i++ + i--; System.out.println(i);

拆解：第一轮求i++的值，表达式值是 2，i 变成 3。接着求i--的值，此时 i 是 3，表达式值是 3，i 变回 2。所以整个表达式i++ + i--的结果是2 + 3 = 5，然后把这个结果赋给 i，i 最终是 5。

这种题在真实业务里几乎不会出现，因为它太反直觉，可读性极差。但面试官用它来检验你对自增自减“表达式值”和“变量状态”理解的深度。我的建议是：如果你能独立算对这道题，运算符的基础就真的扎实了。不用刻意去写这种代码，但要有能力看穿它。

4.5 实操心得：怎么把练习题做成“错题本”

我练运算符时有个习惯：凡是预测结果和实际运行不一致的题，全部记到一个errors.md文件里。格式很简单：

## 题号：第 12 题 表达式：int c = a++ + ++b; 我的预测：c = 9 实际输出：c = 8 错误原因：忽略了 ++b 的表达式值是自增后的值，a++ 的表达式值是自增前的值，两者并非同一时刻

这个错题本的价值在于：你错过的题，往往是有共性的——要么是优先级，要么是类型转换，要么是短路逻辑。整理十道错题后，你会发现自己的薄弱点非常集中。把时间花在薄弱点上，比刷一百道会的题有效得多。

5. 常见问题与排查技巧实录

5.1 明明是两个数字相加，结果却变成了字符串

这个问题几乎每个初学者都遇到过。写System.out.println("结果：" + a + b);原本期望输出"结果：7"，结果输出"结果：34"（假设 a=3，b=4）。

原因很简单：+的运算顺序是从左到右。"结果：" + a先执行，由于有字符串参与，结果是字符串"结果：3"；然后"结果：3" + b又是字符串拼接，得到"结果：34"。

解决办法：先让算术运算执行完毕，再拼接字符串。用括号包起来：

System.out.println("结果：" + (a + b));

这个坑在打印日志时特别常见，尤其是当你写log.info("金额：" + amount1 + amount2)时，输出的数字直接连在一起，排查半天才发现是加号优先级的问题。

5.2==比较字符串时，有时 true 有时 false，到底怎么回事

这是引用比较和值比较的经典混淆题。看代码：

String s1 = "abc"; String s2 = "abc"; String s3 = new String("abc"); System.out.println(s1 == s2); // true，因为都指向常量池里的同一个"abc" System.out.println(s1 == s3); // false，因为 new 强制创建了新对象 System.out.println(s1.equals(s3)); // true，比较内容

原因在于：字符串字面量"abc"如果存在于常量池，编译器会直接复用同一个对象；而new String("abc")强制在堆上新建一个对象。所以==比较的是内存地址，而不是内容。

我在实际开发中定了一条铁律：String 之间的相等判断，永远用equals()，绝不用==。没有例外。你可能会遇到个别场景因为字符串在常量池里恰好相等，导致==也返回 true，但这种“碰运气”的写法一旦换一个场景就崩，绝不能依赖。

5.3 浮点数计算的“精度危机”怎么破

System.out.println(0.1 + 0.2);

输出不是 0.3，而是0.30000000000000004。原因是 double 用二进制科学计数法存储，无法精确表示 0.1 和 0.2 这样的十进制小数。这不是 Java 的缺陷，是所有支持 IEEE 754 标准的语言都存在的问题。

解决方案分场景：

• 对精度要求不高（比如显示百分比）：直接用浮点数，然后通过格式化控制输出String.format("%.2f", value)。
• 对精度要求高（金额、汇率、得分统计）：必须用BigDecimal，并且构造时推荐传字符串new BigDecimal("0.1")，而不是传 doublenew BigDecimal(0.1)——后者会保留二进制浮点的“脏数据”。
• 判断浮点数相等：不要用==，用误差范围或BigDecimal的compareTo方法。

5.4 表达式太复杂，看不出优先级，怎么快速定位

我在练习时最常用的排查手段是“拆解法”——把复杂表达式拆成多个简单表达式，每行只干一件事。好比下棋时先把大局面切成小块，一块块吃透。

// 复杂表达式 int result = a + b * c - d / e % f; // 拆解后 int step1 = b * c; // 乘法优先级最高，先算 int step2 = d / e; // 除法次之 int step3 = step2 % f; // 取余再算 int step4 = a + step1; // 加法 int result = step4 - step3; // 减法

这样拆出来的每一步，都可以单独加打印语句验证。排错效率直接翻倍。如果拆完之后发现某一步的结果和自己预想不一致，就往“类型转换”或“自增自减副作用”两个方向查——绝大多数错都出在这。

5.5 常见错误速查表

5.6 做题时的三大迷信，趁早戒掉

第一，“题目刷越多越厉害”。我见过很多人一天狂刷 200 道，全凭记忆背答案，换个数就懵。运算符练习的核心是“理解求值流程”，不是背答案。每道题都要推演一遍过程，错了就找原因，这才是有效练习。

第二，“不支持的就是错的”。有些题你用a + b + ""拼出了字符串，觉得“这也行”，就没深究为什么。实际上这个结果跟你预期的类型可能完全不一样，只是你碰巧没用到错误结果而已。每一个“巧合正确”都要当成可疑对象排查。

第三，“运算符优先级靠背表就能过关”。优先级表当然要记，但真正的高手是在写代码时直接加括号，不依赖记忆。我在写复杂条件时，从来都是显式加括号，这不丢人——代码是给人看的，括号就是给读者（包括未来的自己）画的导航线。

6. 运算符练习的扩展：从基础语法走向真实开发

6.1 运算符在算法题里的高频用法

如果你在准备 Java 面试，运算符相关的算法题是绕不开的。其中最典型的就是“二进制中 1 的个数”：

public static int countOnes(int n) { int count = 0; while (n != 0) { count++; n = n & (n - 1); } return count; }

这里的核心是n & (n - 1)能把 n 二进制表示中最右边的 1 变成 0。每执行一次，就消掉一个 1。这个技巧在面试题里非常经典，它考察的就是按位与运算的理解深度。

再比如“不用加减乘除做加法”：

public int add(int a, int b) { while (b != 0) { int carry = (a & b) << 1; a = a ^ b; b = carry; } return a; }

原理是用^做无进位加法，用&配合左移计算进位。这种题纯粹是“钻运算符的牛角尖”，真实项目里没人这么写，但面试官用它考察你的位运算功底——你要是能把原理讲明白，基本能证明基础很扎实。

6.2 运算符在真实项目里的经典场景

说完面试题，再回到实际开发。运算符在业务代码里的出现频率其实相当高，只是很多人没意识到自己一直在用。

• 分页计算：totalPages = (totalCount + pageSize - 1) / pageSize用到了加法、减法、除法的组合。这个公式是为了实现“向上取整”，避免除尽时少算一页。
• 权限位标记：假设权限有读、写、执行三种，可以分别定义成1 << 0、1 << 1、1 << 2。用户权限用一个 int 存储：有读有写就是(1 << 0) | (1 << 1)，判断有没有写权限用(permission & (1 << 1)) != 0。这样只用四个字节就存下了一组布尔标记，数据库存储和内存占用都更省。
• 状态机流转：用逻辑与、或判断多个前置条件是否同时满足，比如“订单已支付 && 库存充足”才能发货。
• 奇偶校验：n & 1判断奇偶，比n % 2更快，因为位运算直接在二进制位层面操作。原理是奇数的二进制最低位一定是 1，偶数是 0。

6.3 给自学者的下一步建议

运算符只是 Java 语法长路上的第一道关卡，但这一关打牢了，后续学流程控制、数组、面向对象都会顺畅很多，因为它们的底层判断条件完全依赖运算符的表达式结果。

我建议你学完运算符之后，紧接着做三件事：

1. 自己出 20 道混合表达式题，难度递增，然后用手算验证。出题过程中，你会主动思考“什么情况下容易错”，这种反向学习效率极高。
2. 去把 Java 官方文档里Operators章节扫一遍，重点是优先级表格和每个运算符的行为描述。看得懂英文最好，看不懂开个翻译也能看，关键是确认自己掌握的知识点没有“民间版本”的偏差。
3. 写一个小计算器程序（控制台版即可），要求支持加减乘除、取余、括号运算。这个项目会把运算符、类型转换、流程控制全部串起来，做完之后你对“表达式求值”的理解会进入另一个层次。

从我个人经验来看，运算符练得扎实的人，后续学集合、流式编程会轻松很多，因为Stream里大量用到Comparator的比较逻辑、filter的条件判断，这些本质上都是比较运算符和逻辑运算符的组合应用。现在花的每一分钟，都在为后面的学习铺路。

我练运算符时最大的体会是：它不像框架那样能做出可见的成果，成就感来得慢，但它是整个 Java 语法体系里最“刚性”的基础。真正的高手，不会在i++和++i上面翻车；而翻过车的人，往往很久之后还在同一个地方跌倒。趁现在时间充裕，把这关彻底闯过去。