目录
版本：
JDK1.8之前HashMap由数组+链表组成的，数组是HashMap的主体，链表则是主要为了解决哈希冲突而存在的（“拉链法”解决冲突）。JDK1.8之后在解决哈希冲突时有了较大的变化，当链表长度大于阈值（默认为8）时，将链表转化为红黑树，以减少搜索时间。
Map（基础知识点）
（双列型集合，存放数据无序，key不可重复，value可以重复 ）
HashMap
底层是哈希表，key不可重复，value可以重复。key对应的记录无序
- 添加 put(K key , V value) 返回值为value的值，如果有覆盖则是此key上一个旧值
- 查询 get(object key)
- 遍历Map集合
BookMap.forEach((k,v)->{
(k + “=”+v).sout
});
直接打印map集合（可以直接打印是因为HashMap源码中覆盖ltoString方法）
System.out.println(BookMap);- 修改 ==覆盖 直接put原来的key 更改value
- 删除（底层是哈希表，没有下标，只能通过key删除value）
- 根据key删除value
- clear
1、什么是HashMap，什么时候选择HashMap
说到容器，你肯定会想到 Java中对象存储容器还有ArrayList，LinkedList，HashSet等，HashMap 相对这些容器来说，可以理解为多了一层指向关系，可以用指定Key找到指定Value。
比如：
现在有一个Java Bean 用于存储职员的信息，字段包括（职员姓名，职员年龄，职员身高，职员体重，职员教育程度 … 等等），我是一名人力资源管理，我需要将员工信息整理好发给老板。
★ 问题：
这个时候你必须要想到，如果两个人名字一样可咋办，查到的到底是谁的信息呢？前者信息会被覆盖吗？带着问题来学习一下HashMap数据结构及其工作原理
2、HashMap数据结构及其工作原理
2.1数据结构（JDK1.7）
HashMap 数据结构为 数组+链表，其中：链表的节点存储的是一个 Entry 对象，每个Entry 对象存储四个属性（hash，key，value，next）JDK1.7
- 整体是一个数组；
- 数组每个位置是一个链表；
- 链表每个节点中的Value即我们存储的Object；
2.2数据结构（JDK1.8之后）
我们现在用的都是 JDK 1.8，底层是由“数组+链表+红黑树”组成，如下图
问题： 为什么jdk1.8要改成“数组+链表+红黑树”？
主要是为了提升在 hash 冲突严重时（链表过长）的查找性能，使用链表的查找性能是 O(n)，而使用红黑树是 O(logn)。
3、源码分析
3.1 JDK1.7版本（1.8在后面）
- put()方法
解释写在代码注释里面了⭐😊
public V put(K key, V value) {
//第一次的时候一定是成立
//table默认就是EMPTY_TABLE，这是一个空的Entry数组
if (table == EMPTY_TABLE) {
//threshold = 16 ，如果传的值不是2^n,下面函数给他转成2^n
inflateTable(threshold);
}
//如果key的值为空，直接put一个空的Key，只能是这一个，如果多个空key只能覆盖他
if (key == null)
return putForNullKey(value);
//对key取hash，为了使hash码更加离散，也就是扰动
int hash = hash(key);
int i = indexFor(hash, table.length);
//是空的直接放入，不是空的，遍历entry，先根据hash码，再根据equals
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 void inflateTable(int toSize) {
//15->16 四舍五入容量成为2次方幂
int capacity = roundUpToPowerOf2(toSize);
//容量*0.75
threshold = (int) Math.min(capacity * loadFactor, MAXIMUM_CAPACITY + 1);
//创建指定容量的Entry(这儿的容量是四舍五入的2次方幂)
table = new Entry[capacity];
//初始化一个Hash种子，使得更加离散
initHashSeedAsNeeded(capacity);
}
final boolean initHashSeedAsNeeded(int capacity) {
//默认的情况下 currentAltHashing 是false
boolean currentAltHashing = hashSeed != 0;
//第一项判断jvm是否启动了 true
//capacity=16第一次的情况下，
//Holder.ALTERNATIVE_HASHING_THRESHOLD是Integer的最大值,如果传了值就是指定的值
//第二项判断是false
//useAltHashing就是false
boolean useAltHashing = sun.misc.VM.isBooted() &&
(capacity >= Holder.ALTERNATIVE_HASHING_THRESHOLD);
//异或成为false
boolean switching = currentAltHashing ^ useAltHashing;
//不进这个循环
if (switching) {
hashSeed = useAltHashing
? sun.misc.Hashing.randomHashSeed(this)
: 0;
}
return switching;
}
上面的代码先初始化Entry数组的类，然后设置threshold的值，是为初始化的值*0.75，然后初始化指定容量的Entry，然后设置hashSeed的值，默认的情况的下0，一般的情况下是不会改变，可以具体看下我上面的注释。
如果key为空，这个时候会调用putForNullKey(value);方法，具体的代码如下：
//设置默认的空键的值
private V putForNullKey(V value) {
//遍历所有的Entry，设置好对应的Entry
for (Entry<K,V> e = table[0]; e != null; e = e.next) {
if (e.key == null) {
V oldValue = e.value;
e.value = value;
e.recordAccess(this);
return oldValue;
}
}
//记录修改的次数
modCount++;
//第一次为空的情况下，添加对应Entry
addEntry(0, null, value, 0);
return null;
}
上面的代码就是遍历所有的table的数组，然后设置table的值，一般的情况下，第一次进来的时候是空的，然后就会调用
addEntry(0, null, value, 0);具体的代码如下：
// 0 null value 0
void addEntry(int hash, K key, V value, int bucketIndex) {
//长度大于初始化长度*0.75，同时这项不等于null
//会调用扩容 这个时候不会进入
if ((size >= threshold) && (null != table[bucketIndex])) {
resize(2 * table.length);
hash = (null != key) ? hash(key) : 0;
bucketIndex = indexFor(hash, table.length);
}
//创建Entry的方法
createEntry(hash, key, value, bucketIndex);
}
上面的代码的是先判断是否需要扩容，扩容的条件：**长度大于初始化长度*0.75，同时插入的下标在数组不为null。**然后创建Entry，具体的代码如下：
//创建Entry
void createEntry(int hash, K key, V value, int bucketIndex) {
//先找到表格中的Entry，直接通过table[当前位置]去new一个Entry
Entry<K,V> e = table[bucketIndex];
table[bucketIndex] = new Entry<>(hash, key, value, e);
size++;
}
进入Entry中，典型的头插法（新的节点的下一个节点，是原来的头节点）
创建好的Entry，然后把size的值++，具体的我们来看下扩容的机制，具体的代码如下：
//扩容的长度是原来的长度*2
void resize(int newCapacity) {
//先将原来的值赋值给oldTable
Entry[] oldTable = table;
//老的长度
int oldCapacity = oldTable.length;
//如果的长度等于最大的长度，就直接用最新的（判断到没到Integer最大值）
if (oldCapacity == MAXIMUM_CAPACITY) {
threshold = Integer.MAX_VALUE;
return;
}
//根据新的长度创建好的newTable
Entry[] newTable = new Entry[newCapacity];
//initHashSeedAsNeeded(newCapacity)这个返回值为false
//转移
transfer(newTable, initHashSeedAsNeeded(newCapacity));
table = newTable;
//计算容量*负载因子
threshold = (int)Math.min(newCapacity * loadFactor, MAXIMUM_CAPACITY + 1);
}
上面的代码就是扩容的容量是原来的2倍，然后主要是调用转移的方法
transfer(newTable, initHashSeedAsNeeded(newCapacity));，具体的代码如下：
//rehash = false
void transfer(Entry[] newTable, boolean rehash) {
int newCapacity = newTable.length;
//遍历原来的数组table
for (Entry<K,V> e : table) {
//遍历数组下面的链表
while(null != e) {
Entry<K,V> next = e.next;
//不需要重新rehash
if (rehash) {
e.hash = null == e.key ? 0 : hash(e.key);
}
//计算出新的位置
int i = indexFor(e.hash, newCapacity);
//放入到对应位置
e.next = newTable[i];
newTable[i] = e;
e = next;
}
}
}
- HashMap（）
//initialCapacity = 16
//loadFactor = 0.75
//threshold = initialCapacity
public HashMap(int initialCapacity, float loadFactor) {
//容量小于0，就要抛异常
if (initialCapacity < 0)
throw new IllegalArgumentException("Illegal initial capacity: " +
initialCapacity);
//如果大于一个最大的容量（1<<30）,就让他是最大容量
if (initialCapacity > MAXIMUM_CAPACITY)
initialCapacity = MAXIMUM_CAPACITY;
//如果负载因子小于0，或者他不是一个正常的传进来的负载因子，就抛异常
if (loadFactor <= 0 || Float.isNaN(loadFactor))
throw new IllegalArgumentException("Illegal load factor: " +
loadFactor);
//就把初始容量和负载因子设置进来了
this.loadFactor = loadFactor;
threshold = initialCapacity;
//可以重写这个方法，所有在HashMap初始化之后~在元素插入之前被调用
init();
}
上面的代码主要赋值了三个值，一个initialCapacity初始化的值(16)，loadFactor负载因子(0.75)，threshold的值等于16。
讲到这个时候,put的方法差不多讲完了，差不多的逻辑，就是判断是否是空的，然后如果是空的，初始化这个table，如果这个键是null，然后就put空的null的键，这个时候也是插入数据，先判断需不需要扩容，如果需要扩容，就先扩容，然后再添加。再然后是计算hash的值，以及计算出来的位置，然后遍历这个数组的位置的链表，找到相同的替换，如果没有，直接添加这个Entry，这个时候也是判断是不是需要扩容，如果需要扩容，就先扩容，如果再添加。
流程图：
参考资料：JDK1.7-HashMap的源码_了不起的盖茨比。的博客-CSDN博客_jdk1.7源码
3.1 JDK1.8版本
从非拷贝构造函数的实现来看，Hashmap的数据似乎并没有在最初就初始化好，仅仅设置了一些初始值而已。
//这两个是限定值 当节点数大于8时会转为红黑树存储
static final int TREEIFY_THRESHOLD = 8;
//当节点数小于6时会转为单向链表存储
static final int UNTREEIFY_THRESHOLD = 6;
//红黑树最小长度为 64
static final int MIN_TREEIFY_CAPACITY = 64;
//HashMap容量初始大小
static final int DEFAULT_INITIAL_CAPACITY = 1 << 4; // aka 16
//HashMap容量极限
static final int MAXIMUM_CAPACITY = 1 << 30;
//负载因子默认大小
static final float DEFAULT_LOAD_FACTOR = 0.75f;
//Node是Map.Entry接口的实现类
//在此存储数据的Node数组容量是2次幂
//每一个Node本质都是一个单向链表
transient Node<K,V>[] table;
//HashMap大小,它代表HashMap保存的键值对的多少
transient int size;
//HashMap被改变的次数
transient int modCount;
//下一次HashMap扩容的大小
int threshold;
//存储负载因子的常量
final float loadFactor;
//默认的构造函数
public HashMap() {
this.loadFactor = DEFAULT_LOAD_FACTOR; // all other fields defaulted
}
//指定容量大小
public HashMap(int initialCapacity) {
this(initialCapacity, DEFAULT_LOAD_FACTOR);
}
//指定容量大小和负载因子大小
public HashMap(int initialCapacity, float loadFactor) {
//指定的容量大小不可以小于0,否则将抛出IllegalArgumentException异常
if (initialCapacity < 0)
throw new IllegalArgumentException("Illegal initial capacity: " +
initialCapacity);
//判定指定的容量大小是否大于HashMap的容量极限
if (initialCapacity > MAXIMUM_CAPACITY)
initialCapacity = MAXIMUM_CAPACITY;
//指定的负载因子不可以小于0或为Null，若判定成立则抛出IllegalArgumentException异常
if (loadFactor <= 0 || Float.isNaN(loadFactor))
throw new IllegalArgumentException("Illegal load factor: " +
loadFactor);
this.loadFactor = loadFactor;
// 设置“HashMap阈值”，当HashMap中存储数据的数量达到threshold时，就需要将HashMap的容量加倍。
//tableSizeFor用于查找到大于给定数值的最近2次幂值，比如给定18就是32。给定33就是64。
this.threshold = tableSizeFor(initialCapacity);
}
//传入一个Map集合,将Map集合中元素Map.Entry全部添加进HashMap实例中
public HashMap(Map<? extends K, ? extends V> m) {
this.loadFactor = DEFAULT_LOAD_FACTOR;
//此构造方法主要实现了Map.putAll()
putMapEntries(m, false);
}
HashMap 是按照 lazy-load 原则，在首次使用时被初始化（拷贝构造函数除外）。我们去看看 put 方法实现，似乎只有一个 putVal 的调用：
public V put(K key, V value) {
return putVal(hash(key), key, value, false, true);
}
进入putVal内部
public V put(K key, V value) {
return putVal(hash(key), key, value, false, true);
}
//HashMap.put的具体实现
final V putVal(int hash, K key, V value, boolean onlyIfAbsent,
boolean evict) {
Node<K,V>[] tab; Node<K,V> p; int n, i;
//判定table不为空并且table长度不可为0,否则将从resize函数中获取
if ((tab = table) == null || (n = tab.length) == 0)
n = (tab = resize()).length;
//这样写法有点绕,其实这里就是通过索引获取table数组中的一个元素看是否为Null
if ((p = tab[i = (n - 1) & hash]) == null)
//若判断成立,则New一个Node出来赋给table中指定索引下的这个元素
tab[i] = newNode(hash, key, value, null);
else { //若判断不成立
Node<K,V> e; K k;
//对这个元素进行Hash和key值匹配
if (p.hash == hash &&
((k = p.key) == key || (key != null && key.equals(k))))
e = p;
else if (p instanceof TreeNode) //如果数组中德这个元素P是TreeNode类型
//判定成功则在红黑树中查找符合的条件的节点并返回此节点
e = ((TreeNode<K,V>)p).putTreeVal(this, tab, hash, key, value);
else { //若以上条件均判断失败，则执行以下代码
//向Node单向链表中添加数据
for (int binCount = 0; ; ++binCount) {
if ((e = p.next) == null) {
p.next = newNode(hash, key, value, null);
//若节点数大于等于8
if (binCount >= TREEIFY_THRESHOLD - 1) // -1 for 1st
//转换为红黑树
treeifyBin(tab, hash);
break;
}
if (e.hash == hash &&
((k = e.key) == key || (key != null && key.equals(k))))
break;
p = e; //p记录下一个节点
}
}
if (e != null) { // existing mapping for key
V oldValue = e.value;
if (!onlyIfAbsent || oldValue == null)
e.value = value;
afterNodeAccess(e);
return oldValue;
}
}
++modCount;
if (++size > threshold) //判断是否需要扩容
resize();
afterNodeInsertion(evict);
return null;
}
- 1.首先获取Node数组table对象和长度，若table为null或长度为0，则调用resize()扩容方法获取table最新对象，并通过此对象获取长度大小
- 2.判定数组中指定索引下的节点是否为Null，若为Null 则new出一个单向链表赋给table中索引下的这个节点
- 3.若判定不为Null,我们的判断再做分支
- 3.1 首先对hash和key进行匹配,若判定成功直接赋予e
- 3.2 若匹配判定失败,则进行类型匹配是否为TreeNode 若判定成功则在红黑树中查找符合条件的节点并将其回传赋给e
- 3.3 若以上判定全部失败则进行最后操作,向单向链表中添加数据若单向链表的长度大于等于8,则将其转为红黑树保存，记录下一个节点,对e进行判定若成功则返回旧值
- 4.最后判定数组大小需不需要扩容
resize方法
//重新设置table大小/扩容 并返回扩容的Node数组即HashMap的最新数据
final Node<K,V>[] resize() {
Node<K,V>[] oldTab = table; //table赋予oldTab作为扩充前的table数据
int oldCap = (oldTab == null) ? 0 : oldTab.length;
int oldThr = threshold;
int newCap, newThr = 0;
if (oldCap > 0) {
//判定数组是否已达到极限大小，若判定成功将不再扩容，直接将老表返回
if (oldCap >= MAXIMUM_CAPACITY) {
threshold = Integer.MAX_VALUE;
return oldTab;
}
//若新表大小(oldCap*2)小于数组极限大小 并且 老表大于等于数组初始化大小
else if ((newCap = oldCap << 1) < MAXIMUM_CAPACITY &&
oldCap >= DEFAULT_INITIAL_CAPACITY)
//旧数组大小oldThr 经二进制运算向左位移1个位置 即 oldThr*2当作新数组的大小
newThr = oldThr << 1; // double threshold
}
//若老表中下次扩容大小oldThr大于0
else if (oldThr > 0)
newCap = oldThr; //将oldThr赋予控制新表大小的newCap
else { //若其他情况则将获取初始默认大小
newCap = DEFAULT_INITIAL_CAPACITY;
newThr = (int)(DEFAULT_LOAD_FACTOR * DEFAULT_INITIAL_CAPACITY);
}
//若新表的下表下一次扩容大小为0
if (newThr == 0) {
float ft = (float)newCap * loadFactor; //通过新表大小*负载因子获取
newThr = (newCap < MAXIMUM_CAPACITY && ft < (float)MAXIMUM_CAPACITY ?
(int)ft : Integer.MAX_VALUE);
}
threshold = newThr; //下次扩容的大小
@SuppressWarnings({"rawtypes","unchecked"})
Node<K,V>[] newTab = (Node<K,V>[])new Node[newCap];
table = newTab; //将当前表赋予table
if (oldTab != null) { //若oldTab中有值需要通过循环将oldTab中的值保存到新表中
for (int j = 0; j < oldCap; ++j) {
Node<K,V> e;
if ((e = oldTab[j]) != null) {//获取老表中第j个元素 赋予e
oldTab[j] = null; //并将老表中的元素数据置Null
if (e.next == null) //若此判定成立 则代表e的下面没有节点了
newTab[e.hash & (newCap - 1)] = e; //将e直接存于新表的指定位置
else if (e instanceof TreeNode) //若e是TreeNode类型
//分割树，将新表和旧表分割成两个树，并判断索引处节点的长度是否需要转换成红黑树放入新表存储
((TreeNode<K,V>)e).split(this, newTab, j, oldCap);
else { // preserve order
Node<K,V> loHead = null, loTail = null; //存储与旧索引的相同的节点
Node<K,V> hiHead = null, hiTail = null; //存储与新索引相同的节点
Node<K,V> next;
//通过Do循环 获取新旧索引的节点
do {
next = e.next;
if ((e.hash & oldCap) == 0) {
if (loTail == null)
loHead = e;
else
loTail.next = e;
loTail = e;
}
else {
if (hiTail == null)
hiHead = e;
else
hiTail.next = e;
hiTail = e;
}
} while ((e = next) != null);
//通过判定将旧数据和新数据存储到新表指定的位置
if (loTail != null) {
loTail.next = null;
newTab[j] = loHead;
}
if (hiTail != null) {
hiTail.next = null;
newTab[j + oldCap] = hiHead;
}
}
}
}
}
//返回新表
return newTab;
}
- 1.判定数组是否已达到极限大小，若判定成功将不再扩容，直接将老表返回
- 2.若新表大小(oldCap2)小于数组极限大小&老表大于等于数组初始化大小 判定成功则 旧数组大小oldThr 经二进制运算向左位移1个位置 即 oldThr2当作新数组的大小
- 2.1. 若[2]的判定不成功，则继续判定 oldThr （代表 老表的下一次扩容量）大于0，若判定成功 则将oldThr赋给newCap作为新表的容量
- 2.2 若 [2] 和[2.1]判定都失败,则走默认赋值 代表 表为初次创建
- 3.确定下一次表的扩容量, 将新表赋予当前表
- 4.通过for循环将老表中德值存入扩容后的新表中
- 4.1 获取旧表中指定索引下的Node对象 赋予e 并将旧表中的索引位置数据置空
- 4.2 若e的下面没有其他节点则将e直接赋到新表中的索引位置
- 4.3 若e的类型为TreeNode红黑树类型
- 4.3.1 分割树，将新表和旧表分割成两个树，并判断索引处节点的长度是否需要转换成红黑树放入新表存储
- 4.3.2 通过Do循环 不断获取新旧索引的节点
- 4.3.3 通过判定将旧数据和新数据存储到新表指定的位置
门限值等于（负载因子）x（容量），如果构建 HashMap 的时候没有指定它们，那么就是依据相应的默认常量值。
门限通常是以倍数进行调整 （newThr = oldThr << 1），我前面提到，根据 putVal 中的逻辑，当元素个数超过门限大小时，则调整 Map 大小。
扩容后，需要将老的数组中的元素重新放置到新的数组，这是扩容的一个主要开销来源。
资料参考：通俗易懂Hashmap源码解析_码农小白猿的博客-CSDN博客_hashmap源码
四、面试宝典
1、HashMap 的底层数据结构
JDK 1.8，底层是由“数组+链表+红黑树”组成，如下图，而在 JDK 1.8 之前是由“数组+链表”组成
2、为什么要改成“数组+链表+红黑树”？
主要是为了提升在 hash 冲突严重时（链表过长）的查找性能，使用链表的查找性能是 O(n)，而使用红黑树是 O(logn)。
3、那在什么时候用链表？什么时候用红黑树？
- 对于插入，默认情况下是使用链表节点。当同一个索引位置的节点在新增后达到9个（阈值8）：如果此时数组长度大于等于 64，则会触发链表节点转红黑树节点（treeifyBin）；而如果数组长度小于64，则不会触发链表转红黑树，而是会进行扩容，因为此时的数据量还比较小。
- 对于移除，当同一个索引位置的节点在移除后达到 6 个，并且该索引位置的节点为红黑树节点，会触发红黑树节点转链表节点（untreeify）。
4、为什么链表转红黑树的阈值是8？
时间和空间
- 红黑树节点大小约为链表节点的2倍，在节点太少时，红黑树的查找性能优势并不明显，付出2倍空间的代价作者觉得不值得
- 理想情况下，使用随机的哈希码，节点分布在 hash 桶中的频率遵循泊松分布，按照泊松分布的公式计算，链表中节点个数为8时的概率为 0.00000006，这个概率足够低了，并且到8个节点时，红黑树的性能优势也会开始展现出来，因此8是一个较合理的数字。
5、那为什么转回链表节点是用的6而不是复用8？
如果我们设置节点多于8个转红黑树，少于8个就马上转链表，当节点个数在8徘徊时，就会频繁进行红黑树和链表的转换，造成性能的损耗。
6、HashMap 有哪些重要属性？分别用于做什么的？
除了用来存储我们的节点 table 数组外，HashMap 还有以下几个重要属性：
1）size：HashMap 已经存储的节点个数；
2）threshold：扩容阈值，当 HashMap 的个数达到该值，触发扩容。
3）loadFactor：负载因子，扩容阈值 = 容量 * 负载因子。
7、threshold 除了用于存放扩容阈值还有其他作用吗？
在我们新建 HashMap 对象时， threshold 还会被用来存初始化时的容量。HashMap 直到我们第一次插入节点时，才会对 table 进行初始化，避免不必要的空间浪费。
8、HashMap 的默认初始容量是多少？HashMap 的容量有什么限制吗？
默认初始容量是16。HashMap 的容量必须是2的N次方，HashMap 会根据我们传入的容量计算一个大于等于该容量的最小的2的N次方，例如传 9，容量为16。
9、为什么负载因子默认值是0.75。
在时间和空间上权衡的结果。如果值较高，例如1，此时会减少空间开销，但是 hash 冲突的概率会增大，增加查找成本；而如果值较低，例如 0.5 ，此时 hash 冲突会降低，但是有一半的空间会被浪费，所以折衷考虑 0.75 似乎是一个合理的值。
10、HashMap 的插入流程是怎么样的？
11、扩容的流程
12、死循环问题
导致死循环的根本原因是 JDK 1.7 扩容采用的是“头插法”，会导致同一索引位置的节点在扩容后顺序反掉。而 JDK 1.8 之后采用的是“尾插法”，扩容后节点顺序不会反掉，不存在死循环问题。
hashmap1.7中的死循环是有多个线程并发扩容形成了环状链表，随后再进行扩容的线程会循环取这个环状链表的节点，造成死循环；其次，环状链表是几个节点相互指向，并不是某个节点自己指向自己。
版权声明：本文内容由互联网用户自发贡献，该文观点仅代表作者本人。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如发现本站有涉嫌侵权/违法违规的内容， 请发送邮件至 举报，一经查实，本站将立刻删除。
文章由极客之音整理，本文链接：https://www.bmabk.com/index.php/post/115338.html
