HashMap(常用)方法

短命女 2023-03-01 05:40 10阅读 0赞

### 文章目录 ###

*   *  [Hashmap的存值：][Hashmap]
     *  [Hashmap的取值：][Hashmap 1]
     *  [Hashmap的判断为空][Hashmap 2]
     *  [Hashmap判断是否含有key：][Hashmap_key]
     *  [Hashmap判断是否含有value：][Hashmap_value]
     *  [Hashmap删除这个key值下的value：][Hashmap_key_value]
     *  [Hashmap显示所有的value值：][Hashmap_value 1]
     *  [Hashmap的元素个数：][Hashmap 3]
     *  [Hashmap删除这个key值下的value：][Hashmap_key_value 1]
     *  [Hashmap显示所有的key和value：][Hashmap_key_value 2]
     *  [Hashmap添加另一个同一类型的map下的所有值：][Hashmap_map]
     *  [Hashmap删除这个key和value：][Hashmap_key_value 3]
     *  [Hashmap替换这个key的value：(java8)][Hashmap_key_value_java8]
     *  [清空Hashmap：][Hashmap 4]
     *  [Hashmap的克隆：][Hashmap 5]
     *  [如果当前 Map 不存在键 key 或者该 key 关联的值为 null，那么就执行 put(key, value)；否则，便不执行 put 操作：（java8新增方法）][Map _ key _ key _ null_ put_key_ value_ put _java8]
     *  [如果当前 Map 的value为xx时则值为xx否则为xx：（java8新增方法）compute 方法更适用于更新 key 关联的 value 时，新值依赖于旧值的情况][Map _value_xx_xx_xx_java8_compute _ key _ value]

## Hashmap的存值： ##

public static void main(String[] args) {
             ///*Integer*/map.put("1", 1);//向map中添加值(返回这个key以前的值,如果没有返回null)
             HashMap<String, Integer> map=new HashMap<>();
             System.out.println(map.put("1", 1));//null
             System.out.println(map.put("1", 2));//1
         }

## Hashmap的取值： ##

public static void main(String[] args) {
            HashMap<String, Integer> map=new HashMap<>();
            map.put("DEMO", 1);
            /*Value的类型*///得到map中key相对应的value的值
            System.out.println(map.get("1"));//null
            System.out.println(map.get("DEMO"));//1
        }

## Hashmap的判断为空 ##

public static void main(String[] args) {
            HashMap<String, Integer> map=new HashMap<>();
            /*boolean*///判断map是否为空
            System.out.println(map.isEmpty());//true
            map.put("DEMO", 1);
            System.out.println(map.isEmpty());//false
        }

## Hashmap判断是否含有key： ##

public static void main(String[] args) {
            HashMap<String, Integer> map=new HashMap<>();
            /*boolean*///判断map中是否存在这个key
            System.out.println(map.containsKey("DEMO"));//false
            map.put("DEMO", 1);
            System.out.println(map.containsKey("DEMO"));//true
        }

## Hashmap判断是否含有value： ##

public static void main(String[] args) {
            HashMap<String, Integer> map=new HashMap<>();
            /*boolean*///判断map中是否存在这个value
            System.out.println(map.containsValue(1));//false
            map.put("DEMO", 1);
            System.out.println(map.containsValue(1));//true
        }

## Hashmap删除这个key值下的value： ##

public static void main(String[] args) {
            HashMap<String, Integer> map=new HashMap<>();
            /*Integer*///删除key值下的value
            System.out.println(map.remove("1"));//null
            map.put("DEMO", 2);
            System.out.println(map.remove("DEMO"));//2(删除的值)
        }

## Hashmap显示所有的value值： ##

public static void main(String[] args) {
            HashMap<String, Integer> map=new HashMap<>();
            /*Collection<Integer>*///显示所有的value值
            System.out.println(map.values());//[]
            map.put("DEMO1", 1);
            map.put("DEMO2", 2);
            System.out.println(map.values());//[1, 2]
        }

## Hashmap的元素个数： ##

public static void main(String[] args) {
            HashMap<String, Integer> map=new HashMap<>();
            /*int*///显示map里的值得数量
            System.out.println(map.size());//0
            map.put("DEMO1", 1);
            System.out.println(map.size());//1
            map.put("DEMO2", 2);
            System.out.println(map.size());//2
        }

## Hashmap删除这个key值下的value： ##

public static void main(String[] args) {
            HashMap<String, Integer> map=new HashMap<>();
            /*SET<String>*///显示map所有的key
            System.out.println(map.keySet());//[]
            map.put("DEMO1", 1);
            System.out.println(map.keySet());//[DEMO1]
            map.put("DEMO2", 2);
            System.out.println(map.keySet());//[DEMO1, DEMO2]
        }

## Hashmap显示所有的key和value： ##

public static void main(String[] args) {
            HashMap<String, Integer> map=new HashMap<>();
            /*SET<map<String,Integer>>*///显示所有的key和value
            System.out.println(map.entrySet());//[]
            map.put("DEMO1", 1);
            System.out.println(map.entrySet());//[DEMO1=1]
            map.put("DEMO2", 2);
            System.out.println(map.entrySet());//[DEMO1=1, DEMO2=2]
        }

## Hashmap添加另一个同一类型的map下的所有值： ##

public static void main(String[] args) {
            HashMap<String, Integer> map=new HashMap<>();
            HashMap<String, Integer> map1=new HashMap<>();
            /*void*///将同一类型的map添加到另一个map中
            map1.put("DEMO1", 1);
            map.put("DEMO2", 2);
            System.out.println(map);//{DEMO2=2}
            map.putAll(map1);
            System.out.println(map);//{DEMO1=1, DEMO2=2}
        }

