Java面试题¶

// 强引用
Object obj = new Object();  // 只要obj存在, 对象不会被回收

// 软引用
SoftReference<Object> soft = new SoftReference<>(new Object());
soft.get();  // 内存不足前可获取, 内存不足时返回null

// 弱引用
WeakReference<Object> weak = new WeakReference<>(new Object());
weak.get();  // 下次GC前可获取

// ThreadLocal中Entry继承了WeakReference<ThreadLocal<?>>

// 字符串常量池在堆内存中(JDK 7+)

String s1 = "hello";     // 常量池中创建"hello"
String s2 = "hello";     // 直接引用常量池中的"hello"
System.out.println(s1 == s2);  // true (同一对象)

String s3 = new String("hello");  // 堆中新建对象
System.out.println(s1 == s3);     // false (不同对象)
System.out.println(s1.equals(s3)); // true (值相等)

String s4 = s3.intern();  // 返回常量池中的引用
System.out.println(s1 == s4);  // true

// 直接内存不在JVM堆中, 由操作系统管理
ByteBuffer buffer = ByteBuffer.allocateDirect(1024 * 1024);

// 优点: NIO时避免数据在堆和操作系统间拷贝(零拷贝)
// 缺点: 分配/释放比堆内存慢
// 大小受 -XX:MaxDirectMemorySize 限制
// 使用不当可能导致OOM

// 简化的put流程:
public V put(K key, V value) {
    // 1. 计算hash: key的hashCode的高16位异或低16位
    int hash = hash(key);

    // 2. 计算数组下标: (n-1) & hash
    int index = (table.length - 1) & hash;

    // 3. 该位置为空 → 直接放入新Node
    if (table[index] == null) {
        table[index] = new Node(hash, key, value, null);
    }
    // 4. 该位置不为空
    else {
        // 4a. key已存在 → 覆盖value
        // 4b. 链表 → 尾插法加入链表末尾
        //     如果链表长度 >= 8 且数组长度 >= 64 → 链表转红黑树
        // 4c. 红黑树 → 按红黑树方式插入
    }

    // 5. 如果size > threshold(容量*负载因子) → 扩容
    if (++size > threshold) {
        resize();  // 扩容为原来的2倍
    }
}

static final int hash(Object key) {
    int h;
    return (key == null) ? 0 : (h = key.hashCode()) ^ (h >>> 16);
    //                         高16位异或低16位
}

// 初始容量10, 扩容为1.5倍
int newCapacity = oldCapacity + (oldCapacity >> 1);
// 扩容需要Arrays.copyOf, 拷贝整个数组

// 建议: 如果知道大致大小, 指定初始容量
List<String> list = new ArrayList<>(1000);

// HashSet底层就是HashMap!
public class HashSet<E> {
    private transient HashMap<E, Object> map;
    private static final Object PRESENT = new Object();  // 占位value

    public boolean add(E e) {
        return map.put(e, PRESENT) == null;
    }

    public boolean contains(Object o) {
        return map.containsKey(o);
    }

    public boolean remove(Object o) {
        return map.remove(o) == PRESENT;
    }
}

// HashSet的元素就是HashMap的key
// 所有value都是同一个PRESENT对象

class User {
    String name;
    int age;

    @Override
    public int hashCode() {
        return Objects.hash(name, age);  // 必须重写
    }

    @Override
    public boolean equals(Object o) {    // 必须重写
        if (this == o) return true;
        if (!(o instanceof User)) return false;
        User user = (User) o;
        return age == user.age && Objects.equals(name, user.name);
    }
}

// Iterable: 表示可迭代, 提供iterator()方法
public interface Iterable<T> {  // interface定义类型契约
    Iterator<T> iterator();  // 泛型<T>：类型参数化
}

// Iterator: 迭代器, 负责遍历
public interface Iterator<E> {
    boolean hasNext();
    E next();
    default void remove() { ... }
}

// 实现Iterable的类可以用for-each
for (String s : list) { ... }
// 编译后等价于:
Iterator<String> it = list.iterator();
while (it.hasNext()) {
    String s = it.next();
}

List<String> list = new ArrayList<>(List.of("a", "b", "c"));

// ❌ 遍历时修改集合会抛出ConcurrentModificationException
for (String s : list) {
    if ("b".equals(s)) {
        list.remove(s);  // ConcurrentModificationException!
    }
}

