JAVA集合框架--Set/Map/List

JAVA集合框架

本博客集合了多个博客的知识总结，尾部带有所有参考博客的博客链接

　　集合可以看作是一种容器，用来存储对象信息。所有集合类都位于java.util包下，但支持多线程的集合类位于java.util.concurrent包下。

数组与集合的区别如下：

1）数组长度不可变化而且无法保存具有映射关系的数据；集合类用于保存数量不确定的数据，以及保存具有映射关系的数据。

2）数组元素既可以是基本类型的值，也可以是对象；集合只能保存对象。

Java集合类主要由两个根接口Collection和Map派生出来的，Collection派生出了三个子接口：List、Set、Queue（Java5新增的队列），因此Java集合大致也可分成List、Set、Queue、Map四种接口体系，（注意：Map不是Collection的子接口）。

其中List代表了有序可重复集合，可直接根据元素的索引来访问；Set代表无序不可重复集合，只能根据元素本身来访问；Queue是队列集合；Map代表的是存储key-value对的集合，可根据元素的key来访问value。

上图中淡绿色背景覆盖的是集合体系中常用的实现类，分别是ArrayList、LinkedList、ArrayQueue、HashSet、TreeSet、HashMap、TreeMap等实现类。

Set(无序，不可以重复元素)

1.HashSet

HashSet是Set集合最常用实现类，是其经典实现。HashSet是按照hash算法来存储元素的，因此具有很好的存取和查找性能。

HashSet具有如下特点：

• 不能保证元素的顺序(顺序与添加顺序不同)。
• HashSet不是线程同步的(底层数据结构是哈希表。是线程不安全的)，如果多线程操作HashSet集合，则应通过代码来保证其同步。
• 集合元素值可以是null。

当向HashSet集合存储一个元素时：

HashSet会调用该对象的hashCode()方法得到其hashCode值，然后根据hashCode值决定该对象的存储位置。

HashSet保证元素唯一性

HashSet集合判断两个元素相等的标准是：

1. 两个对象的**hashCode()**方法返回值相等。
2. 两个对象通过**equals()**方法比较返回true；

因此，如果(1)和(2)有一个不满足条件，则认为这两个对象不相等，可以添加成功。

如果元素的HashCode值相同，才会判断equals是否为true。如果元素的hashcode值不同，不会调用equals。

如果两个对象的hashCode()方法返回值相等，但是两个对象通过equals()方法比较返回false，HashSet会以链式结构将两个对象保存在同一位置，这将导致性能下降，因此在编码时应避免出现这种情况。

当你添加相同的字符串进去的时候，不会添加成功。

其中，在HashSet中，String类已经重写了hashcode()方法和equals()方法，用来比较指向的字符串对象所存储的字符串是否相等。

插一下equals与==比较：
java的类型包括两类，一个为基础数据类型，一个为引用类型；在没有重写equals的方法情况下，equals与==比较结果相同，都是对引用地址的比较；基础数据类型都重写了equals方法，拿string类来说，它重写了object的equals方法

但是要将自定义的元素add进HashSet中，则必须定义其自己的hashcode()方法和equals（）方法。
如下所示：（自定义Person类对象）

package com.package2;
import java.util.*;
public class HashSet3 
{
	public static void main(String[] args) 
	{
		HashSet hs = new HashSet();
 
		hs.add(new Person("a1",11));
		hs.add(new Person("a2",12));
		hs.add(new Person("a3",13));
		hs.add(new Person("a2",12));
		hs.add(new Person("a4",14));
		
		Iterator it = hs.iterator();
		/*迭代器：轻量级对象（创建代价小，只能单向移动），工作时遍历并选择序列中的对象
			4个方法：
			1.使用iterator()来返回一个Iterator。
			2.使用Object next()获得集合中的下一个元素。
			3.使用boolean hasNext()检查集合中是否还有元素(判断集合里是否存在下一个元素)。
			4.使用remove()将迭代器新近返回的元素删除。（删除集合里上一次next方法返回的元素）*/
 
		while(it.hasNext())
		{
			Person p = (Person)it.next();
			System.out.println(p.getName()+"::"+p.getAge());
		}
	}
}
class Person
{
	private String name;
	private int age;
	Person(String name,int age)
	{
		this.name = name;
		this.age = age;
	}
	
