Java 基础全览速通

---

目录

1. 基本数据类型与算术运算
2. 运算符详解（赋值、算术、比较、逻辑、位运算、三元）
3. 字符串（不可变性、常用方法、== vs equals、StringBuilder）
4. 数组（声明、初始化、遍历、多维、常用工具）
5. 条件（if / else / switch）
6. 循环（for、增强 for、while、do-while、break/continue/标签）
7. 常见错误与调试建议
8. 练习题（含答案）

---

1. 基本数据类型与算术运算

Java 的基本（原始）数据类型：byte, short, int, long, float, double, char, boolean。其中整数默认是 int，小数默认是 double。

算术运算

常见：+ - * / %。注意：

• 整数除法会丢弃小数部分：5 / 2 == 2（两个 int），如果想要浮点结果至少有一个操作数是浮点：5.0 / 2 或 (double)5 / 2 得到 2.5。
• 取模 %：-5 % 2 == -1（符号遵循被除数）。
• 溢出不会抛异常（例如 int 超过 Integer.MAX_VALUE 会环绕）。

示例：

public class ArithmeticDemo {
    public static void main(String[] args) {
        int a = 5, b = 2;
        System.out.println(a + b); // 7
        System.out.println(a / b); // 2
        System.out.println((double)a / b); // 2.5
        System.out.println(a % b); // 1

        int x = Integer.MAX_VALUE;
        System.out.println(x + 1); // 溢出 -> 负数（环绕）
    }
}

自增/自减

i++（后置）与 ++i（前置）不同：前置先加再用，后置先用再加。

int i = 1;
int a = i++; // a=1, i=2
int j = 1;
int b = ++j; // b=2, j=2

---

2. 运算符详解

2.1 赋值运算符

• 简单：=
• 复合赋值：+=, -=, *=, /=, %=, <<=, >>=, &=, |=, ^=。例如 x += 3 等价于 x = (type)(x + 3)（注意强制类型转换）。

2.2 比较运算符

==, !=, >, >=, <, <=（用于数值、char 或 boolean（只 ==/!=））。对象比较请使用 .equals()（字符串等）。

2.3 逻辑运算符

• 短路逻辑：&& 和 ||（有短路行为，左侧决定结果时不会求右侧）。
• 非短路：& 和 |（对布尔也存在，但会计算双方）。
• 取反：!。

示例（短路）：

int a = 0;
if (a != 0 && (10 / a) > 1) { // 第二项不会执行，避免除以0
    // ...
}

2.4 位运算符（整型）

& | ^ ~ << >> >>>

• << 左移，>> 带符号右移（保留符号位），>>> 无符号右移（高位补 0）。
• ^ 异或，~ 按位取反。

示例（位运算）：

int n = 5; // 0101
System.out.println(n << 1); // 10 (1010)
System.out.println(n & 1); // 1

2.5 三元运算符

condition ? exprIfTrue : exprIfFalse
int a = 10, b = 20;
int max = (a > b) ? a : b;

2.6 运算优先级（常用）

从高到低（只列出常见）：

1. ++ --（前置）、()
2. * / %
3. + -
4. << >> >>>
5. < <= > >=
6. == !=
7. &（按位）
8. ^
9. |
10. &&
11. ||
12. ?:
13. =（赋值）

注意字符串拼接与 + 的优先："sum: " + 1 + 2 会得到 "sum: 12"，因为从左到右。使用括号："sum: " + (1 + 2) 得到 "sum: 3"。

---

3. 字符串（String）详解

String 在 Java 中是不可变（immutable）的对象：一旦创建内容不可更改，任何看似修改的操作都会产生新对象。

常见构造与比较

String s1 = "hello";            // 字面量，放入常量池
String s2 = new String("hello"); // 堆中新的对象

s1 == s2          // false（比较引用）
s1.equals(s2)     // true（比较内容）

常用方法（重要）

• length()：长度
• charAt(index)：按索引取字符
• substring(beginIndex, endIndex)：子串（endIndex 不含）
• indexOf(str) / lastIndexOf(str)
• trim()：去除首尾空白
• split(regex)：按正则分割 -> 返回 String[]
• replace(old, new) / replaceAll(regex, repl)
• toUpperCase() / toLowerCase()
• contains(CharSequence)
• startsWith() / endsWith()

示例：

public class StringDemo {
    public static void main(String[] args) {
        String s = " Hello, Java! ";
        System.out.println(s.trim()); // "Hello, Java!"
        System.out.println(s.substring(1,6)); // "Hello"
        System.out.println(s.indexOf("Java")); // 7
        System.out.println("a".equals("A")); // false
    }
}

拼接性能与 StringBuilder

