HashSet和HashMap

HashMap

概念和特征

?概念：以键值对的形式存储数据，由键映射到值，核心在于Key上。
?特征：键不能重复，值可以重复；key-value允许为null。

????HashMap ? SinceJDK1.2 ? 前身是HashTable(SinceJDK1.0)
????HashMap ? 实现了Map接口

??HashMap底层是一个Entry数组，当发生hash冲突（碰撞）的时候，HashMap是采用链表的方式来解决的，在对应的数组位置存放链表的头结点。对链表而言，新加入的节点会从头结点加入。

??Key不能重复，判断是否重复的标准是：hashCode()和equals()方法, 如果hashCode相同并且equals相等就是一个重复的key。

?注意：放入HashMap集合中的Key必须要覆盖Object类型的hashCode()和equals()方法，否则就会出现重复的Key。

put()和get()方法

?put(K,V)：将键值对存储到HashMap中(放入)??get(K)：根据Key获取Value，如果Key在HashMap中不存在返回null。

??场景：创建HashMap对象，将元素放入HashMap，根据Key获取Value。

import java.util.HashMap;
import java.util.Map;

/**
 * 场景：创建HashMap对象，将元素放入HashMap，根据Key获取Value
 * 小结：HashMap的数据全部都放在{key1=value1,key2=value2...}中，以key=value的形式存放，如果有多个键值对使用逗号分隔
 * HashMap与ArrayList不同，新元素放入集合中是无序的(根据Hash算法排序的)。
 */
public class TestHashMap {
    public static void main(String[] args) {
        //创建HashMap对象，编译期是Map，运行期是HashMap
        Map<String,String> map = new HashMap<>();
        //调用put(k,v)方法将键值对放入集合  首都作为Key，国家作为Value
        map.put("北京","中国");
        map.put("伯尔尼","瑞士");
        map.put("哈瓦那", "古巴");
        map.put("太子港", "海地");
        map.put("科威特城","科威特");
        System.out.println(map);
        //HashMap 集合没有ABC的Key，所以返回结果为null
        //String value = map.get("ABC");
        //System.out.println(value);
        //海地
        String value = map.get("太子港");
        System.out.println(value);
    }
}

其他方法

??size()：获取HashMap的实际元素大小。

??remove(key)：根据Key删除元素。

??clear()：清空HashMap所有元素，但是不会释放对象占用的内存。

??containsKey(key)：判断可以是否在HashMap存在，如果存在返回true，否则返回false。

import java.util.HashMap;
import java.util.Map;

/**
 * 场景：创建HashMap对象，将元素放入HashMap，根据Key获取Value
 * 小结：HashMap的数据全部都放在{key1=value1,key2=value2...}中，以key=value的形式存放，如果有多个键值对使用逗号分隔
 * HashMap与ArrayList不同，新元素放入集合中是无序的(根据Hash算法排序的)。
 */
public class TestHashMap {
    public static void main(String[] args) {
        // 创建HashMap对象，编译期是Map，运行期是HashMap
        Map<String,String> map = new HashMap<>();
        // 调用put(k,v)方法将键值对放入集合  首都作为Key，国家作为Value
        map.put("北京","中国");
        map.put("伯尔尼","瑞士");
        map.put("哈瓦那", "古巴");
        map.put("太子港", "海地");
        map.put("科威特城","科威特");
        System.out.println(map);
        // HashMap 集合没有ABC的Key，所以返回结果为null
        // String value = map.get("ABC");
        // System.out.println(value);
        String value = map.get("太子港");      // 海地
        System.out.println(value);
    }
}

??keySet()：会返回集合中所有的Key。

??values()：返回集合中所有的值。

??entrySet()：获取HashMap中所有的Entry集合。

import java.util.Collection;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

/**
 * 获取HashMap所有的Value
 */