	public int hashCode()
	{
		System.out.println(this.name+"....hashCode");
		return name.hashCode()+age*37;  //保证此元素的返回值尽量不一致。
	}

	public boolean equals(Object obj)
	{
 
		if(!(obj instanceof Person)) //instanceof用来判断一个对象是不是一个类的实例
		
			return false;
 
		Person p = (Person)obj;
		System.out.println(this.name+"...equals.."+p.name);
 
		return this.name.equals(p.name) && this.age == p.age;
		//this.name 是String类型，而String类重写了equals方法，比较的是字符串的内容，不再是地址值。
		//这里其实就是比较名字和年龄是否相同
	}
 
	
	public String getName()
	{
		return name;
	}
	public int getAge()
	{
		return age;
	}
}

HashSet查找原理如下：

基于HashSet以上的存储原理，在查找元素时，HashSet先计算元素的HashCode值（也就是调用对象的hashCode方法的返回值），然后直接到hashCode值对应的位置去取出元素即可，这就是HashSet速度很快的原因。

LinkedHashSet类

LinkedHashSet是HashSet的一个子类，具有HashSet的特性，也是根据元素的hashCode值来决定元素的存储位置。但它使用链表维护元素的次序，元素的顺序与添加顺序一致。由于LinkedHashSet需要维护元素的插入顺序，因此性能略低于HashSet，但在迭代访问Set里的全部元素时由很好的性能。

TreeSet

• 可以对Set集合中的元素进行排序。
• 底层数据结构是二叉树。
• 保证元素唯一性的依据：compareTo方法return 0

TreeSet支持两种排序方法：自然排序和定制排序，默认采用自然排序。

自然排序

让元素自身具备比较性

TreeSet会调用集合元素的 compareTo(Object obj) 方法来比较元素的大小关系，然后将元素按照升序排列，这就是自然排序。

如果试图将一个对象添加到TreeSet集合中，则该对象必须实现Comparable接口，并且覆盖compareTo方法

当一个对象调用方法与另一个对象比较时，例如obj1.compareTo(obj2)，如果该方法返回0，则两个对象相等；如果返回一个正数，则obj1大于obj2；如果返回一个负数，则obj1小于obj2。

Comparable接口:该接口对实现它的每个类的对象强加一个整体排序。 这个排序被称为类的自然排序 ，类的compareTo方法被称为其自然比较方法 。

Java常用类中已经实现了Comparable接口的类有以下几个：

♦ BigDecimal、BigDecimal以及所有数值型对应的包装类：按照它们对应的数值大小进行比较。

♦ Charchter：按照字符的unicode值进行比较。

♦ Boolean：true对应的包装类实例大于false对应的包装类实例。

♦ String：按照字符串中的字符的unicode值进行比较。

♦ Date、Time：后面的时间、日期比前面的时间、日期大。

对于TreeSet集合而言，它判断两个对象是否相等的标准是：两个对象通过compareTo(Object obj)方法比较是否返回0，如果返回0则相等。

String就不做举例，大家都知道String类已经实现该接口，如果我们要往TreeSet里添加的元素是自己刚刚定义的，我们也可以自己定义该元素的类实现Comparable接口，并且覆盖compareTo（）方法：

package com.package1;
 
import java.util.*;
 
class Student implements Comparable//该接口强制让学生具备比较性。
{
	private String name;
	private int age;
 
	Student(String name,int age)
	{
		this.name = name;
		this.age = age;
	}
 
