【笑傲Java面试笔记】容器、集合、映射

1. Collection（容器）

Collection只能容纳对象

coding：请用 Iterable 实现一个随机序列产生数

import java.util.*;

/**
 * 随机序列产生数
 * @Author: wdn
 * @Date: 2023/4/13
*/
public class RandomStringGenerator<T> implements Iterable<T> {

    private final List<T> list;

    public RandomStringGenerator(List<T> list){
        this.list = list;
    }

    @Override
    public Iterator<T> iterator() {
        return new Iterator<T>() {
            @Override
            public boolean hasNext() {
                return true;
            }

            @Override
            public T next() {
                return list.get((int) (list.size() * Math.random()));
            }
        };
    }

    public static void main(String[] args) {
        var list = Arrays.asList("List", "Array", "Tree");
        var gen = new RandomStringGenerator<String>(list);

        var it = gen.iterator();
        for (int i = 0; i < 100; i++) {
            System.out.println(it.next());
        }
    }
}

2. Set（集合）

Set：内容不重复的容器

3. Map（映射）

coding：实现LRU缓存

import java.util.Iterator;
import java.util.LinkedHashMap;
import java.util.Map;
import java.util.stream.Collectors;
import java.util.stream.StreamSupport;

/**
 * 实现LRU缓存
 * LRU：最近最少使用，即最先进来的最先走
 * @Author: wdn
 * @Date: 2023/4/13
*/
public class LRUCache<K, V> implements Iterable<K>{
    // 缓存大小
    int MAX = 3;
    // 记录缓存的数据结构
    LinkedHashMap<K, V> cache = new LinkedHashMap<>();

    public void put(K key, V value){
        if(cache.containsKey(key)){
            // 已经有该缓存
            cache.remove(key);
        }else if(cache.size() >= MAX){
            // 缓存满了，移走最早进来的缓存
            Iterator<K> it = cache.keySet().iterator();
            K first = it.next();
            cache.remove(first);
        }

        cache.put(key, value);
    }

    @Override
    public Iterator<K> iterator() {
        Iterator<Map.Entry<K, V>> it = cache.entrySet().iterator();
        // var it = cache.entrySet().iterator();
        return new Iterator<K>() {
            @Override
            public boolean hasNext() {
                return it.hasNext();
            }

            @Override
            public K next() {
                return it.next().getKey();
            }
        };

        // 等价
        // cache.keySet().iterator();
    }


    public static void main(String[] argv) {
        var lru = new LRUCache<String, Integer>();
        lru.put("A", 1);
        lru.put("B", 2);
        lru.put("C", 3);
        // 一开始的顺序
        System.out.println(
                "leave <-"+
                        StreamSupport.stream(lru.spliterator(), false)
                                .map(Object::toString)
                                .collect(Collectors.joining("<-"))
        );

        // 加入D后
        lru.put("D", 4);
        System.out.println(
                "leave <-"+
                StreamSupport.stream(lru.spliterator(), false)
                        .map(Object::toString)
                .collect(Collectors.joining("<-"))
        );

        // 加入C后
        lru.put("C", 10);
        System.out.println(
                "leave <-"+
                        StreamSupport.stream(lru.spliterator(), false)
                                .map(Object::toString)
                                .collect(Collectors.joining("<-"))
        );

    }
}