Java 核心语法与并发编程实战：66 个关键代码示例

3. 类型转换

自动提升与强制转换需谨慎，后者可能丢失精度。

public class Demo03 {
    public static void main(String[] args) {
        int i = 10;
        long l = i;      // 自动提升
        double d = l;
        int j = (int) d; // 强转可能丢失精度
        System.out.println(j);
    }
}

4. 常量 final

使用 final 定义不可变引用或值。

public class Demo04 {
    public static final double PI = 3.141592653589793;
    public static void main(String[] args) {
        System.out.println(PI);
    }
}

5. 运算符

注意整除与浮点除的区别，以及自增运算符的前后缀差异。

public class Demo05 {
    public static void main(String[] args) {
        int a = 5, b = 2;
        System.out.println(a / b);       // 2 整除
        System.out.println(a / (double) b); // 2.5 浮点
        System.out.println(a++);         // 5（先用后加）
        System.out.println(++a);         // 7（先加后用）
        System.out.println(a & 1);       // 位运算判断奇偶
    }
}

6. 字符串操作

String 是不可变的，常用方法如 trim、replace 等返回新对象。

public class Demo06 {
    public static void main(String[] args) {
        String s = " Java ";
        System.out.println(s.trim().toUpperCase().replace(" ", ""));
        System.out.println(String.join(",", "A", "B", "C"));
    }
}

7. 控制台输入

使用 Scanner 读取用户输入，建议配合 try-with-resources 关闭资源。

import java.util.*;
public class Demo07 {
    public static void main(String[] args) {
        try (Scanner sc = new Scanner(System.in)) {
            System.out.print("请输入名字：");
            String name = sc.nextLine();
            System.out.println("Hi, " + name);
        }
    }
}

8. 格式化输出

printf 支持类似 C 语言的格式化占位符。

public class Demo08 {
    public static void main(String[] args) {
        System.out.printf("%-10s | %8.2f\n", "Revenue", 12345.678);
    }
}

9. if-else

三元运算符适合简单的条件赋值。

public class Demo09 {
    public static void main(String[] args) {
        int score = 86;
        String level = score >= 90 ? "A" : score >= 80 ? "B" : "C";
        System.out.println(level);
    }
}

10. switch 表达式

JDK 14+ 引入的 switch 表达式更简洁，支持箭头语法和模式匹配。

public class Demo10 {
    public static void main(String[] args) {
        String day = "MON";
        int num = switch (day) {
            case "MON", "TUE", "WED", "THU", "FRI" -> 1;
            case "SAT", "SUN" -> 2;
            default -> 0;
        };
        System.out.println(num);
    }
}

11. for 循环

最基础的计数循环。

public class Demo11 {
    public static void main(String[] args) {
        int sum = 0;
        for (int i = 1; i <= 100; i++) sum += i;
        System.out.println(sum);
    }
}

12. while/do-while

do-while 保证至少执行一次。

public class Demo12 {
    public static void main(String[] args) {
        int n = 3;
        do {
            System.out.println(n--);
        } while (n > 0);
    }
}

13. break/continue/标签

多层循环中可使用标签控制跳出范围。

public class Demo13 {
    public static void main(String[] args) {
        outer: for (int i = 0; i < 3; i++) {
            for (int j = 0; j < 3; j++) {
                if (i == 1 && j == 1) break outer;
                System.out.printf("(%d,%d) ", i, j);
            }
        }
    }
}

14. 增强 for

遍历集合或数组时更简洁，底层使用 Iterator。

import java.util.*;
public class Demo14 {
    public static void main(String[] args) {
        for (var x : List.of(1, 2, 3)) System.out.println(x);
    }
}

二、面向对象与设计模式

15. 一维数组

Arrays 工具类提供常用排序与打印功能。

import java.util.Arrays;
public class Demo15 {
    public static void main(String[] args) {
        int[] arr = {3, 1, 2};
        Arrays.sort(arr);
        System.out.println(Arrays.toString(arr));
    }
}

16. 二维数组

多维数组本质是数组的数组。

import java.util.Arrays;
public class Demo16 {
    public static void main(String[] args) {
        int[][] m = {{1, 2}, {3, 4}};
        System.out.println(Arrays.deepToString(m));
    }
}

17. Arrays 工具类

复制、搜索等操作。

import java.util.Arrays;
public class Demo17 {
    public static void main(String[] args) {
        int[] a = {1, 3, 5, 7};
        System.out.println(Arrays.binarySearch(a, 5));
        int[] b = Arrays.copyOf(a, 6);
        System.out.println(Arrays.toString(b));
    }
}

