Java 基础篇完整学习攻略

Java基础篇

• 模块化系统（Java 9+）
  • 模块声明：Java 9引入的模块系统（JPMS）允许将代码组织为独立的模块单元，通过module-info.java文件声明模块及其依赖。
  • 优势：增强封装性，明确模块间依赖关系，减少类路径问题。
  • 实操示例：创建一个简单的模块化项目，包含两个模块com.example.hello和com.example.util。

// module-info.java (com.example.hello)
module com.example.hello {
   
    requires com.example.util;
    exports com.example.hello;
}

// module-info.java (com.example.util)
module com.example.util {
   
    exports com.example.util;
}

• Stream API（Java 8+）
  • 功能：提供高效的集合数据处理能力，支持过滤、映射、聚合等操作。
  • 优势：代码更简洁，支持并行处理提升性能。
  • 实操示例：统计列表中偶数的平方和。

import java.util.Arrays;
import java.util.List;

public class StreamExample {
   
    public static void main(String[] args) {
   
        List<Integer> numbers = Arrays.asList(1, 2, 3, 4, 5, 6);
        int sum = numbers.stream()
                .filter(n -> n % 2 == 0)
                .map(n -> n * n)
                .reduce(0, Integer::sum);
        System.out.println("偶数的平方和：" + sum);
    }
}

Java多线程篇

• CompletableFuture（Java 8+）
  • 功能：实现异步编程，支持链式调用和组合多个异步任务。
  • 优势：替代传统回调方式，代码更易读和维护。
  • 实操示例：模拟两个异步任务串行执行。

import java.util.concurrent.CompletableFuture;
import java.util.concurrent.ExecutionException;

public class CompletableFutureExample {
   
    public static void main(String[] args) throws ExecutionException, InterruptedException {
   
        CompletableFuture<String> future = CompletableFuture.supplyAsync(() -> {
   
            try {
   
                Thread.sleep(1000);
            } catch (InterruptedException e) {
   
                e.printStackTrace();
            }
            return "结果1";
        }).thenApply(result -> {
   
            return result + " -> 结果2";
        });

        System.out.println(future.get());
    }
}

• ReentrantLock（Java 5+）
  • 功能：比synchronized更灵活的锁实现，支持可重入、公平锁和条件变量。
  • 实操示例：使用ReentrantLock实现生产者 - 消费者模型。

import java.util.concurrent.locks.Condition;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;

public class ProducerConsumer {
   
    private final Lock lock = new ReentrantLock();
    private final Condition notFull = lock.newCondition();
    private final Condition notEmpty = lock.newCondition();
    private final int[] buffer = new int[10];
    private int count = 0;

    public void produce(int value) throws InterruptedException {
   
        lock.lock();
        try {
   
            while (count == buffer.length) {
   
                notFull.await();
            }
            buffer[count++] = value;
            notEmpty.signal();
        } finally {
   
            lock.unlock();
        }
    }

    public int consume() throws InterruptedException {
   
        lock.lock();
        try {
   
            while (count == 0) {
   
                notEmpty.await();
            }
            return buffer[--count];
        } finally {
   
            lock.unlock();
        }
    }
}

JVM篇

• G1垃圾回收器（Java 9+默认）
  • 特点：面向大内存应用，将堆划分为多个区域，并行回收，降低停顿时间。
  • 实操参数：启用G1并设置堆大小。

java -XX:+UseG1GC -Xms2g -Xmx2g YourMainClass

• JFR（Java Flight Recorder）
  • 功能：收集JVM运行时数据，用于性能分析和问题诊断。
  • 实操示例：启动JFR记录并生成报告。

java -XX:StartFlightRecording=duration=60s,filename=recording.jfr YourMainClass
jfr print --summary recording.jfr

集合框架篇

• ConcurrentHashMap（Java 8+改进）
  • 改进：采用CAS + synchronized替代分段锁，提升并发性能。
  • 实操示例：多线程环境下安全地更新Map。

import java.util.concurrent.ConcurrentHashMap;

public class ConcurrentHashMapExample {
   
    private static final ConcurrentHashMap<String, Integer> map = new ConcurrentHashMap<>();

    public static void main(String[] args) throws InterruptedException {
   
        Thread t1 = new Thread(() -> {
   
            for (int i = 0; i < 1000; i++) {
   
                map.put("key", map.getOrDefault("key", 0) + 1);
            }
        });

        Thread t2 = new Thread(() -> {
   
            for (int i = 0; i < 1000; i++) {
   
                map.put("key", map.getOrDefault("key", 0) + 1);
            }
        });

        t1.start();
        t2.start();
        t1.join();
        t2.join();

        System.out.println("最终结果：" + map.get("key"));
    }
}

• Stream并行处理
  • 功能：利用多核CPU并行处理集合数据。
  • 注意事项：避免在IO密集型任务中使用，可能导致性能下降。
  • 实操示例：并行计算1到100的和。

import java.util.stream.IntStream;

public class ParallelStreamExample {
   
    public static void main(String[] args) {
   
        long sum = IntStream.rangeClosed(1, 100)
                .parallel()
                .sum();
        System.out.println("并行计算结果：" + sum);
    }
}

新特性篇

• Records（Java 14+）
  • 功能：简化不可变数据类的定义，自动生成构造器、getter等。
  • 实操示例：定义一个简单的Record类。

public record Person(String name, int age) {
   
    // 可以添加自定义方法
    public boolean isAdult() {
   
        return age >= 18;
    }
}

• Pattern Matching for instanceof（Java 16+）
  • 功能：简化类型转换代码。
  • 旧写法：

if (obj instanceof String) {
   
    String s = (String) obj;
    // 使用s
}

- **新写法**：

if (obj instanceof String s) {
   
    // 直接使用s
}

Java 基础篇，零基础学 Java,Java 零基础入门，Java 基础学习攻略，小白学 Java,Java 基础教程，Java 入门教程，Java 基础学习，Java 自学攻略，零基础 Java 教程，Java 基础知识点，Java 编程基础，Java 基础入门攻略，小白 Java 入门，Java 基础学习教程

代码获取方式
https://pan.quark.cn/s/14fcf913bae6