程序博客网 > 钢琴演奏家 软件

HashMap源码分析

来源：互联网 发布：钢琴演奏家 软件 编辑：程序博客网 时间：2024/06/05 12:50

//-----------------------------------------------------------------------------------

转出处：http://blog.csdn.net/chdjj

作者：RowandJJ

//-----------------------------------------------------------------------------------

注：以下源码基于jdk1.7.0_11



之前的几篇文章介绍了List集合中一些比较常见的类，比如ArrayList、LinkedList、Vector等。本篇文章将介绍集合框架的另一块内容——Map集合。本文主要介绍HashMap。
先回顾下哈希表。
哈希表定义：根据设定的hash函数和处理冲突的方式（开放定址、公共溢出区、链地址、重哈希...）将一组关键字映射到一个有限的连续的地址集上（即bucket数组或桶数组），并以关键字在地址集中的“像”作为记录在表中的存储位置，这种表称为hash表，这一映射过程称为散列，所得存储位置称为哈希地址或散列地址。hash表具有良好的查找性能，在冲突概率很小的情况下，时间复杂度为O（1）。
装载因子：loadfactor = 表中填入的记录数/哈希表的长度.所以loadfactor标志着哈希表的装满程度。
直观的看，装载因子越小，发生冲突的概率越小（因为桶中还没装几个数据，就需要扩容），也就是查找性能越好，但同时浪费的空间就变大。相反，装载因子越大，发生冲突的概率越大（等到桶快填满时才能扩容，比如，采用链表法处理冲突，在此种情况下，会导致链表过长），查找性能越差，同时浪费的空间会减少。
后面我们会看到，HashMap默认的装载因子为0.75.

下面，依然是自顶向下分析，首先看Map接口：
[java] view plain copy
 在CODE上查看代码片派生到我的代码片
  1. public interface Map<K,V> {//Map集合的顶级接口定义  
  2.     // Query Operations  
  3.     int size();  
  4.     boolean isEmpty();  
  5.     boolean containsKey(Object key);//是否包含指定键  
  6.     boolean containsValue(Object value);//是否包含指定值  
  7.     V get(Object key);  
  8.     // Modification Operations  
  9.     V put(K key, V value);  
  10.     V remove(Object key);  
  11.     // Bulk Operations  
  12.     void putAll(Map<? extends K, ? extends V> m);//批量放置元素  
  13.     void clear();  
  14.     // Views  
  15.    //三种视图  
  16.     Set<K> keySet();//获取键集  
  17.     Collection<V> values();//获取值集  
  18.     Set<Map.Entry<K, V>> entrySet();//获取键值集合  
  19.   
  20.     interface Entry<K,V> {//Map的内部接口，代表一个键值对  
  21.         K getKey();//获取键  
  22.         V getValue(); //获取值  
  23.         V setValue(V value);//设置值  
  24.         boolean equals(Object o);  
  25.         int hashCode();  
  26.     }  
  27.   
  28.     // Comparison and hashing  
  29.     boolean equals(Object o);  
  30.     int hashCode();  
  31. }  

Map接口定义了Map集合的操作规范，具体实现交由实现类完成，其内部有个接口Entry，代表一个键值对.

AbstractMap是一个抽象类，其实现了Map接口中的大部分函数。
[java] view plain copy
 在CODE上查看代码片派生到我的代码片
  1. public abstract class AbstractMap<K,V> implements Map<K,V>  

下面来看几个方法：

[java] view plain copy
 在CODE上查看代码片派生到我的代码片
  1. public boolean containsKey(Object key) {  
  2.         Iterator<Map.Entry<K,V>> i = entrySet().iterator();//获得迭代器  
  3.         if (key==null) {//判断key是否为空,分别处理  
  4.             while (i.hasNext()) {  
  5.                 Entry<K,V> e = i.next();  
  6.                 if (e.getKey()==null)//为空的话使用等号判断  
  7.                     return true;  
  8.             }  
  9.         } else {  
  10.             while (i.hasNext()) {  
  11.                 Entry<K,V> e = i.next();  
  12.                 if (key.equals(e.getKey()))//不为空的话使用equals方法判断  
  13.                     return true;  
  14.             }  
  15.         }  
  16.         return false;  
  17.     }  
  18.     public boolean containsValue(Object value) {  
  19.         Iterator<Entry<K,V>> i = entrySet().iterator();  
  20.         if (value==null) {  
  21.             while (i.hasNext()) {  
  22.                 Entry<K,V> e = i.next();  
  23.                 if (e.getValue()==null)  
  24.                     return true;  
  25.             }  
  26.         } else {  
  27.             while (i.hasNext()) {  
  28.                 Entry<K,V> e = i.next();  
  29.                 if (value.equals(e.getValue()))  
  30.                     return true;  
  31.             }  
  32.         }  
  33.         return false;  
  34.     }  
