java核心编程实例

www.xservx.com

备案号:蜀ICP备2026035467号-3

🏠 java核心编程实例首页

本页面系统梳理Java核心编程技术体系,涵盖语法进阶、集合框架深度解析、多线程并发编程、IO/NIO模型、反射与泛型机制、常用设计模式实战、JVM内存管理与调优、主流开发框架集成等核心内容。所有案例均基于实际开发场景重构,强调工程实践与问题解决能力培养,适合Java初学者系统构建知识体系,也适合资深开发者作为技术参考手册。

⚡ 网友最常搜索的10个问题

  1. Java中==与equals()方法的区别及底层实现原理
  2. ArrayList与LinkedList在不同场景下的性能对比与源码解析
  3. HashMap的红黑树转换阈值为何是8?负载因子为何是0.75?
  4. 线程池参数如何合理配置?RejectedExecutionHandler如何自定义?
  5. volatile关键字的可见性与禁止指令重排原理是什么?
  6. Java内存模型(JMM)中happens-before规则有哪些?
  7. Java中如何实现线程安全的单例模式?enum方式为何被推荐?
  8. Java NIO中Buffer、Channel、Selector的协作机制详解
  9. Java反射的性能瓶颈在哪?MethodHandle与反射对比
  10. 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接口核心实现对比

特性ArrayListLinkedListVector
底层结构动态数组双向链表动态数组(线程安全)
随机访问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可读取Number及其子类对象
  • ? super T:下界通配符,只能写(消费者),如List可添加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非阻塞IOIO多路复用信号驱动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>

📝 高频面试题深度解析

① Java中字符串拼接的性能优化

字符串拼接方式:+(编译期优化为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),快速
② 为什么重写equals()必须重写hashCode()?

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不同,找不到桶)
③ ArrayList扩容机制详解

初始容量10,扩容为原容量的1.5倍(oldCapacity + (oldCapacity >> 1))。若新容量仍不足,则直接设为所需容量。

扩容操作:System.arraycopy(Native方法,高效内存拷贝)。