一、设计模式高级应用
1.枚举单例模式（线程安全+反序列化安全）：
/**
* 枚举单例：JVM保证唯一实例，避免反射与序列化破坏单例
* 适用场景：全局状态管理（如配置中心、日志工厂）
*/
public enum SingletonEnum {
INSTANCE;
private final DataManager dataManager;
// 私有构造函数
SingletonEnum() {
dataManager = new DataManager();
}
public DataManager getDataManager() {
return dataManager;
}
// 扩展方法：支持动态初始化
public void init(String configPath) {
dataManager.loadConfig(configPath);
}
}
// 测试反序列化安全性
public class SingletonTest {
public static void main(String[] args) throws Exception {
SingletonEnum instance1 = SingletonEnum.INSTANCE;
ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream("singleton.obj"));
oos.writeObject(instance1);
oos.close();
ObjectInputStream ois = new ObjectInputStream(new FileInputStream("singleton.obj"));
SingletonEnum instance2 = (SingletonEnum) ois.readObject();
ois.close();
System.out.println(instance1 == instance2); // 输出true，枚举单例反序列化后仍为同一实例
}
}
2.策略模式+工厂模式组合（消除if-else地狱）：
/**
* 支付策略接口
*/
public interface PaymentStrategy {
boolean pay(String orderId, BigDecimal amount);
String getStrategyName();
}
/**
* 支付宝支付策略
*/
public class AlipayStrategy implements PaymentStrategy {
@Override
public boolean pay(String orderId, BigDecimal amount) {
// 支付宝支付逻辑
System.out.println("支付宝支付订单：" + orderId + "，金额：" + amount);
return true;
}
@Override
public String getStrategyName() {
return "ALIPAY";
}
}
/**
* 支付策略工厂（使用Map实现策略注册）
*/
public class PaymentStrategyFactory {
private static final Map<String, PaymentStrategy> STRATEGY_MAP = new ConcurrentHashMap<>();
// 静态代码块注册策略
static {
STRATEGY_MAP.put("ALIPAY", new AlipayStrategy());
// 可扩展其他策略...
}
// 获取策略方法（支持Lambda动态注册）
public static PaymentStrategy getStrategy(String strategyName) {
return STRATEGY_MAP.getOrDefault(strategyName,
() -> { throw new IllegalArgumentException("不支持的支付策略：" + strategyName); });
}
// 动态注册策略（适用于插件化场景）
public static void registerStrategy(String name, PaymentStrategy strategy) {
STRATEGY_MAP.put(name, strategy);
}
}
// 使用示例
public class PaymentService {
public boolean processPayment(String orderId, BigDecimal amount, String paymentType) {
PaymentStrategy strategy = PaymentStrategyFactory.getStrategy(paymentType);
return strategy.pay(orderId, amount);
}
}
二、并发编程高级技术
3.自定义线程池（带任务优先级与监控）：
/**
* 优先级任务线程池：支持FIFO/LIFO/优先级调度
* 监控指标：任务提交数、成功数、失败数、平均执行时间
*/
public class PriorityThreadPool extends ThreadPoolExecutor {
// 监控统计
private final AtomicLong taskSubmitted = new AtomicLong(0);
private final AtomicLong taskCompleted = new AtomicLong(0);
private final AtomicLong taskFailed = new AtomicLong(0);
private final LongAdder totalExecutionTime = new LongAdder();
public PriorityThreadPool(int corePoolSize, int maximumPoolSize,
long keepAliveTime, TimeUnit unit,
BlockingQueue<Runnable> workQueue) {
super(corePoolSize, maximumPoolSize, keepAliveTime, unit, workQueue);
}
// 重写任务提交方法，记录监控数据
@Override
public Future<?> submit(Runnable task) {
taskSubmitted.incrementAndGet();
return super.submit(() -> {
long start = System.nanoTime();
try {
task.run();
taskCompleted.incrementAndGet();
} catch (Exception e) {
taskFailed.incrementAndGet();
throw e;
} finally {
long end = System.nanoTime();
totalExecutionTime.add(end - start);
}
});
}
// 获取监控指标
public long getTaskSubmitted() {
return taskSubmitted.get();
}
public double getAverageExecutionTime() {
long count = taskCompleted.get();
return count == 0 ? 0 : totalExecutionTime.sum() * 1.0 / count / 1_000_000; // 毫秒
}
// 自定义任务队列（支持优先级）
public static class PriorityBlockingQueue extends LinkedBlockingQueue<Runnable> {
@Override
public boolean offer(Runnable e) {
// 自定义任务排序逻辑（示例：根据任务优先级排序）
if (e instanceof PriorityTask) {
// 实际项目中可使用PriorityBlockingQueue实现优先级调度
}
return super.offer(e);
}
}
// 优先级任务接口
public interface PriorityTask extends Runnable {
int getPriority();
}
}
// 使用示例
public class TaskMonitorDemo {
public static void main(String[] args) throws InterruptedException {
PriorityThreadPool pool = new PriorityThreadPool(
5, 10, 60, TimeUnit.SECONDS,
new PriorityThreadPool.PriorityBlockingQueue()
);
// 提交任务
for (int i = 0; i < 10; i++) {
final int taskId = i;
pool.submit(() -> {
try {
Thread.sleep(100);
System.out.println("任务" + taskId + "完成");
} catch (InterruptedException e) {
Thread.currentThread().interrupt();
}
});
}
pool.shutdown();
pool.awaitTermination(1, TimeUnit.MINUTES);
// 打印监控数据
System.out.println("任务提交数：" + pool.getTaskSubmitted());
System.out.println("平均执行时间：" + pool.getAverageExecutionTime() + "ms");
}
}
4. CompletableFuture异步编排（复杂任务流水线）：
/**
* 订单处理异步流水线：展示CompletableFuture的组合式编程
* 场景：电商订单处理流程（下单→库存检查→支付→物流分配）
*/
public class OrderProcessingPipeline {
private final InventoryService inventoryService;
private final PaymentService paymentService;
private final LogisticsService logisticsService;
public OrderProcessingPipeline(InventoryService inventoryService,
PaymentService paymentService,
LogisticsService logisticsService) {
this.inventoryService = inventoryService;
this.paymentService = paymentService;
this.logisticsService = logisticsService;
}
// 主流程：异步编排多阶段任务
public CompletableFuture<Order> processOrder(OrderRequest request) {
// 1. 创建订单（主线程）
Order order = createOrder(request);
// 2. 异步检查库存
CompletableFuture<Boolean> inventoryCheck = CompletableFuture.supplyAsync(
() -> inventoryService.checkStock(request.getProducts()),
inventoryService.getExecutor()
);
// 3. 异步创建支付（依赖库存检查结果）
CompletableFuture<Payment> paymentFuture = inventoryCheck.thenCompose(hasStock -> {
if (!hasStock) {
throw new InventoryException("库存不足");
}
return CompletableFuture.supplyAsync(
() -> paymentService.createPayment(order),
paymentService.getExecutor()
);
});
// 4. 异步分配物流（依赖支付结果）
CompletableFuture<LogisticsInfo> logisticsFuture = paymentFuture.thenCompose(payment -> {
return CompletableFuture.supplyAsync(
() -> logisticsService.assignLogistics(order, payment),
logisticsService.getExecutor()
);
});
// 5. 合并结果，完成订单
return logisticsFuture.thenApply(logisticsInfo -> {
order.setPaymentStatus(PaymentStatus.PAID);
order.setLogisticsInfo(logisticsInfo);
return order;
}).exceptionally(ex -> {
// 异常处理：回滚库存、取消支付
handleException(order, ex);
return order;
});
}
private Order createOrder(OrderRequest request) {
// 创建订单逻辑
return new Order();
}
private void handleException(Order order, Throwable ex) {
// 异常处理逻辑
System.err.println("订单处理失败：" + ex.getMessage());
}
// 服务接口（示例）
interface InventoryService {
ExecutorService getExecutor();
boolean checkStock(List<Product> products);
}
interface PaymentService {
ExecutorService getExecutor();
Payment createPayment(Order order);
}
interface LogisticsService {
ExecutorService getExecutor();
LogisticsInfo assignLogistics(Order order, Payment payment);
}
// 数据模型
record OrderRequest(List<Product> products) {}
record Order() {}
record Product(String id, int quantity) {}
record Payment(String id) {}
record LogisticsInfo(String trackingNumber) {}
enum PaymentStatus { PAID, PENDING, FAILED }
class InventoryException extends Exception {
public InventoryException(String message) { super(message); }
}
}
// 使用示例
public class OrderProcessingDemo {
public static void main(String[] args) throws ExecutionException, InterruptedException {
OrderProcessingPipeline pipeline = new OrderProcessingPipeline(
inventoryService, paymentService, logisticsService
);
OrderRequest request = new OrderRequest(Arrays.asList(
new Product("P001", 2),
new Product("P002", 1)
));
CompletableFuture<Order> future = pipeline.processOrder(request);
// 同步获取结果（实际项目中建议使用异步回调）
Order order = future.get();
System.out.println("订单处理完成：" + order);
}
}
三、性能优化高级技巧
5. 对象池模式（减少GC压力）：
/**
* 高性能对象池：支持对象生命周期管理与自动回收
* 场景：频繁创建销毁的对象（如数据库连接、线程上下文）
*/
public class ObjectPool<T> {
private final int maxSize;
private final ConcurrentLinkedQueue<T> objectQueue;
private final Supplier<T> objectCreator;
private final Consumer<T> objectInitializer;
private final Consumer<T> objectDestroyer;
private final Predicate<T> objectValidator;
private final AtomicInteger activeObjects = new AtomicInteger(0);
private final AtomicLong createCount = new AtomicLong(0);
private final AtomicLong borrowCount = new AtomicLong(0);
private final AtomicLong returnCount = new AtomicLong(0);
public ObjectPool(int maxSize,
Supplier<T> objectCreator,
Consumer<T> objectInitializer,
Consumer<T> objectDestroyer,
Predicate<T> objectValidator) {
this.maxSize = maxSize;
this.objectQueue = new ConcurrentLinkedQueue<>();
this.objectCreator = objectCreator;
this.objectInitializer = objectInitializer;
this.objectDestroyer = objectDestroyer;
this.objectValidator = objectValidator;
// 预创建对象
for (int i = 0; i < maxSize / 2; i++) {
objectQueue.offer(createObject());
}
}
// 创建新对象
private T createObject() {
T object = objectCreator.get();
objectInitializer.accept(object);
createCount.incrementAndGet();
activeObjects.incrementAndGet();
return object;
}
// 借用对象（支持超时等待）
public T borrowObject(long timeout, TimeUnit unit) throws InterruptedException {
T object = objectQueue.poll();
// 验证对象有效性
if (object != null && !objectValidator.test(object)) {
destroyObject(object);
object = null;
}
// 若队列中无有效对象，则创建新对象
if (object == null) {
int currentActive = activeObjects.get();
if (currentActive < maxSize) {
object = createObject();
} else {
// 等待对象返回（使用BlockingQueue实现）
object = objectQueue.poll(timeout, unit);
if (object != null && !objectValidator.test(object)) {
destroyObject(object);
object = null;
}
if (object == null) {
throw new ObjectPoolException("获取对象超时");
}
}
}
borrowCount.incrementAndGet();
return object;
}
// 返回对象到池中
public void returnObject(T object) {
if (object == null) {
return;
}
// 检查对象是否可回收
if (objectValidator.test(object)) {
objectQueue.offer(object);
returnCount.incrementAndGet();
} else {
destroyObject(object);
}
}
// 销毁对象
private void destroyObject(T object) {
try {
objectDestroyer.accept(object);
} catch (Exception e) {
System.err.println("销毁对象失败：" + e.getMessage());
} finally {
activeObjects.decrementAndGet();
}
}
// 获取监控指标
public long getCreateCount() {
return createCount.get();
}
public long getBorrowCount() {
return borrowCount.get();
}
public long getReturnCount() {
return returnCount.get();
}
public int getActiveObjects() {
return activeObjects.get();
}
public int getPoolSize() {
return objectQueue.size();
}
// 自定义异常
class ObjectPoolException extends Exception {
public ObjectPoolException(String message) { super(message); }
}
// 示例：数据库连接池
public static void main(String[] args) throws Exception {
ObjectPool<Connection> connectionPool = new ObjectPool<>(
100,
() -> {
// 创建数据库连接
try {
return DriverManager.getConnection("jdbc:mysql://localhost:3306/test", "user", "password");
} catch (SQLException e) {
throw new RuntimeException(e);
}
},
conn -> {
// 初始化连接（如设置自动提交）
try {
conn.setAutoCommit(true);
} catch (SQLException e) {
throw new RuntimeException(e);
}
},
conn -> {
// 销毁连接
try {
if (!conn.isClosed()) {
conn.close();
}
} catch (SQLException e) {
throw new RuntimeException(e);
}
},
conn -> {
// 验证连接有效性
try {
return !conn.isClosed() && conn.isValid(5000);
} catch (SQLException e) {
return false;
}
}
);
// 使用连接
Connection conn = connectionPool.borrowObject(10, TimeUnit.SECONDS);
try {
// 执行SQL
Statement stmt = conn.createStatement();
ResultSet rs = stmt.executeQuery("SELECT 1");
while (rs.next()) {
System.out.println(rs.getInt(1));
}
rs.close();
stmt.close();
} finally {
// 归还连接
connectionPool.returnObject(conn);
}
// 打印池状态
System.out.println("连接池状态：活跃数=" + connectionPool.getActiveObjects() +
", 池中数=" + connectionPool.getPoolSize());
}
}
6. 高性能序列化（Protobuf替代Java序列化）：
/**
* Protobuf序列化：比Java原生序列化快3-5倍，体积小50%
* 场景：分布式系统RPC通信、日志存储
*/
// 生成的Protobuf类（通过protoc编译器生成）
public final class UserInfo {
// 字段定义
private final String name;
private final int age;
private final boolean isVip;
private final List<String> hobbies;
// 构造函数、getter等省略...
// 序列化方法
public byte[] toByteArray() {
// Protobuf序列化逻辑（实际由生成的代码实现）
return "序列化后的数据".getBytes();
}
// 反序列化方法
public static UserInfo parseFrom(byte[] data) {
// Protobuf反序列化逻辑
return new UserInfo("张三", 25, true, Arrays.asList("阅读", "编程"));
}
// 性能测试
public static void main(String[] args) {
// 创建测试对象
UserInfo user = new UserInfo("李四", 30, false, Arrays.asList("音乐", "运动", "旅行"));
// Protobuf序列化性能
long protobufStart = System.nanoTime();
byte[] protobufData = user.toByteArray();
long protobufEnd = System.nanoTime();
// Java原生序列化性能
long javaStart = System.nanoTime();
byte[] javaData = javaSerialize(user);
long javaEnd = System.nanoTime();
// 输出性能对比
System.out.println("Protobuf序列化耗时：" + (protobufEnd - protobufStart) / 1_000 + "μs");
System.out.println("Java序列化耗时：" + (javaEnd - javaStart) / 1_000 + "μs");
System.out.println("Protobuf体积：" + protobufData.length + "字节");
System.out.println("Java体积：" + javaData.length + "字节");
// 反序列化测试
UserInfo protobufUser = UserInfo.parseFrom(protobufData);
UserInfo javaUser = (UserInfo) javaDeserialize(javaData);
System.out.println("反序列化结果一致：" + protobufUser.equals(javaUser));
}
// Java原生序列化辅助方法
private static byte[] javaSerialize(Object obj) {
try (ByteArrayOutputStream baos = new ByteArrayOutputStream();
ObjectOutputStream oos = new ObjectOutputStream(baos)) {
oos.writeObject(obj);
return baos.toByteArray();
} catch (IOException e) {
throw new RuntimeException(e);
}
}
private static Object javaDeserialize(byte[] data) {
try (ByteArrayInputStream bais = new ByteArrayInputStream(data);
ObjectInputStream ois = new ObjectInputStream(bais)) {
return ois.readObject();
} catch (IOException | ClassNotFoundException e) {
throw new RuntimeException(e);
}
}
}
// Protobuf配置示例（pom.xml）
<!-- Maven依赖 -->
<dependency>
<groupId>com.google.protobuf</groupId>
<artifactId>protobuf-java</artifactId>
<version>3.21.12</version>
</dependency>
<dependency>
<groupId>com.google.protobuf</groupId>
<artifactId>protobuf-java-util</artifactId>
<version>3.21.12</version>
</dependency>
<!-- 插件配置 -->
<plugin>
<groupId>org.xolstice.maven.plugins</groupId>
<artifactId>protobuf-maven-plugin</artifactId>
<version>0.6.1</version>
<configuration>
<protocArtifact>com.google.protobuf:protoc:3.21.12:exe:${os.detected.classifier}</protocArtifact>
<pluginId>grpc-java</pluginId>
<pluginArtifact>io.grpc:protoc-gen-grpc-java:1.54.0:exe:${os.detected.classifier}</pluginArtifact>
</configuration>
<executions>
<execution>
<goals>
<goal>compile</goal>
<goal>compile-custom</goal>
</goals>
</execution>
</executions>
</plugin>
四、函数式编程与Stream高级操作
7. 高阶函数与Lambda组合（行为参数化）：
/**
* 高阶函数示例：支持行为参数化的集合处理
* 场景：数据过滤、转换、聚合的通用处理框架
*/
public class FunctionalProgramming {
// 1. 谓词接口：用于过滤
@FunctionalInterface
public interface Predicate<T> {
boolean test(T t);
}
// 2. 函数接口：用于转换
@FunctionalInterface
public interface Function<T, R> {
R apply(T t);
}
// 3. 消费者接口：用于处理结果
@FunctionalInterface
public interface Consumer<T> {
void accept(T t);
}
// 4. 高阶函数：通用过滤方法
public <T> List<T> filter(List<T> list, Predicate<T> predicate) {
List<T> result = new ArrayList<>();
for (T item : list) {
if (predicate.test(item)) {
result.add(item);
}
}
return result;
}
// 5. 高阶函数：通用映射方法
public <T, R> List<R> map(List<T> list, Function<T, R> function) {
List<R> result = new ArrayList<>();
for (T item : list) {
result.add(function.apply(item));
}
return result;
}
// 6. 组合操作：过滤+映射+消费
public <T, R> void process(List<T> list,
Predicate<T> filterPredicate,
Function<T, R> mapFunction,
Consumer<R> consumer) {
filter(list, filterPredicate)
.stream()
.map(mapFunction)
.forEach(consumer);
}
// 使用示例
public static void main(String[] args) {
FunctionalProgramming fp = new FunctionalProgramming();
List<Integer> numbers = Arrays.asList(1, 2, 3, 4, 5, 6, 7, 8, 9, 10);
// 示例1：过滤偶数并加倍
List<Integer> evenDoubled = fp.map(
fp.filter(numbers, n -> n % 2 == 0),
n -> n * 2
);
System.out.println("偶数加倍：" + evenDoubled);
// 示例2：组合操作（打印大于5的数的平方）
fp.process(numbers,
n -> n > 5,
n -> n * n,
System.out::println
);
// 示例3：使用Lambda实现复杂逻辑
List<String> names = Arrays.asList("Alice", "Bob", "Charlie", "David", "Eve");
List<String> filteredNames = fp.filter(names, name -> name.length() > 3 && name.startsWith("C"));
System.out.println("过滤后的名字：" + filteredNames);
}
}
8. Stream高级操作（并行流+自定义Collector）：
/**
* Stream高级应用：并行处理与自定义Collector
* 场景：大数据集处理、复杂聚合操作
*/
public class StreamAdvanced {
// 数据模型
record Person(String name, int age, double salary, String department) {}
// 自定义Collector：分组并计算薪资统计
public static <T> Collector<T, ?, Map<String, SalaryStats>> groupByDepartmentAndStats() {
return Collector.of(
() -> new HashMap<String, SalaryStats>(),
(map, person) -> {
String dept = person.department();
map.computeIfAbsent(dept, k -> new SalaryStats())
.accumulate(person.salary());
},
(map1, map2) -> {
map2.forEach((dept, stats) -> {
map1.computeIfAbsent(dept, k -> new SalaryStats())
.merge(stats);
});
return map1;
},
LinkedHashMap::new // 保持插入顺序
);
}
// 薪资统计类
static class SalaryStats {
private long count = 0;
private double sum = 0;
private double max = Double.MIN_VALUE;
private double min = Double.MAX_VALUE;
void accumulate(double salary) {
count++;
sum += salary;
max = Math.max(max, salary);
min = Math.min(min, salary);
}
void merge(SalaryStats other) {
count += other.count;
sum += other.sum;
max = Math.max(max, other.max);
min = Math.min(min, other.min);
}
double getAverage() {
return count == 0 ? 0 : sum / count;
}
@Override
public String toString() {
return "平均薪资: " + getAverage() +
", 最高: " + max +
", 最低: " + min +
", 人数: " + count;
}
}
// 使用示例
public static void main(String[] args) {
// 生成测试数据
List<Person> people = generateTestData(100000);
// 1. 串行流处理
long serialStart = System.nanoTime();
Map<String, SalaryStats> serialResult = people.stream()
.collect(groupByDepartmentAndStats());
long serialEnd = System.nanoTime();
// 2. 并行流处理
long parallelStart = System.nanoTime();
Map<String, SalaryStats> parallelResult = people.parallelStream()
.collect(groupByDepartmentAndStats());
long parallelEnd = System.nanoTime();
// 输出结果
System.out.println("串行处理结果：");
serialResult.forEach((dept, stats) -> System.out.println(dept + ": " + stats));
System.out.println("串行耗时：" + (serialEnd - serialStart) / 1_000_000 + "ms");
System.out.println("\n并行处理结果：");
parallelResult.forEach((dept, stats) -> System.out.println(dept + ": " + stats));
System.out.println("并行耗时：" + (parallelEnd - parallelStart) / 1_000_000 + "ms");
// 3. 复杂Stream操作链示例
double averageAgeOfHighEarners = people.stream()
.filter(p -> p.salary() > 5000) // 过滤高薪人员
.mapToInt(Person::age) // 提取年龄
.average() // 计算平均年龄
.orElse(0);
System.out.println("\n高薪人员平均年龄：" + averageAgeOfHighEarners);
}
// 生成测试数据
private static List<Person> generateTestData(int count) {
List<Person> result = new ArrayList<>();
Random random = new Random(42);
String[] departments = {"研发", "产品", "设计", "测试", "运营"};
for (int i = 0; i < count; i++) {
String dept = departments[random.nextInt(departments.length)];
result.add(new Person(
"员工" + i,
22 + random.nextInt(20),
3000 + random.nextDouble() * 10000,
dept
));
}
return result;
}
}
五、JDK新特性高级应用
9. Records模式（不可变数据模型）：
/**
* Records高级应用：不可变数据模型与模式匹配
* 场景：领域模型、事件溯源、不可变数据传输
*/
// 基础Record类
public record User(String id, String name, int age, Role role) {}
// 枚举角色
enum Role {
ADMIN, MANAGER, DEVELOPER, USER
}
// 扩展Record（Java 16+）
public record PremiumUser(String id, String name, int age, Role role, List<String> permissions)
extends User(id, name, age, role) {}
// 模式匹配示例
public class RecordPatternMatching {
public static void main(String[] args) {
// 创建Record对象
User user = new User("U001", "张三", 28, Role.DEVELOPER);
PremiumUser premiumUser = new PremiumUser("U002", "李四", 35, Role.ADMIN,
Arrays.asList("READ", "WRITE", "DELETE"));
// 1. 类型模式匹配
String userInfo = user instanceof PremiumUser premium ?
"高级用户：" + premium.name() + ", 权限：" + premium.permissions() :
"普通用户：" + user.name() + ", 角色：" + user.role();
System.out.println(userInfo);
// 2. 解构模式匹配
if (user instanceof User { name: String n, age: int a } && a > 25) {
System.out.println("用户" + n + "年龄大于25岁");
}
// 3. 嵌套模式匹配
if (premiumUser instanceof PremiumUser {
role: Role.ADMIN,
permissions: List<String> perms when perms.contains("DELETE")
} adminUser) {
System.out.println("管理员" + adminUser.name() + "拥有删除权限");
}
// 4. Record数据转换
User basicUser = convertToBasicUser(premiumUser);
System.out.println("转换后的普通用户：" + basicUser);
}
// Record转换方法
private static User convertToBasicUser(PremiumUser premiumUser) {
// Record支持按字段构造新对象
return new User(premiumUser.id(), premiumUser.name(),
premiumUser.age(), premiumUser.role());
}
// 5. Record与Stream结合
public static void processUsers(List<User> users) {
// 过滤高级用户并提取姓名
List<String> premiumUserNames = users.stream()
.filter(u -> u instanceof PremiumUser)
.map(u -> (PremiumUser) u)
.map(PremiumUser::name)
.toList();
System.out.println("高级用户列表：" + premiumUserNames);
}
}
10. 模式匹配与Switch表达式（Java 17+）：
/**
* 模式匹配Switch表达式：简化复杂条件判断
* 场景：状态机、类型判断、事件处理
*/
public class PatternMatchingSwitch {
// 事件模型
record Event(String type, Object data) {}
// 处理不同类型的事件
public String handleEvent(Event event) {
return switch (event.type()) {
case "USER_CREATED" -> handleUserCreated((UserCreatedData) event.data());
case "ORDER_PLACED" -> handleOrderPlaced((OrderData) event.data());
case "PAYMENT_COMPLETED" -> handlePaymentCompleted((PaymentData) event.data());
default -> "未知事件类型：" + event.type();
};
}
// 用户创建事件数据
record UserCreatedData(String userId, String userName, String email) {}
// 订单创建事件数据
record OrderData(String orderId, String userId, double amount) {}
// 支付完成事件数据
record PaymentData(String paymentId, String orderId, double amount, String status) {}
// 处理用户创建事件
private String handleUserCreated(UserCreatedData data) {
return "用户创建成功：" + data.userId() + ", 姓名：" + data.userName();
}
// 处理订单创建事件
private String handleOrderPlaced(OrderData data) {
return "订单创建成功：" + data.orderId() + ", 金额：" + data.amount();
}
// 处理支付完成事件
private String handlePaymentCompleted(PaymentData data) {
return "支付完成：" + data.paymentId() + ", 订单：" + data.orderId() +
", 金额：" + data.amount() + ", 状态：" + data.status();
}
// 复杂模式匹配示例
public int calculateDiscount(Object item) {
return switch (item) {
// 匹配商品类型和价格
case Product p when p.price() > 1000 -> 20; // 高价商品打8折
case Product p when p.price() > 500 -> 10; // 中价商品打9折
case Product p -> 5; // 低价商品打95折
case Book b when b.isHardcover() -> 15; // 精装书特殊折扣
default -> 0; // 无折扣
};
}
// 商品模型
record Product(String id, String name, double price) {}
// 书籍模型
record Book(String id, String name, double price, boolean isHardcover) extends Product(id, name, price) {}
// 使用示例
public static void main(String[] args) {
PatternMatchingSwitch handler = new PatternMatchingSwitch();
// 处理事件
Event userEvent = new Event("USER_CREATED", new UserCreatedData("U1001", "张三", "zhangsan@example.com"));
System.out.println(handler.handleEvent(userEvent));
Event orderEvent = new Event("ORDER_PLACED", new OrderData("O202306", "U1001", 899.5));
System.out.println(handler.handleEvent(orderEvent));
// 计算折扣
Product laptop = new Product("P001", "笔记本电脑", 8999.0);
Book novel = new Book("B001", "Java编程思想", 128.0, true);
System.out.println("笔记本电脑折扣：" + handler.calculateDiscount(laptop) + "%");
System.out.println("精装书折扣：" + handler.calculateDiscount(novel) + "%");
}
}
扫一扫
2128
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
