java程序设计教程习题
备案号:蜀ICP备2026035467号-3|网址:www.xservx.com

《java程序设计教程习题》——系统化训练 Java 开发核心能力

本习题集以《java程序设计教程》核心知识点为纲,结合企业实际开发场景与主流招聘要求,构建“基础→进阶→实战”三级训练体系,覆盖Java语言基础、面向对象编程、集合框架、异常处理、多线程、I/O流、网络编程、JDBC等全部核心模块,提供200+典型例题、50+综合实战题、30+企业面试真题,每题均含详细解析、易错点提醒与扩展思考,帮助学习者构建扎实的知识体系与工程化思维。

本习题集特别针对初学者在学习过程中常见的认知盲区与技术难点进行专项设计,例如:成员变量与局部变量作用域混淆、this关键字在构造器中的使用、接口与抽象类的适用场景判断、HashMap线程安全性问题、synchronized锁升级机制、NIO与BIO的本质差异、JDBC连接池原理等高频易错点,均通过精心设计的习题与深度解析予以突破。

【学习路径建议】

  1. 阶段一:夯实基础——完成“基础语法”与“面向对象”章节,掌握变量、运算符、流程控制、类与对象、继承多态、抽象类与接口等核心概念,能独立编写50~100行功能完整的Java程序。
  2. 阶段二:深化理解——深入“集合框架”“异常处理”“多线程”,重点理解集合类层次结构、异常分类与自定义异常、线程生命周期与同步机制,能分析并发场景下的资源竞争与数据一致性问题。
  3. 阶段三:实战提升——完成“I/O流”“网络编程”“JDBC”,掌握文件读写、Socket通信、数据库连接与CRUD操作,能开发小型桌面应用或Web后端基础模块。
  4. 阶段四:面试强化——反复研读“面试真题”,结合企业真实考察点进行模拟训练,重点突破JVM内存模型、GC机制、Spring生态关联知识等延伸考点。
⚡ 学习提示:建议配合Oracle官方JDK文档与Java SE API文档同步查阅,形成“理论→代码→验证→归纳”闭环学习路径。

一、基础语法:变量、运算符与流程控制

Java基础语法是编程能力的基石,看似简单,实则暗藏玄机。本章节聚焦初学者易混淆点,如基本数据类型取值范围、自动类型转换陷阱、三目运算符短路特性、switch语句对字符串与枚举的支持差异等,通过实战题强化理解。

【例题1】基本数据类型与默认值

阅读以下代码,写出控制台输出结果:

public class DefaultValueDemo {
    static byte b;
    static short s;
    static int i;
    static long l;
    static float f;
    static double d;
    static boolean bool;
    static char c;
    static String str;
    public static void main(String[] args) {
        System.out.println("byte: " + b);
        System.out.println("short: " + s);
        System.out.println("int: " + i);
        System.out.println("long: " + l);
        System.out.println("float: " + f);
        System.out.println("double: " + d);
        System.out.println("boolean: " + bool);
        System.out.println("char: '" + c + "'");
        System.out.println("String: " + str);
    }
}

【解析】类的成员变量若未显式初始化,将自动赋予默认值:数值类型为0(int型),float/double为0.0,boolean为false,char为'\u0000'(空字符),引用类型(如String)为null。注意:局部变量必须显式初始化,否则编译报错。

【易错点】字符'\u0000'打印时不可见,输出为单引号中间无内容;String为null时直接输出"null"字符串,非报错。

【扩展】Java中int占4字节(32位),取值范围为-2³¹ ~ 2³¹-1,即-2147483648 ~ 2147483647;long占8字节(64位),范围更大;float为单精度(32位),double为双精度(64位),精度差异在科学计算中需重点考量。

【例题2】自增运算符陷阱

分析以下代码执行结果:

public class IncrementDemo {
    public static void main(String[] args) {
        int a = 5;
        int b = a++ + ++a + a++;
        System.out.println("a = " + a + ", b = " + b);
        int c = 10;
        int d = ++c + c++ + ++c;
        System.out.println("c = " + c + ", d = " + d);
    }
}

【解析】关键在于理解前缀++(先自增再取值)与后缀++(先取值再自增)的求值顺序与栈操作:

  • 第一段:a初始为5 → a++取值5后a变为6 → ++a先自增a为7再取值7 → a++取值7后a变为8 → b=5+7+7=19,最终a=8
  • 第二段:c初始为10 → ++c先自增c为11再取值11 → c++取值11后c变为12 → ++c先自增c为13再取值13 → d=11+11+13=35,最终c=13

