Map 集合

Map集合体系

/*
    V put(K key,V value)                    添加元素
    V remove(Object key)                    根据键删除键值对元素
    void clear()                            移除所有的键值对元素
    boolean containsKey(Object key)         判断集合是否包含指定的键
    boolean containsValue(Object value)     判断集合是否包含指定的值
    boolean isEmpty()                       判断集合是否为空
    int size()                              集合的长度，也就是集合中键值对的个数

V get(Object key);

    Set<K> keySet();  

Collection<V> values();

 Map.of(K k1, V v1, K k2, V v2, K k3, V v3) 静态方法

        该方法 是 Java 9 引入的一个静态工厂方法，用于快速创建 包含3个键值对的不可变 Map。

方法特点

1. ​​静态方法​​：属于 Map 接口，可以直接通过 Map.of() 调用
2. ​​泛型方法​​：支持任意类型的键(K)和值(V)
3. ​​参数列表​​：接受3个键值对（共6个参数）
4. ​​不可变Map​​：返回的 Map 是不可修改的  UnsupportedOperationException
5. ​​不允许null​​：键和值都不能为null，否则会抛出 NullPointerException
6. ​​不允许重复键​​：如果键重复，会抛出 IllegalArgumentException

使用示例

Map<String, Integer> ageMap = Map.of(
    "Alice", 25,
    "Bob", 30,
    "Charlie", 28
);

System.out.println(ageMap); // 输出: {Alice=25, Bob=30, Charlie=28}

注意事项

1. 返回的 Map 是不可变的，尝试修改会抛出 UnsupportedOperationException
2. Java 9 提供了从0到10个键值对的重载方法（Map.of() 到 Map.of(K k1, V v1, ..., K k10, V v10)）
3. 如果需要更多元素或可变 Map，可以使用 HashMap 或其他 Map 实现类

替代方案

如果需要创建可变的 Map 或包含更多元素：

// 使用 HashMap
Map<String, Integer> mutableMap = new HashMap<>();
mutableMap.put("Alice", 25);
mutableMap.put("Bob", 30);
mutableMap.put("Charlie", 28);

// 使用 Map.ofEntries 创建更多元素的不可变 Map
Map<String, Integer> largeMap = Map.ofEntries(
    entry("Alice", 25),
    entry("Bob", 30),
    entry("Charlie", 28),
    entry("David", 35)
);

这个方法为创建小型不可变 Map 提供了简洁的语法糖。

 Map.ofEntries() 静态方法

   Map.ofEntries() 是 Java 9 引入的另一个静态工厂方法，用于创建包含任意数量键值对的不可变 Map。与 Map.of() 方法相比，它更适合创建包含较多元素的 Map。

方法签名

static <K,V> Map<K,V> ofEntries(Map.Entry<? extends K,? extends V>... entries)

方法特点

1. ​​可变参数​​：可以接受任意数量的 Map.Entry 对象
2. ​​创建不可变Map​​：返回的 Map 是不可修改的
3. ​​不允许null​​：键和值都不能为null
4. ​​不允许重复键​​：如果键重复会抛出 IllegalArgumentException
5. ​​与 Map.Entry.entry() 配合使用​​：通常与 Map.entry() 静态方法一起使用

使用示例

import static java.util.Map.entry;

Map<String, Integer> ageMap = Map.ofEntries(
    entry("Alice", 25),
    entry("Bob", 30),
    entry("Charlie", 28),
    entry("David", 35),
    entry("Eve", 32)
);

System.out.println(ageMap);
// 输出: {Alice=25, Bob=30, Charlie=28, David=35, Eve=32}

与 Map.of() 的比较

注意事项

1. 返回的 Map 是不可变的，尝试修改会抛出 UnsupportedOperationException
2. 如果传入的 entries 数组为 null，会抛出 NullPointerException
3. 性能考虑：对于非常大的 Map，考虑使用 HashMap 然后包装为不可变

实际应用场景

// 创建配置 Map
Map<String, String> config = Map.ofEntries(
    entry("server.host", "localhost"),
    entry("server.port", "8080"),
    entry("db.url", "jdbc:mysql://localhost:3306/mydb"),
    entry("db.username", "admin"),
    entry("db.password", "secret")
);

// 创建枚举值映射
Map<Integer, String> statusCodes = Map.ofEntries(
    entry(200, "OK"),
    entry(404, "Not Found"),
    entry(500, "Internal Server Error")
);

   Map.ofEntries() 提供了比 Map.of() 更灵活的方式来创建包含较多元素的不可变 Map，特别适合需要一次性初始化较多键值对的场景。

*/