18. 方法与重载

同名方法参数列表不同即可重载。

public class Demo18 {
    static int add(int a, int b) { return a + b; }
    static double add(double a, double b) { return a + b; }
    public static void main(String[] args) {
        System.out.println(add(1, 2));
        System.out.println(add(1.2, 3.4));
    }
}

19. 可变参数

允许调用时传入不定数量的参数。

public class Demo19 {
    static int sum(int... xs) {
        int s = 0;
        for (int x : xs) s += x;
        return s;
    }
    public static void main(String[] a) {
        System.out.println(sum(1, 2, 3, 4));
    }
}

20. 类与对象

基本的 POJO 结构。

class User {
    String name;
    int age;
}
public class Demo20 {
    public static void main(String[] args) {
        User u = new User();
        u.name = "Tom";
        u.age = 20;
        System.out.println(u.name + ":" + u.age);
    }
}

21. 封装

隐藏内部实现细节，通过 Getter/Setter 访问。

class Account {
    private double balance;
    public double getBalance() { return balance; }
    public void deposit(double amt) {
        if (amt <= 0) throw new IllegalArgumentException();
        balance += amt;
    }
}

22. 构造器与 this

构造器链式调用。

class Point {
    int x, y;
    Point() { this(0, 0); }
    Point(int x, int y) { this.x = x; this.y = y; }
}

23. static 成员与静态块

静态成员属于类而非实例，静态块在类加载时执行。

class IdGen {
    static long next = 1;
    static {
        System.out.println("class loaded");
    }
    static synchronized long nextId() {
        return next++;
    }
}

24. 继承与 super

子类扩展父类行为。

class Animal {
    void say() { System.out.println("..."); }
}
class Dog extends Animal {
    @Override
    void say() {
        super.say();
        System.out.println("wang");
    }
}

25. 多态与重写

运行时绑定，根据实际对象类型决定方法。

class Shape {
    double area() { return 0; }
}
class Circle extends Shape {
    double r;
    Circle(double r) { this.r = r; }
    @Override
    double area() { return Math.PI * r * r; }
}
class Square extends Shape {
    double a;
    Square(double a) { this.a = a; }
    @Override
    double area() { return a * a; }
}

26. 抽象类

无法实例化，用于定义通用模板。

abstract class Transport {
    abstract void move();
}
class Car extends Transport {
    void move() { System.out.println("Car go"); }
}

27. 接口（default/static）

Java 8+ 支持默认方法和静态方法。

interface Logger {
    void info(String msg);
    default void warn(String msg) { System.out.println("WARN " + msg); }
    static Logger nop() { return m -> {}; }
}

28. 内部类与匿名类

外部类的私有成员可在内部类中访问。

class Outer {
    private int v = 42;
    class Inner {
        int get() { return v; }
    }
}
class UseAnon {
    static Runnable r = new Runnable() {
        public void run() { System.out.println("anon run"); }
    };
}

29. 泛型类

类型安全，避免强制转换。

class Box<T> {
    private T v;
    public void set(T v) { this.v = v; }
    public T get() { return v; }
}

30. 泛型方法与通配符（PECS）

Producer Extends, Consumer Super。

import java.util.*;
class G {
    static <T> void copy(List<? super T> dst, List<? extends T> src) {
        dst.addAll(src);
    }
}

31. 枚举

替代魔法字符串的最佳实践。

enum Role { ADMIN, USER, GUEST }

三、集合框架与 Stream API

32. ArrayList/LinkedList

ArrayList 随机访问快，LinkedList 插入删除快。

import java.util.*;
public class Demo32 {
    public static void main(String[] a) {
        List<Integer> arr = new ArrayList<>();
        arr.add(1);
        arr.add(2);
        Deque<Integer> link = new LinkedList<>();
        link.addFirst(3);
        link.addLast(4);
        System.out.println(arr + " | " + link);
    }
}

33. HashMap/LinkedHashMap/TreeMap

哈希表、链表顺序、红黑树排序。

import java.util.*;
public class Demo33 {
    public static void main(String[] a) {
        Map<String, Integer> m1 = new HashMap<>();
        m1.put("b", 2);
        m1.put("a", 1);
        Map<String, Integer> m2 = new LinkedHashMap<>();
        m2.put("b", 2);
        m2.put("a", 1);
        Map<String, Integer> m3 = new TreeMap<>();
        m3.put("b", 2);
        m3.put("a", 1);
        System.out.println(m1.keySet());
        System.out.println(m2.keySet());
        System.out.println(m3.keySet());
    }
}