【工程建议】实际开发中应避免在单表达式中多次使用自增/自减运算符,易读性差且易引发维护风险,建议拆分为多步赋值。

【例题3】switch对字符串的支持与性能

以下代码是否能编译通过?若能,请说明Java内部如何实现字符串switch?

public class StringSwitch {
    public static void main(String[] args) {
        String day = "Monday";
        switch (day) {
            case "Monday":
                System.out.println("Start of work week");
                break;
            case "Friday":
                System.out.println("End of work week");
                break;
            default:
                System.out.println("Midweek day");
        }
    }
}

【解析】从Java 7开始支持字符串switch。内部实现机制为:

  1. 先调用字符串的hashCode()方法获取哈希值;
  2. 用哈希值匹配case标签的哈希值;
  3. 若哈希值相同(可能存在哈希冲突),再调用equals()方法比较字符串内容是否相等;
  4. 最终通过跳转表(jump table)定位执行分支。

【性能提示】字符串switch性能略低于整型switch(因增加hashCode与equals调用),但差异微小,日常开发可忽略;若用于高频循环内,建议改用整型枚举值优化。

【综合题】表达式求值与类型提升

分析以下代码输出结果并解释原因:

public class TypePromotion {
    public static void main(String[] args) {
        byte b1 = 10;
        byte b2 = 20;
        // byte b3 = b1 + b2; // 编译错误!
        int i1 = b1 + b2;
        long l1 = b1 + b2;
        double d1 = b1 + b2;
        System.out.println("i1=" + i1 + ", l1=" + l1 + ", d1=" + d1);
        short s1 = 30000;
        short s2 = 30000;
        // short s3 = s1 + s2; // 编译错误!
        int i2 = s1 + s2;
        System.out.println("i2=" + i2);
    }
}

【解析】Java中,byte/short/char在运算时会自动提升为int类型(称为“整数提升”),因此b1+b2结果为int,不能直接赋值给byte变量;同理short运算结果也为int。若需赋值回short,必须强制类型转换:short s3 = (short)(s1 + s2);

二、面向对象:封装、继承、多态与设计原则

面向对象编程(OOP)是Java的核心思想,本章节深入剖析封装性实现(访问控制符)、继承机制(super关键字、方法重写)、多态性(动态绑定)、抽象类与接口的对比、以及设计模式在习题中的应用,帮助学习者构建面向对象思维模型。

【例题4】封装性与访问控制

以下代码中,哪些语句会编译报错?请说明原因并修正。

class Person {
    private String name;
    int age;
    protected String address;
    public String email;
    public void setName(String name) {
        this.name = name;
    }
    public String getName() {
        return name;
    }
}
public class TestEncapsulation {
    public static void main(String[] args) {
        Person p = new Person();
        // p.name = "Alice"; // ❌ 编译错误:private成员不可访问
        p.age = 25; // ✅ 默认访问(包访问权限)
        p.address = "Beijing"; // ✅ protected:同包或子类可访问
        p.email = "alice@example.com"; // ✅ public可访问
        p.setName("Bob");
        System.out.println(p.getName());
    }
}

【关键点】Java访问控制符优先级:private < 默认(包级)< protected < public。封装的核心在于隐藏实现细节,仅暴露必要接口(如setter/getter),确保对象状态安全。

【例题5】方法重写与多态性

写出以下程序输出结果,并解释动态绑定机制:

class Animal {
    void makeSound() {
        System.out.println("Some sound");
    }
    void eat() {
        System.out.println("Eating");
    }
}
class Dog extends Animal {
    @Override
    void makeSound() {
        System.out.println("Bark");
    }
    void play() {
        System.out.println("Playing");
    }
}
public class PolymorphismDemo {
    public static void main(String[] args) {
        Animal a = new Dog(); // 向上转型
        a.makeSound(); // Bark(动态绑定)
        a.eat();       // Eating(继承自Animal)
        // a.play();   // ❌ 编译错误:Animal无play()方法
        Dog d = (Dog)a; // 向下转型(需确保安全)
        d.play();       // Playing
    }
}

【解析】多态的三要素:①继承;②方法重写;③父类引用指向子类对象。调用方法时,JVM在运行时根据实际对象类型(new Dog())查找方法表,决定调用哪个版本——即“动态绑定”。