public class TestHashMap3 {
    public static void main(String[] args) {
        //创建HashMap对象，编译期是Map，运行期是HashMap
        Map<String,String> map = new HashMap<>();
        //调用put(k,v)方法将键值对放入集合  首都作为Key，国家作为Value
        map.put("北京","中国");
        map.put("伯尔尼","瑞士");
        map.put("哈瓦那", "古巴");
        map.put("太子港", "海地");
        map.put("科威特城","科威特");
        System.out.println(map.size());
        //Collection以及Collection下面的子类，数据以[]存储
        //Map以及Map下面的子类，数据以{}存储
        //[瑞士, 海地, 古巴, 科威特, 中国]
        //返回HashMap集合所有的Value
        Collection<String> values = map.values();
        System.out.println(values);
        //遍历Collection
        for(String value: values) {
            System.out.print(value+"\t");
        }
    }
}

遍历HashMap里面的元素

??HashMap 可以理解为一张平面表，由两列多行组成。

?

?场景：遍历HashMap集合的每个元素

package com.whsxt.day7.map;

import java.util.HashMap;
import java.util.Map;

/**
 * @author caojie
 *场景：遍历HashMap集合的每个元素
 */
public class TestHashMap4 {
    public static void main(String[] args) {
        Map<String,String> map = new HashMap<>();
        map.put("北京","中国");
        map.put("伯尔尼","瑞士");
        map.put("哈瓦那", "古巴");
        map.put("太子港", "海地");
        map.put("科威特城","科威特");
        //map.entrySet() 获取HashMap中所有的Entry对象
        //Map.Entry<String,String> entry 表示HashMap集合中的每一个Entry对象
        //entry编译期是一个接口类型(Map.Entry)，运行期是一个HashMap$Node类型
        //遍历HashMap集合的每个元素，每个元素都以Entry类型存在
        for(Map.Entry<String,String> entry : map.entrySet()) {
            //获取HashMap 的key
            String key =entry.getKey();
            //获取Hash Map的Value
            String value =entry.getValue();
            System.out.println(key+"\t\t\t"+value);
        }
    }
}

HashMap和缓存

??缓存特征：牺牲空间换取时间。

??缓存是内存的一种形式：经常需要获取并且不轻易改变的数据就会放入缓存中，缓存中的数据只加载一次。

??HashMap中的数据在工作中通常以缓存的形式存在，也就是说工作中HashMap通常当做缓存使用。

?

??场景1：存储全国所有的城市信息，城市名称作为Key，城市相关的信息作为value[id,cityName,cityCode,cityDesc],要求根据Key，获取城市相关的信息

??步骤：1. 创建一个缓存(HashMap),将所有的城市信息的加载工作放入static块

???2. 提供一个公有的静态的方法给外界，外界可以根据Key获取缓存中的value信息

public class City {
    private int id;

    private String cityName;

    /**
     * 城市的区号
     */
    private String cityCode;

    /**
     * 城市的描述(介绍信息)
     */
    private String cityDesc;

    public int getId() {
        return id;
    }
    public void setId(int id) {
        this.id = id;
    }
    public String getCityName() {
        return cityName;
    }
    public void setCityName(String cityName) {
        this.cityName = cityName;
    }
    public String getCityCode() {
        return cityCode;
    }
    public void setCityCode(String cityCode) {
        this.cityCode = cityCode;
    }
    public String getCityDesc() {
        return cityDesc;
    }
    public void setCityDesc(String cityDesc) {
        this.cityDesc = cityDesc;
    }

    public City() {}

    public City(int id, String cityName, String cityCode, String cityDesc) {
        super();
        this.id = id;
        this.cityName = cityName;
        this.cityCode = cityCode;
        this.cityDesc = cityDesc;
    }   

    @Override
    public String toString() {
        return "City [id=" + id + ", cityName=" + cityName + ", cityCode=" + cityCode + ", cityDesc=" + cityDesc + "]";
    }
}

定义缓存

import java.util.HashMap;
import java.util.Map;

/**
 * 使用HashMap作为缓存
 */
public class CityCache {
    /**
     * 存储所有的城市信息
     */
    private static Map<String,City> cityCache = new HashMap<>();
    static {
        cityCache.put("北京",new City(1, "北京","010","帝都"));
        cityCache.put("上海",new City(2, "上海","021","魔都"));
        cityCache.put("广州",new City(3, "广州","020","羊城"));
        cityCache.put("深圳",new City(4, "深圳","0755","鹏程"));
        cityCache.put("武汉",new City(5, "武汉","027","江城"));
    }