34. HashSet/LinkedHashSet/TreeSet

去重集合。

import java.util.*;
public class Demo34 {
    public static void main(String[] a) {
        System.out.println(new HashSet<>(List.of(3, 1, 2))); // 无序
        System.out.println(new LinkedHashSet<>(List.of(3, 1, 2))); // 插入序
        System.out.println(new TreeSet<>(List.of(3, 1, 2))); // 自然序
    }
}

35. Queue/Deque

队列与双端队列。

import java.util.*;
public class Demo35 {
    public static void main(String[] a) {
        Queue<Integer> q = new ArrayDeque<>();
        q.offer(1);
        q.offer(2);
        System.out.println(q.poll());
        Deque<Integer> d = new ArrayDeque<>();
        d.addFirst(1);
        d.addLast(2);
        System.out.println(d.removeLast());
    }
}

36. Comparable/Comparator

自定义排序规则。

import java.util.*;
class Person implements Comparable<Person> {
    String n;
    int a;
    Person(String n, int a) { this.n = n; this.a = a; }
    public int compareTo(Person o) {
        return Integer.compare(a, o.a);
    }
    public String toString() { return n + ":" + a; }
}
public class Demo36 {
    public static void main(String[] a) {
        List<Person> list = new ArrayList<>(List.of(new Person("A", 30), new Person("B", 20)));
        list.sort(Comparator.comparing(p -> p.n)); // 使用 Comparator
        System.out.println(list);
    }
}

37. Stream 基本操作

函数式编程风格处理集合。

import java.util.*;
import java.util.stream.*;
public class Demo37 {
    public static void main(String[] a) {
        var r = IntStream.rangeClosed(1, 10).filter(x -> x % 2 == 0).map(x -> x * x).boxed().toList();
        System.out.println(r);
    }
}

38. Optional

避免空指针异常的容器。

import java.util.*;
public class Demo38 {
    static Optional<String> find(boolean ok) {
        return ok ? Optional.of("ok") : Optional.empty();
    }
    public static void main(String[] a) {
        System.out.println(find(true).orElse("N/A"));
    }
}

39. Collectors 分组/分区

Stream 聚合操作。

import java.util.*;
import java.util.stream.*;
public class Demo39 {
    public static void main(String[] a) {
        record P(String n, int a) {}
        var ps = List.of(new P("A", 18), new P("B", 20), new P("C", 20));
        var byAge = ps.stream().collect(Collectors.groupingBy(P::a));
        var part = ps.stream().collect(Collectors.partitioningBy(p -> p.a >= 20));
        System.out.println(byAge);
        System.out.println(part);
    }
}

四、异常处理与文件 I/O

40. try-catch-finally & 多重捕获

JDK 7+ 支持多重捕获。

public class Demo40 {
    public static void main(String[] args) {
        try {
            Integer.parseInt("x");
        } catch (NumberFormatException | NullPointerException e) {
            System.out.println("bad number");
        } finally {
            System.out.println("done");
        }
    }
}

41. 自定义异常

业务逻辑错误应抛出特定异常。

class BizException extends RuntimeException {
    BizException(String m) { super(m); }
}

42. try-with-resources

自动关闭资源，推荐用于 IO 操作。

import java.io.*;
public class Demo42 {
    public static void main(String[] args) throws Exception {
        try (var in = new ByteArrayInputStream("hi".getBytes());
             var out = new ByteArrayOutputStream()) {
            out.write(in.readAllBytes());
            System.out.println(out);
        }
    }
}

43. NIO.2 文件读写

Files 工具类简化路径操作。

import java.nio.file.*;
import java.nio.charset.StandardCharsets;
import java.io.IOException;
public class Demo43 {
    public static void main(String[] args) throws IOException {
        Path p = Path.of("/tmp/demo.txt");
        Files.writeString(p, "hello", StandardCharsets.UTF_8);
        System.out.println(Files.readString(p));
    }
}

44. 对象序列化

注意 Serializable 接口的安全性。

import java.io.*;
class Book implements Serializable {
    String name;
    Book(String n) { name = n; }
}
public class Demo44 {
    public static void main(String[] args) throws Exception {
        var f = new File("/tmp/book.bin");
        try (var o = new ObjectOutputStream(new FileOutputStream(f))) {
            o.writeObject(new Book("Java"));
        }
        try (var i = new ObjectInputStream(new FileInputStream(f))) {
            System.out.println(((Book) i.readObject()).name);
        }
    }
}

45. 缓冲流