首先是containsKey和containsValue方法，需要注意的是这里的key和value是允许为空的，也就是说其子类默认是支持null键和值的。这里的entrySet方法是个抽象方法：
[java] view plain copy
 在CODE上查看代码片派生到我的代码片
  1. public abstract Set<Entry<K,V>> entrySet();  

abstractMap并没有实现put方法，而简单的抛出了异常，这要求子类必须复写此方法：

[java] view plain copy
 在CODE上查看代码片派生到我的代码片
  1. public V put(K key, V value) {  
  2.        throw new UnsupportedOperationException();  
  3.    }  

但是其却实现了get方法：
[java] view plain copy
 在CODE上查看代码片派生到我的代码片
  1. public V get(Object key) {  
  2.        Iterator<Entry<K,V>> i = entrySet().iterator();  
  3.        if (key==null) {//依然是根据键值是否为null做不同处理  
  4.            while (i.hasNext()) {  
  5.                Entry<K,V> e = i.next();  
  6.                if (e.getKey()==null)  
  7.                    return e.getValue();  
  8.            }  
  9.        } else {  
  10.            while (i.hasNext()) {  
  11.                Entry<K,V> e = i.next();  
  12.                if (key.equals(e.getKey()))  
  13.                    return e.getValue();  
  14.            }  
  15.        }  
  16.        return null;  
  17.    }  

下面来看HashMap。

[java] view plain copy
 在CODE上查看代码片派生到我的代码片
  1. public class HashMap<K,V>  
  2.     extends AbstractMap<K,V>  
  3.     implements Map<K,V>, Cloneable, Serializable  

HashMap继承了AbstractMap类，并实现了Map接口以及Cloneable、Serializable接口。
其成员变量如下：
[java] view plain copy
 在CODE上查看代码片派生到我的代码片
  1. static final int DEFAULT_INITIAL_CAPACITY = 16;//默认初始容量  
  2.    static final int MAXIMUM_CAPACITY = 1 << 30;//最大容量为2的30次方  
  3.    static final float DEFAULT_LOAD_FACTOR = 0.75f;//默认装载因子为0.75  
  4.    transient Entry<K,V>[] table;//桶数组，存放键值对  
  5.    transient int size;//实际存储的键值对个数  
  6.    int threshold;//HashMap的阈值，用于判断是否需要调整HashMap的容量（threshold = 容量*加载因子）  
  7.    final float loadFactor;//装载因子  
  8.    transient int modCount;//hashmap被改变的次数  
  9.    static final int ALTERNATIVE_HASHING_THRESHOLD_DEFAULT = Integer.MAX_VALUE;  

这里我们得到如下信息：1.HashMap的默认大小为16，即桶数组的默认长度为16；2.HashMap的默认装载因子是0.75；3.HashMap内部的桶数组存储的是Entry对象，也就是键值对对象。
再看构造器：
[java] view plain copy
 在CODE上查看代码片派生到我的代码片
  1. public HashMap(int initialCapacity, float loadFactor) {//可手动设置初始容量和装载因子的构造器  
  2.        if (initialCapacity < 0)  
  3.            throw new IllegalArgumentException("Illegal initial capacity: " +  
  4.                                               initialCapacity);  
  5.        if (initialCapacity > MAXIMUM_CAPACITY)  
  6.            initialCapacity = MAXIMUM_CAPACITY;  
  7.        if (loadFactor <= 0 || Float.isNaN(loadFactor))  
  8.            throw new IllegalArgumentException("Illegal load factor: " +  
  9.                                               loadFactor);  
  10.        // Find a power of 2 >= initialCapacity  
  11.        //找出“大于initialCapacity”的最小的2的幂  
  12.        int capacity = 1;  
  13.        while (capacity < initialCapacity)  
  14.            capacity <<= 1;  
  15.        this.loadFactor = loadFactor;  
  16.        threshold = (int)Math.min(capacity * loadFactor, MAXIMUM_CAPACITY + 1);  
  17.        //初始化桶数组  
  18.        table = new Entry[capacity];  
  19.        useAltHashing = sun.misc.VM.isBooted() &&  
  20.                (capacity >= Holder.ALTERNATIVE_HASHING_THRESHOLD);  
  21.        init();//一个钩子函数，默认实现是空  
  22.    }  
  23.   
  24.    public HashMap(int initialCapacity) {  
  25.        this(initialCapacity, DEFAULT_LOAD_FACTOR);  
  26.    }  
  27.    public HashMap() {//使用默认的初始容量和默认的加载因子构造HashMap  
  28.        this(DEFAULT_INITIAL_CAPACITY, DEFAULT_LOAD_FACTOR);  
  29.    }  
  30.    public HashMap(Map<? extends K, ? extends V> m) {  
  31.        this(Math.max((int) (m.size() / DEFAULT_LOAD_FACTOR) + 1,  
  32.                      DEFAULT_INITIAL_CAPACITY), DEFAULT_LOAD_FACTOR);  
  33.        putAllForCreate(m);  
  34.    }  
  35.    // internal utilities  
  36.   
  37.    void init() {  
  38.    }  