    /**
     * 根据Key获取对应的城市信息
     * @param key 城市的名称
     * @return 城市相关的信息City
     */
    public static City getCityByKey(String key) {
        return cityCache.get(key);
    }
}

使用缓存

public class TestCache {
    public static void main(String[] args) {
        // 获取缓存中的数据
        /*
         * 第一步：将CityCache加载到JVM
         * 第二步：检查CityCache.class有没有静态数据，如果有初始化静态数据
         * 第三步：调用静态方法getCityByKey(key)获取缓存中的数据
         * 注意：静态方法调用之前缓存中所有的数据初始化完毕
         *      缓存中的数据只会初始化一次，在第一次调用静态方法之前初始化
         *      所以说：第一次调用静态方法相对较慢(加载静态数据)，后面会很快
         */
        City city = CityCache.getCityByKey("深圳");
        System.out.println(city);
        // 第二次调用静态方法不会初始化CityCache缓存中的数据
        City city2 = CityCache.getCityByKey("广州");
        System.out.println(city2);
    }
}

?

?场景2：使用HashMap作为缓存，来存储环境变量的信息，根据Key获取环境变量的值

import java.util.Map;

/**
 * 环境变量的缓存
 */
public class EnvCache {

    /**
     * 获取系统所有的环境变量信息，存储到HashMap缓存中
     */
    private static Map<String,String> envMap = System.getenv();

    /**
     * 遍历缓存中的每个键值对
     */
    public static void iteratorEnv() {
        for(Map.Entry<String,String> entry: envMap.entrySet()) {
            String key = entry.getKey();
            String value = entry.getValue();
            System.out.println(key+"\t\t\t"+value);
        }
    }

    /**
     * 根据Key获取环境变量对应的值
     * @param key
     * @return
     */
    public static String getValueByKey(String key) {
        return envMap.get(key);
    }
}

获取缓存数据：

public class TestEnv {
    public static void main(String[] args) {
        // 遍历缓存的数据
        // EnvCache.iteratorEnv();
        // 根据Key获取对应的环境变量值
        String value =EnvCache.getValueByKey("Path");
        System.out.println(value);
    }
}

补充：HashMap中的坑

import java.util.HashMap;
import java.util.Map;

/**
 * HashMap的陷阱
 */
public class TestHashMapTrap {
    public static void main(String[] args) {
        Map<String,String> map = new HashMap<>();
        //HashMap键必须唯一，如果将相同的Key放入HashMap，后面的key-value会覆盖前面的key-value
        map.put("北京","中国");
        map.put("北京","CHINA");
        map.put("北京","CHINESE");
        // A.1   B.3   C.编译错误   D.编译成功,运行失败
        System.out.println(map.size());     // 1
    }
}

?问题：为什么String作为HashMap的Key，不能重复，而Student作为HashMap的Key，却可以重复？

??因为String定义了判断是否重复的逻辑，而Student没有。

??String作为Key放入HashMap之前，会首先调用hashCode()方法，判断集合中有没有相同的hashCode，如果有相同的hashCode,然后再调用equals()方法,判断有没有相等的值，如果hashCode相同并且equals相等，说明有重复的Key，不会放入，只会将新的key-value对覆盖旧的key-value对。

以下代码：将Student作为Key，String作为Value，由于Student没有判断Key是否重复，所以size=2;

public class Student {
    private int id;
    private String stuName;

    public int getId() {
        return id;
    }
    public void setId(int id) {
        this.id = id;
    }
    public String getStuName() {
        return stuName;
    }
    public void setStuName(String stuName) {
        this.stuName = stuName;
    }

    public Student() {}
    public Student(int id, String stuName) {
        this.id = id;
        this.stuName = stuName;
    }

    @Override
    public String toString() {
        return "Student [id=" + id + ", stuName=" + stuName + "]";
    }
}
import java.util.HashMap;
import java.util.Map;

/**
 * HashMap的陷阱
 */
public class TestHashMapTrap {
    public static void main(String[] args) {
        //Student作为Key，String作为Value
        Map<Student,String> map = new HashMap<>();
        map.put(new Student(1,"Tom"), "Tom");
        map.put(new Student(1,"Tom"), "Tom");
        System.out.println(map.size());     // 2
        System.out.println(map);
    }
}

