`
greemranqq
  • 浏览: 975728 次
  • 性别: Icon_minigender_1
  • 来自: 重庆
社区版块
存档分类
最新评论

Java 深入集合--HashMap

阅读更多

一、HashMap介绍:

    上面一篇介绍了hashTable,这里HashMap的作用就不多啰嗦了。HashMap 实现的功能和hashTable 差不多,具体实现和功能我们从源码进行分析。

 

 

二、源码分析:

2.1 类实现:

      public class HashMap<K,V> extends AbstractMap<K,V> implements Map<K,V>,        Cloneable, Serializable{...}

      这里我们可以看到继承了 AbstractMap<K,V>  还实现了 Map<K,V>,其他的参考hashTable,其实 AbstractMap<K,V>  去看源码知道已经实现了Map<K,V> 接口,为什么这里还需要去实现呢?很多人这里有有疑问,觉得很啰嗦,下面我谈一下介绍,和自己的看法.

      Map 接口提供了键值对 这类型数据的通用的方法,而AbstractMap 这是对Map实现的抽象类,我们知道一般抽象类都是用来定义一个概念,一种通用的,不指向具体事物。 

      这里举个例子:假设我们知道动物都有  eat(food)  的行为,相当于Map. 然后我们设计一个抽象类去实现 void eat(food) {System.out.println(food);} 相当于AbstractMap。然后这个时候我们去实现各个动物比如:人,熊猫等等,都去继承这个抽象类,相当于hashMap ,  TreeMap 一样,这样我们就可以省略eat 这个通用的实现了。当然实际上这些通用实现可能不满足我们的需求,那么我就要从写。

      事实上这里还是没明白为什么 HashMap 还要实现Map接口,因为抽象类已经实现了啊。为啥还要实现呢?其实你进入AbstractMap ,仔细观察会发现:

       public abstract Set<Entry<K,V>> entrySet(); 

       这里其实没有对 entrySet 进行实现的,相当于复制了Map的接口方法。我们从JDK 解释中明白:

       1.AbstractMap 提供 Map 接口的骨干实现,以最大限度地减少实现此接口所需的工作。

       2.要实现不可修改的映射,编程人员只需扩展此类并提供 entrySet 方法的实现即可。

       第一句话很好理解,提供方便,第二句话强调了 实现不可修改的映射,也就是说我们继承了AbstractMap ,实现entrySet()方法,那么当前类的集合就是不可修改的了。具体点说,就是你调用 put(),putAll(),remove(),clear() 方法,数据都会存在,并且put()还会报错,具体请看源码和API。

        好了,说了这么多,其实是简单解释了AbstractMap 的作用。而实现Map 接口,从功能上来说,没啥作用,因为去掉也没影响。但是从接口上来说,我们可以从JAVA 集合的关系图中接口图就能看出,Map Collection Itertor 是最顶层的东西,我们习惯面向接口编程,这样我们的hashMap 也能能直接指向Map 接口,整个结构更加的完整,这是我的想法,请补充指正!下面继续进行 代码的详细研究吧!

 

 public HashMap() {
        
        this.loadFactor = DEFAULT_LOAD_FACTOR;// 0.75
        threshold = (int)(DEFAULT_INITIAL_CAPACITY * DEFAULT_LOAD_FACTOR);
        table = new Entry[DEFAULT_INITIAL_CAPACITY];// 16
        init();
    }
// 这里我们new HashMap 无论带参数 或者不带参数,主要都是设置增长因子0.75
// 当前增长的位置
// 以及Entry 的数组,这里可以参看hashTable ,下面继续看 Entry 类

 

static class Entry<K,V> implements Map.Entry<K,V> {
        // 这是定义的内部类,Key value 内部属性,
        final K key;
        V value;
        Entry<K,V> next;
        final int hash;
        Entry(int h, K k, V v, Entry<K,V> n) {
            value = v;
            next = n;
            key = k;
            hash = h;
        }

        public final K getKey() {
            return key;
        }

        public final V getValue() {
            return value;
        }

        public final V setValue(V newValue) {
            // 这里仅仅 提供了对值覆盖方法
	    V oldValue = value;
            value = newValue;
            return oldValue;
        }

        public final boolean equals(Object o) {
            // 这里对类型 key value 地址值 和 值得判断
            if (!(o instanceof Map.Entry))
                return false;
            Map.Entry e = (Map.Entry)o;
            Object k1 = getKey();
            Object k2 = e.getKey();
            if (k1 == k2 || (k1 != null && k1.equals(k2))) {
                Object v1 = getValue();
                Object v2 = e.getValue();
                if (v1 == v2 || (v1 != null && v1.equals(v2)))
                    return true;
            }
            return false;
        }

        public final int hashCode() {
            // 这里是对key 和 value 两个的地址值 进行 异或运算,得出的hashcode
            return (key==null   ? 0 : key.hashCode()) ^
                   (value==null ? 0 : value.hashCode());
        }
       // 这两个方法 真没看懂,有什么作用。。。
       // 知道了人,麻烦帮帮忙解释下
       // 当然因为这方法在put remove 等地方都会自动调用估计在扩展的里面的东西留
       // 下扩充空间吧
        void recordAccess(HashMap<K,V> m) {
        }

        void recordRemoval(HashMap<K,V> m) {
        }
    }

    我们可以看到,hashMap 也是一个内部类的数组,内部类 有ket value 属性而已,下面看看主要方法实现

   

// 可以看到 这里是有返回值的 ,而且是返回的value    
public V put(K key, V value) {
        if (key == null)
           // 可以看出 key 是可以为null的。并且对值 也进行了操作,请看下面
           return putForNullKey(value);
        int hash = hash(key.hashCode());
        int i = indexFor(hash, table.length);
        for (Entry<K,V> e = table[i]; e != null; e = e.next) {
            Object k;
            if (e.hash == hash && ((k = e.key) == key || key.equals(k))) {
                V oldValue = e.value;
                e.value = value;
                e.recordAccess(this);
                return oldValue;
            }
        }

        modCount++;
        addEntry(hash, key, value, i);
        return null;
    }

private V putForNullKey(V value) {
        for (Entry<K,V> e = table[0]; e != null; e = e.next) {
             // 这里做了便利,对key 为null 的值
            if (e.key == null) {
                V oldValue = e.value;
                // 这里进行了赋值操作,并且返回的是 旧的一个值
                e.value = value;
                e.recordAccess(this);
                return oldValue;
            }
        }
        // 数据自增一
        modCount++;
        // 这里指定了 key 为null 的元素存放的位置,从下面的方法 以及构造,我们看出
        // 所有key 为null 的存放位置,默认是放在0的位置,也就是数组第一个
        addEntry(0, null, value, 0);
        return null;
    }

//addEntry(0, null, value, 0);
void addEntry(int hash, K key, V value, int bucketIndex) {
	Entry<K,V> e = table[bucketIndex];
        table[bucketIndex] = new Entry<K,V>(hash, key, value, e);
        if (size++ >= threshold)
            resize(2 * table.length);
    }
// 当然这里还进行可 扩容的操作,当当前元素size >=  增长位置threshold 的时候
  void resize(int newCapacity) {
        Entry[] oldTable = table;
        int oldCapacity = oldTable.length;
        // 这里我很意外,这里设置了一个最大初始化的位置,是Integer 最大值的一半
        // 当元素刚好有MAXIMUM_CAPACITY这么多时,就一个赋值 return,后面就无法完成扩容了
        // 而我们看到扩容是 都是2*table.length,而这个数是一个单数- -,那么这里理论上是无法
        // 得到执行的。也就是没用的,谁知道 这里的设计是为了什么呢?

        if (oldCapacity == MAXIMUM_CAPACITY) {
            threshold = Integer.MAX_VALUE;
            return;
        }
        // 这里就是新的扩容了,
        Entry[] newTable = new Entry[newCapacity];
        // 这里就是数组的复制,并且位置是从新计算了的。感觉上是比较耗的,因为会从新计算存放        // 的位置,不是单纯的复制,关于位置的计算,下面继续。
        transfer(newTable);
        table = newTable;
        threshold = (int)(newCapacity * loadFactor);
    }
   
这是 put 方法 里面的两个东西

int hash = hash(key.hashCode());
int i = indexFor(hash, table.length);

 // hash值算法,为了减小重复而这样方式的
 // 这里先不谈,专门找章节介绍,可以参考:http://marystone.iteye.com/blog/709945
 static int hash(int h) {
        // This function ensures that hashCodes that differ only by
        // constant multiples at each bit position have a bounded
        // number of collisions (approximately 8 at default load factor).
        h ^= (h >>> 20) ^ (h >>> 12);
        return h ^ (h >>> 7) ^ (h >>> 4);
    }
    //参考:http://blog.csdn.net/heyutao007/article/details/6206153
    static int indexFor(int h, int length) {
        return h & (length-1);
    }

// 通过相同的hash 和 indexFors 算法,快速的取值
public V get(Object key) {
        if (key == null)
            return getForNullKey();
        int hash = hash(key.hashCode());
        for (Entry<K,V> e = table[indexFor(hash, table.length)];
             e != null;
             e = e.next) {
            Object k;
            if (e.hash == hash && ((k = e.key) == key || key.equals(k)))
                return e.value;
        }
        return null;
    }
 

 

   综上可以看看出:put 方法 是通过hash算法,以及indexFor 算出值应该存放在数组的哪个位置,并不是顺序存放的,这样的好处是 在取值的 也可以通过算法 就行读取。但是存放过程中进过了大量的计算,以及数组的操作,因此不难理解存放是比较耗时的,而取值是很快的。

 

  下面我们来看看几个常用的方法:

   remove():
   

 public V remove(Object key) {
        Entry<K,V> e = removeEntryForKey(key);
        return (e == null ? null : e.value);
    }
 // final 提高查找速度
 final Entry<K,V> removeEntryForKey(Object key) {
        // 通过hash 和 i, 找出table 中元素的位置
        int hash = (key == null) ? 0 : hash(key.hashCode());
        int i = indexFor(hash, table.length);
        Entry<K,V> prev = table[i];
        Entry<K,V> e = prev;

        while (e != null) {
            Entry<K,V> next = e.next;
            Object k;
            // 通过该元素的hash 和 key 值,进行对比 确认元素
            if (e.hash == hash &&
                ((k = e.key) == key || (key != null && key.equals(k)))) {
                modCount++;
                size--;
                // 通过数组用后一个元素 覆盖当前元素,完成移除操作
                // 这里size --,当时数组空间其实并没减少,只是最后一个元素你无法访问了
                // 相当于 1,2,3,4,5 移除3, 就变成了1,2,4,5,5,但是size 5变成了4!
                // 这里估计是想操作数组又需要时间 和空间吧!
                if (prev == e)
                    table[i] = next;
                else
                    prev.next = next;
                e.recordRemoval(this);
                return e;
            }
            prev = e;
            e = next;
        }

        return e;
    }
    

 

   下面来看我们常用的几个方法:

    public Set<KkeySet();

    public Set<Map.Entry<K,V>> entrySet();

    public Collection<V> values();

 

     

// 获得所有value 的集合 
public Collection<V> values() {
        Collection<V> vs = values;
        return (vs != null ? vs : (values = new Values()));
    }

    private final class Values extends AbstractCollection<V> {
        public Iterator<V> iterator() {
            return newValueIterator();
        }
     // ..略
}
 // 获得所有Entry的集合 
public Set<Map.Entry<K,V>> entrySet() {
	return entrySet0();
    }

    private Set<Map.Entry<K,V>> entrySet0() {
        Set<Map.Entry<K,V>> es = entrySet;
        return es != null ? es : (entrySet = new EntrySet());
    }

    private final class EntrySet extends AbstractSet<Map.Entry<K,V>> {
        public Iterator<Map.Entry<K,V>> iterator() {
            return newEntryIterator();
        }
       // ... 略

}

// 获得所有key的集合 
public Set<K> keySet() {
        Set<K> ks = keySet;
        return (ks != null ? ks : (keySet = new KeySet()));
    }

    private final class KeySet extends AbstractSet<K> {
        public Iterator<K> iterator() {
            return newKeyIterator();
        }
        // ... 略
}
   如果看过hashTable 的源码就会发现,它是通过 3个标志 判断取的是什么,调用的一个方法,而hashMap
   这里主要其实也差不多,newKeyIterator 等3个方法,继承的HashIterator
   
 private final class ValueIterator extends HashIterator<V> {
        public V next() {
            return nextEntry().value;
        }
    }

    private final class KeyIterator extends HashIterator<K> {
        public K next() {
            return nextEntry().getKey();
        }
    }

    private final class EntryIterator extends HashIterator<Map.Entry<K,V>> {
        public Map.Entry<K,V> next() {
            return nextEntry();
        }
    }
      就能获得你需要的元素了,下面主要看HashIterator:
    
 private abstract class HashIterator<E> implements Iterator<E> {
        // 这里感觉和Entry 差不多,其实是的,这里内部类主要是为了维护table[Entry]
        Entry<K,V> next;	// next entry to return
        // 这里控制多线程修改,用来判断同时操作 快速的抛出异常
        int expectedModCount;	// For fast-fail
        int index;		// current slot
        Entry<K,V> current;	// current entry
        //  
        HashIterator() {
            expectedModCount = modCount;
            if (size > 0) { // advance to first entry
                Entry[] t = table;
                // 这里其实是通过循环 对next 赋值,每次都取得第一个值,
                // 这写法好真简洁!
                while (index < t.length && (next = t[index++]) == null)
                    ;
            }
        }

        public final boolean hasNext() {
            return next != null;
        }
        // 这里就能获得entry,然后通过entry 就能获得需要的值了
        final Entry<K,V> nextEntry() {
            // 这里就是刚才线程控制啦,虽然是线程不安全的,但是迭代器中不允许几种同时操作
            if (modCount != expectedModCount)
                throw new ConcurrentModificationException();
            Entry<K,V> e = next;
            if (e == null)
                throw new NoSuchElementException();
             
            if ((next = e.next) == null) {
                Entry[] t = table;                while (index < t.length && (next = t[index++]) == null)
                    ;
            }
	    current = e;
            return e;
        }
        
        public void remove() {
            if (current == null)
                throw new IllegalStateException();
            // 移除操作,对迭代过程的控制,迭代不能删除的
            if (modCount != expectedModCount)
                throw new ConcurrentModificationException();
            Object k = current.key;
            current = null;
            HashMap.this.removeEntryForKey(k);
            expectedModCount = modCount;
        }

    }
 
小结 :这里就介绍了 hashMap 的常用方法,总的来说和hashTable 实现的功能上差不多,但是细节上上的区别,比如:1.hashMap 没table 那线程安全锁,因此线程是不安全的,速度更快。2:hash 值上,hashMap 独立了hash算法,并且算法是通过key value 多次算出来的,减少了重复性。3:hashMap 可以放key 为null 的值,并且默认是数组第一个。4:设计上都是可以获得Set 集合,从而遍历集合,hashMap 是独立了内部类,分别获得key  value entry,而hashTale 仅仅是3个变量去获得,hashMap 扩展性更好。当然还有其他的实现方式的区别,就不解释了,需要再慢慢研究。
     hashMap 这里就结束了,希望大家多批评指定,小弟一定学习改正!
分享到:
评论

相关推荐

    20-集合框架020-HashMap-1080P 高清-AVC20

    在这个主题中,我们将深入探讨HashMap类,它是Java集合框架中的一个关键组件,特别是在标题“20-集合框架020-HashMap-1080P 高清-AVC20”和描述中所提到的内容。 HashMap是Java.util包中的一个类,它实现了Map接口...

    面试真题包含spring-java-集合-框架-并发-spring-运维-数据库等多领域45卷合集.rar

    集合框架的"集合框架.pdf"将涵盖ArrayList、LinkedList、HashMap、HashSet、TreeMap等基础数据结构,以及泛型、迭代器、比较器等概念。求职者应能熟练运用这些集合,并了解其性能特点。 对于服务器端技术,"Tomcat...

    java基础 集合-22-迭代器设计模式

    本文将深入探讨Java中的迭代器模式及其在集合框架中的应用。 迭代器模式是一种行为设计模式,它提供了一种方法来顺序访问聚合对象的元素,而不暴露其底层表示。在Java中,迭代器模式广泛用于遍历集合类,如...

    关于java基础集合-定义及练习资料

    本资料主要关注Java集合的基础定义以及相关的练习,帮助开发者深入理解和掌握这些概念。 首先,我们来详细讲解Java集合的定义。在Java中,集合是一种容器,可以用来存储一组对象。集合框架包括了接口(如List、Set...

    Java-Interview-超全集合github上评分最高的jiva面试题

    "Java-Interview-超全集合github上评分最高的jiva面试题"就是一个这样的宝藏,它涵盖了Java编程语言、Git版本控制工具以及面试策略等多个方面的知识点。以下是这些内容的详细解析: 1. **Java基础** - **数据类型...

    【死磕Java集合】-集合源码分析.pdf

    在Java集合框架中,LinkedList、ArrayList、HashMap、TreeMap等都是非常常用的数据结构。本文将对Java集合框架的源码进行分析,深入探讨其实现原理和机制。 一、LinkedList源码分析 LinkedList是一种以双向链表...

    Java基础-模拟HashMap集合(基于数组和链表) 数组和链表.pdf

    Java基础-模拟HashMap集合(基于数组和链表) 在本文中,我们将详细介绍如何模拟Java的HashMap集合,使用数组和链表来实现Hash表的存储。我们将从基本概念开始,逐步深入到HashMap的实现细节中。 什么是HashMap? ...

    Java基础----集合类汇总

    本文将深入探讨Java集合类的汇总,包括List、Set和Map这三大核心接口及其实现类。 首先,让我们从List接口开始。List是一种有序的集合,允许有重复元素,并且支持通过索引来访问元素。ArrayList和LinkedList是List...

    Java-Java集合体系-List-Set

    Java集合体系是Java编程中非常核心的部分,涵盖了用于存储和操作数据的各种数据结构。在Java中,集合主要分为三大接口:List、...在面试中,深入理解集合的底层原理和操作性能,能展现出扎实的Java基础和问题解决能力。

    java基础教程----精华版

    - `java.util`包中的ArrayList, LinkedList, HashMap等是常用的集合类,提供了存储和操作对象的方法。 - 集合框架包括List, Set, Queue, Map等接口,以及它们的实现类。 7. **多线程**: - Java内置对多线程的...

    深入Java集合学习系列:HashMap的实现原理

    在Java编程语言中,集合框架是开发者日常工作中不可或缺的一部分,HashMap作为其中的重要成员,它的实现原理对于理解Java性能优化和数据结构有深远的意义。HashMap是一个基于哈希表的数据结构,它实现了Map接口,...

    精通java集合框架--List,Set..

    本文将深入探讨Java集合框架的核心概念,包括`List`、`Set`、`Map`以及它们之间的区别和联系。 #### Java集合框架简介 Java集合框架是Java平台的一部分,它由一系列接口组成,这些接口描述了不同类型的容器,比如...

    中信java培训资料------第一部分

    文本文件【7月3日.txt】至【7月25日.txt】可能是每日学习要点或作业的记录,随着时间推移,内容可能涉及更多高级主题,如集合框架(ArrayList、LinkedList、HashMap等)、IO流、线程并发、网络编程、数据库连接以及...

    深入解读大厂java面试必考基本功-HashMap集合配套文档代码资料

    在本套课程中,将会非常深入、非常详细、非常全面的解读HashMap以及源码底层设计的思想。从底层的数据结构到底层源码分析以及怎样使用提高HashMap集合的效率问题等进行分析。如果掌握本套课程,那么再看其他javase的...

    Java 实例 - HashMap遍历源代码-详细教程.zip

    在Java编程语言中,HashMap是集合框架中一个重要的类,用于存储键值对的数据结构。这个实例教程将深入解析HashMap的遍历方法及其源代码,帮助开发者更好地理解和使用HashMap。以下是对这个主题的详细讲解: 1. **...

    CoreJava串讲---超好!

    6. **集合框架**:Java集合框架包括List、Set、Queue和Map四大接口,以及ArrayList、LinkedList、HashSet、HashMap等实现类。熟练运用集合框架可以有效地组织和操作数据。 7. **IO流**:Java的IO流提供了读写文件、...

    2JAVA编程高级-集合类.pdf

    ### JAVA编程高级——集合类知识点详解 #### 一、Java中的集合类概述 在Java编程中,集合类是一个非常重要的概念,它主要用于存储和管理对象的集合。...掌握这些知识点对于深入理解和使用Java集合框架至关重要。

    java-tutorial-2008-03-14

    ArrayList、LinkedList、HashSet、HashMap等都是常用的集合类,我们将探讨它们的用法和各自的特点。 5. **输入/输出(I/O)系统**:Java提供了丰富的I/O流API,用于处理文件读写、网络通信等。我们将会学习...

    java面试java-interview-guide-master.zip

    以下将从Java语言基础、核心特性、集合框架、多线程、网络编程、异常处理、JVM内存管理、数据库交互、设计模式以及面试策略等多个方面,详细阐述这些知识点。 1. **Java语言基础**: - 变量、数据类型:了解基本...

Global site tag (gtag.js) - Google Analytics