// ✅ 使用Iterator的remove
Iterator<String> it = list.iterator();
while (it.hasNext()) {
    if ("b".equals(it.next())) {
        it.remove();  // 安全删除
    }
}

// ✅ 使用removeIf
list.removeIf(s -> "b".equals(s));

// LRU缓存实现
class LRUCache<K, V> extends LinkedHashMap<K, V> {
    private final int capacity;

    public LRUCache(int capacity) {
        super(capacity, 0.75f, true);  // accessOrder=true
        this.capacity = capacity;
    }

    @Override
    protected boolean removeEldestEntry(Map.Entry<K, V> eldest) {
        return size() > capacity;  // 超过容量时移除最久未访问的
    }
}

// Stream API
List<String> names = users.stream()
    .filter(u -> u.getAge() > 18)
    .sorted(Comparator.comparing(User::getAge))
    .map(User::getName)
    .distinct()
    .limit(10)
    .collect(Collectors.toList());

// Map新方法
map.getOrDefault(key, defaultValue);
map.putIfAbsent(key, value);
map.computeIfAbsent(key, k -> new ArrayList<>());
map.merge(key, value, (v1, v2) -> v1 + v2);
map.forEach((k, v) -> System.out.println(k + "=" + v));

// Collection新方法
list.removeIf(s -> s.isEmpty());
list.replaceAll(String::toUpperCase);
list.sort(Comparator.naturalOrder());

// 不可变集合(JDK 9+)
List<String> list = List.of("a", "b", "c");
Map<String, Integer> map = Map.of("a", 1, "b", 2);
Set<String> set = Set.of("a", "b", "c");

// 1. 同步实例方法 → 锁住this对象
public synchronized void method() { ... }

// 2. 同步静态方法 → 锁住Class对象
public static synchronized void method() { ... }

// 3. 同步代码块 → 锁住指定对象
synchronized (lockObj) { ... }

// ReentrantLock使用
ReentrantLock lock = new ReentrantLock();

lock.lock();
try {
    // 临界区
} finally {
    lock.unlock();  // 必须在finally中释放
}

// 尝试获取锁，超时返回false
if (lock.tryLock(5, TimeUnit.SECONDS)) {
    try {
        // 获取成功
    } finally {
        lock.unlock();
    }
} else {
    // 获取超时
}

// Condition
Condition notFull = lock.newCondition();
Condition notEmpty = lock.newCondition();

lock.lock();
try {
    while (queue.isFull()) {
        notFull.await();    // 等待"不满"条件
    }
    queue.add(item);
    notEmpty.signal();       // 通知"不空"
} finally {
    lock.unlock();
}

// 不用volatile → 线程B可能永远看不到flag的变化
// 用volatile → 线程B能立即看到flag的变化
volatile boolean flag = false;

// 线程A
flag = true;

// 线程B
while (!flag) {  // 能看到flag变为true
    // ...
}

// 典型问题: 双检锁单例
class Singleton {
    // 必须加volatile! 防止指令重排
    private static volatile Singleton instance;

    public static Singleton getInstance() {
        if (instance == null) {                 // 第一次检查
            synchronized (Singleton.class) {  // synchronized同步锁，保证线程安全
                if (instance == null) {           // 第二次检查
                    instance = new Singleton();   // ①分配内存 ②初始化 ③赋值
                    // 不加volatile: ②③可能重排为③②
                    // 导致其他线程拿到未初始化的对象
                }
            }
        }
        return instance;
    }
}

volatile int count = 0;

// ❌ count++不是原子操作(读→改→写)
// 多线程下count++仍会出问题
count++;  // 实际是: temp = count; temp = temp + 1; count = temp;

// ✅ 使用AtomicInteger
AtomicInteger count = new AtomicInteger(0);
count.incrementAndGet();

public ThreadPoolExecutor(
    int corePoolSize,        // 核心线程数 (即使空闲也不回收)
    int maximumPoolSize,     // 最大线程数
    long keepAliveTime,      // 非核心线程的空闲存活时间
    TimeUnit unit,           // 存活时间单位
    BlockingQueue<Runnable> workQueue,  // 任务队列
    ThreadFactory threadFactory,        // 线程工厂(命名等)
    RejectedExecutionHandler handler    // 拒绝策略
)

