不做大哥好多年
xiaonaiqiang
2021-11-16
目录

09.HashMap

# 01.HashMap字典

# 1、介绍

  • HashMap 是一个散列表，它存储的内容是键值对(key-value)映射

  • HashMap 实现了 Map 接口，根据键的 HashCode 值存储数据，具有很快的访问速度

  • 最多允许一条记录的键为 null，不支持线程同步

  • HashMap 是无序的，即不会记录插入的顺序

  • HashMap 继承于AbstractMap，实现了 Map、Cloneable、java.io.Serializable 接口

# 2、HashMap创建

package com.example01;

import java.util.HashMap;
import java.util.Map;
import java.util.stream.Collectors;
import java.util.stream.Stream;

public class Test {

    public static void main(String[] strings) {
        //1、使用匿名内部类
        Map<String, String>  m1 = new HashMap<String, String>() {{
            put("k1", "v1");
            put("k2", "v2");
        }};
        System.out.println(m1); // {k1=v1, k2=v2}
        
        //2、使用Java 8的Stream和Collectors
        Map<String, String> m2 = Stream.of(new String[][] {
                { "k1", "v1" },
                { "k2", "v2" },
        }).collect(Collectors.toMap(data -> data[0], data -> data[1]));
        System.out.println(m2);  // {k1=v1, k2=v2}

        // Java9中语法 Map.of
        Map<String, String> m3 = Map.of("k1", "v1", "k2", "v2");
        System.out.println(m3);  // {k1=v1, k2=v2}
    }

}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30

# 3、字典基本操作

package com.example01;
import java.util.HashMap;