## Hashmap删除这个key和value： ##

public static void main(String[] args) {
            HashMap<String, Integer> map=new HashMap<>();
            /*boolean*///删除这个键值对
            map.put("DEMO1", 1);
            map.put("DEMO2", 2);
            System.out.println(map);//{DEMO1=1, DEMO2=2}
            System.out.println(map.remove("DEMO2", 1));//false
            System.out.println(map.remove("DEMO2", 2));//true
            System.out.println(map);//{DEMO1=1}
        }

## Hashmap替换这个key的value：(java8) ##

public static void main(String[] args) {
            HashMap<String, Integer> map=new HashMap<>();
            /*value*///判断map中是否存在这个key
            map.put("DEMO1", 1);
            map.put("DEMO2", 2);
            System.out.println(map);//{DEMO1=1, DEMO2=2}
            System.out.println(map.replace("DEMO2", 1));//2
            System.out.println(map);//{DEMO1=1, DEMO2=1}
        }

## 清空Hashmap： ##

public static void main(String[] args) {
            HashMap<String, Integer> map=new HashMap<>();
            /*void*///清空map
            map.put("DEMO1", 1);
            map.put("DEMO2", 2);
            System.out.println(map);//{DEMO1=1, DEMO2=2}
            map.clear();//2
            System.out.println(map);//{}
        }

## Hashmap的克隆： ##

public static void main(String[] args) {
            HashMap<String, Integer> map=new HashMap<>();
            /*object*///克隆这个map
            map.put("DEMO1", 1);
            map.put("DEMO2", 2);
            System.out.println(map.clone());//{DEMO1=1, DEMO2=2}
            Object clone = map.clone();
            System.out.println(clone);//{DEMO1=1, DEMO2=2}
        }

## 如果当前 Map 不存在键 key 或者该 key 关联的值为 null，那么就执行 put(key, value)；否则，便不执行 put 操作：（java8新增方法） ##

public static void main(String[] args) {
    		HashMap<String, Integer> map=new HashMap<>();
    		/*boolean*///判断map中是否存在这个key
    		map.put("DEMO1", 1);
    		map.put("DEMO2", 2);
    		System.out.println(map);//{DEMO1=1, DEMO2=2}
    		System.out.println(map.putIfAbsent("DEMO1", 12222));//1
    		System.out.println(map.putIfAbsent("DEMO3", 12222));//null
    		System.out.println(map);//{DEMO1=1, DEMO2=2}
    	}

## 如果当前 Map 的value为xx时则值为xx否则为xx：（java8新增方法）compute 方法更适用于更新 key 关联的 value 时，新值依赖于旧值的情况 ##

public static void main(String[] args) {
            HashMap<String, Integer> map=new HashMap<>();
            /*boolean*///当这个value为null时为1，否则为3
            map.put("DEMO1", 1);
            map.put("DEMO2", 2);
            System.out.println(map);//{DEMO1=1, DEMO2=2}
            map.compute("DEMO2", (k,v)->v==null?1:3);
            System.out.println(map);//{DEMO1=1, DEMO2=3}
        }

map.computeIfAbsent(key, mappingFunction);
    map.computeIfPresent(key, remappingFunction);
    map.forEach());
    map.merge(key, value, remappingFunction);
    map.getOrDefault(key, defaultValue);

[Hashmap]: https://blog.csdn.net/chenyao1994/article/details/92802458#Hashmap_1
[Hashmap 1]: https://blog.csdn.net/chenyao1994/article/details/92802458#Hashmap_10
[Hashmap 2]: https://blog.csdn.net/chenyao1994/article/details/92802458#Hashmap_20
[Hashmap_key]: https://blog.csdn.net/chenyao1994/article/details/92802458#Hashmapkey_30
[Hashmap_value]: https://blog.csdn.net/chenyao1994/article/details/92802458#Hashmapvalue_40
[Hashmap_key_value]: https://blog.csdn.net/chenyao1994/article/details/92802458#Hashmapkeyvalue_50
[Hashmap_value 1]: https://blog.csdn.net/chenyao1994/article/details/92802458#Hashmapvalue_60
[Hashmap 3]: https://blog.csdn.net/chenyao1994/article/details/92802458#Hashmap_71
[Hashmap_key_value 1]: https://blog.csdn.net/chenyao1994/article/details/92802458#Hashmapkeyvalue_83
[Hashmap_key_value 2]: https://blog.csdn.net/chenyao1994/article/details/92802458#Hashmapkeyvalue_95
[Hashmap_map]: https://blog.csdn.net/chenyao1994/article/details/92802458#Hashmapmap_107
[Hashmap_key_value 3]: https://blog.csdn.net/chenyao1994/article/details/92802458#Hashmapkeyvalue_120
[Hashmap_key_value_java8]: https://blog.csdn.net/chenyao1994/article/details/92802458#Hashmapkeyvaluejava8_133
[Hashmap 4]: https://blog.csdn.net/chenyao1994/article/details/92802458#Hashmap_145
[Hashmap 5]: https://blog.csdn.net/chenyao1994/article/details/92802458#Hashmap_157
[Map _ key _ key _ null_ put_key_ value_ put _java8]: https://blog.csdn.net/chenyao1994/article/details/92802458#_Map__key__key__null_putkey_value_put_java8_169
[Map _value_xx_xx_xx_java8_compute _ key _ value]: https://blog.csdn.net/chenyao1994/article/details/92802458#_Map_valuexxxxxxjava8compute__key__value__183