??注意：HashMap中的Key必须要覆盖Object类型的hashCode()和equals()方法，这两个方法用来判断HashMap集合中是否存在相同的Key。

HashMap的存储机制

??问题：HashMap集合中的key-value对没有规律（没有顺序），但是HashMap会根据Key的hashCode进行排序

???HashMap 存储机制：第一次 put(k,v) 会初始化 Node[] table = new Node[16]; ，然后将 hashCode&table.length-1 作为数组的下标，最后创建 Node类型对象 ， Node newNode = new Node(hash,key,value,null); 将newNode对象放入到table数组中，下标就是hashCode&table.length-1。

??HashMap核心静态内部类Node，实现了Entry接口，每当你put元素到HashMap，都会创建一个Node对象

?注意：1的hashCode为49
??12的hashCode为1569

??1和12的 hashCode& table.length-1 的索引下标都是1，就会造成hashCode码的碰撞，由于1是先put，12后put，那么将12放入到1的下一个节点中（一个槽中放入两个数值，单链表的形式存储）。

?场景：将 "北京","中国"作为键值对放入HashMap集合。

??步骤：1. 获取“北京”的hashCode ，hashCode 获取方式如下：(hashCode ^ (hashCode >>> 16))。

???2. 检查内存表table[] 是否为空，如果第一次做put(k,v)操作，table就是null值，需要创建table[]，然后分配空间，空间默认大小是16，默认负载因子是0.75，默认的阀值是12。

???3. 如果是第一次put(k,v), 会创建一个静态内部类的对象Node，存储key的hashCode，key，value。

???4. 需要将Node对象放入到table[]数组中，放到数组的那个slot(槽位)呢？

???5. 将key的hashCode& table.length-1,得到槽位的索引下标。

???6. 根据索引下表将Node对象放入到table[]数组中。

???7. ++size。

???8. 判断size有没有超过阀值(12)，如果超过了就会重新扩容。

public class HashMap<K,V> extends AbstractMap<K,V> implements Map<K,V>, Cloneable, Serializable {
    /**
     * 默认容量  1<<4=16
     */
    static final int DEFAULT_INITIAL_CAPACITY = 1 << 4;     // aka 16

    /**
    默认负载因子0.75
    阀值=(int)DEFAULT_INITIAL_CAPACITY*DEFAULT_LOAD_FACTOR
    超过阀值HashMap会自动扩容
    */
    static final float DEFAULT_LOAD_FACTOR = 0.75f;

    static class Node<K,V> implements Map.Entry<K,V> {
        final int hash;
        final K key;
        V value;
        Node<K,V> next;

        Node(int hash, K key, V value, Node<K,V> next) {
            this.hash = hash;
            this.key = key;
            this.value = value;
            this.next = next;
        }

        public final K getKey()        { return key; }
        public final V getValue()      { return value; }
        public final String toString() { return key + "=" + value; }

        public final int hashCode() {
            return Objects.hashCode(key) ^ Objects.hashCode(value);
        }

        public final V setValue(V newValue) {
            V oldValue = value;
            value = newValue;
            return oldValue;
        }

        public final boolean equals(Object o) {
            if (o == this)
                return true;
            if (o instanceof Map.Entry) {
                Map.Entry<?,?> e = (Map.Entry<?,?>)o;
                if (Objects.equals(key, e.getKey()) &&
                    Objects.equals(value, e.getValue()))
                    return true;
            }
            return false;
        }
    }
}

HashSet(掌握)

??HashSet的底层实际就是一个HashMap（是一个简化版的HashMap），因此，查询效率和增删效率都比较高。每当将新元素放入HashSet实际上是将新元素放入HashMap，key(键)必须唯一，值是一个哑巴值。

??HashSet集合实现了Set接口，存储HashSet的值，不能重复。

???注意：存储HashSet集合中的元素，必须覆盖Object类型的hashCode()方法和equals()方法，这样才能保证对象唯一。

HashSet常用方法

??add()：将元素（对象）放入容器

??size()：获取HashSet集合的元素大小

??remove(obj)：删除元素