需要注意的点：
1.构造器支持指定初始容量和装载因子，为避免数组扩容带来的性能问题，建议根据需求指定初始容量。装载因子尽量不要修改，0.75是个比较靠谱的值。
2.实际的容量capacity一般情况下是大于我们传进去的initialCapacity的，因为内部会通过一个循环去找到一个比initialCapacity大且为2的整数次幂的一个数作为实际容量。除非传进去的数恰好为2的整数次方（capacity取2的整数次幂，是为了使不同hash值发生碰撞的概率较小，这样就能使元素在哈希表中均匀地散列。）。

通过前面的分析，我们知道了HashMap内部通过Entry数组保存键值对，那么这个Entry是怎么实现的呢？
接下来我们看下Entry的实现：
[java] view plain copy
 在CODE上查看代码片派生到我的代码片
  1. static class Entry<K,V> implements Map.Entry<K,V> {//实现Map.Entry接口  
  2.        final K key;//键,final类型，不可更改/  
  3.        V value;//值  
  4.        Entry<K,V> next;//HashMap通过链表法解决冲突，这里的next指向链表的下一个元素  
  5.        int hash;//hash值  
  6.        /** 
  7.         * Creates new entry. 
  8.         */  
  9.        //构造器需指定链表的下一个结点,所有冲突结点放到一个链表上  
  10.        Entry(int h, K k, V v, Entry<K,V> n) {  
  11.            value = v;  
  12.            next = n;  
  13.            key = k;  
  14.            hash = h;  
  15.        }  
  16.        public final K getKey() {  
  17.            return key;  
  18.        }  
  19.        public final V getValue() {  
  20.            return value;  
  21.        }  
  22.        //允许设置value  
  23.        public final V setValue(V newValue) {  
  24.            V oldValue = value;  
  25.            value = newValue;  
  26.            return oldValue;  
  27.        }  
  28.        public final boolean equals(Object o) {  
  29.            if (!(o instanceof Map.Entry))  
  30.                return false;  
  31.            Map.Entry e = (Map.Entry)o;  
  32.            //保证键值都相等  
  33.            Object k1 = getKey();  
  34.            Object k2 = e.getKey();  
  35.            if (k1 == k2 || (k1 != null && k1.equals(k2))) {  
  36.                Object v1 = getValue();  
  37.                Object v2 = e.getValue();  
  38.                if (v1 == v2 || (v1 != null && v1.equals(v2)))  
  39.                    return true;  
  40.            }  
  41.            return false;  
  42.        }  
  43.        public final int hashCode() {//键为空则hash值为0，否则通过通过hashcode计算  
  44.            return (key==null   ? 0 : key.hashCode()) ^  
  45.                   (value==null ? 0 : value.hashCode());  
  46.        }  
  47.        public final String toString() {  
  48.            return getKey() + "=" + getValue();  
  49.        }  
  50.        /** 
  51.         * This method is invoked whenever the value in an entry is 
  52.         * overwritten by an invocation of put(k,v) for a key k that's already 
  53.         * in the HashMap. 
  54.         */  
  55.        void recordAccess(HashMap<K,V> m) {  
  56.        }  
  57.        /** 
  58.         * This method is invoked whenever the entry is 
  59.         * removed from the table. 
  60.         */  
  61.        void recordRemoval(HashMap<K,V> m) {  
  62.        }  
  63.    }  

