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集合。