Java面试题

☕ Java基础

1. Java语言特性

Q: Java的主要特性有哪些？

A:

• 面向对象：封装、继承、多态
• 平台无关性：一次编写，到处运行
• 自动内存管理：垃圾回收机制
• 多线程支持：内置线程支持
• 安全性：字节码验证、安全管理器
• 健壮性：强类型检查、异常处理

2. 数据类型

Q: Java中的基本数据类型有哪些？

A:

• 整型：byte(1字节)、short(2字节)、int(4字节)、long(8字节)
• 浮点型：float(4字节)、double(8字节)
• 字符型：char(2字节)
• 布尔型：boolean(1位)

3. String相关

Q: String、StringBuilder、StringBuffer的区别？

A:

• String：不可变，线程安全，适合少量字符串操作
• StringBuilder：可变，非线程安全，适合单线程大量字符串操作
• StringBuffer：可变，线程安全，适合多线程大量字符串操作

// 性能对比示例
public class StringPerformance {
    public static void main(String[] args) {
        int n = 10000;
        
        // String - 性能最差
        long start = System.currentTimeMillis();
        String str = "";
        for (int i = 0; i < n; i++) {
            str += "a";
        }
        System.out.println("String: " + (System.currentTimeMillis() - start));
        
        // StringBuilder - 性能最好
        start = System.currentTimeMillis();
        StringBuilder sb = new StringBuilder();
        for (int i = 0; i < n; i++) {
            sb.append("a");
        }
        System.out.println("StringBuilder: " + (System.currentTimeMillis() - start));
    }
}

🧵 多线程

1. 线程创建方式

Q: Java中创建线程的方式有哪些？

A:

1. 继承Thread类
2. 实现Runnable接口
3. 实现Callable接口
4. 使用线程池

// 方式1：继承Thread
class MyThread extends Thread {
    @Override
    public void run() {
        System.out.println("Thread running");
    }
}

// 方式2：实现Runnable
class MyRunnable implements Runnable {
    @Override
    public void run() {
        System.out.println("Runnable running");
    }
}

// 方式3：实现Callable
class MyCallable implements Callable<String> {
    @Override
    public String call() throws Exception {
        return "Callable result";
    }
}

// 使用示例
public class ThreadExample {
    public static void main(String[] args) {
        // 方式1
        new MyThread().start();
        
        // 方式2
        new Thread(new MyRunnable()).start();
        
        // 方式3
        ExecutorService executor = Executors.newSingleThreadExecutor();
        Future<String> future = executor.submit(new MyCallable());
        
        // 方式4：线程池
        ThreadPoolExecutor pool = new ThreadPoolExecutor(
            2, 4, 60L, TimeUnit.SECONDS,
            new LinkedBlockingQueue<>(100)
        );
        pool.execute(() -> System.out.println("Pool task"));
    }
}

2. 线程同步

Q: Java中的同步机制有哪些？

A:

• synchronized关键字
• ReentrantLock
• volatile关键字
• 原子类(Atomic)
• CountDownLatch、Semaphore等

public class SynchronizationExample {
    private int count = 0;
    private final Object lock = new Object();
    private final ReentrantLock reentrantLock = new ReentrantLock();
    private volatile boolean flag = false;
    private final AtomicInteger atomicCount = new AtomicInteger(0);
    
    // synchronized方法
    public synchronized void syncMethod() {
        count++;
    }
    
    // synchronized代码块
    public void syncBlock() {
        synchronized (lock) {
            count++;
        }
    }
    
    // ReentrantLock
    public void lockMethod() {
        reentrantLock.lock();
        try {
            count++;
        } finally {
            reentrantLock.unlock();
        }
    }
    
    // 原子操作
    public void atomicMethod() {
        atomicCount.incrementAndGet();
    }
}

🗂️ 集合框架

1. 集合体系

Q: Java集合框架的层次结构？

A: