Java集合应用案例面试题
缓存实现
Q1: 如何使用LinkedHashMap实现LRU缓存？
public class LRUCacheExample {
// 1. 基于LinkedHashMap实现的LRU缓存
public 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;
}
}
// 2. 线程安全的LRU缓存
public class ConcurrentLRUCache<K, V> {
private final LRUCache<K, V> cache;
private final ReadWriteLock lock = new ReentrantReadWriteLock();
public ConcurrentLRUCache(int capacity) {
this.cache = new LRUCache<>(capacity);
}
public V get(K key) {
lock.readLock().lock();
try {
return cache.get(key);
} finally {
lock.readLock().unlock();
}
}
public V put(K key, V value) {
lock.writeLock().lock();
try {
return cache.put(key, value);
} finally {
lock.writeLock().unlock();
}
}
}
// 3. 使用示例
public void demonstrateCache() {
LRUCache<String, String> cache = new LRUCache<>(3);
cache.put("1", "one"); // {1=one}
cache.put("2", "two"); // {1=one, 2=two}
cache.put("3", "three"); // {1=one, 2=two, 3=three}
cache.get("1"); // 访问1，1移到最后
cache.put("4", "four"); // 2被移除，{1=one, 3=three, 4=four}
}
}
消息队列
Q2: 如何实现一个简单的消息队列系统？
public class MessageQueueExample {
// 1. 消息定义
public class Message {
private String id;
private String content;
private long timestamp;
private int priority;
// 构造方法和getter/setter
}
// 2. 优先级消息队列
public class PriorityMessageQueue {
private final PriorityBlockingQueue<Message> queue;
public PriorityMessageQueue() {
queue = new PriorityBlockingQueue<>(11,
(m1, m2) -> Integer.compare(m2.priority, m1.priority));
}
public void send(Message message) {
queue.offer(message);
}
public Message receive() throws InterruptedException {
return queue.take();
}
}
// 3. 多主题消息系统
public class TopicMessageSystem {
private final ConcurrentHashMap<String, BlockingQueue<Message>> topics;
public TopicMessageSystem() {
topics = new ConcurrentHashMap<>();
}
public void createTopic(String topic) {
topics.putIfAbsent(topic, new LinkedBlockingQueue<>());
}
public void publish(String topic, Message message) {
BlockingQueue<String> queue = topics.get(topic);
if (queue != null) {
queue.offer(message);
}
}
public Message subscribe(String topic) throws InterruptedException {
BlockingQueue<Message> queue = topics.get(topic);
if (queue != null) {
return queue.take();
}
return null;
}
}
}
数据处理
Q3: 如何使用集合框架处理大数据集？
public class DataProcessingExample {
// 1. 分批处理
public class BatchProcessor<T> {
private final List<T> data;
private final int batchSize;
public BatchProcessor(List<T> data, int batchSize) {
this.data = data;
this.batchSize = batchSize;
}
public void process(Consumer<List<T>> consumer) {
for (int i = 0; i < data.size(); i += batchSize) {
List<T> batch = data.subList(
i, Math.min(i + batchSize, data.size())
);
consumer.accept(batch);
}
}
}
// 2. 并行流处理
public class ParallelProcessor<T> {
private final Collection<T> data;
public ParallelProcessor(Collection<T> data) {
this.data = data;
}
public <R> List<R> process(Function<T, R> mapper) {
return data.parallelStream()
.map(mapper)
.collect(Collectors.toList());
}
public <R> List<R> processWithFilter(
Predicate<T> filter, Function<T, R> mapper) {
return data.parallelStream()
.filter(filter)
.map(mapper)
.collect(Collectors.toList());
}
}
// 3. 使用示例
public void demonstrateProcessing() {
List<Integer> numbers = new ArrayList<>();
for (int i = 0; i < 1000000; i++) {
numbers.add(i);
}
// 分批处理
BatchProcessor<Integer> batchProcessor =
new BatchProcessor<>(numbers, 1000);
batchProcessor.process(batch -> {
// 处理每一批数据
batch.forEach(System.out::println);
});
// 并行处理
ParallelProcessor<Integer> parallelProcessor =
new ParallelProcessor<>(numbers);
List<Integer> result = parallelProcessor.processWithFilter(
n -> n % 2 == 0, // 过滤偶数
n -> n * 2 // 将数字翻倍
);
}
}
数据结构
Q4: 如何实现常见的数据结构？
public class DataStructureExample {
// 1. 实现栈
public class Stack<E> {
private final Deque<E> deque = new ArrayDeque<>();
public void push(E element) {
deque.addFirst(element);
}
public E pop() {
return deque.removeFirst();
}
public E peek() {
return deque.peekFirst();
}
public boolean isEmpty() {
return deque.isEmpty();
}
}
// 2. 实现队列
public class Queue<E> {
private final Deque<E> deque = new ArrayDeque<>();
public void enqueue(E element) {
deque.addLast(element);
}
public E dequeue() {
return deque.removeFirst();
}
public E peek() {
return deque.peekFirst();
}
public boolean isEmpty() {
return deque.isEmpty();
}
}
// 3. 实现优先级队列
public class PriorityQueue<E> {
private final java.util.PriorityQueue<E> queue;
public PriorityQueue(Comparator<? super E> comparator) {
this.queue = new java.util.PriorityQueue<>(comparator);
}
public void add(E element) {
queue.offer(element);
}
public E remove() {
return queue.poll();
}
public E peek() {
return queue.peek();
}
}
}
实际应用
Q5: 如何在实际项目中应用集合框架？
public class RealWorldExample {
// 1. 购物车实现
public class ShoppingCart {
private final Map<Product, Integer> items = new HashMap<>();
public void addItem(Product product, int quantity) {
items.merge(product, quantity, Integer::sum);
}
public void removeItem(Product product, int quantity) {
items.computeIfPresent(product, (k, v) -> {
int newQuantity = v - quantity;
return newQuantity <= 0 ? null : newQuantity;
});
}
public double getTotal() {
return items.entrySet().stream()
.mapToDouble(e -> e.getKey().getPrice() * e.getValue())
.sum();
}
}
// 2. 任务调度系统
public class TaskScheduler {
private final PriorityBlockingQueue<Task> taskQueue;
private final ScheduledExecutorService executor;
public TaskScheduler(int threadCount) {
this.taskQueue = new PriorityBlockingQueue<>();
this.executor = Executors.newScheduledThreadPool(threadCount);
}
public void scheduleTask(Task task) {
taskQueue.offer(task);
executor.schedule(() -> {
Task nextTask = taskQueue.poll();
if (nextTask != null) {
executeTask(nextTask);
}
}, task.getDelay(), TimeUnit.MILLISECONDS);
}
private void executeTask(Task task) {
// 执行任务
}
}
// 3. 缓存系统
public class CacheSystem<K, V> {
private final ConcurrentHashMap<K, V> cache;
private final ScheduledExecutorService cleaner;
public CacheSystem(long cleanupInterval) {
this.cache = new ConcurrentHashMap<>();
this.cleaner = Executors.newSingleThreadScheduledExecutor();
// 定期清理过期数据
cleaner.scheduleAtFixedRate(
this::cleanup,
cleanupInterval,
cleanupInterval,
TimeUnit.MILLISECONDS
);
}
public V get(K key) {
return cache.get(key);
}
public void put(K key, V value) {
cache.put(key, value);
}
private void cleanup() {
// 清理逻辑
}
}
}
Q6: 如何处理高并发场景下的集合操作？
public class ConcurrentOperationExample {
// 1. 并发计数器
public class ConcurrentCounter {
private final ConcurrentHashMap<String, AtomicLong> counters;
public ConcurrentCounter() {
this.counters = new ConcurrentHashMap<>();
}
public void increment(String key) {
counters.computeIfAbsent(key, k -> new AtomicLong())
.incrementAndGet();
}
public long getCount(String key) {
AtomicLong counter = counters.get(key);
return counter != null ? counter.get() : 0;
}
}
// 2. 并发请求限制器
public class RequestLimiter {
private final ConcurrentHashMap<String, Deque<Long>> requests;
private final int maxRequests;
private final long timeWindow;
public RequestLimiter(int maxRequests, long timeWindow) {
this.requests = new ConcurrentHashMap<>();
this.maxRequests = maxRequests;
this.timeWindow = timeWindow;
}
public boolean isAllowed(String key) {
long now = System.currentTimeMillis();
Deque<Long> times = requests.computeIfAbsent(
key, k -> new ConcurrentLinkedDeque<>()
);
while (!times.isEmpty() && times.getFirst() < now - timeWindow) {
times.removeFirst();
}
if (times.size() < maxRequests) {
times.addLast(now);
return true;
}
return false;
}
}
// 3. 并发缓存
public class ConcurrentCache<K, V> {
private final ConcurrentHashMap<K, V> cache;
private final int maxSize;
public ConcurrentCache(int maxSize) {
this.cache = new ConcurrentHashMap<>();
this.maxSize = maxSize;
}
public V get(K key, Supplier<V> loader) {
return cache.computeIfAbsent(key, k -> {
if (cache.size() >= maxSize) {
// 移除一些缓存项
Iterator<Map.Entry<K, V>> it = cache.entrySet().iterator();
if (it.hasNext()) {
it.next();
it.remove();
}
}
return loader.get();
});
}
}
}
面试关键点
- 理解集合框架在实际应用中的角色
- 掌握不同场景下的集合选择
- 了解并发集合的使用场景
- 熟悉数据处理的最佳实践
- 掌握自定义数据结构的实现
- 理解性能优化的方法
- 注意内存使用和垃圾回收
- 考虑线程安全和并发问题