【例题6】抽象类 vs 接口

对比抽象类与接口在Java中的异同,并为以下场景选择合适设计:

场景1:定义“交通工具”,所有交通工具都有“启动”和“停止”行为,但具体实现不同;部分交通工具(如汽车)有“载客数量”属性。

场景2:定义“可充电设备”,所有设备都支持“充电”行为,但充电方式各异;部分设备还需支持“放电”行为。

【分析】

  • 场景1 → 抽象类:因需共享状态(载客数量),且“启动/停止”可提供默认空实现或部分实现;
  • 场景2 → 接口:因“可充电”是能力而非实体,且一个设备可同时支持多种充电协议(多实现),符合接口多实现特性。

Java 8+增强:接口可含默认方法(default)与静态方法(static),但抽象类仍不可多继承;接口更侧重“能做什么”,抽象类侧重“是什么”。

【综合题】单例模式的线程安全实现

请写出三种线程安全的单例模式实现方式,并比较其优缺点:

// 1. 饿汉式(类加载即初始化,天然线程安全)
class SingletonEager {
    private static final SingletonEager INSTANCE = new SingletonEager();
    private SingletonEager() {}
    public static SingletonEager getInstance() {
        return INSTANCE;
    }
}
// 2. 双重检查锁定(DCL)
class SingletonDCL {
    private static volatile SingletonDCL instance;
    private SingletonDCL() {}
    public static SingletonDCL getInstance() {
        if (instance == null) {
            synchronized (SingletonDCL.class) {
                if (instance == null) {
                    instance = new SingletonDCL();
                }
            }
        }
        return instance;
    }
}
// 3. 静态内部类(推荐)
class SingletonInner {
    private static class Holder {
        private static final SingletonInner INSTANCE = new SingletonInner();
    }
    private SingletonInner() {}
    public static SingletonInner getInstance() {
        return Holder.INSTANCE;
    }
}

【对比】

实现方式优点缺点
饿汉式简单、线程安全、无同步开销类加载即实例化,可能浪费内存
DCL延迟加载、高性能需volatile防止指令重排,实现复杂
静态内部类延迟加载、线程安全、实现简洁依赖JVM类加载机制,理解成本略高

三、集合框架:List、Set、Map与泛型应用

集合框架是Java开发中最常用的数据结构,本章节聚焦ArrayList与LinkedList差异、HashSet/TreeSet实现原理、HashMap底层结构(数组+链表+红黑树)、ConcurrentHashMap线程安全机制、以及泛型在类型安全中的作用,结合高频考点深入解析。

【例题7】ArrayList vs LinkedList

在以下操作场景中,应优先选择哪个集合?为什么?

  1. 频繁通过索引访问元素(如get(100));
  2. 频繁在列表头部插入/删除元素;
  3. 需要线程安全的列表;
  4. 内存空间敏感,元素数量动态变化但较少。

【解析】

  • ① → ArrayList:基于数组实现,随机访问时间复杂度O(1);LinkedList需遍历,O(n/2);
  • ② → LinkedList:双链表结构,头插头删仅修改指针,O(1);ArrayList需移动后续元素,O(n);
  • ③ → Collections.synchronizedList(new ArrayList<>())或CopyOnWriteArrayList(读多写少场景更优);
  • ④ → ArrayList:LinkedList每个节点需额外存储前后指针,内存开销更大;若元素少且变动不大,数组扩容影响可忽略。

【例题8】HashMap底层结构与扩容机制

请描述JDK 8中HashMap的存储结构,并解释以下问题:

  1. 当哈希冲突时,何时将链表转为红黑树?
  2. 扩容时如何保证线程安全?
  3. 为何要重置threshold = (int)(capacity * loadFactor)?

【解析】

  • JDK 8中,HashMap = 数组 + 链表 + 红黑树(当链表长度≥8且数组长度≥64时转为红黑树);
  • 链表转红黑树条件:链表长度 ≥ 8 且 数组长度 ≥ 64;若数组长度<64,优先扩容而非转树(因扩容可分散哈希冲突);
  • 扩容非线程安全!需外部同步;JDK 8中扩容采用“头插法”改为“尾插法”,避免多线程下形成环形链表导致死循环;
  • threshold为下次扩容临界值,loadFactor默认0.75是时间与空间的折中(过高增加冲突,过低浪费空间)。

