网站备案号:蜀ICP备2026035467号-3
java实例代码 | www.xservx.com

java实例代码

精选企业级Java编程实例、常见问题解决方案及深度技术解析,涵盖JVM原理、Spring Boot实战、并发编程、设计模式等实用内容,助力开发者快速提升编码能力。

基础入门 框架实战

基础语法与核心类库

字符串处理实例详解

字符串是Java中最常用的数据类型之一,掌握其常用方法对日常开发至关重要。以下提供多个典型应用场景,帮助开发者高效处理字符串操作。

字符串反转多种实现方式

在Java中,字符串反转可通过多种方式实现,每种方式在性能和可读性上各有特点:

public class StringReverse { // 方法一:使用StringBuilder public static String reverse1(String str) { return new StringBuilder(str).reverse().toString(); } // 方法二:字符数组倒序遍历 public static String reverse2(String str) { char[] chars = str.toCharArray(); StringBuilder result = new StringBuilder(); for (int i = chars.length - 1; i >= 0; i--) { result.append(chars[i]); } return result.toString(); } // 方法三:递归实现 public static String reverse3(String str) { if (str == null || str.length() <= 1) return str; return reverse3(str.substring(1)) + str.charAt(0); } }
⚡

性能对比:StringBuilder方式在大多数场景下性能最优;递归方式代码简洁但对长字符串易导致栈溢出;字符数组方式在内存受限场景更可控。

格式化处理技巧

Java提供了多种字符串格式化方式,包括传统printf风格、MessageFormat及Java 15引入的文本块。

public class StringFormat { // printf风格 public static void printfFormat() { String name = "张三"; int age = 28; double score = 95.678; System.out.printf("姓名:%s,年龄:%d岁,成绩:%.2f分%n", name, age, score); // 输出:姓名:张三,年龄:28岁,成绩:95.68分 } // MessageFormat方式 public static void messageFormat() { String pattern = "用户{0}于{1}登录系统"; Object[] params = {"李四", "2025-04-05 14:30:22"}; String result = MessageFormat.format(pattern, params); System.out.println(result); } // 文本块(Java 15+) public static void textBlock() { String json = """ { "name": "王五", "age": 32, "email": "wangwu@example.com" }"""; System.out.println(json); } }

正则表达式应用实例

正则表达式在验证、提取和替换场景中不可或缺,以下展示常用模式及实际应用。

public class RegexExamples { // 邮箱验证 public static boolean isValidEmail(String email) { String regex = "^[a-zA-Z0-9_+&*-]+(?:\\.[a-zA-Z0-9_+&*-]+)*@(?:[a-zA-Z0-9-]+\\.)+[a-zA-Z]{2,7}$"; return email != null && email.matches(regex); } // 提取数字 public static List extractNumbers(String text) { List numbers = new ArrayList<>(); Pattern pattern = Pattern.compile("\\d+"); Matcher matcher = pattern.matcher(text); while (matcher.find()) { numbers.add(matcher.group()); } return numbers; } // 替换敏感词 public static String filterSensitive(String text, String[] sensitiveWords) { String result = text; for (String word : sensitiveWords) { result = result.replaceAll("(?i)" + Pattern.quote(word), "*".repeat(word.length())); } return result; } }

集合框架深度解析

集合框架是Java核心库的重要组成部分,合理选择集合类型对程序性能影响显著。以下从使用场景、性能特征及常见陷阱三方面展开说明。

ArrayList vs LinkedList

选择合适的List实现是开发中的关键决策,需根据具体操作频率权衡:

操作类型 ArrayList LinkedList
随机访问get(i) O(1) - 数组索引直接访问 O(n) - 需遍历节点
尾部添加add(e) O(1) - 均摊 O(1)
中间插入/删除 O(n) - 需移动元素 O(1) - 修改指针
内存占用 较低 - 仅存储元素 较高 - 需存储前后指针

典型场景:频繁随机读取用ArrayList;频繁中间插入/删除用LinkedList;需要栈操作可用ArrayDeque替代Stack提升性能。

HashMap与TreeMap对比

Map选择需综合考虑排序需求、键类型及访问模式:

public class MapComparison { // HashMap - 无序,基于哈希 public static void hashMapDemo() { Map map = new HashMap<>(); map.put("apple", 5); map.put("banana", 3); map.put("cherry", 7); // 输出顺序不保证插入顺序 map.forEach((k, v) -> System.out.println(k + ": " + v)); } // LinkedHashMap - 保持插入顺序 public static void linkedHashMapDemo() { Map map = new LinkedHashMap<>(); map.put("apple", 5); map.put("banana", 3); map.put("cherry", 7); // 输出顺序与插入顺序一致 map.forEach((k, v) -> System.out.println(k + ": " + v)); } // TreeMap - 有序,基于红黑树 public static void treeMapDemo() { Map map = new TreeMap<>(); map.put("apple", 5); map.put("banana", 3); map.put("cherry", 7); // 输出按键的自然顺序排序 map.forEach((k, v) -> System.out.println(k + ": " + v)); } }

关键差异:TreeMap支持排序但操作复杂度O(log n);HashMap平均O(1)但无序;LinkedHashMap在两者间取得平衡,适合需要稳定迭代顺序的场景。

线程安全集合方案

并发环境下需选择合适集合避免数据竞争,以下是主流方案对比:

集合类型 实现方式 适用场景
Vector/Hashtable 方法级synchronized 旧版兼容,低并发场景
Collections.synchronizedXxx 包装器同步 简单同步需求
CopyOnWriteArrayList 写时复制 读多写少场景(如监听器列表)
ConcurrentHashMap 分段锁/CAS 高并发读写(推荐首选)
BlockingQueue 生产者-消费者模式 线程间数据传递
⚙️

实践建议:优先使用java.util.concurrent包中的并发集合;避免手动同步大型集合;注意迭代时需额外加锁。

Spring框架实战

Spring Boot快速启动

构建一个基础Web应用,展示自动配置与起步依赖的便捷性。

import org.springframework.boot.SpringApplication; import org.springframework.boot.autoconfigure.SpringBootApplication; import org.springframework.web.bind.annotation.*; @SpringBootApplication @RestController public class DemoApplication { public static void main(String[] args) { SpringApplication.run(DemoApplication.class, args); } @GetMapping("/hello") public String hello(@RequestParam(name="name", defaultValue="开发者") String name) { return "Hello, " + name + "!"; } }
〔

需在pom.xml中添加spring-boot-starter-web依赖

依赖注入详解

展示构造器注入、字段注入及Setter注入的差异与推荐用法。

import org.springframework.beans.factory.annotation.Autowired; import org.springframework.stereotype.Service; @Service public class UserService { private final UserRepository userRepository; // 推荐:构造器注入(强制依赖) @Autowired public UserService(UserRepository userRepository) { this.userRepository = userRepository; } // 可选:Setter注入(可选依赖) private EmailService emailService; @Autowired public void setEmailService(EmailService emailService) { this.emailService = emailService; } }

AOP日志管理

通过切面实现统一日志记录与性能监控。

import org.aspectj.lang.ProceedingJoinPoint; import org.aspectj.lang.annotation.*; import org.slf4j.Logger; import org.slf4j.LoggerFactory; import org.springframework.stereotype.Component; @Aspect @Component public class LogAspect { private static final Logger logger = LoggerFactory.getLogger(LogAspect.class); @Pointcut("execution(* com.example..*(..))") public void serviceLayer() {} @Around("serviceLayer()") public Object logExecutionTime(ProceedingJoinPoint joinPoint) throws Throwable { long start = System.currentTimeMillis(); Object result = joinPoint.proceed(); long executionTime = System.currentTimeMillis() - start; logger.info("{} executed in {} ms", joinPoint.getSignature(), executionTime); return result; } }

事务管理配置

展示声明式事务的典型用法与传播行为选择。

import org.springframework.transaction.annotation.Transactional; import org.springframework.stereotype.Service; @Service public class OrderService { @Autowired private OrderRepository orderRepository; // 默认:REQUIRED传播行为 @Transactional public void createOrder(Order order) { // 业务逻辑 orderRepository.save(order); // 若此处抛出异常,整个事务回滚 if (order.getAmount() < 0) { throw new IllegalArgumentException("订单金额不能为负"); } } // 支持嵌套事务 @Transactional(propagation = Propagation.REQUIRES_NEW) public void createLog(String message) { logRepository.save(new Log(message)); } }

Spring MVC请求处理流程

深入理解Spring MVC的请求处理机制,掌握核心组件协作流程:

1. 前端控制器DispatcherServlet

接收所有HTTP请求,作为中央控制器协调各组件工作

2. 处理器映射HandlerMapping

根据请求URL找到对应的处理器(Controller方法)

3. 处理器适配器HandlerAdapter

执行处理器,处理参数绑定、类型转换等细节

4. 视图解析器ViewResolver

解析逻辑视图名到物理视图路径(如JSP、Thymeleaf模板)

5. 渲染响应

视图对象将模型数据渲染为最终响应内容

public class CustomHandlerInterceptor implements HandlerInterceptor { @Override public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception { // 记录请求开始时间 request.setAttribute("startTime", System.currentTimeMillis()); return true; // 返回true继续执行,false中断 } @Override public void afterCompletion(HttpServletRequest request, HttpServletResponse response, Object handler, Exception ex) throws Exception { // 记录总处理时间 Long startTime = (Long) request.getAttribute("startTime"); long cost = System.currentTimeMillis() - startTime; System.out.println("请求处理耗时:" + cost + "ms"); } }
〈

拦截器注册:通过实现WebMvcConfigurer接口注册自定义拦截器,支持按路径匹配规则配置。

并发编程实践

线程池参数优化策略

合理配置线程池参数是高并发系统的关键,以下提供通用计算公式与实际案例:

import java.util.concurrent.*; public class ThreadPoolConfig { // CPU核心数 private static final int CPU_COUNT = Runtime.getRuntime().availableProcessors(); // 计算核心线程数 public static int calculateCorePoolSize() { // IO密集型:核心线程数 = CPU核心数 * 2 // CPU密集型:核心线程数 = CPU核心数 + 1 // 混合型:核心线程数 ≈ CPU核心数 * (1 + waitTime/computeTime) return CPU_COUNT * 2; // 示例:IO密集型场景 } // 创建线程池示例 public static ExecutorService createThreadPool() { return new ThreadPoolExecutor( calculateCorePoolSize(), // corePoolSize CPU_COUNT * 4, // maximumPoolSize 60L, TimeUnit.SECONDS, // keepAliveTime new LinkedBlockingQueue<>(1000), // workQueue new ThreadFactory() { private int count = 1; @Override public Thread newThread(Runnable r) { Thread t = new Thread(r); t.setName("worker-thread-" + count++); return t; } }, new ThreadPoolExecutor.CallerRunsPolicy() // 拒绝策略 ); } // 实际使用示例 public static void executeTasks() { ExecutorService pool = createThreadPool(); for (int i = 0; i < 100; i++) { int taskId = i; pool.execute(() -> { System.out.println("Task " + taskId + " executed by " + Thread.currentThread().getName()); // 模拟任务执行 try { Thread.sleep(100); } catch (InterruptedException e) { Thread.currentThread().interrupt(); } }); } pool.shutdown(); } }
参数 推荐值 说明
corePoolSize IO密集型:CPU×2
CPU密集型:CPU+1
核心线程数,线程池维持的最小线程数
maximumPoolSize 核心数×2~4 最大线程数,任务激增时扩展上限
workQueue LinkedBlockingQueue/ArrayBlockingQueue 任务队列,选择有界/无界影响内存占用
keepAliveTime 60-300秒 非核心线程空闲存活时间

volatile与synchronized深度对比

理解内存可见性与原子性保障的差异是并发编程基础:

import java.util.concurrent.atomic.AtomicInteger; public class VisibilityExample { // volatile确保可见性但不保证原子性 private volatile boolean running = true; private int counter = 0; // 使用AtomicInteger保证原子性 private final AtomicInteger atomicCounter = new AtomicInteger(0); // 线程A:修改状态 public void stop() { running = false; // 写入对其他线程立即可见 } // 线程B:读取状态 public void run() { while (running) { // 安全读取volatile变量 doWork(); } } // 问题示例:非原子操作 public void incrementCounter() { counter++; // 等价于 counter = counter + 1,存在竞态条件 } // 正确方式:使用AtomicInteger public void safeIncrement() { atomicCounter.incrementAndGet(); // 原子操作 } // synchronized同时保证可见性与原子性 public synchronized void synchronizedIncrement() { counter++; // 互斥访问,保证原子性 } private void doWork() { // 模拟工作 try { Thread.sleep(10); } catch (InterruptedException e) { Thread.currentThread().interrupt(); } } }
↑

核心差异:volatile仅保证内存可见性,适用于状态标志;synchronized保证可见性+原子性,适用于复合操作;AtomicXXX类提供无锁原子操作。

死锁检测与预防方案

死锁是并发编程的典型陷阱,以下提供检测工具与预防策略:

import java.util.concurrent.locks.ReentrantLock; import java.util.concurrent.TimeUnit; public class DeadlockExample { private final Object lockA = new Object(); private final Object lockB = new Object(); // 危险示例:可能导致死锁 public void dangerousMethod() { new Thread(() -> { synchronized (lockA) { System.out.println("Thread 1 acquired lockA"); try { Thread.sleep(100); } catch (InterruptedException e) {} synchronized (lockB) { System.out.println("Thread 1 acquired lockB"); } } }).start(); new Thread(() -> { synchronized (lockB) { System.out.println("Thread 2 acquired lockB"); try { Thread.sleep(100); } catch (InterruptedException e) {} synchronized (lockA) { System.out.println("Thread 2 acquired lockA"); } } }).start(); } // 预防方案1:统一锁顺序 public void safeMethod() { new Thread(() -> { synchronized (lockA) { System.out.println("Safe Thread 1 acquired lockA"); try { Thread.sleep(100); } catch (InterruptedException e) {} synchronized (lockB) { System.out.println("Safe Thread 1 acquired lockB"); } } }).start(); // 确保锁顺序一致(都先获取lockA) new Thread(() -> { synchronized (lockA) { System.out.println("Safe Thread 2 acquired lockA"); try { Thread.sleep(100); } catch (InterruptedException e) {} synchronized (lockB) { System.out.println("Safe Thread 2 acquired lockB"); } } }).start(); } // 预防方案2:使用tryLock超时机制 public void timeoutMethod() { ReentrantLock lock1 = new ReentrantLock(); ReentrantLock lock2 = new ReentrantLock(); new Thread(() -> { try { if (lock1.tryLock(500, TimeUnit.MILLISECONDS)) { System.out.println("Timeout Thread 1 acquired lock1"); if (lock2.tryLock(500, TimeUnit.MILLISECONDS)) { System.out.println("Timeout Thread 1 acquired lock2"); lock2.unlock(); } lock1.unlock(); } } catch (InterruptedException e) { Thread.currentThread().interrupt(); } }).start(); new Thread(() -> { try { if (lock2.tryLock(500, TimeUnit.MILLISECONDS)) { System.out.println("Timeout Thread 2 acquired lock2"); if (lock1.tryLock(500, TimeUnit.MILLISECONDS)) { System.out.println("Timeout Thread 2 acquired lock1"); lock1.unlock(); } lock2.unlock(); } } catch (InterruptedException e) { Thread.currentThread().interrupt(); } }).start(); } }
检测工具 使用方式 输出信息
jstack jstack -l <pid> 显示线程堆栈及死锁检测结果
JConsole GUI工具,选择"Threads"标签 可视化线程状态与死锁检测
VisualVM 安装Deadlock Detector插件 实时监控与死锁告警

设计模式与架构实践

工厂模式实战应用

工厂模式通过封装对象创建逻辑,提升系统灵活性与可维护性:

import java.util.HashMap; import java.util.Map; // 抽象产品接口 interface Payment { void pay(double amount); } // 具体产品实现 class AlipayPayment implements Payment { @Override public void pay(double amount) { System.out.println("使用支付宝支付:" + amount + "元"); } } class WechatPayment implements Payment { @Override public void pay(double amount) { System.out.println("使用微信支付:" + amount + "元"); } } class UnionPayPayment implements Payment { @Override public void pay(double amount) { System.out.println("使用银联支付:" + amount + "元"); } } // 简单工厂 class PaymentFactory { private static final Map PAYMENT_MAP = new HashMap<>(); static { PAYMENT_MAP.put("alipay", new AlipayPayment()); PAYMENT_MAP.put("wechat", new WechatPayment()); PAYMENT_MAP.put("unionpay", new UnionPayPayment()); } public static Payment createPayment(String type) { Payment payment = PAYMENT_MAP.get(type.toLowerCase()); if (payment == null) { throw new IllegalArgumentException("不支持的支付方式: " + type); } return payment; } } // 客户端使用 public class PaymentService { public void processPayment(String type, double amount) { Payment payment = PaymentFactory.createPayment(type); payment.pay(amount); } }
→

扩展性优化:可结合Spring配置实现动态工厂,或使用策略模式+工厂模式组合提升灵活性。

策略模式在业务中的应用

策略模式将算法族封装为独立类,使算法可独立于使用它的客户端变化:

import java.util.HashMap; import java.util.Map; // 策略接口 interface DiscountStrategy { double calculate(double originalPrice); } // 具体策略实现 class NoDiscount implements DiscountStrategy { @Override public double calculate(double originalPrice) { return originalPrice; } } class VipDiscount implements DiscountStrategy { @Override public double calculate(double originalPrice) { return originalPrice * 0.8; // 8折 } } class FestivalDiscount implements DiscountStrategy { private final double discountRate; public FestivalDiscount(double discountRate) { this.discountRate = discountRate; } @Override public double calculate(double originalPrice) { return originalPrice * discountRate; } } // 上下文 class PricingContext { private DiscountStrategy strategy; public void setStrategy(DiscountStrategy strategy) { this.strategy = strategy; } public double calculatePrice(double originalPrice) { if (strategy == null) { strategy = new NoDiscount(); } return strategy.calculate(originalPrice); } } // 客户端使用 public class PricingService { private final PricingContext context = new PricingContext(); private final Map strategyMap = new HashMap<>(); public PricingService() { strategyMap.put("vip", new VipDiscount()); strategyMap.put("festival", new FestivalDiscount(0.7)); } public double calculate(String type, double price) { DiscountStrategy strategy = strategyMap.get(type); if (strategy != null) { context.setStrategy(strategy); } else { context.setStrategy(new NoDiscount()); } return context.calculatePrice(price); } }
策略类型 适用场景 优势
简单策略 固定折扣规则 代码清晰,易于测试
参数化策略 可变折扣规则 支持动态配置
组合策略 多规则叠加场景 策略可组合使用

JVM原理与调优

内存模型与对象生命周期

理解JVM内存模型是进行性能调优的基础,以下是HotSpot虚拟机的核心区域划分:

public class JvmMemoryDemo { public static void main(String[] args) { // 1. 方法区:存储类信息(JDK8+为元空间) // 2. 堆:对象实例(新生代+老年代) // 3. 栈:方法调用栈帧 // 4. 本地方法栈:Native方法调用 // 5. 程序计数器:当前线程执行字节码行号 // 示例:对象生命周期 User user = new User("张三", 25); // 新生代 Eden区 // 1. 对象创建:在Eden区分配内存 // 2. Minor GC:当Eden满时触发GC // 3. Survivor区:存活对象移至Survivor区 // 4. 老年代:长时间存活对象进入老年代 // 5. Full GC:老年代不足时触发 // 对象可达性分析 user = null; // 对象变为不可达 System.gc(); // 建议触发GC(不保证立即执行) } } class User { private String name; private int age; public User(String name, int age) { this.name = name; this.age = age; } @Override protected void finalize() throws Throwable { System.out.println("User对象被回收: " + name); super.finalize(); } }
内存区域 JDK版本 主要用途 溢出异常
方法区 JDK8前 存储类元数据、常量、静态变量 java.lang.OutOfMemoryError: PermGen space
元空间 JDK8+ 替代方法区,使用本地内存 java.lang.OutOfMemoryError: Metaspace
堆 所有版本 对象实例存储 java.lang.OutOfMemoryError: Java heap space
栈 所有版本 方法调用栈帧 java.lang.StackOverflowError

JVM调优实战参数

合理配置JVM参数可显著提升应用性能,以下是生产环境常用配置方案:

# 基础配置(8GB内存服务器) java -jar app.jar \ -Xms4g \ # 初始堆大小 -Xmx4g \ # 最大堆大小 -XX:MetaspaceSize=256m \ # 元空间初始大小 -XX:MaxMetaspaceSize=512m \ # 元空间最大大小 -XX:+UseG1GC \ # 使用G1垃圾收集器 -XX:MaxGCPauseMillis=200 \ # 最大GC暂停时间 -XX:G1HeapRegionSize=4m \ # G1区域大小 -XX:+ParallelRefProcEnabled \ # 并行处理引用 -XX:+ExplicitGCInvokesConcurrent \ # System.gc()并发执行 -XX:+HeapDumpOnOutOfMemoryError \ # OOM时生成堆转储 -XX:HeapDumpPath=/var/log/heapdump.hprof \ # 堆转储路径 -XX:+PrintGCDetails \ # 打印GC详情 -XX:+PrintGCDateStamps \ # 打印GC时间戳 -Xloggc:/var/log/gc.log # GC日志文件 # 常用分析命令 # jstat -gcutil 1000 10 # 每秒输出GC统计 # jmap -histo:live | head -20 # 对象分布统计 # jstack > stack.txt # 线程堆栈分析
↘

调优原则:优先确保GC暂停时间可控;避免频繁Full GC;通过堆转储分析内存泄漏;结合业务负载动态调整参数。

开发工具与调试技巧

调试技巧与断点设置

高效使用IDE调试功能可大幅提升问题排查效率,以下展示高级调试技巧:

import java.util.ArrayList; import java.util.List; public class DebugExample { // 示例:条件断点 public List filterUsers(List users, int minAge) { List result = new ArrayList<>(); for (User user : users) { // 设置条件断点:user.getAge() >= minAge if (user.getAge() >= minAge) { result.add(user.getName()); } } return result; } // 示例:日志断点(IDE支持) public void processOrder(String orderId, double amount) { // 设置日志断点:打印"Processing order: " + orderId System.out.println("Processing order: " + orderId); // 模拟处理逻辑 if (amount > 1000) { // 设置条件断点:amount > 1000 System.out.println("High value order detected: " + orderId); } } // 示例:异常断点 public void divide(int a, int b) { try { // 设置异常断点:java.lang.ArithmeticException int result = a / b; // 当b=0时触发异常断点 System.out.println("Result: " + result); } catch (ArithmeticException e) { System.out.println("Division by zero!"); } } }
断点类型 设置方法 适用场景
普通断点 行号处点击 基础调试
条件断点 右键断点→Condition 特定条件触发(如user.getId() == 100)
日志断点 右键断点→Log message 无需中断执行的变量监控
异常断点 Run→View Breakpoints→Java Exception Breakpoints 定位异常抛出位置

常用性能分析工具

性能调优需结合专业工具进行数据采集与分析:

JProfiler

商业级性能分析工具,支持CPU/内存/线程分析

〔

实时监控,图形化界面直观

VisualVM

Oracle官方免费工具,功能全面

〔

支持插件扩展,内存占用低

Arthas

阿里开源Java诊断工具

// 常用命令示例 dashboard // 实时监控 thread -n 10 // 查看最高CPU线程 sc *Demo* // 查看类信息 watch com.Demo main '{params, returnObj}'