HashMap简单入门(二)

在上一篇中我们回顾了Map，这次我们开始回顾HashMap

HashMap特点：

1）HashMap底层是哈希表；

2）键唯一，要保证键唯一，所以底层的哈希表主要作用在key上。存在HashMap的键位置的对象所属类必须复写hashCode和equals函数，而存在value位置的对象所属的类可以不复写hashCode和equals函数；

3）存取无序；

4）线程不安全，所以效率高；

补充：由于HashMap底层是哈希表，而HashMap集合上面的键又是保存在哈希表中的。所以根据哈希表的特点，保存在HashMap键的位置上数据都要复写hashCode()和equals()函数，这样才能保证key值唯一和存取无序。

HashMap集合中的所有方法全部来自于Map接口，对Map接口中的方法做了全部的实现。

 

练习：键为自定义Teacher类的对象，值为字符串住址。

分析和步骤：

1）创建一个Teacher类，在这个类中定义两个属性name和age，同时并定义构造函数给属性赋值，定义set和get函数，并复写toString()函数；

2）定义一个测试类HashMapDemo2,在这个类中的main函数中创建HashMap的对象map，key和value的泛型分别是Teacher类型和String类型；

3）使用集合对象map调用put函数向集合中添加几个数据，Teacher类的匿名对象作为HashMap集合的key，其中有两个重复的姓名和年龄，String

类型的地址作为value；

4）根据集合对象map调用keySet()函数获取HashMap的key值，保存到Set集合中Teacher类作为泛型；

5）循环遍历集合；

Teacher类：

/*
 * 描述老师
 */
public class Teacher {
    //属性和年龄
    String name;
    int age;
    public Teacher(String name, int age) {
        super();
        this.name = name;
        this.age = age;
    }
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    public int getAge() {
        return age;
    }
    public void setAge(int age) {
        this.age = age;
    }
    public String toString() {
        return "Teacher [name=" + name + ", age=" + age + "]";
    }
    //复写hashCode和equals函数
    public int hashCode() {
        final int prime = 31;
        int result = 1;
        result = prime * result + age;
        result = prime * result + ((name == null) ? 0 : name.hashCode());
        return result;
    }
    public boolean equals(Object obj) {
        if (this == obj)
            return true;
        if (obj == null)
            return false;
        if (getClass() != obj.getClass())
            return false;
        Teacher other = (Teacher) obj;
        if (age != other.age)
            return false;
        if (name == null) {
            if (other.name != null)
                return false;
        } else if (!name.equals(other.name))
            return false;
        return true;
    }
}

测试类代码：

/*
 * 练习：键为自定义Teacher类的对象，值为字符串住址。
 * 问题：Teacher类的对象作为key有重复的，而Map的key值不允许有重复的，那么为什么有重复的呢？
 *     我们得知HashMap底层是哈希表结构用来控制key,而此时key的值是自定义类的对象，我们之前学习过哈希表
 * 的特点，如果想要保存在哈希表中的对象所属的类必须复写hashCode()和equals()函数
 */
public class HashMapDemo1 {
    public static void main(String[] args) {
        //创建集合对象
        HashMap<Teacher, String> map = new HashMap<Teacher,String>();
        //向集合中添加数据
        map.put(new Teacher("黑旋风",20), "黑龙江");
        map.put(new Teacher("助教",24), "上海");
        map.put(new Teacher("班导",28), "江苏");
        map.put(new Teacher("黑旋风",20), "上海");
        //获得键的集合
        Set<Teacher> keys = map.keySet();
        //迭代集合
        for (Iterator<Teacher> it = keys.iterator(); it.hasNext();) {
            Teacher key =  it.next();
            //获得value
            String value = map.get(key);
            System.out.println(key+"----"+value);
        }
    }
}

通过以上代码发现key值有重复的，而这和我们之前学习的Map集合中key值唯一性相互矛盾了，原因是由于HashMap的key值唯一是由于底层保存HashMap的键是哈希表结构，而哈希表能够保证对象唯一，要求保存的对象所属的类必须复写hashCode()和equals()函数，而我们自定义的Teacher类根本就没有复写HashCode()和equals()函数，所以

这里的key值出现了不唯一的情况，那么怎样解决上述的问题呢？

我们让Teacher类复写hashCode()和equals()函数即可。

自定义对象作为HashMap的key值，需要注意什么问题：

1）Map集合中保存的一组对象（一对），不管是key还是value都是对象。

2）我们现在可以自己定义一个对象作为HashMap集合的key值。

3）HashMap集合的key是需要使用哈希表来保证唯一。

4）存在key位置上的自定义对象就需要复写Object类中的hashCode和equals方法。

HashTable和HashMap的区别：

HashTable：无论key还是value都不能为null，线程安全

HashTable容器使用synchronized来保证线程安全，但在线程竞争激烈的情况下HashTable的效率非常低下。因为当一个线程访问HashTable的同步方法时，其他线程访问HashTable的同步方法时，可能会进入阻塞或轮询状态。如线程1使用put进行添加元素，线程2不但不能使用put方法添加元素，并且也不能使用get方法来获取元素，所以竞争越激烈效率越低。

HashMap：可以存储null键和null值，线程不安全

因为多线程环境下，使用Hashmap进行put操作会引起死循环，导致CPU利用率接近100%，所以在并发情况下不能使用HashMap。

Hash碰撞：

我个人理解为当进行put()操作的时候，两个线程同时去争抢同一个节点

Hash碰撞解决：

通常境况下有链表法和开放地址法这两种方法。

了解ConcurrentHashMap

下面是引用自网络的一些结论：

底层：Segment数组结构和HashEntry数组结构组成

Segment是一种可重入锁ReentrantLock，在ConcurrentHashMap里扮演锁的角色，HashEntry则用于存储键值对数据。一个ConcurrentHashMap里包含一个Segment数组，Segment的结构和HashMap类似，是一种数组和链表结构， 一个Segment里包含一个HashEntry数组，每个HashEntry是一个链表结构的元素， 每个Segment守护者一个HashEntry数组里的元素,当对HashEntry数组的数据进行修改时，必须首先获得它对应的Segment锁。

ConcurrentHashMap的锁分段技术（简单了解）：

HashTable容器在竞争激烈的并发环境下表现出效率低下的原因，是因为所有访问HashTable的线程都必须竞争同一把锁，那假如容器里有多把锁，每一把锁用于锁容器其中一部分数据，那么当多线程访问容器里不同数据段的数据时，线程间就不会存在锁竞争，从而可以有效的提高并发访问效率，这就是ConcurrentHashMap所使用的锁分段技术，首先将数据分成一段一段的存储，然后给每一段数据配一把锁，当一个线程占用锁访问其中一个段数据的时候，其他段的数据也能被其他线程访问。

哈希表简单理解