//1.创建Map集合的对象
Map<String, String> m = new HashMap<>();

//2.添加元素
//put方法的细节：PUT方法是有返回值的`
//添加/覆盖
//在添加数据的时候，如果键不存在，那么直接把键值对对象添加到map集合当中,方法返回null
//在添加数据的时候，如果键是存在的，那么会把原有的键值对对象覆盖，会把被覆盖的值进行返回。

遍历方法

//Map集合的第一种遍历方式

//三个课堂练习：
//
//练习一：  利用键找值的方式遍历map集合，要求：装着键的单列集合使用增强for的形式进行遍历
//练习二：  利用键找值的方式遍历map集合，要求：装着键的单列集合使用迭代器的形式进行遍历
//练习三：  利用键找值的方式遍历map集合，要求：装着键的单列集合使用lambda表达式的形式进行遍历

// 练习一：增强for循环遍历键集合
Set<String> keySet1 = map.keySet();
for (String key : keySet1) {
    String value = map.get(key);
    System.out.println("键：" + key + "，值：" + value);
}

// 练习二：迭代器遍历键集合
Set<String> keySet2 = map.keySet();
Iterator<String> iterator = keySet2.iterator();
while (iterator.hasNext()) {
    String key = iterator.next();
    String value = map.get(key);
    System.out.println("键：" + key + "，值：" + value);
}

// 练习三：Lambda表达式遍历键集合
Set<String> keySet3 = map.keySet();
keySet3.forEach(key -> {
    String value = map.get(key);
    System.out.println("键：" + key + "，值：" + value);
});

//Map集合的第二种遍历方式

//三个课堂练习：
//练习一：  通过键值对对象进行遍历map集合，要求：装着键值对对象的单列集合使用增强for的形式进行遍历
//练习二：  通过键值对对象进行遍历map集合，要求：装着键值对对象的单列集合使用迭代器的形式进行遍历
//练习三：  通过键值对对象进行遍历map集合，要求：装着键值对对象的单列集合使用lambda的形式进行遍历

// 练习一：增强for遍历Entry集合
Set<Map.Entry<String, Integer>> entrySet1 = map.entrySet();
for (Map.Entry<String, Integer> entry : entrySet1) {
    String key = entry.getKey();
    Integer value = entry.getValue();
    System.out.println(key + "：" + value);
}

// 练习二：迭代器遍历Entry集合
Set<Map.Entry<String, Integer>> entrySet2 = map.entrySet();
Iterator<Map.Entry<String, Integer>> iterator = entrySet2.iterator();
while (iterator.hasNext()) {
    Map.Entry<String, Integer> entry = iterator.next();
    String key = entry.getKey();
    Integer value = entry.getValue();
    System.out.println(key + "：" + value);
}

// 练习三：Lambda表达式遍历Entry集合
Set<Map.Entry<String, Integer>> entrySet3 = map.entrySet();
entrySet3.forEach(entry -> {
    String key = entry.getKey();
    Integer value = entry.getValue();
    System.out.println(key + "：" + value);
});
    

        //3.利用lambda表达式进行遍历
        //底层：
        //forEach其实就是利用第二种方式进行遍历，依次得到每一个键和值
        //再调用accept方法
        map.forEach(new BiConsumer<String, String>() {
            @Override
            public void accept(String key, String value) {
                System.out.println(key + "=" + value);
            }
        });

        System.out.println("-----------------------------------");

        map.forEach((String key, String value)->{
                System.out.println(key + "=" + value);
            }
        );

        System.out.println("-----------------------------------");

        map.forEach((key, value)-> System.out.println(key + "=" + value));


    }

/*
   LinkedHashMap:
       由键决定：
           有序、不重复、无索引。
       有序：
           保证存储和取出的顺序一致
       原理：
           底层数据结构是依然哈希表，只是每个键值对元素又额外的多了一个双链表的机制记录存储的顺序。
 */

HashMap在Java8后的改进（包含Java8）

HashMap初始化容量永远都是2的次幂

关于HashMap的初始化容量的设置

Hashtable

Properties

TreeMap