需要注意的点：
1.HashMap内部数组存储的是键值对，也就是Entry对象；
2.Entry对象保存了键、值，并持有一个next指针指向下一个Entry对象（HashMap通过链表法解决冲突）；
3.Entry可以通过setValue设置值，但不允许设置键.

下面我们研究下HashMap中比较重要的方法。从put开始：
[java] view plain copy
 在CODE上查看代码片派生到我的代码片
  1. public V put(K key, V value) {//向集合中添加一个键值对  
  2.       if (key == null)//如果键为空，则调用putForNullKey  
  3.           return putForNullKey(value);  
  4.       int hash = hash(key);//否则根据key生成一个hash索引值  
  5.       int i = indexFor(hash, table.length);//在根据索引值找到插入位置  
  6.     //循环遍历指定位置的Entry链表，若找到一个键与当前键完全一致的Entry，那么覆盖原来的键所对应的值,并返回原值   
  7.      for (Entry<K,V> e = table[i]; e != null; e = e.next) {  
  8.           Object k;  
  9.           //hash值相同且键相同  
  10.           if (e.hash == hash && ((k = e.key) == key || key.equals(k))) {  
  11.               V oldValue = e.value;  
  12.               e.value = value;//替换原值  
  13.               e.recordAccess(this);  
  14.               return oldValue;  
  15.           }  
  16.       }  
  17.      //若没有找到这样的键，则将当前键值插入该位置，并使其位于链表头部.  
  18.       modCount++;  
  19.       addEntry(hash, key, value, i);  
  20.       return null;  
  21.   }  

put方法是向hashMap中添加一个键值对，这个方法需要注意的有：
1.允许键为null。put方法会针对null键做相应的处理，调用pullforNullKey方法：
[java] view plain copy
 在CODE上查看代码片派生到我的代码片
  1.   private V putForNullKey(V value) {  
  2.      //空键，其hash值为0，必然存储在数组的0索引位置上。  
  3. //我们需要遍历0位置的entry链表，如果已经有一个null键了，那么也是覆盖  
  4.         for (Entry<K,V> e = table[0]; e != null; e = e.next) {  
  5.             if (e.key == null) {  
  6.                 V oldValue = e.value;  
  7.                 e.value = value;  
  8.                 e.recordAccess(this);  
  9.                 return oldValue;  
  10.             }  
  11.         }  
  12. //若没有，则插入  
  13.         modCount++;  
  14.         addEntry(0, null, value, 0);  
  15.         return null;  
  16.     }  

2.不允许两个键相同，如果键相同，那么后插入的键所对应的值会覆盖之前的值。
3.HashMap是通过调用hash()方法获得键的hash值，并通过indexFor方法找到实际插入位置，具体代码如下：
[java] view plain copy
 在CODE上查看代码片派生到我的代码片
  1.   final int hash(Object k) {//根据键生成hash值  
  2.         int h = 0;  
  3.         if (useAltHashing) {  
  4.             if (k instanceof String) {  
  5.                 return sun.misc.Hashing.stringHash32((String) k);  
  6.             }  
  7.             h = hashSeed;  
  8.         }  
  9.         h ^= k.hashCode();  
  10.         h ^= (h >>> 20) ^ (h >>> 12);  
  11.         return h ^ (h >>> 7) ^ (h >>> 4);  
  12.     }  
  13. //根据hash值计算键在桶数组的位置  
  14.     static int indexFor(int h, int length) {  
  15.         return h & (length-1);//由put方法可知，这个length就是数组长度，而且由构造器发现数组长度始终为2的整数次方，那么这个&操作实际上就是是h%length的高效表示方式,可以使结果小于数组长度.  
  16.     }  

4.put方法通过addEntry方法将键值插到合适位置:
5.当容量超过阈值（threshold）时,会发生扩容，扩容后的数组是原数组的两倍。
[java] view plain copy
 在CODE上查看代码片派生到我的代码片
  1. void addEntry(int hash, K key, V value, int bucketIndex) {  
  2.         if ((size >= threshold) && (null != table[bucketIndex])) {//容量超过阈值  
  3.             resize(2 * table.length);//数组扩容为原来的两倍  
  4.             hash = (null != key) ? hash(key) : 0;  
  5.             bucketIndex = indexFor(hash, table.length);  
  6.         }  
  7.         createEntry(hash, key, value, bucketIndex);  
  8.     }  
  9.     void createEntry(int hash, K key, V value, int bucketIndex) {  
  10.         Entry<K,V> e = table[bucketIndex];//获取原来在该位置上的Entry对象  
  11.         table[bucketIndex] = new Entry<>(hash, key, value, e);//将当前的键值插到该位置，并作为链表的起始结点。其next指针指向先前的Entry  
  12.         size++;  
  13.     }  