频繁拼接 String（例如在循环内）会产生许多临时对象。推荐使用 StringBuilder（非线程安全）或 StringBuffer（线程安全）：

StringBuilder sb = new StringBuilder();
for (int i = 0; i < 1000; i++) {
    sb.append(i).append(",");
}
String result = sb.toString();

小坑

• s == null 与 s.equals(...)：调用 equals 前要保证不为 null。
• String 是不可变的，记得用 StringBuilder 提升性能。
• split 用正则；要分割点号时写 "\\."。

---

4. 数组（Array）

数组是固定长度、类型一致的容器。分为原始类型数组和对象数组。

声明与初始化

int[] a;          // 声明
a = new int[5];   // 初始化，默认值为 0

int[] b = {1,2,3}; // 静态初始化
String[] s = new String[3]; // 默认 null

访问长度：a.length（注意不是 length()）。

遍历

索引遍历：

for (int i = 0; i < a.length; i++) {
    System.out.println(a[i]);
}

增强 for（foreach）遍历：

for (int v : a) {
    System.out.println(v);
}

注意：增强 for 中的迭代变量是只读副本，不能用来修改原数组元素（例如 v = v + 1 不会改变数组）。要修改元素请用索引遍历。

多维数组

int[][] matrix = new int[3][4];
matrix[0][1] = 5;

多维数组在 Java 中其实是“数组的数组”，不同行可以有不同长度（即不一定是矩形）。

常用工具（java.util.Arrays）

import java.util.Arrays;

int[] a = {3,1,2};
Arrays.sort(a); // 排序
System.out.println(Arrays.toString(a)); // [1,2,3]

int[] b = Arrays.copyOf(a, 5); // 复制并扩容，空位填 0
int[][] two = {{1,2},{3,4}};
System.out.println(Arrays.deepToString(two)); // [[1,2],[3,4]]

示例：数组常见错误

• ArrayIndexOutOfBoundsException：索引越界（合法索引是 0 到 length-1）。
• 忘记初始化数组会出现 NullPointerException（当你声明 String[] s; 但没 new 时）。

---

5. 条件（if、switch）

if / else if / else

int n = 7;
if (n % 2 == 0) {
    System.out.println("even");
} else if (n % 3 == 0) {
    System.out.println("divisible by 3");
} else {
    System.out.println("others");
}

switch

传统 switch（适用于 int, char, String 等）：

String day = "MON";
switch (day) {
    case "MON":
        System.out.println("Monday");
        break;
    case "TUE":
        System.out.println("Tuesday");
        break;
    default:
        System.out.println("Other day");
}

注意 break，否则会 fall-through（穿透到下一个 case）。

较新的 Java（Java 12+）支持增强 switch 表达式（箭头语法）：

int result = switch (day) {
    case "MON" -> 1;
    case "TUE" -> 2;
    default -> 0;
};

（如果你在较老版本上编译，记得不要使用增强语法。）

---

6. 循环（详尽）

for（经典）

for (int i = 0; i < 10; i++) {
    System.out.println(i);
}

增强 for（foreach）

适用于数组和 Iterable：

int[] a = {1,2,3};
for (int v : a) {
    System.out.println(v);
}

不能在 foreach 中使用索引（除非额外维护计数器），也不能通过赋值改变原数组元素。

while

int i = 0;
while (i < 5) {
    System.out.println(i++);
}

do-while

至少执行一次：

int i = 0;
do {
    System.out.println(i);
    i++;
} while (i < 1);

break 与 continue

• break 退出最近的循环（或 switch）。
• continue 跳过本次循环迭代，进入下一次。
• Java 支持标签（label）用于跳出多层循环（谨慎使用，易读性差）：

outer:
for (int i = 0; i < 10; i++) {
    for (int j = 0; j < 10; j++) {
        if (i * j > 50) break outer; // 跳出外层循环
    }
}

---

练习题（含参考答案）

练习 1

写代码：计算 1 到 100 中所有偶数和的值并输出。
参考答案

int sum = 0;
for (int i = 2; i <= 100; i += 2) sum += i;
System.out.println(sum);

练习 2

给定字符串 s = "abc,def,ghi"，拆分为数组并打印每个元素的长度。
参考答案

String s = "abc,def,ghi";
String[] parts = s.split(",");
for (String p : parts) System.out.println(p.length());

练习 3

写函数判断数组是否包含重复元素（简单实现）。
参考答案（O(n^2)）

public static boolean hasDuplicate(int[] a) {
    for (int i = 0; i < a.length; i++) {
        for (int j = i + 1; j < a.length; j++) {
            if (a[i] == a[j]) return true;
        }
    }
    return false;
}

（进阶：用 HashSet 可以降到 O(n)）