【例题9】ConcurrentHashMap线程安全机制

对比JDK 7与JDK 8中ConcurrentHashMap的实现差异,并说明其如何提升并发性能。

【解析】

  • JDK 7:Segment分段锁结构,每个Segment含HashEntry数组+链表,锁粒度为Segment;最多支持16线程并发(默认16个Segment);
  • JDK 8:取消Segment,采用Node数组 + 链表/红黑树,锁粒度降为单个桶(bin),使用synchronized + CAS实现无锁化;
  • 性能提升:减少锁竞争、支持更多并发线程、降低扩容开销;CAS操作避免阻塞,synchronized仅锁当前桶头节点,不影响其他桶。

【例题10】泛型擦除与边界

分析以下代码是否能编译通过,若不能,说明原因并提出解决方案:

public class GenericTest {
    public static void main(String[] args) {
        List list = new ArrayList<>();
        list.add("Hello");
        List rawList = list; // 原始类型(raw type)
        rawList.add(123); // ⚠️ 编译警告,运行时可能抛ClassCastException
        String s = (String)rawList.get(1); // ClassCastException!
    }
}

【解析】Java泛型为“伪泛型”,仅在编译期存在类型检查(泛型擦除),运行时类型信息被擦除为Object。使用原始类型会跳过类型检查,导致运行时异常。

【最佳实践】避免使用原始类型;若需处理未知类型,使用通配符或边界通配符 / ;

四、多线程:线程生命周期、同步机制与并发工具类

多线程是Java高并发编程的基础,本章节深入剖析线程创建与启动、线程生命周期状态转换、synchronized与ReentrantLock机制、volatile关键字原理、线程池使用与参数调优、以及CompletableFuture异步编程模型。

【例题11】线程状态与wait/sleep/yield

写出以下代码可能的输出顺序,并解释各方法对线程状态的影响:

public class ThreadStateDemo {
    private static final Object lock = new Object();
    public static void main(String[] args) {
        Thread t1 = new Thread(() -> {
            synchronized (lock) {
                System.out.println("T1: acquired lock");
                try {
                    lock.wait(); // 进入WAITING状态,释放锁
                } catch (InterruptedException e) {}
                System.out.println("T1: resumed");
            }
        });
        Thread t2 = new Thread(() -> {
            synchronized (lock) {
                System.out.println("T2: acquired lock");
                lock.notify(); // 唤醒一个等待线程(需先持有lock)
                System.out.println("T2: notified");
                try {
                    Thread.sleep(100); // TIMED_WAITING,不释放锁
                } catch (InterruptedException e) {}
                System.out.println("T2: slept");
            }
        });
        t1.start();
        t2.start();
    }
}

【解析】执行顺序可能为:
T1: acquired lock
T2: acquired lock
T2: notified
T2: slept
T1: resumed

  • wait():必须在synchronized块中调用;释放对象锁;进入WAITING状态;需notify/notifyAll唤醒;
  • sleep(100):不释放任何锁;进入TIMED_WAITING状态;100ms后自动恢复;
  • yield():提示调度器让出CPU,但不保证立即切换;状态仍为RUNNABLE。

【例题12】synchronized锁升级机制

请说明JDK 6后synchronized锁的四种状态及升级路径,并解释为何要进行锁升级。

【解析】锁状态升级路径:无锁 → 偏向锁 → 轻量级锁 → 重量级锁

  • 无锁:对象初始状态,无锁竞争;
  • 偏向锁:首次加锁时,将线程ID记录在对象头;后续同一线程再进入时无需CAS,直接执行;适用于单线程场景;
  • 轻量级锁:有竞争但线程交替执行时,通过自旋(CAS)获取锁;避免线程挂起开销;
  • 重量级锁:自旋失败后,线程挂起进入阻塞队列;适用于多线程高竞争场景。

升级目的:减少无竞争情况下的同步开销,提升性能;不可降级(锁降级仅在JVM内部特殊场景发生,开发者不可控)。

【例题13】volatile与内存可见性

分析以下代码是否能保证“线程A修改flag后,线程B能立即看到”?为什么?

public class VolatileDemo {
    private static volatile boolean flag = false;
    public static void main(String[] args) {
        new Thread(() -> {
            while (!flag) {
                // 空循环等待
            }
            System.out.println("Thread B: flag is true!");
        }).start();
        try { Thread.sleep(1000); } catch (InterruptedException e) {}
        new Thread(() -> {
            flag = true; // 修改volatile变量
            System.out.println("Thread A: set flag to true");
        }).start();
    }
}