// ❌ 不推荐(队列无界, 可能OOM)
Executors.newFixedThreadPool(10);      // LinkedBlockingQueue(无界)
Executors.newSingleThreadExecutor();   // LinkedBlockingQueue(无界)
Executors.newCachedThreadPool();       // SynchronousQueue, 线程数无上限

// ✅ 推荐手动创建
new ThreadPoolExecutor(
    10, 20, 60L, TimeUnit.SECONDS,
    new ArrayBlockingQueue<>(1000),
    new ThreadPoolExecutor.CallerRunsPolicy()
);

// 异步执行
CompletableFuture<String> future = CompletableFuture.supplyAsync(() -> {
    return fetchData();  // 异步获取数据
});

// 链式操作
CompletableFuture<String> result = CompletableFuture
    .supplyAsync(() -> getUserId())          // 异步执行
    .thenApply(id -> getUser(id))            // 同步转换
    .thenApplyAsync(user -> format(user))    // 异步转换
    .exceptionally(e -> "默认值");           // 异常处理

// 多个异步任务组合
CompletableFuture<String> future1 = CompletableFuture.supplyAsync(() -> fetchFromDB());
CompletableFuture<String> future2 = CompletableFuture.supplyAsync(() -> fetchFromAPI());

// 等待所有完成
CompletableFuture.allOf(future1, future2).join();

// 等待任一完成
CompletableFuture.anyOf(future1, future2).thenAccept(System.out::println);

// 两个结果合并
future1.thenCombine(future2, (r1, r2) -> r1 + r2);

// 伪代码
boolean compareAndSwap(V expected, V newValue) {
    if (当前值 == expected) {
        当前值 = newValue;
        return true;   // 成功
    }
    return false;        // 失败, 需要重试
}

// CAS是CPU原子指令(cmpxchg), 不需要加锁

// AtomicInteger的incrementAndGet
public final int incrementAndGet() {
    return U.getAndAddInt(this, VALUE, 1) + 1;
}

// 自旋重试
public final int getAndAddInt(Object o, long offset, int delta) {
    int v;
    do {
        v = getIntVolatile(o, offset);        // 读取当前值
    } while (!compareAndSwapInt(o, offset, v, v + delta));  // CAS更新
    return v;
}

// 加版本号
AtomicStampedReference<Integer> ref = new AtomicStampedReference<>(1, 0);

int stamp = ref.getStamp();  // 获取版本号
int value = ref.getReference();

// CAS时同时检查值和版本号
ref.compareAndSet(value, newValue, stamp, stamp + 1);

ThreadLocal<User> userContext = new ThreadLocal<>();

// 设置当前线程的值
userContext.set(currentUser);

// 获取当前线程的值
User user = userContext.get();

// 使用完必须remove！
userContext.remove();

// 使用完后一定要remove！
try {
    threadLocal.set(value);
    // 业务逻辑
} finally {
    threadLocal.remove();  // 必须清理
}

// 或使用InheritableThreadLocal (父线程传递给子线程)
// 或使用TransmittableThreadLocal (线程池场景)

// 等待N个任务完成
CountDownLatch latch = new CountDownLatch(3);

// 工作线程
for (int i = 0; i < 3; i++) {
    executor.execute(() -> {
        doWork();
        latch.countDown();  // 计数减1
    });
}

latch.await();  // 主线程等待, 直到计数为0
System.out.println("所有任务完成");

// N个线程互相等待, 到齐后一起继续
CyclicBarrier barrier = new CyclicBarrier(3, () -> {
    System.out.println("所有线程到达栅栏, 一起出发!");  // 到齐后执行
});

for (int i = 0; i < 3; i++) {
    executor.execute(() -> {
        prepare();
        barrier.await();  // 等待其他线程到达
        execute();         // 所有线程到齐后一起执行
    });
}

// 限制并发数量
Semaphore semaphore = new Semaphore(3);  // 最多3个并发

for (int i = 0; i < 10; i++) {
    executor.execute(() -> {
        semaphore.acquire();  // 获取许可(可用许可-1)
        try {  // try/catch捕获异常
            accessResource();  // 最多3个线程同时执行
        } finally {
            semaphore.release();  // 释放许可
        }
    });
}