	public int compareTo(Object obj)
	{
 
		//return 0;
		
		if(!(obj instanceof Student))
			throw new RuntimeException("不是学生对象");
		Student s = (Student)obj;
 
		//System.out.println(this.name+"....compareto....."+s.name);
		if(this.age>s.age)
			return 1;
		if(this.age==s.age)
		{
			return this.name.compareTo(s.name);
		}
		return -1;
		/**/
	}
	public String getName()
	{
		return name;
	}
	public int getAge()
	{
		return age;
	}
}
public class TreeSet2 
{
	public static void main(String[] args) 
	{
		TreeSet ts = new TreeSet();
		ts.add(new Student("lisi02",22));
		ts.add(new Student("lisi02",21));
		ts.add(new Student("lisi007",20));
		ts.add(new Student("lisi09",19));
		ts.add(new Student("lisi06",18));
		ts.add(new Student("lisi06",18));
		ts.add(new Student("lisi007",29));
		Iterator it = ts.iterator();
		while(it.hasNext())
		{
			Student stu = (Student)it.next();
			System.out.println(stu.getName()+"..."+stu.getAge());
		}
	}
}

定制排序

当元素自身不具备比较性时，或者具备的比较性不是所需要的。这时就需要让集合自身具备比较性（即利用其另一种构造函数建立对象）。在集合初始化时，就有了比较方式。

想要实现定制排序，需要在创建TreeSet集合对象时，提供一个Comparator对象与该TreeSet集合关联，由Comparator对象负责集合元素的排序逻辑。

也就是说：利用某个指定类实现Comparator接口，并且重写compare（）方法，则此类会成为一个具备比较方法的类（自己创建一个比较器）。在建立TreeSet的时候，将此类对象传入其中。 则此时，添加进TreeSet中的元素可按照指定比较方法进行排序。

Comparator比较器接口：比较功能，对一些对象的集合施加了一个整体排序 。 

/*
 * 使元素按照长度来排序，若长度相同，则按照自然排序。
 */
public class TreeSettest {
 
	public static void main(String[] args) {
		//创建对象
		TreeSet ts=new TreeSet(new MyCompare());
		
		//添加元素
		ts.add("abc");
		ts.add("bcc");
		ts.add("das");
		ts.add("bcde");
		ts.add("asdfg");
		ts.add("befqfca");
		
		//进行迭代
		Iterator it=ts.iterator();
		
		//循环取出元素
		while(it.hasNext())
		{
			System.out.println(it.next());
		}
 
	}
 
}
 
//定义一个类实现Comparator接口，并且覆盖compare（）方法。
class MyCompare implements Comparator
{
 
	@Override
	public int compare(Object o1, Object o2) {
		//进行强制类型转换
		String s1=(String) o1;
		String s2=(String) o2;
		
		//进行比较
		if(s1.length()>s2.length())
			return 1;
		if(s1.length()<s2.length())
			return -1;
		if(s1.length()==s2.length())
		{
			return s1.compareTo(s2);
		}
		return 0;
	}
}

综上：自然排序实现的是Comparable接口，定制排序实现的是Comparator接口。

EnumSet类

EnumSet是一个专为枚举类设计的集合类，不允许添加null值。EnumSet的集合元素也是有序的，它以枚举值在Enum类内的定义顺序来决定集合元素的顺序。

各Set实现类的性能分析

HashSet的性能比TreeSet的性能好（特别是添加，查询元素时），因为TreeSet需要额外的红黑树算法维护元素的次序，如果需要一个保持排序的Set时才用TreeSet，否则应该使用HashSet。

LinkedHashSet是HashSet的子类，由于需要链表维护元素的顺序，所以插入和删除操作比HashSet要慢，但遍历比HashSet快。

EnumSet是所有Set实现类中性能最好的，但它只能 保存同一个枚举类的枚举值作为集合元素。

以上几个Set实现类都是线程不安全的，如果多线程访问，必须手动保证集合的同步性

List

这个集合主要在于了解它所具有方法就好：推荐   https://blog.csdn.net/Barcon/article/details/82628120

List集合代表一个有序、可重复集合，集合中每个元素都有其对应的顺序索引。List集合默认按照元素的添加顺序设置元素的索引，可以通过索引（类似数组的下标）来访问指定位置的集合元素。