【解析】能!volatile关键字保证:

  1. 可见性:写操作立即刷新到主内存;读操作从主内存加载;
  2. 禁止指令重排序(通过内存屏障实现);
  3. 不保证原子性(如i++仍需同步)。

注意:若将flag改为普通变量,线程B可能因缓存未更新而永远循环(CPU缓存一致性问题)。

【例题14】线程池核心参数与拒绝策略

请解释ThreadPoolExecutor构造函数中以下参数含义,并为高并发日志处理系统设计合理配置:

new ThreadPoolExecutor(
    corePoolSize,
    maximumPoolSize,
    keepAliveTime,
    unit,
    workQueue,
    threadFactory,
    handler
);

【参数说明】

  • corePoolSize:核心线程数(常驻线程数);
  • maximumPoolSize:最大线程数(任务积压时可创建的上限);
  • keepAliveTime:非核心线程空闲存活时间;
  • workQueue:任务队列(如LinkedBlockingQueue、ArrayBlockingQueue);
  • handler:拒绝策略(当队列满且线程达max时触发)。

【日志系统配置建议】

  • corePoolSize = CPU核数(日志处理为I/O密集型,可设为2×CPU核数);
  • maximumPoolSize = 2×corePoolSize;
  • workQueue = ArrayBlockingQueue(10000)(有界队列防OOM);
  • handler = new ThreadPoolExecutor.CallerRunsPolicy()(由调用线程执行,背压保护);
  • keepAliveTime = 60L(秒)。

五、异常处理:分类、自定义异常与最佳实践

异常处理是Java程序健壮性的保障,本章节深入剖析Error与Exception区别、受检异常与非受检异常、try-with-resources自动资源管理、自定义异常设计原则,以及异常处理的性能影响与规避策略。

【例题15】异常分类与处理

请判断以下异常属于哪类(受检/非受检/Error),并说明处理方式:

  1. NullPointerException
  2. IOException
  3. OutOfMemoryError
  4. ClassNotFoundException

【解析】

  • NullPointerException:非受检异常(RuntimeException子类),编译不强制处理;应通过空值检查规避;
  • IOException:受检异常(Exception子类但非RuntimeException),编译强制处理(try-catch或throws);
  • OutOfMemoryError:Error子类,表示JVM严重错误,通常不可恢复;需优化内存使用或增加堆大小;
  • ClassNotFoundException:受检异常(Exception),常用于反射场景,需显式处理。

【例题16】try-with-resources自动资源管理

对比以下两种文件读取方式,说明try-with-resources的优势:

// 方式1:传统try-catch-finally
BufferedReader br = null;
try {
    br = new BufferedReader(new FileReader("data.txt"));
    String line = br.readLine();
    System.out.println(line);
} catch (IOException e) {
    e.printStackTrace();
} finally {
    if (br != null) try { br.close(); } catch (IOException e) {}
}
// 方式2:try-with-resources
try (BufferedReader br = new BufferedReader(new FileReader("data.txt"))) {
    String line = br.readLine();
    System.out.println(line);
} catch (IOException e) {
    e.printStackTrace();
}

【优势】

  • 自动调用close()方法(要求实现AutoCloseable接口);
  • 代码简洁,避免finally块中资源关闭的嵌套try-catch;
  • 若close()抛异常,会被抑制(suppressed)并附加到主异常中,不丢失异常信息。

【例题17】自定义异常设计

为电商系统设计一个业务异常类,要求支持错误码、错误消息与可选的附加数据。

public class BusinessException extends RuntimeException {
    private final String code;
    private final Map data;
    public BusinessException(String code, String message) {
        super(message);
        this.code = code;
        this.data = null;
    }
    public BusinessException(String code, String message, Map data) {
        super(message);
        this.code = code;
        this.data = data;
    }
    public String getCode() { return code; }
    public Map getData() { return data; }
}

【设计要点】

  • 继承RuntimeException(非受检),便于业务层统一捕获;
  • 包含错误码(code),便于前端差异化处理;
  • 支持附加数据(如用户ID、订单号),方便日志追踪;
  • 可配合全局异常处理器(@ControllerAdvice)实现统一返回格式。

六、I/O流:字节流、字符流与NIO模型

