Java Map集合 #

Map<String, Integer> map = new HashMap<>();

// 添加
map.put("A", 1);
map.put("B", 2);
map.putIfAbsent("C", 3);  // 键不存在时添加

// 获取
Integer value = map.get("A");
Integer defaultValue = map.getOrDefault("D", 0);

// 删除
map.remove("A");
map.remove("B", 2);  // 键值都匹配才删除

// 判断
map.containsKey("A");
map.containsValue(1);
map.isEmpty();
map.size();

// 替换
map.replace("A", 10);
map.replace("A", 10, 20);  // 旧值匹配才替换

// 清空
map.clear();

Map<String, Integer> map = new HashMap<>();

// 添加
map.put("张三", 25);
map.put("李四", 30);
map.put("王五", 28);

// 获取
System.out.println(map.get("张三"));  // 25
System.out.println(map.get("赵六"));  // null

// 遍历键
for (String key : map.keySet()) {
    System.out.println(key + ": " + map.get(key));
}

// 遍历值
for (Integer value : map.values()) {
    System.out.println(value);
}

// 遍历键值对
for (Map.Entry<String, Integer> entry : map.entrySet()) {
    System.out.println(entry.getKey() + ": " + entry.getValue());
}

// forEach
map.forEach((k, v) -> System.out.println(k + ": " + v));

Map<String, Integer> map = new HashMap<>();

// 批量添加
Map<String, Integer> other = new HashMap<>();
other.put("A", 1);
other.put("B", 2);
map.putAll(other);

// 计算方法
map.compute("A", (k, v) -> v == null ? 1 : v + 1);
map.computeIfAbsent("B", k -> 2);  // 键不存在时计算
map.computeIfPresent("A", (k, v) -> v * 2);  // 键存在时计算

// 合并
map.merge("A", 1, Integer::sum);  // 存在则相加，不存在则设置

Map<String, Integer> map = new LinkedHashMap<>();

map.put("C", 3);
map.put("A", 1);
map.put("B", 2);

System.out.println(map);  // {C=3, A=1, B=2}（保持插入顺序）

public class LRUCache<K, V> extends LinkedHashMap<K, V> {
    private final int maxSize;
    
    public LRUCache(int maxSize) {
        super(maxSize, 0.75f, true);  // accessOrder=true
        this.maxSize = maxSize;
    }
    
    @Override
    protected boolean removeEldestEntry(Map.Entry<K, V> eldest) {
        return size() > maxSize;
    }
}

// 使用
LRUCache<String, String> cache = new LRUCache<>(3);
cache.put("A", "1");
cache.put("B", "2");
cache.put("C", "3");
cache.get("A");  // 访问A
cache.put("D", "4");  // B会被移除（最久未访问）
System.out.println(cache);  // {C=3, A=1, D=4}

Map<String, Integer> map = new TreeMap<>();

map.put("C", 3);
map.put("A", 1);
map.put("B", 2);

System.out.println(map);  // {A=1, B=2, C=3}（按键排序）

// 降序
Map<String, Integer> map = new TreeMap<>(Comparator.reverseOrder());

// 按值排序
Map<String, Integer> map = new TreeMap<>();
map.put("A", 3);
map.put("B", 1);
map.put("C", 2);

List<Map.Entry<String, Integer>> list = new ArrayList<>(map.entrySet());
list.sort(Map.Entry.comparingByValue());

TreeMap<String, Integer> map = new TreeMap<>();
map.put("A", 1);
map.put("C", 3);
map.put("E", 5);

// 查找
System.out.println(map.firstKey());      // A
System.out.println(map.lastKey());       // E
System.out.println(map.lowerKey("C"));   // A
System.out.println(map.higherKey("C"));  // E

// 子图
System.out.println(map.headMap("C"));    // {A=1}
System.out.println(map.tailMap("C"));    // {C=3, E=5}
System.out.println(map.subMap("A", "E")); // {A=1, C=3}

Map<String, Integer> map = new HashMap<>();
map.put("A", 1);
map.put("B", 2);

// 遍历键
for (String key : map.keySet()) {
    System.out.println(key + ": " + map.get(key));
}

for (Integer value : map.values()) {
    System.out.println(value);
}

// 推荐方式
for (Map.Entry<String, Integer> entry : map.entrySet()) {
    System.out.println(entry.getKey() + ": " + entry.getValue());
}

// forEach
map.forEach((k, v) -> System.out.println(k + ": " + v));

// Stream
map.entrySet().stream()
    .filter(e -> e.getValue() > 1)
    .forEach(e -> System.out.println(e.getKey() + ": " + e.getValue()));