实现List接口的集合主要有：ArrayList、LinkedList、Vector、Stack。

ArrayList

ArrayList是一个动态数组，也是我们最常用的集合，是List类的典型实现。

它允许任何符合规则的元素插入甚至包括null。

每一个ArrayList都有一个初始容量（10），该容量代表了数组的大小。随着容器中的元素不断增加，容器的大小也会随着增加。在每次向容器中增加元素的同时都会进行容量检查，当快溢出时，就会进行扩容操作（1.5倍）。所以如果我们明确所插入元素的多少，最好指定一个初始容量值，避免过多的进行扩容操作而浪费时间、效率。

ArrayList擅长查询，但是增删稍慢。同时ArrayList是非同步的。

LinkedList

LinkedList是List接口的另一个实现，除了可以根据索引访问集合元素外，LinkedList还实现了Deque接口，可以当作双端队列来使用，也就是说，既可以当作“栈”使用，又可以当作队列使用。

LinkedList内部以链表的形式保存集合中的元素，所以查询集合中的元素性能较差，但在插入删除元素时有较好的性能。

线程不同步

Vector

与ArrayList相似，但是Vector是同步的。所以说Vector是线程安全的动态数组。它的操作与ArrayList几乎一样。

有一点不一样：扩容是原来的2倍

但是被替代，效率低

Stack

Stack继承自Vector，实现一个后进先出的堆栈。

Stack提供5个额外的方法使得Vector得以被当作堆栈使用。

基本的push和pop 方法，还有peek方法得到栈顶的元素，empty方法测试堆栈是否为空，search方法检测一个元素在堆栈中的位置。

Stack刚创建后是空栈。

ListIterator接口

ListIterator接口继承Iterator接口，提供了专门操作List的方法。ListIterator接口在Iterator接口的基础上增加了以下几个方法：

• boolean hasPrevious()：判断集合里是否存在上一个元素。如果有，该方法返回 true。
• Object
  previous()：返回集合里上一个元素。
  void add(Object o)：在指定位置插入一个元素。

两个接口相比较，不难发现，ListIterator增加了向前迭代的功能（Iterator只能向后迭代），ListIterator还可以通过add()方法向List集合中添加元素（Iterator只能删除元素）。

在迭代时，不可以通过集合对象的方法操作集合中的元素。因为会发生ConcurrentModificationException异常。
所以，在迭代器时，只能用迭代器自有的方法操作元素

Map

Map接口采用键值对Map<K,V>的存储方式，保存具有映射关系的数据，因此，Map集合里保存两组值，一组值用于保存Map里的key，另外一组值用于保存Map里的value，key和value可以是任意引用类型的数据。 **key值不允许重复，可以为null。**如果添加key-value对时Map中已经有重复的key，则新添加的value会覆盖该key原来对应的value。常用实现类有HashMap、LinkedHashMap、TreeMap等。

Map集合的两种取出方式：

1，Set < k> keySet：将map中所有的键存入到Set集合。因为Set具备迭代器。
所有可以迭代方式取出所有的键，在根据get方法。获取每一个键对应的值。

Map集合的取出原理：将map集合转成set集合。在通过迭代器取出。

2，Set<Map.Entry<k,v>> entrySet：将map集合中的映射关系存入到了set集合中，
而这个关系的数据类型就是：Map.Entry

实现步骤：

1，调用Map集合中的entrySet()方法，将集合中的映射关系对象存储到Set集合中

2，迭代Set集合

3，获取Set集合的元素，是映射关系的对象

4，通过映射关系对象的方法，getKey()和getValue(),获取键值对

Entry其实就是Map中的一个static内部接口。 entry将键值对的对应关系封装成了对象，即键值对对象

为什么要定义在内部呢？
因为只有有了Map集合，有了键值对，才会有键值的映射关系。关系属于Map集合中的一个内部事物。而且该事物在直接访问Map集合中的元素。

HashMap与Hashtable：

HashMap与Hashtable是Map接口的两个典型实现，它们之间的关系完全类似于ArrayList与Vertor。HashTable是一个古老的Map实现类，它提供的方法比较繁琐，目前基本不用了。