I/O操作涉及文件读写、网络通信,本章节对比传统BIO与NIO差异,解析FileInputStream/BufferedReader使用场景、字符编码问题、NIO核心组件(Channel、Buffer、Selector),以及Files工具类的便捷用法。

【例题18】字符流 vs 字节流

以下代码在读取含中文的文本文件时可能出现乱码吗?如何修正?

FileInputStream fis = new FileInputStream("chinese.txt");
int b;
while ((b = fis.read()) != -1) {
    System.out.print((char)b);
}

【问题】字节流逐字节读取,未考虑字符编码(如UTF-8中一个中文占3字节),导致拆分字符而乱码。

【修正】使用字符流并指定编码:

try (BufferedReader br = new BufferedReader(
        new InputStreamReader(new FileInputStream("chinese.txt"), "UTF-8"))) {
    String line;
    while ((line = br.readLine()) != null) {
        System.out.println(line);
    }
}

【例题19】NIO核心组件

请简述NIO中Channel、Buffer、Selector的作用,并比较BIO与NIO的差异。

【解析】

  • Channel:双向通道(可读可写),替代传统流;如FileChannel、SocketChannel;
  • Buffer:缓冲区,数据载体(如ByteBuffer);需flip()切换读写模式;
  • Selector:多路复用器,单线程管理多个Channel;通过select()轮询就绪事件。

BIO vs NIO

特性BIONIO
通信模型流式,阻塞缓冲区,非阻塞
线程模型一连接一线程多路复用(1线程管理多连接)
适用场景连接数少、数据量大连接数多、数据量小

【例题20】Files工具类实用方法

使用Files类完成以下操作:复制目录、递归删除非空目录、读取文件为字符串、列出目录下所有.java文件。

// 复制目录(递归)
Path source = Paths.get("src");
Path target = Paths.get("dist");
Files.walk(source)
    .forEach(p -> {
        try {
            Path relative = source.relativize(p);
            Path dest = target.resolve(relative);
            if (Files.isDirectory(p)) {
                Files.createDirectories(dest);
            } else {
                Files.copy(p, dest, StandardCopyOption.REPLACE_EXISTING);
            }
        } catch (IOException e) { e.printStackTrace(); }
    });
// 递归删除非空目录
Files.walkFileTree(target, new SimpleFileVisitor() {
    @Override
    public FileVisitResult visitFile(Path file, BasicFileAttributes attrs) throws IOException {
        Files.delete(file);
        return FileVisitResult.CONTINUE;
    }
    @Override
    public FileVisitResult postVisitDirectory(Path dir, IOException exc) throws IOException {
        Files.delete(dir);
        return FileVisitResult.CONTINUE;
    }
});
// 读取文件为字符串
String content = Files.readString(Paths.get("config.properties"), StandardCharsets.UTF_8);
// 列出.java文件
Files.list(Paths.get("."))
    .filter(p -> p.toString().endsWith(".java"))
    .forEach(System.out::println);

七、网络编程:Socket通信与HTTP客户端

网络编程是分布式系统的基础,本章节剖析TCP/UDP差异、Socket通信流程(服务端/客户端)、NIO实现高并发服务器、以及Java 11+内置的HttpClient异步请求用法。

【例题21】TCP Socket通信模型

请写出一个简单的Echo服务器与客户端代码,并说明关键步骤。

// 服务器端(单线程,仅示意)
ServerSocket server = new ServerSocket(8080);
Socket client = server.accept(); // 阻塞等待连接
BufferedReader in = new BufferedReader(new InputStreamReader(client.getInputStream()));
PrintWriter out = new PrintWriter(client.getOutputStream(), true);
String msg = in.readLine();
out.println("Echo: " + msg);
client.close();
server.close();
// 客户端
Socket socket = new Socket("localhost", 8080);
BufferedReader in = new BufferedReader(new InputStreamReader(socket.getInputStream()));
PrintWriter out = new PrintWriter(socket.getOutputStream(), true);
out.println("Hello");
System.out.println(in.readLine());
socket.close();

【关键点】

  • 服务端:创建ServerSocket → accept()阻塞等待 → 获取输入/输出流 → 通信 → 关闭;
  • 客户端:创建Socket(自动连接) → 获取流 → 通信 → 关闭;
  • 注意:实际应用需多线程处理多客户端,且需异常处理与资源关闭(try-with-resources)。

【例题22】Java 11+ HttpClient