这个resize方法就是扩容方法：
[java] view plain copy
 在CODE上查看代码片派生到我的代码片
  1. void resize(int newCapacity) {  
  2.         Entry[] oldTable = table;  
  3.         int oldCapacity = oldTable.length;  
  4.         if (oldCapacity == MAXIMUM_CAPACITY) {  
  5.             threshold = Integer.MAX_VALUE;  
  6.             return;  
  7.         }  
  8.         Entry[] newTable = new Entry[newCapacity];//创建新数组  
  9.         boolean oldAltHashing = useAltHashing;  
  10.         useAltHashing |= sun.misc.VM.isBooted() &&  
  11.                 (newCapacity >= Holder.ALTERNATIVE_HASHING_THRESHOLD);  
  12.         boolean rehash = oldAltHashing ^ useAltHashing;  
  13.         transfer(newTable, rehash);//将原数组中所有键值对转移至新数组  
  14.         table = newTable;  
  15.         threshold = (int)Math.min(newCapacity * loadFactor, MAXIMUM_CAPACITY + 1);  
  16.     }  
  17. void transfer(Entry[] newTable, boolean rehash) {  
  18.         int newCapacity = newTable.length;  
  19.         for (Entry<K,V> e : table) {//需遍历每个Entry,耗时  
  20.             while(null != e) {  
  21.                 Entry<K,V> next = e.next;  
  22.                 if (rehash) {  
  23.                     e.hash = null == e.key ? 0 : hash(e.key);  
  24.                 }  
  25.                 int i = indexFor(e.hash, newCapacity);  
  26.                 e.next = newTable[i];  
  27.                 newTable[i] = e;  
  28.                 e = next;  
  29.             }  
  30.         }  
  31.     }  

6.扩容操作需要开辟新数组，并对原数组中所有键值对重新散列，非常耗时。我们应该尽量避免HashMap扩容。

再来看get方法：
[java] view plain copy
 在CODE上查看代码片派生到我的代码片
  1. public V get(Object key) {  
  2.         if (key == null)//若键为空  
  3.             return getForNullKey();  
  4.         Entry<K,V> entry = getEntry(key);//获取Entry对象  
  5. //未找到就返回null，否则返回键所对应的值  
  6.         return null == entry ? null : entry.getValue();  
  7.     }  

这个getForNullKey方法就是在数组0索引位上的链表去寻找null键：
[java] view plain copy
 在CODE上查看代码片派生到我的代码片
  1. private V getForNullKey() {  
  2.        for (Entry<K,V> e = table[0]; e != null; e = e.next) {  
  3.            if (e.key == null)  
  4.                return e.value;  
  5.        }  
  6.        return null;  
  7.    }  

而这个getEntry方法就是通过键生成hash值，然后得到其在数组的索引位，查找该位置的链表，找到第一个满足的键，并返会Entry对象：

[java] view plain copy
 在CODE上查看代码片派生到我的代码片
  1. final Entry<K,V> getEntry(Object key) {  
  2.         int hash = (key == null) ? 0 : hash(key);  
  3.         for (Entry<K,V> e = table[indexFor(hash, table.length)];  
  4.              e != null;  
  5.              e = e.next) {  
  6.             Object k;  
  7.             if (e.hash == hash &&  
  8.                 ((k = e.key) == key || (key != null && key.equals(k))))  
  9.                 return e;  
  10.         }  
  11.         return null;  
  12.     }  

再看下remove方法：
[java] view plain copy
 在CODE上查看代码片派生到我的代码片
  1. public V remove(Object key) {  
  2.         Entry<K,V> e = removeEntryForKey(key);  
  3.         return (e == null ? null : e.value);  
  4.     }  
  5.     final Entry<K,V> removeEntryForKey(Object key) {  
  6.         int hash = (key == null) ? 0 : hash(key);//先计算hash值  
  7.         int i = indexFor(hash, table.length);//找到索引位  
  8.         Entry<K,V> prev = table[i];  
  9.         Entry<K,V> e = prev;  
  10.         while (e != null) {//遍历链表找到该键，并修改链表相关指针指向  
  11.             Entry<K,V> next = e.next;  
  12.             Object k;  
  13.             if (e.hash == hash &&  
  14.                 ((k = e.key) == key || (key != null && key.equals(k)))) {  
  15.                 modCount++;  
  16.                 size--;  
  17.                 if (prev == e)  
  18.                     table[i] = next;  
  19.                 else  
  20.                     prev.next = next;  
  21.                 e.recordRemoval(this);  
  22.                 return e;  
  23.             }  
  24.             prev = e;  
  25.             e = next;  
  26.         }  
  27.         return e;  
  28.     }  

