java中的HsahMap

HsahMap

HashMap 是 Java 中最常用的集合类之一,它实现了 Map 接口,基于哈希表存储键值对
HashMap的存储是无顺序的
HashMap存储的是键值对(key-value)其中键key是唯一的,值(value)可以重复。
HashMap的底层是数组和链表

HashMap的常见方法

添加方法:
1,put(K key, V value):将键值对插入到 HashMap 中。如果添加的是新的内容,返回null。如果键已经存在,则更新对应的值,返回更新前的值
2,putIfAbsent(K key, V value) 如果没有这个key,新增上去。有这个key,就不新增上去

更改方法:
1,replace(K key, V value) 修改数据,将key是张三的,更新为19。如果没有这个key,则不做替换(理解什么也不做)

获取方法:
1,get(Object key):根据键获取对应的值。如果键不存在,返回 null。  
2,keySet():返回的类型是Set, 返回的值是HashMap中所有键的集合。
3,values():返回类型是Collection,返回的值是HashMap 中所有值的集合。
4,entrySet():返回 HashMap 中所有键值对的集合。返回的是Set类型。
5,size(): 返回 HashMap 中键值对的数量。返回类型是int

删除方法:
1,remove(Object key):根据键删除对应的键值对。移除不存在的键名,返回的是 null  
2,remove(Object key,Object value):删除对应的键名和对应的值。返回的类型是布尔
3,clear():清空 HashMap,移除所有键值对。

检查元素:
1,containsKey(Object key):返回的类型是布尔,判断 HashMap 中是否包含指定的键。
2,containsValue(V value) 检查是否包含某个value值,如果包含返回true,不包含返回false
3,isEmpty(): 检查 HashMap 是否为空。返回的是布尔值。

克隆方法:
1,lone()来复制一个 HashMap 对象,返回值是一个对象,因此需要使用强制转化,是一个浅拷贝。
总结:下次学习某个类型的方法,也像这样归一下类。会好很多。

新增数据 put

package part;
// HashMap在java->util这个包下
import java.util.HashMap;
public class Java01 {
    public static void main(String[] args)  {
        HashMap map = new HashMap();
        map.put("zhangsan", "18");
        map.put("lisi", "17");
        // 输出 {lisi=17, zhangsan=18}
        System.out.println(map);
    }
}

put新增内容,返回null, 如果键已经存在,则更新对应的值

package part;
// HashMap在java->util这个包下
import java.util.HashMap;
public class Java01 {
    public static void main(String[] args)  {
        HashMap map = new HashMap();
        map.put("zhangsan", "18");
        // 如果添加的是新的内容,返回null。
        System.out.println(map.put("lisi", "17"));
        // 这次的键名和第一次的键名,重复了,就会出现覆盖哈。因为键名是唯一的。如果键已经存在,返回更新前的值。输出18
        System.out.println( map.put("zhangsan", "25"));
        // 输出 {lisi=17, zhangsan=25}
        System.out.println(map);
    }
}

HashMap存储的是键值对,键key是唯一的


package part;
// HashMap在java->util这个包下
import java.util.HashMap;
public class Java01 {
    public static void main(String[] args)  {
        HashMap map = new HashMap();
        map.put("zhangsan", "18");
        map.put("lisi", "17");
        // 这次的键名和第一次的键名,重复了,就会出现覆盖哈。因为键名是唯一的
        map.put("zhangsan", "25");
        // 输出 {lisi=17, zhangsan=25}
        System.out.println(map);
    }
}

putIfAbsent 如果没有这个key,新增上去。 有这个key,就不新增上去

package part;
// HashMap在java->util这个包下
import java.util.HashMap;
public class Java01 {
    public static void main(String[] args) {
        HashMap map = new HashMap();
        map.put("zhangsan", "18");
        // 如果没有这个key,新增上去。 有这个key,就不新增上去
        map.putIfAbsent("zhangsan", "19");
        System.out.println(map);
    }
}

修改数据:替换replace

package part;
// HashMap在java->util这个包下
import java.util.HashMap;
public class Java01 {
    public static void main(String[] args) {
        HashMap map = new HashMap();
        map.put("zhangsan", "18");
        // 将key是张三的,更新为19。如果没有这个key,则不做替换(理解什么也不做)
        map.replace("zhangsan", "199");
        // 什么也不会做
        map.replace("lisi", "19");
        System.out.println(map); // {zhangsan=199}
    }
}

keySet():返回 HashMap 中所有键的集合。


package part;
// HashMap在java->util这个包下
import java.util.HashMap;
import java.util.Set;
public class Java01 {
    public static void main(String[] args) {
        HashMap map = new HashMap();
        map.put("zhangsan", "18");
        map.put("lisi", "19");
        // keySet():返回 HashMap 中所有键的集合,返回类型是Set
        Set set = map.keySet();
        System.out.println(set); // [lisi, zhangsan]
    }
}

