Java基础核心知识点与面试题深度解析-代码聚汇网

Java基础核心知识点与面试题深度解析

幸运小姐·2026-08-23·阅读 22 GEO检测（免费）

Java基础面试题JVM

|难度：普通|阅读约 16 分钟

1. Java基础面试题全景解析

作为从业十年的Java技术面试官，我整理了这份覆盖Java基础核心知识点的面试题集。不同于网上零散的题目汇总，这份资料按照知识体系结构化编排，从内存模型到集合框架，从多线程到JVM原理，每个问题都附带深度解析和实际应用场景说明。

需要模型API调用？免费领10W Token，多模型网关一键接入 Claude、DeepSeek 等主流模型。

2. Java基础核心知识体系

2.1 数据类型与运算符

Java的8种基本数据类型及其内存占用：

byte: 1字节
short: 2字节
int: 4字节
long: 8字节
float: 4字节
double: 8字节
char: 2字节
boolean: JVM规范未明确定义

注意：基本数据类型存储在栈内存，而对象存储在堆内存。自动装箱拆箱操作会影响性能，在循环中应避免频繁使用。

2.2 面向对象三大特性

封装、继承、多态的实际应用示例：

java复制// 多态示例
interface Animal {
    void makeSound();
}

class Dog implements Animal {
    public void makeSound() {
        System.out.println("Bark");
    }
}

class Cat implements Animal {
    public void makeSound() {
        System.out.println("Meow");
    }
}

public class Main {
    public static void main(String[] args) {
        Animal myAnimal = new Dog();  // 向上转型
        myAnimal.makeSound();  // 输出Bark
        
        myAnimal = new Cat();
        myAnimal.makeSound();  // 输出Meow
    }
}

3. 集合框架深度剖析

3.1 List接口实现类对比

特性	ArrayList	LinkedList	Vector
底层结构	数组	双向链表	数组
线程安全	不安全	不安全	安全
随机访问效率	O(1)	O(n)	O(1)
增删效率	O(n)	O(1)	O(n)

3.2 HashMap工作原理

HashMap的put操作流程：

计算key的hash值
通过(n-1)&hash确定桶位置
如果发生哈希冲突：
- JDK1.7：头插法
- JDK1.8：尾插法，链表长度>8转红黑树
超过负载因子(默认0.75)则扩容为2倍

4. 多线程与并发编程

4.1 线程状态转换

Java线程的6种状态：

NEW
RUNNABLE
BLOCKED
WAITING
TIMED_WAITING
TERMINATED

4.2 synchronized实现原理

对象头中的Mark Word结构：

code复制| 锁状态   | 25bit          | 4bit     | 1bit(偏向锁) | 2bit(锁标志) |
|----------|----------------|----------|--------------|--------------|
| 无锁     | hashCode       | 分代年龄 | 0            | 01           |
| 偏向锁   | 线程ID+Epoch   | 分代年龄 | 1            | 01           |
| 轻量级锁 | 指向栈中锁记录 |          |              | 00           |
| 重量级锁 | 指向互斥量     |          |              | 10           |

5. JVM内存模型与GC

5.1 运行时数据区

程序计数器：线程私有
虚拟机栈：线程私有，存储栈帧
本地方法栈：线程私有
堆：线程共享，存放对象实例
方法区：线程共享，存储类信息

5.2 GC算法比较

算法	优点	缺点	适用场景
Serial	简单高效	单线程STW	客户端模式
Parallel	多线程并行	仍会STW	吞吐量优先
CMS	并发收集，低延迟	内存碎片，CPU敏感	响应时间优先
G1	可预测停顿，高吞吐	内存占用较大	大内存服务端

6. 异常处理机制

Java异常类继承体系：

code复制Throwable
├── Error
│   ├── VirtualMachineError
│   └── ...
└── Exception
    ├── RuntimeException
    │   ├── NullPointerException
    │   └── ...
    └── IOException
        ├── FileNotFoundException
        └── ...

最佳实践：不要捕获Throwable或Error，对于可恢复异常使用checked exception，编程错误使用unchecked exception。

7. IO与NIO对比

7.1 传统IO模型

java复制try (FileInputStream fis = new FileInputStream("test.txt");
     BufferedInputStream bis = new BufferedInputStream(fis)) {
    byte[] buffer = new byte[1024];
    int bytesRead;
    while ((bytesRead = bis.read(buffer)) != -1) {
        // 处理数据
    }
}

