🏠 java核心编程实例首页
本页面系统梳理Java核心编程技术体系,涵盖语法进阶、集合框架深度解析、多线程并发编程、IO/NIO模型、反射与泛型机制、常用设计模式实战、JVM内存管理与调优、主流开发框架集成等核心内容。所有案例均基于实际开发场景重构,强调工程实践与问题解决能力培养,适合Java初学者系统构建知识体系,也适合资深开发者作为技术参考手册。
⚡ 网友最常搜索的10个问题
- Java中==与equals()方法的区别及底层实现原理
- ArrayList与LinkedList在不同场景下的性能对比与源码解析
- HashMap的红黑树转换阈值为何是8?负载因子为何是0.75?
- 线程池参数如何合理配置?RejectedExecutionHandler如何自定义?
- volatile关键字的可见性与禁止指令重排原理是什么?
- Java内存模型(JMM)中happens-before规则有哪些?
- Java中如何实现线程安全的单例模式?enum方式为何被推荐?
- Java NIO中Buffer、Channel、Selector的协作机制详解
- Java反射的性能瓶颈在哪?MethodHandle与反射对比
- Spring中AOP底层是JDK动态代理还是CGLIB?如何选择?
⚙️ 页面导航说明
本页面所有导航均采用锚点跳转,无实际二级页面跳转,所有内容均在本页完整展示,便于快速定位与深度阅读。
📘 Java基础语法深度解析
Java提供8种基本数据类型:byte(1字节)、short(2字节)、int(4字节)、long(8字节)、float(4字节)、double(8字节)、char(2字节,UTF-16编码)、boolean(仅true/false,实现未规定)。引用类型包括类、接口、数组、枚举。
注意:基本类型在栈上分配,性能高;引用类型在堆上分配,支持动态内存管理。自动装箱/拆箱虽方便,但频繁操作易引发性能问题与NullPointerException。
⚡ 示例:自动装箱陷阱
Integer a = 1000;
Integer b = 1000;
System.out.println(a == b); // false(超出缓存范围[-128,127])
Integer c = 100;
Integer d = 100;
System.out.println(c == d); // true(使用缓存对象)
Java控制流语句包括if-else、switch、for、while、do-while。switch支持int、char、String(JDK7+)、enum(JDK5+)。JDK7前switch仅支持int及可隐式转换为int的类型。
注意:switch中的case标签必须为编译时常量,不能是变量或方法返回值。break语句防止穿透,但有时故意省略以实现多条件合并处理。
⚡ 示例:switch枚举类型
enum Season {SPRING, SUMMER, AUTUMN, WINTER}
Season s = Season.SUMMER;
switch (s) {
case SPRING -> System.out.println("春暖花开");
case SUMMER -> System.out.println("夏日炎炎");
case AUTUMN -> System.out.println("秋高气爽");
case WINTER -> System.out.println("冬雪皑皑");
}
异常体系:Throwable → Error(JVM严重错误)、Exception(可处理异常)→ RuntimeException(运行时异常)与IOException等检查异常。
try-with-resources(JDK7+)自动关闭实现了AutoCloseable接口的资源,避免资源泄漏。finally块始终执行,但若其中含return或异常,将覆盖try中的返回值或异常。
⚡ 示例:try-with-resources
try (BufferedReader br = new BufferedReader(new FileReader("data.txt"))) {
String line;
while ((line = br.readLine()) != null) {
System.out.println(line);
}
} catch (IOException e) {
System.err.println("读取失败:" + e.getMessage());
}
🔍 集合框架与泛型机制
⚡ List接口核心实现对比
| 特性 | ArrayList | LinkedList | Vector |
|---|---|---|---|
| 底层结构 | 动态数组 | 双向链表 | 动态数组(线程安全) |
| 随机访问 | O(1) | O(n) | O(1) |
| 插入/删除 | O(n)(需移动) | O(1)(需定位) | O(n) |
| 线程安全 | 否 | 否 | 是(synchronized) |
| 扩容机制 | 1.5倍 | 无 | 2倍 |
⚡ HashMap核心机制详解
HashMap采用数组+链表+红黑树结构(JDK8+):
- 数组初始容量16,负载因子0.75(平衡时间与空间)
- 当链表长度≥8且数组长度≥64时转为红黑树
- 红黑树节点数≤6时退化为链表(避免频繁转换)
- put操作:计算hash→定位桶位→遍历链表/树→插入或更新
- 扩容:新容量=2倍旧容量,rehash(高位参与运算减少冲突)
⚡ 示例:自定义HashMap键类
class Person {
String name;
int age;
@Override
public boolean equals(Object o) {
if (this == o) return true;
if (!(o instanceof Person)) return false;
Person p = (Person) o;
return age == p.age && Objects.equals(name, p.name);
}
@Override
public int hashCode() {
return Objects.hash(name, age);
}
}
⚡ 泛型通配符使用场景
- ? extends T:上界通配符,只能读(生产者),如List extends Number>可读取Number及其子类对象
- ? super T:下界通配符,只能写(消费者),如List super Integer>可添加Integer对象
- ?:无界通配符,仅用于Object方法调用,如List>不能添加元素(除null)
⚡ 多线程与并发编程
Java创建线程方式:继承Thread类、实现Runnable接口、实现Callable接口+FutureTask、线程池提交任务。推荐使用Runnable/Callable+线程池,避免继承限制与资源浪费。
⚡ 示例:Callable+FutureTask异步计算
Callable task = () -> {
Thread.sleep(1000);
return 42;
};
FutureTask future = new FutureTask<>(task);
new Thread(future).start();
System.out.println("结果:" + future.get()); // 阻塞等待结果
线程池核心参数:corePoolSize(核心线程数)、maximumPoolSize(最大线程数)、keepAliveTime(空闲线程存活时间)、workQueue(阻塞队列)、threadFactory(线程工厂)、handler(拒绝策略)。
常见拒绝策略:AbortPolicy(抛异常)、CallerRunsPolicy(调用者线程执行)、DiscardPolicy(静默丢弃)、DiscardOldestPolicy(丢弃队首任务)。
⚡ 示例:自定义线程池配置
ExecutorService pool = new ThreadPoolExecutor(
4, 8, 60L, TimeUnit.SECONDS,
new LinkedBlockingQueue<>(100),
Executors.defaultThreadFactory(),
new ThreadPoolExecutor.CallerRunsPolicy()
);
同步工具类:CountDownLatch(倒计时门栓)、CyclicBarrier(循环栅栏)、Semaphore(信号量)、Exchanger(数据交换)。
Lock接口:ReentrantLock(可重入锁)、ReentrantReadWriteLock(读写锁)。注意使用try-finally确保unlock调用。
⚡ 示例:读写锁优化读多写少场景
class Cache {
private final Map map = new HashMap<>();
private final ReentrantReadWriteLock lock = new ReentrantReadWriteLock();
public Object get(String key) {
lock.readLock().lock();
try { return map.get(key); }
finally { lock.readLock().unlock(); }
}
public void put(String key, Object value) {
lock.writeLock().lock();
try { map.put(key, value); }
finally { lock.writeLock().unlock(); }
}
}
📥 输入输出与NIO模型
⚡ IO模型对比
| 模型 | 阻塞IO | 非阻塞IO | IO多路复用 | 信号驱动IO | 异步IO |
|---|---|---|---|---|---|
| 模型特点 | 阻塞等待数据 | 轮询检查数据 | select/poll/epoll监听 | 信号通知就绪 | 内核完成拷贝后通知 |
| Java支持 | java.io.* | java.nio.*非阻塞 | java.nio.channels.Selector | 不支持 | java.nio.channels.AsynchronousChannel |
⚡ NIO核心组件
- Buffer:数据容器(ByteBuffer、CharBuffer等),包含position、limit、capacity属性
- Channel:双向通道(FileChannel、SocketChannel),支持异步读写
- Selector:多路复用器,监听多个Channel的事件(连接、读、写)
⚡ 示例:非阻塞服务器(简化版)
ServerSocketChannel ssc = ServerSocketChannel.open();
ssc.configureBlocking(false);
ssc.bind(new InetSocketAddress(8080));
Selector selector = Selector.open();
ssc.register(selector, SelectionKey.OP_ACCEPT);
while (selector.select() > 0) {
Iterator it = selector.selectedKeys().iterator();
while (it.hasNext()) {
SelectionKey key = it.next();
if (key.isAcceptable()) {
SocketChannel sc = ssc.accept();
sc.configureBlocking(false);
sc.register(selector, SelectionKey.OP_READ);
} else if (key.isReadable()) {
SocketChannel sc = (SocketChannel) key.channel();
ByteBuffer buf = ByteBuffer.allocate(1024);
sc.read(buf);
buf.flip();
sc.write(buf);
}
it.remove();
}
}
🔍 反射与动态代理
⚡ 反射核心API
- Class.forName("com.example.MyClass"):加载类
- Class.getMethod(name, paramTypes):获取public方法
- Class.getDeclaredMethod(name, paramTypes):获取任意方法
- Method.invoke(obj, args):执行方法
- Constructor.newInstance(args):创建实例
⚡ 反射性能优化
反射调用比直接调用慢10-20倍,原因包括:
- 安全检查(访问控制修饰符校验)
- 参数包装/拆箱(基本类型装箱)
- 方法查找与缓存缺失
优化方案:setAccessible(true)关闭安全检查、缓存Method对象、使用MethodHandle(JDK7+,更轻量级)。
⚡ 示例:MethodHandle性能测试
MethodHandles.Lookup lookup = MethodHandles.lookup();
MethodHandle mh = lookup.findVirtual(String.class, "length",
MethodType.methodType(int.class));
int len = (int) mh.invokeExact("test"); // 静态类型安全
⚡ 动态代理实现原理
JDK动态代理基于接口(Proxy+InvocationHandler),CGLIB基于继承(生成子类,使用MethodInterceptor)。
Spring默认策略:有接口用JDK代理,无接口用CGLIB(JDK8后CGLIB性能接近JDK)。
🎨 设计模式在Java中的应用
⚡ 单例模式实现对比
| 方式 | 线程安全 | 懒加载 | 性能 | 推荐度 |
|---|---|---|---|---|
| 饿汉式 | 是 | 否 | 高 | ★☆☆☆☆ |
| synchronized方法 | 是 | 是 | 低 | ★☆☆☆☆ |
| 双重检查锁 | 是 | 是 | 高 | ★★★☆☆ |
| 静态内部类 | 是 | 是 | 高 | ★★★★☆ |
| enum | 天然 | 否 | 高 | ★★★★★ |
⚡ 工厂模式与依赖注入
Spring的BeanFactory/ApplicationContext即工厂模式实现。@Autowired依赖注入本质是工厂+反射+注解解析。
⚡ 示例:自定义简单工厂
interface Animal { void speak(); }
class Dog implements Animal { public void speak() { System.out.println("汪!"); } }
class Cat implements Animal { public void speak() { System.out.println("喵!"); } }
class AnimalFactory {
public static Animal create(String type) {
return switch (type) {
case "dog" -> new Dog();
case "cat" -> new Cat();
default -> throw new IllegalArgumentException("未知动物");
};
}
}
⚡ 装饰器模式在IO中的应用
BufferedInputStream装饰FileInputStream,动态添加缓冲功能;InputStreamReader将字节流转换为字符流。
优势:避免继承爆炸(如FileBufferedInputStream无需新类),符合开闭原则。
⚙️ JVM内存管理与调优
⚡ JVM运行时数据区
- 程序计数器:线程私有,记录当前执行字节码行号
- 虚拟机栈:线程私有,存储栈帧(局部变量表、操作数栈等)
- 本地方法栈:线程私有,服务native方法
- 堆:线程共享,存储对象实例(新生代+老年代)
- 方法区(JDK8后为元空间Metaspace):存储类信息、常量、静态变量
⚡ 常见OOM场景与解决方案
| 异常 | 原因 | 解决方案 |
|---|---|---|
| java.lang.OutOfMemoryError: Java heap space | 堆内存不足 | 增大-Xmx、排查内存泄漏 |
| java.lang.OutOfMemoryError: Metaspace | 元空间不足(类加载过多) | 增大-XX:MaxMetaspaceSize、检查类加载器泄漏 |
| java.lang.StackOverflowError | 栈深度过大(递归过深) | 优化递归逻辑、增大-Xss |
⚡ GC日志分析要点
启用GC日志:-XX:+PrintGCDetails -Xloggc:gc.log
关键指标:Full GC频率(过高需调优)、停顿时间(影响响应)、存活对象大小(决定堆容量)。
🔧 主流开发框架集成
⚡ Spring核心机制
- IOC容器:依赖注入,解耦组件
- AOP:动态代理实现横切逻辑(日志、事务)
- 事务管理:@Transactional声明式事务
- 条件装配:@Conditional按需加载Bean
⚡ 示例:声明式事务
@Service
public class UserService {
@Transactional
public void transfer(String from, String to, double amount) {
accountDao.debit(from, amount);
accountDao.credit(to, amount);
}
}
⚡ MyBatis动态SQL
支持<if>、<choose>、<where>、<set>、<foreach>等标签动态构建SQL。
⚡ 示例:动态查询
<select id="findUsers" resultType="User">
SELECT * FROM user
<where>
<if test="name != null">
AND name LIKE #{name}
</if>
<if test="minAge != null">
AND age > #{minAge}
</if>
</where>
</select>
📝 高频面试题深度解析
字符串拼接方式:+(编译期优化为StringBuilder)、StringBuilder(非线程安全)、StringBuffer(线程安全)。循环中拼接必须用StringBuilder,避免创建大量临时对象。
⚡ 示例:性能对比
// 10万次拼接
String s = "";
for (int i = 0; i < 100000; i++) s += i; // O(n²),极慢
StringBuilder sb = new StringBuilder();
for (int i = 0; i < 100000; i++) sb.append(i); // O(n),快速
Java规范要求:equals()相等的对象必须hashCode()相等。否则在HashMap中可能导致相同键存入不同桶,破坏唯一性约束。
⚡ 示例:违反规范的后果
Map map = new HashMap<>();
Person p1 = new Person("张三", 25);
Person p2 = new Person("张三", 25);
map.put(p1, "value");
System.out.println(map.get(p2)); // null(hashCode不同,找不到桶)
初始容量10,扩容为原容量的1.5倍(oldCapacity + (oldCapacity >> 1))。若新容量仍不足,则直接设为所需容量。
扩容操作:System.arraycopy(Native方法,高效内存拷贝)。