Java基础知识总结

Java面试高频知识点总结

📚 Java基础

1. 面向对象三大特性

// 封装示例
public class Person {
    private String name;  // 封装
    
    public String getName() { 
        return name; 
    }
}

// 继承示例
class Student extends Person { }

// 多态示例
Animal animal = new Dog();  // 父类引用指向子类对象

2. == 和 equals() 的区别

• ==：比较基本类型值或对象内存地址
• equals()：通常需要重写，用于比较对象内容

String s1 = new String("hello");
String s2 = new String("hello");

s1 == s2;      // false（不同对象）
s1.equals(s2); // true（内容相同）

3. String、StringBuffer、StringBuilder

📦 Java集合框架

1. HashMap原理（JDK8+）

// 数组 + 链表/红黑树结构
static final int TREEIFY_THRESHOLD = 8;  // 链表转树阈值
static final int UNTREEIFY_THRESHOLD = 6; // 树转链表阈值

// put过程伪代码
1. 计算key的hash值
2. 如果table为空则初始化
3. 如果桶为空，直接插入
4. 如果桶不为空：
   - 键相同则更新值
   - 如果是树节点，树插入
   - 否则遍历链表插入
5. 链表长度>8时转为红黑树

2. ConcurrentHashMap线程安全实现

• JDK7：分段锁(Segment)
• JDK8+：
  • Node + CAS + synchronized
  • 只锁定当前桶（链表头/树根）
  • 并发控制更细粒度

3. ArrayList vs LinkedList

🔁 多线程与并发

1. 线程状态转换

2. synchronized vs ReentrantLock

3. 线程池核心参数

ThreadPoolExecutor(
    int corePoolSize,     // 核心线程数
    int maximumPoolSize,  // 最大线程数
    long keepAliveTime,   // 空闲线程存活时间
    TimeUnit unit,        // 时间单位
    BlockingQueue<Runnable> workQueue, // 工作队列
    RejectedExecutionHandler handler   // 拒绝策略
)

四种拒绝策略：

1. AbortPolicy：默认策略，直接抛异常
2. CallerRunsPolicy：用调用者线程执行任务
3. DiscardPolicy：静默丢弃任务
4. DiscardOldestPolicy：丢弃队列最老任务

⚙️ JVM与性能调优

1. 内存区域划分

JVM内存区域
“方法区”
“堆”
“虚拟机栈”
“本地方法栈”
“程序计数器”

2. 垃圾回收算法

• 标记-清除：产生内存碎片
• 复制算法：适合新生代（Eden/Survivor）
• 标记-整理：适合老年代
• 分代收集：新生代(Minor GC) + 老年代(Full GC)

3. 常见GC收集器

🧩 设计模式

1. 单例模式（双重校验锁）

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;
    }
}

2. 工厂模式

interface Car {
    void drive();
}

class Tesla implements Car { /*...*/ }
class BMW implements Car { /*...*/ }

class CarFactory {
    public Car createCar(String type) {
        switch(type) {
            case "Tesla": return new Tesla();
            case "BMW": return new BMW();
            default: throw new IllegalArgumentException();
        }
    }
}

3. Spring中的设计模式

• 工厂模式：BeanFactory
• 代理模式：AOP实现
• 单例模式：默认Bean作用域
• 模板方法：JdbcTemplate
• 观察者模式：ApplicationEvent

✨ Java 8+ 新特性

1. Lambda表达式

// 传统写法
Collections.sort(list, new Comparator<String>() {
    public int compare(String s1, String s2) {
        return s1.length() - s2.length();
    }
});

// Lambda写法
Collections.sort(list, (s1, s2) -> s1.length() - s2.length());

2. Stream API

List<String> result = list.stream()
    .filter(s -> s.startsWith("A"))
    .map(String::toUpperCase)
    .sorted()
    .collect(Collectors.toList());

3. Optional避免NPE

Optional<User> user = userService.findById(id);
user.ifPresent(u -> System.out.println(u.getName()));

String name = user.map(User::getName)
                 .orElse("Unknown");