提高 IO 性能。

import java.io.*;
public class Demo45 {
    public static void main(String[] args) throws Exception {
        try (var in = new BufferedInputStream(new FileInputStream("/etc/hosts"))) {
            byte[] buf = in.readAllBytes();
            System.out.println(buf.length);
        }
    }
}

46. 目录遍历 Files.walk

递归遍历文件系统。

import java.nio.file.*;
import java.io.IOException;
public class Demo46 {
    public static void main(String[] a) throws IOException {
        try (var s = Files.walk(Path.of("."), 1)) {
            s.forEach(System.out::println);
        }
    }
}

47. 正则表达式

文本匹配与提取。

import java.util.regex.*;
public class Demo47 {
    public static void main(String[] a) {
        var m = Pattern.compile("(\\w+)@(\\w+\\.\\w+)").matcher("hi [email protected]");
        if (m.find()) System.out.println(m.group(1) + "@" + m.group(2));
    }
}

48. 命令行参数

程序启动时的输入。

public class Demo48 {
    public static void main(String[] args) {
        for (String s : args) System.out.println(s);
    }
}

五、并发编程进阶

49. 创建线程：Thread/Runnable

Lambda 表达式简化线程创建。

public class Demo49 {
    public static void main(String[] a) {
        new Thread(() -> System.out.println("hi from " + Thread.currentThread().getName())).start();
    }
}

50. sleep/yield/join

线程生命周期控制。

public class Demo50 {
    public static void main(String[] a) throws InterruptedException {
        Thread t = new Thread(() -> {
            try { Thread.sleep(100); } catch (InterruptedException ignored) {}
        });
        t.start();
        t.join();
        System.out.println("joined");
    }
}

51. synchronized 同步

内置锁机制。

class Counter {
    private int c;
    public synchronized void inc() { c++; }
    public synchronized int get() { return c; }
}

52. volatile 可见性演示

保证多线程下的变量可见性。

public class Demo52 {
    static volatile boolean running = true;
    public static void main(String[] a) throws Exception {
        var t = new Thread(() -> {
            while (running) {}
        });
        t.start();
        Thread.sleep(10);
        running = false;
        t.join();
        System.out.println("stop");
    }
}

53. 原子类 AtomicInteger

无锁并发更新。

import java.util.concurrent.atomic.*;
class Cnt {
    AtomicInteger n = new AtomicInteger();
    void inc() { n.incrementAndGet(); }
}

54. ReentrantLock

显式锁，支持公平性与中断等待。

import java.util.concurrent.locks.*;
class SafeBox {
    private int v;
    private final Lock lock = new ReentrantLock();
    void set(int x) {
        lock.lock();
        try { v = x; }
        finally { lock.unlock(); }
    }
    int get() {
        lock.lock();
        try { return v; }
        finally { lock.unlock(); }
    }
}

55. ReadWriteLock

读多写少场景优化。

import java.util.concurrent.locks.*;
class CacheRW {
    private int v;
    private final ReadWriteLock rw = new ReentrantReadWriteLock();
    int get() {
        rw.readLock().lock();
        try { return v; }
        finally { rw.readLock().unlock(); }
    }
    void set(int x) {
        rw.writeLock().lock();
        try { v = x; }
        finally { rw.writeLock().unlock(); }
    }
}

56. Condition await/signal

细粒度线程通信。

import java.util.concurrent.locks.*;
class Waiter {
    final Lock lock = new ReentrantLock();
    final Condition ready = lock.newCondition();
    boolean ok = false;
    void waitIt() throws InterruptedException {
        lock.lock();
        try { while (!ok) ready.await(); }
        finally { lock.unlock(); }
    }
    void fire() {
        lock.lock();
        try { ok = true; ready.signalAll(); }
        finally { lock.unlock(); }
    }
}

57. ThreadLocal

线程隔离变量。

public class Demo57 {
    static ThreadLocal<String> ctx = ThreadLocal.withInitial(() -> "guest");
}

58. BlockingQueue 生产者 - 消费者

阻塞队列协调生产消费。

import java.util.concurrent.*;
public class Demo58 {
    public static void main(String[] a) throws Exception {
        BlockingQueue<Integer> q = new LinkedBlockingQueue<>(2);
        new Thread(() -> {
            try {
                for (int i = 1; i <= 3; i++) { q.put(i); }
                q.put(-1);
            } catch (InterruptedException ignored) {}
        }).start();
        new Thread(() -> {
            try {
                for (;;) {
                    int x = q.take();
                    if (x == -1) break;
                    System.out.println("consume " + x);
                }
            } catch (InterruptedException ignored) {}
        }).start();
    }
}