7.2 NIO核心组件

Channel：双向数据传输通道
Buffer：数据容器
Selector：多路复用器

NIO示例：

java复制try (ServerSocketChannel serverChannel = ServerSocketChannel.open()) {
    serverChannel.bind(new InetSocketAddress(8080));
    serverChannel.configureBlocking(false);
    Selector selector = Selector.open();
    serverChannel.register(selector, SelectionKey.OP_ACCEPT);
    
    while (true) {
        selector.select();
        Set<SelectionKey> keys = selector.selectedKeys();
        Iterator<SelectionKey> iter = keys.iterator();
        
        while (iter.hasNext()) {
            SelectionKey key = iter.next();
            if (key.isAcceptable()) {
                // 处理连接
            }
            iter.remove();
        }
    }
}

8. 常见面试题精讲

8.1 String为什么不可变

安全：防止敏感信息被修改
哈希缓存：String常用作HashMap的key
线程安全：天然线程安全
字符串常量池：实现字符串复用

8.2 equals与==的区别

==比较对象内存地址
equals比较对象内容（可重写）

String比较的特殊情况：

java复制String s1 = "hello";
String s2 = "hello";
String s3 = new String("hello");

System.out.println(s1 == s2);  // true，常量池同一对象
System.out.println(s1 == s3);  // false，不同对象
System.out.println(s1.equals(s3)); // true，内容相同

9. 设计模式实战

9.1 单例模式实现

双重检查锁定实现：

java复制public class Singleton {
    private volatile static Singleton instance;
    
    private Singleton() {}
    
    public static Singleton getInstance() {
        if (instance == null) {
            synchronized (Singleton.class) {
                if (instance == null) {
                    instance = new Singleton();
                }
            }
        }
        return instance;
    }
}

9.2 工厂模式应用

简单工厂示例：

java复制interface Product {
    void use();
}

class ConcreteProductA implements Product {
    public void use() {
        System.out.println("Using Product A");
    }
}

class ProductFactory {
    public static Product createProduct(String type) {
        if ("A".equals(type)) {
            return new ConcreteProductA();
        }
        throw new IllegalArgumentException("Unknown product type");
    }
}

10. 性能优化技巧

10.1 字符串拼接优化

避免在循环中使用+拼接字符串：

java复制// 反例
String result = "";
for (int i = 0; i < 100; i++) {
    result += i;  // 每次循环创建新StringBuilder和String对象
}

// 正例
StringBuilder sb = new StringBuilder();
for (int i = 0; i < 100; i++) {
    sb.append(i);
}
String result = sb.toString();

10.2 集合初始化优化

指定集合初始容量：

java复制// 已知元素数量为100时
List<String> list = new ArrayList<>(100);  // 避免多次扩容
Map<String, Integer> map = new HashMap<>(128);  // 2的幂次方

11. Java新特性

11.1 Java 8 Lambda表达式

java复制List<String> names = Arrays.asList("Alice", "Bob", "Charlie");

// 传统方式
Collections.sort(names, new Comparator<String>() {
    public int compare(String a, String b) {
        return a.compareTo(b);
    }
});

// Lambda方式
Collections.sort(names, (a, b) -> a.compareTo(b));

// 方法引用
names.forEach(System.out::println);

11.2 Stream API使用

java复制List<Integer> numbers = Arrays.asList(1, 2, 3, 4, 5);

int sum = numbers.stream()
    .filter(n -> n % 2 == 0)
    .mapToInt(n -> n * 2)
    .sum();

12. 面试实战技巧

12.1 问题回答结构

使用STAR法则：

Situation：问题背景
Task：需要解决的问题
Action：采取的措施
Result：取得的结果

12.2 代码手写规范

先理清思路再写代码
注意边界条件处理
添加必要注释
考虑异常情况
完成后自行测试用例

13. 学习路线建议

Java进阶学习路径：

核心基础：语法、集合、IO
并发编程：线程、锁、JUC
JVM原理：内存模型、GC、调优
主流框架：Spring、MyBatis
分布式技术：Dubbo、Zookeeper
性能优化：JVM调优、SQL优化

14. 资源推荐

经典书籍：

《Java编程思想》
《Effective Java》
《Java并发编程实战》
《深入理解Java虚拟机》

在线资源：

Oracle官方文档
Java源码（特别是java.util和java.concurrent包）
GitHub优质开源项目
技术博客（美团技术团队、阿里技术等）