使用HttpClient发送GET请求并异步处理响应(支持JSON)。

HttpClient client = HttpClient.newHttpClient();
HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("https://api.example.com/data"))
    .GET()
    .build();
// 同步
HttpResponse response = client.send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());
// 异步(CompletableFuture)
client.sendAsync(request, HttpResponse.BodyHandlers.ofString())
    .thenApply(HttpResponse::body)
    .thenAccept(System.out::println)
    .join();

【优势】原生支持HTTP/2、异步非阻塞、与CompletableFuture集成,替代过时的HttpURLConnection。

八、JDBC:数据库连接与事务管理

JDBC是Java操作数据库的标准API,本章节讲解Driver注册、Connection管理、PreparedStatement防SQL注入、事务控制(commit/rollback)、批处理优化、以及连接池(HikariCP)集成。

【例题23】PreparedStatement防SQL注入

对比普通Statement与PreparedStatement的执行方式,说明为何后者能防SQL注入。

// ❌ 易受SQL注入攻击
String sql = "SELECT * FROM users WHERE name = '" + userInput + "'";
Statement stmt = conn.createStatement();
ResultSet rs = stmt.executeQuery(sql);
// ✅ 安全方式
String sql = "SELECT * FROM users WHERE name = ?";
PreparedStatement pstmt = conn.prepareStatement(sql);
pstmt.setString(1, userInput);
ResultSet rs = pstmt.executeQuery();

【原理】PreparedStatement将SQL与参数分离:SQL语句预编译生成执行计划,参数仅作为值绑定,不会被解析为SQL语法,从而杜绝注入。

【例题24】事务控制与隔离级别

写出一个转账操作的事务处理代码,并说明四种隔离级别对脏读、不可重复读、幻读的影响。

conn.setAutoCommit(false); // 关闭自动提交
try {
    // 扣款
    PreparedStatement ps1 = conn.prepareStatement("UPDATE accounts SET balance = balance - ? WHERE id = ?");
    ps1.setBigDecimal(1, amount);
    ps1.setInt(2, fromId);
    ps1.executeUpdate();
    // 加款
    PreparedStatement ps2 = conn.prepareStatement("UPDATE accounts SET balance = balance + ? WHERE id = ?");
    ps2.setBigDecimal(1, amount);
    ps2.setInt(2, toId);
    ps2.executeUpdate();
    conn.commit(); // 提交
} catch (SQLException e) {
    conn.rollback(); // 回滚
    throw e;
} finally {
    conn.setAutoCommit(true);
}

【隔离级别对比】

级别脏读不可重复读幻读
READ_UNCOMMITTED允许允许允许
READ_COMMITTED禁止允许允许
REPEATABLE_READ禁止禁止允许
SERIALIZABLE禁止禁止禁止

默认级别:MySQL为REPEATABLE_READ,Oracle为READ_COMMITTED。

九、面试真题:高频考点与深度解析

本章节精选10道企业真实面试题,覆盖JVM内存模型、GC机制、Spring核心原理、设计模式应用等,每题包含参考答案与面试官追问点,助您高效备战技术面。

【真题1】JVM内存模型与OOM

问题:请描述JVM运行时数据区组成部分,并说明哪些区域可能抛出OutOfMemoryError?

【参考答案】

  • 程序计数器:线程私有,记录当前指令地址;线程切换后恢复执行;不会OOM;
  • 虚拟机栈:线程私有,存储栈帧(局部变量表、操作数栈等);栈溢出(StackOverflowError)或内存溢出(OOM)(扩展栈时);
  • 本地方法栈:为Native方法服务;类似虚拟机栈;
  • 堆:线程共享,存储对象实例;OOM(新生代/老年代空间不足);
  • 方法区/元空间:存储类信息、常量、静态变量;OOM(元空间耗尽,Java 8+);
  • 运行时常量池:方法区的一部分,存放编译期常量;OOM(常量池溢出)。

【追问】如何分析OOM问题?
→ 使用jmap生成堆转储文件(heap dump),用VisualVM或Eclipse MAT分析对象分布;
→ 查看GC日志(-XX:+PrintGCDetails),定位内存泄漏点或堆参数配置不当。

【真题2】HashMap与ConcurrentHashMap线程安全性

问题:为什么HashMap线程不安全?ConcurrentHashMap如何保证线程安全?