values():返回 HashMap 中所有值的集合

package part;
// HashMap在java->util这个包下
import java.util.Collection;
import java.util.HashMap;
import java.util.Set;

public class Java01 {
    public static void main(String[] args) {
        HashMap map = new HashMap();
        map.put("zhangsan", "18");
        map.put("lisi", "19");
        // map.values():返回 HashMap 中所有值的集合。类型是: Collection
        Collection list = map.values();
        System.out.println(list); // [19, 18]
    }
}

增强for循环遍历

public class Java01 {
    public static void main(String[] args) {
        HashMap map = new HashMap();
        map.put("zhangsan", "18");
        map.put("lisi", "19");
        // 获取所有键名的集合
        Set set = map.keySet();
        for (Object key : set) {
            // 输出 19  18
            System.out.println(map.get(key));
        }
    }
}

containsKey(Object key):判断 HashMap 中是否包含指定的键,返回是一个布尔值

package part;
// HashMap在java->util这个包下
import java.util.Collection;
import java.util.HashMap;
import java.util.Set;

public class Java01 {
    public static void main(String[] args) {
        HashMap map = new HashMap();
        map.put("zhangsan", "18");
        map.put("lisi", "19");
        // containsKey(Object key):判断 HashMap 中是否包含指定的键。返回是一个布尔值
        Boolean bool = map.containsKey("zhangsan");
        System.out.println(bool); // true
    }
}

containsValue(V value) 检查是否包含某个value值,如果包含返回true,不包含返回false


package part;
// HashMap在java->util这个包下
import java.util.Collection;
import java.util.HashMap;
import java.util.Set;

public class Java01 {
    public static void main(String[] args) {
        HashMap map = new HashMap();
        map.put("zhangsan", "18");
        map.put("lisi", "19");
        // containsValue(V value) 检查是否包含某个value值,如果包含返回true,不包含返回false
        System.out.println( map.containsValue("19")); // true
    }
}

entrySet():返回 HashMap 中所有键值对的集合。


package part;
// HashMap在java->util这个包下
import java.util.Collection;
import java.util.HashMap;
import java.util.Map;
import java.util.Set;

public class Java01 {
    public static void main(String[] args) {
        // 键名是字符串,键值也是字符串,我们使用的是泛型进行约束
        HashMap<String, String> map = new HashMap();
        map.put("zhangsan", "18");
        map.put("lisi", "19");
        // 下面的 Map.Entry 是一个接口,固定这样写的
        Set<Map.Entry<String, String>> keyItem = map.entrySet();
        for (Map.Entry<String, String> entry : keyItem) {
            // 遍历每一项 
            // lisi 19
            // zhangsan 18
            System.out.println(entry);
        }
    }
}

remove(Object key) 删除

package part;
import java.util.HashMap;
public class Java01 {
    public static void main(String[] args) {
        // 键名是字符串,键值也是字符串,我们使用的是泛型进行约束
        HashMap<String, String> map = new HashMap();
        map.put("zhangsan", "18");
        map.put("lisi", "19");
        // 会把张三这个键名给删除掉。此时map就只有lisi这一项了
        map.remove("zhangsan");
        // 删除 键名是lisi,它的值是 100的这一项,返回值是一个布尔类型的
        Boolean flag= map.remove("lisi","100");
        System.out.println(flag); // false
        System.out.println(map);
    }
}

clone浅拷贝,返回类型是对象,需要强制转换

package part;
import java.util.HashMap;
public class Java01 {
    public static void main(String[] args) {
        // 键名是字符串,键值也是字符串,我们使用的是泛型进行约束
        HashMap<String, String> map = new HashMap();
        map.put("zhangsan", "18");
        map.put("lisi", "19");
        // clone是浅拷贝,并且返回来的是一个对象,因此需要强制转换的哈
        HashMap<String,String> newMap= (HashMap<String,String>)map.clone();
        // {zhangsan=18, lisi=19}
        System.out.println(newMap);
    }
}

尾声

准备开始学习java了。
今天学习的第五天,每天都会发文章,我要卷起来。
请小伙伴们监督我,奥利给

posted @   何人陪我共长生  阅读(167)  评论(0编辑  收藏  举报
相关博文:
阅读排行:
· 清华大学推出第四讲使用 DeepSeek + DeepResearch 让科研像聊天一样简单!
· 推荐几款开源且免费的 .NET MAUI 组件库
· 实操Deepseek接入个人知识库
· 易语言 —— 开山篇
· 【全网最全教程】使用最强DeepSeekR1+联网的火山引擎,没有生成长度限制,DeepSeek本体
点击右上角即可分享
微信分享提示