1. HashMap与Hashtable主要存在以下典型区别：

• HashMap是线程不安全，HashTable是线程安全的。
• HashMap可以使用null值作为key或value；Hashtable不允许使用null值作为key和value，如果把null放进HashTable中，将会发生空指针异常。
• Hashtable继承自Dictionary类，而HashMap继承自AbstractMap类。但二者都实现了Map接口。
• 内部实现使用的数组初始化和扩容方式不同
• HashTable直接使用对象的hashCode。而HashMap重新计算hash值。

为了成功的在HashMap和Hashtable中存储和获取对象，用作key的对象必须实现hashCode()方法和equals()方法。

HashMap工作原理如下：（1.7） O（n）

HashMap基于hashing原理，通过put()和get()方法存储和获取对象。

        当我们将键值对传递给put()方法时，它调用key对象的hashCode()方法来计算hashCode值，然后使用indexFor方法找到bucket位置来储存值对象。如果该位置没有对象存在，就将此对象直接放进数组当中；如果该位置已经有对象存在了，则顺着此存在的对象的链开始寻找(为了判断是否是否值相同，map不允许），判断当前数组中处理hash冲突的方式为链表还是红黑树(check第一个节点类型即可),分别处理
　　
　　get(key)方法时获取key的hash值，计算hash&(n-1)得到在链表数组中的位置first=tab[hash&(n-1)],先判断first的key是否与参数key相等equals()方法，不等就遍历后面的链表找到相同的key值返回对应的Value值即可

HashMap使用链表来解决碰撞问题，当发生碰撞了**，新值存放在数组中，旧值在新值的链表上。**

indexFor方法: 如何找寻对应的数组下标：

static int indexFor(int h, int length) {
        return h & (length-1);//length=2 的整数次幂
    }

这里哈希值与上(length-1)，length=传入的容量是16的话，16-1=15，二进制1111，即对h取低四位，从而对应0-15个位桶
即无论我们指定的容量为多少，构造方法都会将实际容量设为不小于指定容量的2的次方的一个数，且最大值不能超过2的30次方

JDK1.8 O(logn)

JDK8中采用的是位桶+链表/红黑树的方式，也是非线程安全的。当某个位桶的链表的长度达到某个阀值的时候，这个链表就将转换成红黑树。

JDK8中，当同一个hash值的节点数不小于8时，将不再以单链表的形式存储了，会被调整成一颗红黑树。这就是JDK7与JDK8中HashMap实现的最大区别。

JDK中Entry的名字变成了Node，原因是和红黑树的实现TreeNode相关联。

具体源码实现请参考：https://blog.csdn.net/hefenglian/article/details/79763634

HashMap加载因子

主要是就：为了减少冲突的概率，不要让链表过长，减少查询成本

Hashtable 初始容量是11 ，扩容方式为2N+1;

HashMap 初始容量是16,扩容方式为2N;

提高空间利用率和 减少查询成本的折中，主要是泊松分布，0.75的话碰撞最小，

HashMap有两个参数影响其性能：初始容量和加载因子。容量是哈希表中桶的数量，初始容量只是哈希表在创建时的容量。加载因子是哈希表在其容量自动扩容之前可以达到多满的一种度量。当哈希表中的条目数超出了加载因子与当前容量的乘积时，则要对该哈希表进行扩容、rehash操作（即重建内部数据结构），扩容后的哈希表将具有两倍的原容量。

通常，加载因子需要在时间和空间成本上寻求一种折衷。

2. LinkedHashMap实现类

LinkedHashMap使用双向链表来维护key-value对的次序（其实只需要考虑key的次序即可），该链表负责维护Map的迭代顺序，与插入顺序一致，因此性能比HashMap低，但在迭代访问Map里的全部元素时有较好的性能。

3. Properties

Properties类是Hashtable类的子类，它相当于一个key、value都是String类型的Map，主要用于读取配置文件。

4. TreeMap实现类

TreeMap是SortedMap的实现类，是一个红黑树的数据结构，每个key-value对作为红黑树的一个节点。TreeMap存储key-value对时，需要根据key对节点进行排序。TreeMap也有两种排序方式：

♦ 自然排序：TreeMap的所有key必须实现Comparable接口，而且所有的key应该是同一个类的对象，否则会抛出ClassCastException。

♦ 定制排序：创建TreeMap时，传入一个Comparator对象，该对象负责对TreeMap中的所有key进行排序。

各Map实现类的性能分析

♦ HashMap通常比Hashtable（古老的线程安全的集合）要快

♦ TreeMap通常比HashMap、Hashtable要慢，因为TreeMap底层采用红黑树来管理key-value。

♦ LinkedHashMap比HashMap慢一点，因为它需要维护链表来保存key-value的插入顺序。

代码实例：

package com.package1;
/*
 * 功能：获取一个字符串“abababcgh”中各个字母出现的次数，并且打印
 * 方式：利用TreeMap实现。
 */
import java.util.*;
import java.util.Map.Entry;
 
public class MapDemo2 {
 
	public static void main(String[] args) {
		
		String s="sfcnewjgwfvskfksdjfjsakdjjjjj";
		Getnum(s);
 
	}
	
	public static void Getnum(String s)
	{
		char[] a=s.toCharArray();
		
		TreeMap<Character,Integer> tm=new TreeMap<Character,Integer>();
		
		//根据数组中的元素，循环查找集合中是否存在
		for(int i=0;i<a.length;i++)
		{
			Integer values=tm.get(a[i]);
			
			//判断values的值
			if(values==null)
			{
				//将数组中的值put到集合中
				tm.put(a[i], 1);
			}
			else
			{
				values=values+1;
				tm.put(a[i], values);
				
			}			
		}
		System.out.println(tm);
		
		//取出数据
        //取出方式1：keySet();
		Set<Character> ks=tm.keySet();
		Iterator<Character> it=ks.iterator();
		
		while(it.hasNext())
		{
			Character key=it.next();    //得到K
			Integer in=tm.get(key);     //根据K取出value
			
			System.out.println(key+"("+in+")");
		}
	
		//方式2：entrySet();
		Set<Map.Entry<Character,Integer>> es =tm.entrySet();
		Iterator<Map.Entry<Character, Integer>> it=es.iterator();

		//循环取出
		while(it.hasNext())
		{
			//me为映射关系
			Entry<Character, Integer> me=it.next();
			//根据映射关系取出K-V
			Character c=me.getKey();
			Integer in=me.getValue();
			
			System.out.println(c+"("+in+")");
			
		}
	}
}

面试官提问

1）介绍HashMap：
按照特性来说明一下：储存的是键值对，线程不安全，非Synchronied，储存的比较快，能够接受null。

按照工作原理来叙述一下：Map的put（key，value）来储存元素，通过get（key）来得到value值，通过hash算法来计算hascode值，用hashCode标识Entry在bucket中存储的位置，储存结构就算哈希表。

“2）你知道HashMap的工作原理吗？” “你知道HashMap的get()方法的工作原理吗？”
“HashMap是基于hashing的原理，我们使用put(key, value)存储对象到HashMap中，使用get(key)从HashMap中获取对象。
当我们给put()方法传递键和值时，我们先对键调用hashCode()方法，返回的hashCode用于找到bucket位置来储存Entry对象。

”这里关键点在于指出，HashMap是在bucket中储存键对象和值对象，作为Map.Entry。
这一点有助于理解获取对象的逻辑。如果你没有意识到这一点，或者错误的认为仅仅只在bucket中存储值的话，你将不会回答如何从HashMap中获取对象的逻辑。这个答案相当的正确，也显示出面试者确实知道hashing以及HashMap的工作原理。

3）提问：两个hashcode相同的时候会发生说明？

hashcode相同，bucket的位置会相同，也就是说会发生碰撞，哈希表中的结构其实有链表（LinkedList），这种冲突通过将元素储存到LinkedList中，解决碰撞。储存顺序是放在表头。

4）如果两个键的hashcode相同，如何获取值对象？

如果两个键的hashcode相同，即找到bucket位置之后，我们通过key.equals（）找到链表LinkedList中正确的节点，最终找到要找的值对象。

一些优秀的开发者会指出使用不可变的、声明作final的对象，并且采用合适的equals()和hashCode()方法的话，将会减少碰撞的发生，提高效率。不可变性使得能够缓存不同键的hashcode，这将提高整个获取对象的速度，使用String，Interger这样的wrapper类作为键是非常好的选择。

5）如果HashMap的大小超过了负载因子(load factor)定义的容量？怎么办？

HashMap里面默认的负载因子大小为0.75，也就是说，当一个map填满了75%的bucket时候，和其它集合类(如ArrayList等)一样，将会创建原来HashMap大小的两倍的bucket数组，来重新调整map的大小，并将原来的对象放入新的bucket数组中。这个过程叫作rehashing，因为它调用hash方法找到新的bucket位置。

6）重新调整HashMap大小的话会出现什么问题？

多线程情况下会出现竞争问题，因为你在调节的时候，LinkedList储存是按照顺序储存，调节的时候回将原来最先储存的元素（也就是最下面的）遍历，多线程就好试图重新调整，这个时候就会出现死循环。

当多线程的情况下，可能产生条件竞争(race condition)。

当重新调整HashMap大小的时候，确实存在条件竞争，因为如果两个线程都发现HashMap需要重新调整大小了，它们会同时试着调整大小。在调整大小的过程中，存储在链表中的元素的次序会反过来，因为移动到新的bucket位置的时候，HashMap并不会将元素放在链表的尾部，而是放在头部，这是为了避免尾部遍历(tail traversing)。如果条件竞争发生了，那么就死循环了。

7）HashMap在并发执行put操作，会引起死循环，为什么？
是因为多线程会导致hashmap的node链表形成环形链表，一旦形成环形链表，node 的next节点永远不为空，就会产生死循环获取node。从而导致CPU利用率接近100%。

8）为什么String, Interger这样的wrapper类适合作为键？
因为他们一般不是不可变的，源码上面final，使用不可变类，而且重写了equals和hashcode方法，避免了键值对改写。提高HashMap性能。

String, Interger这样的wrapper类作为HashMap的键是再适合不过了，而且String最为常用。因为String是不可变的，也是final的，而且已经重写了equals()和hashCode()方法了。其他的wrapper类也有这个特点。不可变性是必要的，因为为了要计算hashCode()，就要防止键值改变，如果键值在放入时和获取时返回不同的hashcode的话，那么就不能从HashMap中找到你想要的对象。不可变性还有其他的优点如线程安全。如果你可以仅仅通过将某个field声明成final就能保证hashCode是不变的，那么请这么做吧。因为获取对象的时候要用到equals()和hashCode()方法，那么键对象正确的重写这两个方法是非常重要的。如果两个不相等的对象返回不同的hashcode的话，那么碰撞的几率就会小些，这样就能提高HashMap的性能。

9）使用CocurrentHashMap代替Hashtable？
可以，但是Hashtable提供的线程更加安全。
Hashtable是synchronized的，但是ConcurrentHashMap同步性能更好，因为它仅仅根据同步级别对map的一部分进行上锁。ConcurrentHashMap当然可以代替HashTable，但是HashTable提供更强的线程安全性。

10）hashing的概念
散列法（Hashing）或哈希法是一种将字符组成的字符串转换为固定长度（一般是更短长度）的数值或索引值的方法，称为散列法，也叫哈希法。由于通过更短的哈希值比用原始值进行数据库搜索更快，这种方法一般用来在数据库中建立索引并进行搜索，同时还用在各种解密算法中。

参考链接：
https://blog.csdn.net/qq_25827845/article/details/51287142
https://www.cnblogs.com/bingyimeiling/p/10255037.html
https://blog.csdn.net/hefenglian/article/details/79763634