public class Test {
    public static void main(String[] strings) {
        // 1、创建 HashMap 对象 Sites
        HashMap<String, String> Sites = new HashMap<String, String>();
        //  2、添加键值对
        Sites.put("k1", "v1");
        Sites.put("k2", "v2");
        // 3、获取元素
        System.out.println(Sites.get("k1"));  // v1
        // 4、删除元素
        Sites.remove("k1");
        // 5、清空字典
         Sites.clear();
        // 6、计算大小
        System.out.println( Sites.size() );

        // 7、输出 key 和 value
        for (String i : Sites.keySet()) {
            System.out.println("key: " + i + " value: " + Sites.get(i));
        }
        // 8、返回所有 value 值
        for(String value: Sites.values()) {
            // 输出每一个value
            System.out.print(value + ", ");
        }
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30

# 02.字典常用方法

# 1、isEmpty()

  • isEmpty() 方法用于检查该 HashMap 是否为空
  • 如果 HashMap 中不包含任何键/值对的映射关系则返回 true，否则返回 false
import java.util.HashMap;

public class Test{
    public static void main(String args[]){
        HashMap<String, String> Sites = new HashMap<String, String>();
        // 检查该 HashMap 是否含有元素
        System.out.println("是否为空? " +  Sites.isEmpty() );
    }
}
1
2
3
4
5
6
7
8
9

# 2、putAll()

  • putAll() 方法将指定所有的键/值对插入到 HashMap 中
package com.example01;
import java.util.HashMap;

public class Test {
    public static void main(String[] strings) {
        // 1、创建 HashMap 对象 Sites
        HashMap<String, Integer> m1 = new HashMap<>();
        m1.put("k1", 1);
        m1.put("k2", 2);
        HashMap<String, Integer> m2 = new HashMap<>();
        m2.put("k1", 10);
        m2.put("k3", 3);

        m1.putAll(m2);
        System.out.println(m1);  //{k1=10, k2=2, k3=3}
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

# 3、putIfAbsent()

  • putIfAbsent() 方法会先判断指定的键（key）是否存在，不存在才会插入到 HashMap 中
package com.example01;
import java.util.HashMap;

public class Test {
    public static void main(String[] strings) {
        HashMap<String, Integer> m1 = new HashMap<>();
        m1.put("k1", 1);
        m1.put("k2", 2);
        // putIfAbsent 如果存在就放弃写入
        m1.putIfAbsent("k1", 10);
        m1.putIfAbsent("k3", 3);
        System.out.println(m1);
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14

# 4、containsKey()

  • containsKey() 方法检查 hashMap 中是否存在指定的 key 对应的映射关系
import java.util.HashMap;

public class Test{
    public static void main(String args[]){
        HashMap<Integer, String> sites = new HashMap<>();
        sites.put(1, "Google");
        if(sites.containsKey(1)) {
            System.out.println("key 为 1 存在于 sites 中");
        }
    }
}
1
2
3
4
5
6
7
8
9
10
11

# 5、containsValue()

  • containsValue() 方法检查 hashMap 中是否存在指定的 value 对应的映射关系
import java.util.HashMap;

public class Test{
    public static void main(String args[]){
        HashMap<Integer, String> sites = new HashMap<>();
        sites.put(1, "Google");
        if(sites.containsValue("Runoob")) {
            System.out.println("Runoob 存在于 sites 中");
        }
    }
}
1
2
3
4
5
6
7
8
9
10
11

# 6、replace()

  • replace() 方法替换 hashMap 中是指定的 key 对应的 value
package com.example01;
import java.util.HashMap;

public class Test {
    public static void main(String[] strings) {
        HashMap<Integer, String> sites = new HashMap<>();
        sites.put(1, "v1");
        sites.put(2, "v2");
        String value = sites.replace(2, "v3");
        System.out.println(sites);  // {1=v1, 2=v3}
    }
}
1
2
3
4
5
6
7
8
9
10
11
12

# 7、replaceAll()

  • replaceAll() 方法将 hashMap 中的所有映射关系替换成给定的函数所执行的结果
import java.util.HashMap;

public class Test{
    public static void main(String args[]){
        HashMap<Integer, String> sites = new HashMap<>();
        sites.put(1, "Google");
        sites.put(2, "Runoob");
        sites.put(3, "Taobao");

        sites.replaceAll((key, value) -> value.toUpperCase());
        System.out.println("Updated HashMap: " + sites);  // Updated HashMap: {1=GOOGLE, 2=RUNOOB, 3=TAOBAO}
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13

# 8、getOrDefault()

  • getOrDefault() 方法获取指定 key 对应对 value，如果找不到 key ，则返回设置的默认值
import java.util.HashMap;

public class Test{
    public static void main(String args[]){
        HashMap<Integer, String> sites = new HashMap<>();
        sites.put(1, "Google");
        String value1 = sites.getOrDefault(1, "Not Found");
        System.out.println("Value for key 1:  " + value1);  // Value for key 1:  Google
    }
}
1
2
3
4
5
6
7
8
9
10

# 9、forEach()

  • forEach() 方法用于对 HashMap 中的每个映射执行指定的操作
import java.util.HashMap;

public class Test{
    public static void main(String args[]){
        HashMap<String, Integer> prices = new HashMap<>();
        prices.put("Shoes", 200);
        prices.put("Bag", 300);
        prices.put("Pant", 150);

        prices.forEach((key, value) -> {
            System.out.print(key + "=" + value + " ");  // Pant=150 Bag=300 Shoes=200 
        });
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14

# 10、entrySet()

  • entrySet() 方法返回映射中包含的映射的 Set 视图
package com.example01;
import java.util.HashMap;
import java.util.Map;

public class Test {
    public static void main(String[] strings) {
        HashMap<String, Integer> numbers = new HashMap<>();
        numbers.put("One", 1);
        numbers.put("Two", 2);
        numbers.put("Three", 3);

        // entrySet()返回了 HashMap 中所有映射项的一个 set 集合视图
        // for-each loop 在该视图中访问了每一映射项
        for(Map.Entry<String, Integer> entry: numbers.entrySet()) {
            System.out.println(entry);
        }
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
上次更新: 2024/5/31 11:18:42
08.HashSet
10.Iterator

← 10.Iterator→

最近更新
01
04.数组双指针排序_子数组
03-25
02
08.动态规划
03-25
03
06.回溯算法
03-25
更多文章>
Theme by Vdoing | Copyright © 2019-2025 逍遥子 技术博客 京ICP备2021005373号