59. CountDownLatch

等待一组线程完成。

import java.util.concurrent.*;
public class Demo59 {
    public static void main(String[] a) throws Exception {
        var latch = new CountDownLatch(3);
        for (int i = 0; i < 3; i++) new Thread(() -> { latch.countDown(); }).start();
        latch.await();
        System.out.println("all done");
    }
}

60. CyclicBarrier

多次重复的屏障。

import java.util.concurrent.*;
public class Demo60 {
    public static void main(String[] a) {
        var barrier = new CyclicBarrier(3, () -> System.out.println("go!"));
        for (int i = 0; i < 3; i++) new Thread(() -> {
            try { barrier.await(); }
            catch (Exception ignored) {}
        }).start();
    }
}

61. Semaphore

信号量控制并发数量。

import java.util.concurrent.*;
public class Demo61 {
    public static void main(String[] a) {
        var sem = new Semaphore(2);
        for (int i = 0; i < 5; i++) new Thread(() -> {
            try {
                sem.acquire();
                System.out.println("in");
                Thread.sleep(50);
            } catch (Exception ignored) {}
            finally { sem.release(); }
        }).start();
    }
}

62. Phaser

灵活的阶段同步器。

import java.util.concurrent.*;
public class Demo62 {
    public static void main(String[] a) {
        Phaser p = new Phaser(3);
        for (int i = 0; i < 3; i++) new Thread(() -> {
            p.arriveAndAwaitAdvance();
            System.out.println("phase1");
            p.arriveAndDeregister();
        }).start();
    }
}

63. ExecutorService 线程池

复用线程资源。

import java.util.concurrent.*;
public class Demo63 {
    public static void main(String[] a) throws Exception {
        ExecutorService pool = Executors.newFixedThreadPool(4);
        Future<Integer> f = pool.submit(() -> 42);
        System.out.println(f.get());
        pool.shutdown();
    }
}

64. ScheduledExecutorService 定时任务

调度延迟或周期性任务。

import java.util.concurrent.*;
public class Demo64 {
    public static void main(String[] a) {
        var sch = Executors.newScheduledThreadPool(1);
        sch.scheduleAtFixedRate(() -> System.out.println("tick"), 0, 1, TimeUnit.SECONDS);
    }
}

*注：示例 64 会持续打印，演示时请手动停止进程或添加退出条件。

65. CompletableFuture

异步编排与组合。

import java.util.concurrent.*;
public class Demo65 {
    public static void main(String[] a) throws Exception {
        var f = CompletableFuture.supplyAsync(() -> 21).thenApply(x -> x * 2);
        System.out.println(f.get());
    }
}

66. ForkJoinPool

分治算法并行计算。

import java.util.concurrent.*;
import java.util.*;
public class Demo66 {
    static class Sum extends RecursiveTask<Long> {
        final int[] arr;
        final int lo, hi;
        static final int TH = 1_000;
        Sum(int[] arr, int lo, int hi) {
            this.arr = arr;
            this.lo = lo;
            this.hi = hi;
        }
        protected Long compute() {
            if (hi - lo <= TH) {
                long s = 0;
                for (int i = lo; i < hi; i++) s += arr[i];
                return s;
            }
            int mid = (lo + hi) / 2;
            var left = new Sum(arr, lo, mid);
            var right = new Sum(arr, mid, hi);
            left.fork();
            long r = right.compute();
            return left.join() + r;
        }
    }
    public static void main(String[] a) {
        int[] data = new Random().ints(1_000_000, 1, 10).toArray();
        long s = ForkJoinPool.commonPool().invoke(new Sum(data, 0, data.length));
        System.out.println(s);
    }
}

进一步学习与架构思维

掌握这些代码片段只是起点。从'写得通'到'写得稳'，你需要关注单元测试、异常边界处理以及不可变对象的设计（如 record 或 Collections.unmodifiable*）。在系统层面，理解并发原语如何演变为线程池隔离，进而支撑服务化的超时、重试、熔断与限流策略。同时，结合 HTTP 客户端、JSON 编解码及向量数据库等现代组件，利用 CompletableFuture 进行异步编排，才能真正落地分布式系统与 AI 数据接口。最后，别忘了 JFR、JIT/GC 基础以及指标日志链路对性能与可观测性的价值。

技术学习是一场马拉松，希望这份清单能成为你构建坚实地基的参考。继续深入微服务架构、高可用设计及性能优化，你的全栈之路将越走越宽。