Java 核心语法与并发编程实战示例

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

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);
        System.out.println(a / (double) b);
        System.out.println(a++);
        System.out.println(++a);
        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);
    }
}

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

进一步学习与架构思维

• 从'写得通'到'写得稳'：关注单元测试、异常边界、不可变对象（record / Collections.unmodifiable*）。
• 从单体到分布式：理解并发原语到线程池隔离，进而到服务化（超时、重试、熔断、限流）的设计理念。
• 数据与 AI 接口：HTTP 客户端（Java 11+ HttpClient）、JSON 编解码（Jackson/Gson）、向量数据库/消息队列客户端的异步调用，落地到 CompletableFuture 组合编排。
• 性能与可观测：JFR（Java Flight Recorder）、JIT/GC 基础、指标与日志链路。

基础语法、面向对象编程、集合与流、文件 I/O、并发与线程、现代并发与编排、Web/AI/数据组件、全栈/架构、Java 基本数据类型、控制结构、类与对象、继承与多态、抽象类与接口、集合框架、Stream API、文件读取与写入、路径与文件操作、线程基础、同步与锁、线程池、异步编程、Web 开发基础、AI 与机器学习、数据分析与处理。