【参考答案】

  • HashMap线程不安全原因:扩容时多线程可能导致链表成环(JDK 7)或数据丢失(JDK 8);
  • ConcurrentHashMap线程安全:JDK 8中对每个桶(bin)加synchronized锁,结合CAS操作;
    → 插入时:若桶为空,CAS设置;若不为空,锁桶头节点;
    → 扩容时:多线程协作扩容(每个线程处理部分桶),无全局锁。

【追问】为何不用ReentrantLock而用synchronized?
→ synchronized在JDK 6后性能大幅提升(偏向锁、轻量级锁),且JVM可对其做更多优化(如锁消除)。

【真题3】Spring事务传播行为

问题:解释@Transactional的REQUIRED和REQUIRES_NEW传播行为差异,并举例说明适用场景。

【参考答案】

  • REQUIRED:若当前存在事务则加入,否则新建事务;
    → 场景:订单创建(主事务),包含库存扣减、优惠券使用(均在主事务内,任一失败则回滚);
  • REQUIRES_NEW:挂起当前事务,新建独立事务;
    → 场景

【真题4】设计模式在源码中的应用

问题:请举例说明工厂模式、代理模式、模板方法模式在JDK或Spring中的应用。

【参考答案】

  • 工厂模式:Spring的BeanFactory、JDK的Calendar.getInstance();
  • 代理模式:Spring AOP基于JDK动态代理(接口)或CGLIB(类);
  • 模板方法:JDBC的DriverManager.getConnection(),抽象类java.io.InputStream定义模板方法。

【真题5】GC Roots与可达性分析

问题:哪些对象可作为GC Roots?请说明强/软/弱/虚引用的区别。

【参考答案】

  • GC Roots:虚拟机栈引用对象、方法区常量引用、方法区静态属性引用、本地方法栈引用;
  • 引用类型:
    → 强引用:普通对象引用,不会被GC;
    → 软引用:内存不足时回收,适合缓存;
    → 弱引用:下一次GC即回收,如WeakHashMap;
    → 虚引用:必须配合ReferenceQueue,用于跟踪对象回收活动。

【网友还关心】高频问题解答

Java 8新特性
lambda表达式
Stream API
Optional类

Java 8核心新特性概览

  1. 接口默认方法:使用default关键字为接口提供默认实现,避免实现类修改;
  2. Lambda表达式:简化匿名内部类,语法:(params) → expression;
  3. Stream API:函数式操作集合,支持filter/map/sort/reduce等链式调用;
  4. Optional:避免NullPointerException,提供isPresent()/orElse()等方法;
  5. 新日期API:java.time包(LocalDate、LocalDateTime、DateTimeFormatter);
  6. 方法引用:::操作符,如String::valueOf;
  7. 重复注解:@Repeatable允许同一注解多次使用。

Lambda表达式详解

Lambda表达式本质是函数式接口(FunctionalInterface,仅含一个抽象方法)的实例化。示例:

// 1. 无参
Runnable r1 = () -> System.out.println("Hello");
// 2. 单参数(类型可省略)
Function f1 = s -> s.length();
// 3. 多参数
BiPredicate bp = (x, y) -> x > y;
// 4. 复合表达式
Predicate p = s -> s != null && s.length() > 3;

使用场景:集合遍历(forEach)、过滤(filter)、排序(Comparator.comparing)等。

Stream API实战

对List进行过滤、映射、收集:

List names = Arrays.asList("Alice", "Bob", "Charlie", "David");
List result = names.stream()
    .filter(s -> s.length() > 3) // 过滤长度>3的字符串
    .map(String::toUpperCase)    // 转大写
    .sorted()                   // 排序
    .collect(Collectors.toList());

并行流:使用parallelStream()自动分治处理,适合大数据集;注意线程安全与资源竞争。

Optional使用规范

避免空指针,推荐写法:

// 创建Optional
Optional opt1 = Optional.ofNullable(value); // value可为null
Optional opt2 = Optional.of(value);        // value必须非null
Optional opt3 = Optional.empty();          // 空Optional
// 安全获取
String result = opt1.orElse("default");            // 为空时返回默认值
String result2 = opt1.orElseGet(() -> "computed"); // 用Supplier计算默认值
String result3 = opt1.orElseThrow(IllegalArgumentException::new); // 为空则抛异常
// 链式操作
Optional userOpt = Optional.ofNullable(repo.findById(123));
String email = userOpt.flatMap(User::getEmailOpt)
                     .orElse("no-email@example.com");