import java.util.HashSet;
import java.util.Set;

public class TestHashSet {
    public static void main(String[] args) {
        Set<String> set = new HashSet<>();
        set.add("Tom");
        set.add("Tom");
        set.add("Tom");
        set.add("Tom");
        set.add("Tom");
        System.out.println(set.size());     // 1
        set.remove("Tom");
        System.out.println(set.size());     // 0
    }
}

??HashSet特征：不会有重复的元素。

??第一次调用add()方法将Tom放入HashSet集合，由于集合中没有元素直接放入。第二次调用add()方法将Tom放入HashSet集合，会判断有没有重复的Tom,如果没有就放入，如果有就不会放入，只会将新的Tom覆盖旧的Tom。判断元素是否重复的依据是hashCode()和equals()方法， hashCode相同并且equals()相等说明HashSet中有重复的元素。

??元素不能重复，所以存储对象(元素)的信息使用ArrayList或者LinkedList，因为Set中的元素不能重复（例如：有可能班上有两个学生都叫做张三）。
??HashSet元素之间缺乏联系，所以不能使用get()方法获取元素。

?场景1：有一个ArrayList集合[1,2,2,3,5,7,7,8]，需要将重复的元素清除掉

import java.util.ArrayList;
import java.util.HashSet;
import java.util.List;
import java.util.Set;

public class TestHashSet {
    static List<Integer> list = new ArrayList<>();
    static {
        list.add(1);
        list.add(2);
        list.add(2);
        list.add(3);
        list.add(5);
        list.add(5);
    }
    public static void main(String[] args) {
        Set<Integer> set =new HashSet<>(list);
        list.clear();
        list.addAll(set);
        System.out.println(list);
    }
}

??contains()：判断元素是否在集合中存在，true存在，false不存在。

?场景2：输入一个手机号码，判断该号码是否在HashSet集合中存在，如果存在就不执行后面的业务逻辑，如果不存在就下发垃圾短信。

import java.util.HashSet;
import java.util.Scanner;
import java.util.Set;

/**
 * 白名单：将手机号码存入到白名单中，如果输入的手机号不在白名单就下发垃圾短信
 * 1 创建HashSet对象
 * 2 加载白名单
 * 3 创建Scanner对象
 * 4 输入手机号码
 * 5 判断输入的手机号码是否在白名单中，如果不在下发短信
 */
public class TestHashSetWhite {
    /**
     * 存储白名单的HashSet
     */
    private final static Set<String> MOBILE_SET= new HashSet<>();

    static {
        MOBILE_SET.add("15609898765");
        MOBILE_SET.add("15609898761");
        MOBILE_SET.add("15609898769");
    }

    public static void main(String[] args) {
        Scanner input = new Scanner(System.in);
        System.out.println("请输入手机号码");
        String mobile = input.nextLine();
        //条件成立：手机号码不在白名单中，下发短信
        if(!MOBILE_SET.contains(mobile)) {
            System.out.println("下发短信。。。。。。。。。");
        }else {
            System.out.println("不下发短信");
        }
    }
}

?注意：List集合和Set集合都有contains(key) 方法，但是List里面有重复的元素，所以调用该方法效率低下，工作中contains(key)方法，通常用于set集合。

原文地址：https://www.cnblogs.com/lyang-a/p/11551785.html

时间： 2024-10-31 10:41:03

HashSet和HashMap的相关文章

你对hashset和hashmap了解多少？

首先,我们来看hashset. 他的构造函数:    public HashSet() {        map = new HashMap<>();    } 很惊讶吧.构造函数里面竟然有个hashmap! public boolean add(E e) {        return map.put(e, PRESENT)==null;    } 再看 add方法.里面有个present ,去看看present的定义: private static final Object PRESENT

Java集合Set、Map、HashSet、HashMap、TreeSet、TreeMap等

1.Set和Map的关系: Set代表一种集合元素无序.不可重复的集合,Map代表一种由多个key-value对组成的集合. Set的集合继承体系: Map关系集合 Map集合的key特征:所有key不能重复,key之间没有顺序.Map集合的所有key将具有set集合的特征. 对Set做改造可将Set改造成Map集合: 2.HashSet和HashMap的区别和联系:    对于HashSet,系统采用Hash算法决定集合元素的存储位置:对于HashMap,系统将value当成key的附属物,系

