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了。

今天学习的第五天，每天都会发文章，我要卷起来。

请小伙伴们监督我，奥利给