BlockingQueue<String> queue = new ArrayBlockingQueue<>(100);

// 阻塞方法
queue.put("item");     // 队列满时阻塞
queue.take();          // 队列空时阻塞

// 非阻塞方法
queue.offer("item");   // 满时返回false
queue.poll();          // 空时返回null

// 超时方法
queue.offer("item", 1, TimeUnit.SECONDS);  // 满时等1秒
queue.poll(1, TimeUnit.SECONDS);            // 空时等1秒

// 1. 构造器注入（推荐）
@Component
public class UserService {
    private final UserRepository userRepo;

    @Autowired  // Spring 4.3+单构造器可省略
    public UserService(UserRepository userRepo) {
        this.userRepo = userRepo;
    }
}

// 2. Setter注入
@Autowired
public void setUserRepo(UserRepository userRepo) {
    this.userRepo = userRepo;
}

// 3. 字段注入（不推荐，无法final，测试不便）
@Autowired
private UserRepository userRepo;

@Aspect
@Component
public class LogAspect {

    @Before("execution(* com.example.service.*.*(..))")
    public void before(JoinPoint jp) {
        // 方法执行前
    }

    @After("execution(* com.example.service.*.*(..))")
    public void after(JoinPoint jp) {
        // 方法执行后(无论是否异常)
    }

    @AfterReturning(pointcut = "execution(...)", returning = "result")
    public void afterReturning(Object result) {
        // 方法正常返回后
    }

    @AfterThrowing(pointcut = "execution(...)", throwing = "ex")
    public void afterThrowing(Exception ex) {
        // 方法抛出异常后
    }

    @Around("execution(* com.example.service.*.*(..))")
    public Object around(ProceedingJoinPoint pjp) throws Throwable {
        // 方法执行前
        long start = System.currentTimeMillis();
        Object result = pjp.proceed();  // 执行目标方法
        // 方法执行后
        long cost = System.currentTimeMillis() - start;
        return result;
    }
}

@SpringBootApplication
// 等价于:
@SpringBootConfiguration  // = @Configuration, 标识为配置类
@EnableAutoConfiguration  // ⭐ 开启自动配置
@ComponentScan            // 包扫描

@Configuration
@ConditionalOnClass(DataSource.class)  // classpath有DataSource
@ConditionalOnMissingBean(DataSource.class)  // 用户没自定义
@EnableConfigurationProperties(DataSourceProperties.class)  // 读取配置
public class DataSourceAutoConfiguration {

    @Bean
    public DataSource dataSource(DataSourceProperties properties) {
        // 根据配置创建数据源
    }
}

@Transactional(
    propagation = Propagation.REQUIRED,     // 传播行为
    isolation = Isolation.DEFAULT,          // 隔离级别
    timeout = 30,                           // 超时(秒)
    readOnly = false,                       // 只读
    rollbackFor = Exception.class           // 回滚条件
)
public void transfer(Long from, Long to, BigDecimal amount) {
    accountDao.debit(from, amount);
    accountDao.credit(to, amount);
}

@Service
public class A {
    @Autowired
    private B b;  // A依赖B
}

@Service
public class B {
    @Autowired
    private A a;  // B依赖A
}

// DefaultSingletonBeanRegistry
Map<String, Object> singletonObjects;           // 一级缓存: 成品Bean
Map<String, Object> earlySingletonObjects;      // 二级缓存: 早期Bean(可能是代理)
Map<String, ObjectFactory<?>> singletonFactories; // 三级缓存: Bean工厂

@Component
public class AuthInterceptor implements HandlerInterceptor {  // extends继承；implements实现接口

    @Override  // @Override重写父类方法
    public boolean preHandle(HttpServletRequest request,
                            HttpServletResponse response, Object handler) {
        // 请求处理前 (如权限检查)
        return true;  // true继续, false中断
    }

    @Override
    public void postHandle(HttpServletRequest request,
                          HttpServletResponse response, Object handler,
                          ModelAndView modelAndView) {
        // 请求处理后, 渲染前
    }

    @Override
    public void afterCompletion(HttpServletRequest request,
                               HttpServletResponse response, Object handler,
                               Exception ex) {
        // 请求完成后 (如资源清理)
    }
}