java数据结构之HashSet和HashMap(java核心卷Ⅰ读书笔记)

增加 删除 remove方法,可以删除指定的一个元素. 查找 ********************* **************************** HashSet既不可以用 0 1 2 3这种索引来确定元素的值,也不能用key来确定元素的值 ********************* HashSet就长这样的  ["aa" , "bb"] 长成这样的数据结构 ****************** HashMap长成这样的    {a=123  ,  

HashSet和HashMap的区别

HashSet和HashMap的区别.Java的HashSet类是由哈希表支持.它不保证 set 的迭代顺序:特别是它不保证该顺序恒久不变.此类允许使用 null 元素.HashSet类为基本操作提供了稳定性能,这些基本操作包括 add.remove.contains 和 size,假定哈希函数将这些元素正确地分布在桶中.. Java的HashMap和Hashtable都实现了Map接口.它们及其子类都采用Hash算法决定Map中key的存储. HashMap和Hashtable的主要区别有:线

Java集合 -- HashSet 和 HashMap

HashSet 集合 HashMap 集合 HashSet集合 1.1 Set 接口的特点 Set体系的集合: A:存入集合的顺序和取出集合的顺序不一致 B:没有索引 C:存入集合的元素没有重复 1.2 HashSet 使用&唯一性原理 1.2.1 HashSet的使用 1.2.1.1 案例代码一: public class HashSetDemo2 { public static void main(String[] args) { //创建集合对象 HashSet<Student>

Java HashSet和HashMap源码剖析

转自: Java HashSet和HashMap源码剖析 总体介绍 之所以把HashSet和HashMap放在一起讲解,是因为二者在Java里有着相同的实现,前者仅仅是对后者做了一层包装,也就是说HashSet里面有一个HashMap(适配器模式).因此本文将重点分析HashMap. HashMap实现了Map接口,允许放入null元素,除该类未实现同步外,其余跟Hashtable大致相同,跟TreeMap不同,该容器不保证元素顺序,根据需要该容器可能会对元素重新哈希,元素的顺序也会被重新打散,

java基础之问题：请说出hashCode方法、equals方法、HashSet、HashMap之间的关系

①HashSet是采用HashMap来实现的:这个HashMap的key就是放进HashSet中的对象,value就是一个Object类型的对象 ②当调用HashSet的add方法时,实际上是想HashMap中增加了一行(key-value对),该行的key就是往HashSet增加的那个对象,该行的value就是一个Object类型的常量. ③HashMap底层采用数组来维护 ④调用增加的那个对象的hashCode方法,来得到一个hashCode,然后根据该值来计算出一个数组的下标索引(计算出数

HashMap与HashTable、HashSet与HashMap异同

1. HashMap与HashTable的区别: (1)HashMap允许将null作为一个entry的key或者value,而Hashtable不允许.当get()方法返回null值时,即可以表示HashMap中没有该键,也可以表示该键所对应的值为null.因此,在HashMap中不能由get()方法来判断HashMap中是否存在某个键,而应该用containsKey()方法来判断. (2)HashMap把Hashtable的contains方法去掉了,改成containsvalue和cont

HashSet HashTable HashMap的区别 及其Java集合介绍

(1)HashSet是set的一个实现类,hashMap是Map的一个实现类,同时hashMap是hashTable的替代品(为什么后面会讲到). (2)HashSet以对象作为元素,而HashMap以(key-value)的一组对象作为元素,且HashSet拒绝接受重复的对象.HashMap可以看作三个视图:key的Set,value的Collection,Entry的Set. 这里HashSet就是其实就是HashMap的一个视图. HashSet内部就是使用Hashmap实现的,和Hash

验证HashSet和HashMap不是线程安全

JAVA集合类: java.util包下的HashSet和HashMap类不是线程安全的, java.util.concurrent包下的ConcurrentHashMap类是线程安全的. 写2个测试类来验证下: package com.cdfive.learn.thread; import java.util.ArrayList; import java.util.Collections; import java.util.HashSet; import java.util.List; imp