最后看下clear方法：
[java] view plain copy
 在CODE上查看代码片派生到我的代码片
  1. public void clear() {  
  2.        modCount++;  
  3.        Entry[] tab = table;  
  4.        for (int i = 0; i < tab.length; i++)//遍历数组  
  5.            tab[i] = null;//置空  
  6.        size = 0;  
  7.    }  

总结：
1.HashMap的默认大小为16，即桶数组的默认长度为16；
2.HashMap的默认装载因子是0.75；
3.HashMap内部的桶数组存储的是Entry对象，也就是键值对对象。
4.构造器支持指定初始容量和装载因子，为避免数组扩容带来的性能问题，建议根据需求指定初始容量。装载因子尽量不要修改，0.75是个比较靠谱的值。
5.桶数组的长度始终是2的整数次方（大于等于指定的初始容量），这样做可以减少冲突概率，提高查找效率。（可以从indexfor函数中看出，h&(length-1),若length为奇数，length-1为偶数那么h&(length-1)结果的最后一位必然为0，也就是说所有键都被散列到数组的偶数下标位置,这样会浪费近一半空间。另外，length为2的整数次方也保证了h&(length-1)与h%length等效）.
6.HashMap接受null键；
7.HashMap不允许键重复，但是值是可以重复的。若键重复，那么新值会覆盖旧值。
8.HashMap通过链表法解决冲突问题，每个Entry都有一个next指针指向下一个Entry，冲突元素（不是键相同，而是hash值相同）会构成一个链表。并且最新插入的键值对始终位于链表首部。
9.当容量超过阈值（threshold）时,会发生扩容，扩容后的数组是原数组的两倍。扩容操作需要开辟新数组，并对原数组中所有键值对重新散列，非常耗时。我们应该尽量避免HashMap扩容。
10.HashMap非线程安全。
0 0
钢琴演奏家 软件 钢琴演奏家 软件
原创粉丝点击
热门IT博客
彩票数据分析软件彩票数据分析软件
淘宝助手是干什么用的淘宝助手是干什么用的
c 并发编程实践
白玉菩提子淘宝谁家卖
永利娱乐系统源码搭建
仁化县网络问政回复
java项目http转https
怎么注册淘宝联盟
phpcms linux 权限
21天学通java txt
淘宝贪吃飒
华为liteos 源码下载
淘宝充值平台官网登录
自学钢琴软件
ubuntu 安装koala
mac vscode c语言
手机屏幕录视频软件
安徽工程大学网络教学
java jlabel 鼠标事件
淘宝导航首页颜色代码
热门问题 老师的惩罚 人脸识别 我在镇武司摸鱼那些年 重生之率土为王 我在大康的咸鱼生活 盘龙之生命进化 天生仙种 凡人之先天五行 春回大明朝 姑娘不必设防，我是瞎子 尿道口红红的怎么回事 早晨尿液发红 尿道口溃疡 尿路感染小便出血 早上尿液发红 晚上尿床是怎么回事 小孩晚上尿床怎么回事 小孩子老是尿床是怎么回事 尿裤子故事 尿裤子视顿大全 一咳嗽就尿裤子怎么回事 咳嗽尿裤子怎么回事 梦见尿裤子 女孩憋不住尿裤子 尿裤子图片 尿裤子作文 女子尿裤子视顿 尿裤子的故事 尿裤子事件 安吉里卡尿裤子 憋不住尿裤子视顿大全 尿裤子比赛故事 尿裤子故事长 考试尿裤子 男生尿裤子视顿 女子憋不住尿湿裤子照片动态 女子憋不住尿湿裤子照片 2岁小孩子尿裤子沟通技巧 梦见自己尿裤子 憋不住尿裤子 尿后提裤子滴尿正常吗 小孩老是尿裤子怎么回事 小孩尿裤子怎么回事 男人尿裤子 内急尿裤子故事 男孩尿裤子 男生尿裤子 老师尿裤子 尿裤子的照片 小孩尿裤子 小孩尿裤子是什么原因

程序博客网，程序员的互联网技术博客家园。csdn论坛精品 msdn技术资料都在这里