Java 核心语法与并发编程实战指南

4. 常量 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. 字符串操作

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. 控制台输入

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. 格式化输出

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 表达式

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

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

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. 一维数组

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. 类与对象

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. 封装

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）

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）

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 }

集合框架与流

32. 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));
        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 分组/分区

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 & 多重捕获

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

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 文件读写

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. 对象序列化

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. 缓冲流

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

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);
    }
}

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);
    }
}

进一步学习与架构思维

从'写得通'到'写得稳'，建议关注单元测试、异常边界及不可变对象设计。在分布式场景下，理解并发原语到线程池隔离，再到服务化（超时、重试、熔断）的设计理念。数据与 AI 接口方面，可结合 HTTP 客户端、JSON 编解码及向量数据库异步调用，利用 CompletableFuture 组合编排。性能与可观测性则需掌握 JFR、JIT/GC 基础及指标日志链路。

技术学习是持续的过程。通过实际代码示例和常见模式的掌握，你将能够应对复杂项目和架构设计。希望这些内容能成为你的实用参考，助你逐步提升技术能力。