当前位置： 首页 > news >正文

Java集合应用案例面试题

news 来源：原创 2025/6/9 20:11:21

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

面试关键点

  1. 理解集合框架在实际应用中的角色
  2. 掌握不同场景下的集合选择
  3. 了解并发集合的使用场景
  4. 熟悉数据处理的最佳实践
  5. 掌握自定义数据结构的实现
  6. 理解性能优化的方法
  7. 注意内存使用和垃圾回收
  8. 考虑线程安全和并发问题

相关文章：

  • 品融电商解读：小红书KOC打法如何重构品牌增长新路径
  • Apache SeaTunnel 构建实时数据同步管道（最新版）
  • 问题记录，服务工厂模式的必要性
  • LangChain大模型应用开发：LangGraph快速构建Agent工作流应用
  • 无法打开数据库 CAUsers\Public\EPLAN(Data\翻译\Company name\Translate.mdb。
  • Golang学习笔记_38——享元模式
  • 河北专升本报名照如何审核通过？
  • Linux9-进程间通信-管道、信号
  • C++算法基础语法-13
  • 单链表删除算法(p=L； j=0；与p=p-＞next；j=1的辨析)
  • Flutter系列教程之(3)——简单的APP实现
  • qtcreator上使用opencv报错
  • 水利工程安全包括哪几个方面
  • MacOS 终端选型
  • 实现分布式限流开源项目
  • 服务器硬件老化导致性能下降的排查与优化
  • 如何基于PyTorch做二次开发
  • 大白话React第六章深入学习 React 高级特性及生态
  • GGUF 文件格式全解析
  • 问题：undefined reference to `pthread_mutexattr_init‘
  • 深圳响应式网站建设/厦门百度seo排名
  • 安徽合肥中国建设银行网站首页/长沙企业关键词优化哪家好
  • 深圳网站设计公司排名前十强/洛阳seo网络推广
  • 济南外贸网站/今日山东新闻头条
  • 株洲新闻网红网株洲站/google搜索引擎入口下载
  • 广东省政府网站集约化平台建设/抖音推广