Java系统教程-JVM/Spring/并发/集合-mrgr.cn编程知识平台

Java 是一门静态强类型、面向对象、跨平台（Write Once, Run Anywhere）的语言，长期占据企业级后端开发的主导地位。本教程按"语法 → 面向对象 → 集合 → JVM → 并发 → IO → Spring"的顺序系统展开。

一、环境与基础语法

JDK（Java Development Kit）包含编译器 javac 与运行时 java。Java 是强类型语言，8 种基本类型为 byte/short/int/long/float/double/char/boolean，其余为引用类型。

第一个程序

public class Hello {
    public static void main(String[] args) {
        String name = "mrgr.cn";
        System.out.println("hello " + name);
    }
}

Java 严格区分大小写，源文件名必须与 public class 名一致。每个语句以分号结尾，代码块用大括号包裹。

提示：Java 14+ 支持 record、switch 表达式、文本块 """ 等现代语法，Java 21 引入虚拟线程（Virtual Thread），让高并发更轻量。

二、面向对象与接口

Java 是纯粹的面向对象语言（基本类型除外）。类与对象是核心：类是模板，对象是实例。

类的定义

public class Animal {
    private String name;          // 封装：私有字段

    public Animal(String name) {  // 构造方法
        this.name = name;
    }

    public String speak() {       // 方法
        return name + " 发出声音";
    }
}

Animal dog = new Animal("Dog");
System.out.println(dog.speak());

继承与接口

Java 单继承，用 extends 继承类，用 implements 实现接口（可多实现）。接口定义行为契约，抽象类用于代码复用。

interface Speakable {
    String speak();
}

class Cat extends Animal implements Speakable {
    public Cat(String name) { super(name); }

    @Override
    public String speak() {       // 重写
        return super.getName() + " 喵喵叫";
    }
}

封装：用 private 保护字段，提供 getter/setter。
继承：子类获得父类的非私有成员，可重写方法。
多态：父类引用指向子类对象，运行时调用子类实现。

三、集合框架深入

Java 集合框架（Collection Framework）是日常开发最高频的工具，主要分两大体系：Collection（单列）与 Map（双列）。

核心实现

ArrayList：基于数组，随机访问快，增删慢（需移动元素）。
LinkedList：基于链表，增删快，随机访问慢。
HashMap：基于哈希表，O(1) 查找，无序。
TreeMap：基于红黑树，按 key 排序。
HashSet：底层是 HashMap 的 key。

Map<String, Integer> map = new HashMap<>();
map.put("mrgr", 5);
map.put("java", 28);
map.forEach((k, v) -> System.out.println(k + "=" + v));

// Java 8 Stream 处理集合
List<Integer> nums = List.of(1, 2, 3, 4, 5);
int sum = nums.stream().filter(n -> n % 2 == 0).mapToInt(Integer::intValue).sum();
System.out.println(sum); // 6

四、JVM 内存与垃圾回收

JVM 内存模型是理解 Java 性能与排障的基础。运行时数据区包括堆、方法区（元空间）、虚拟机栈、本地方法栈、程序计数器。

内存区域

堆（Heap）：存放对象实例，GC 主战场，分新生代（Eden + S0 + S1）与老年代。
方法区 / 元空间：存放类元信息、常量池、静态变量。
虚拟机栈：每个方法调用创建栈帧，存放局部变量与操作数栈。

垃圾回收

JVM 通过可达性分析判断对象是否存活（GC Roots 出发不可达即回收）。常见收集器：Parallel（吞吐量优先）、CMS / G1（低延迟）、ZGC / Shenandoah（亚毫秒停顿）。

要点：String s = "a" + "b" 在编译期会被优化为常量 "ab"；循环里拼接字符串请用 StringBuilder，避免产生大量临时对象。

五、并发编程 JUC

Java 的 java.util.concurrent（JUC）包提供了丰富的并发工具，是高并发后端开发的核心。

线程与线程池

ExecutorService pool = Executors.newFixedThreadPool(4);
List<Future<String>> futures = new ArrayList<>();
for (int i = 0; i < 10; i++) {
    final int n = i;
    futures.add(pool.submit(() -> "task-" + n + " done"));
}
for (Future<String> f : futures) {
    System.out.println(f.get());  // 阻塞获取结果
}
pool.shutdown();

锁与并发工具

synchronized：JVM 内置锁，可修饰方法或代码块。
ReentrantLock：更灵活的显式锁，支持公平锁、可中断。
ConcurrentHashMap：线程安全的 HashMap，分段锁 / CAS 实现。
CountDownLatch / Semaphore：协调多线程协作。
CompletableFuture：编排异步任务，支持链式组合。

Java 21 的虚拟线程让"一请求一线程"模型几乎无成本，适合 IO 密集的并发场景。

六、IO 与网络编程

Java IO 体系分字节流（InputStream/OutputStream）与字符流（Reader/Writer），NIO 引入 Channel + Buffer + Selector 支持非阻塞 IO。

// 用 NIO 读取文件
Path path = Path.of("data.txt");
List<String> lines = Files.readAllLines(path, StandardCharsets.UTF_8);
lines.forEach(System.out::println);

网络编程

基于 ServerSocket 的 BIO 模型每连接一线程，适合连接数少的场景；高并发服务端多用 NIO / Netty 框架，基于事件驱动与多路复用。

七、Spring 框架与生态

Spring 是 Java 后端的事实标准，核心是 IoC（控制反转）与 AOP（面向切面）。Spring Boot 通过自动配置大幅简化了搭建流程。

REST 接口示例

@RestController
@RequestMapping("/api")
public class UserController {

    @Autowired
    private UserService userService;

    @GetMapping("/users/{id}")
    public User getUser(@PathVariable Long id) {
        return userService.findById(id);
    }
}

Spring 生态还包含 Spring Security（安全）、Spring Data（数据访问）、Spring Cloud（微服务）等。配合 MyBatis / JPA 做持久层，是当下企业后端的主流组合。

本教程到此结束。建议结合实战项目把 Java 用到一个真实接口服务里，遇到问题可到后端问答提问。

Java 系统教程