Java集合

集合、数组都是对多个数据进行存储操作的结构，简称java容器
（此时的存储，主要指的是内存层面的存储，不涉及持久化的存储）

数组存储的特点：

1. 一旦初始化，其长度就确定了。
2. 数组一旦定义好，其元素的类型也就确定了。我们也就只能操作指定类型的数据了。
   比如：

String []arr; int[] arr1 ; Object[] arr2;

数组存储的弊端：

1. 一旦初始化以后，其长度就不可修改
2. 数组中提供的方法非常有限，对于添加删除插入等操作非常不便，同时效率不高
3. 获取数组中实际元素的个数的需求，数组没有现成的属性或方法可以用
4. 数组存储数据的特点：有序、可重复。对于无序、不可重复的需求，不能满足。

集合存储的优点：解决数组存储数据方面的弊端。

---

java集合可以分为Collection和Map两种体系

1. Collection接口：单列集合，用来存储一个一个的对象

• List：元素有序、可重复的集合 -->“动态”数组
• Set：元素无序、不可重复的集合 -->高中的“集合”

2. Map接口：双列集合，保存具有映射关系的“Key-value”的集合，即存储一对的数据

List内包含很多实现类，比如：ArrayList、LinkedList、Vector

Set的实现类，比如：HashSet、LinkedHashSet、TreeSet

Map的实现类，比如：HashMap、LinkedHashMap、TreeMap、Hashtable、Properties

---

Collection接口中的方法使用

✨向Collection接口的实现类的对象中添加数据obj时，要求obj所在类要重写equals()

1. add()：添加
2. size()：求集合元素
3. addAll(当前集合)：把当前集合所有元素加到另一个集合去
4. clear()：清空集合数据
5. isEmpty()：判断是否有元素，有返回false

@Test
public void test1() {Collection coll = new ArrayList();// add(Object e) 将元素e添加到集合coll中coll.add("AA");coll.add("BB");coll.add(123); //自动装箱coll.add(new Date());//size(): 获取添加的元素的个数System.out.println(coll.size()); // 4//addAll():Collection coll1 = new ArrayList();coll1.add(456);coll1.add("CC");coll.addAll(coll1); //把coll1集合中的所有元素加到coll中System.out.println(coll.size()); // 6System.out.println(coll);//clear(): 清空集合数据，而不是赋值为空coll.clear();//isEmpty():判断当前集合是否有元素,没有则返回trueSystem.out.println(coll.isEmpty());
}

6. contains(Object obj):判断当前集合中是否包含obj,判断的是内容，而不是地址!
7. //containsAll(Collection coll1):判断形参coll1所有元素是否都存在于当前集合中

@Test
public void test2() {Collection coll = new ArrayList();coll.add(123);coll.add(456);coll.add(new String("Tom"));coll.add(false);coll.add(new Person("Jerry",20));//contains(Object obj):判断当前集合中是否包含obj,判断的是内容，而不是地址!//我们在判断时会调用obj对象所在类的equals()boolean contains = coll.contains(123);System.out.println(contains); //trueSystem.out.println(coll.contains(new String("Tom")));  // trueSystem.out.println(coll.contains(new Person("Jerry",20)));//containsAll(Collection coll1):判断形参coll1所有元素是否都存在与当前集合中Collection coll1 = Arrays.asList(123,456);System.out.println(coll.containsAll(coll1)); //coll中是否包含coll1中所有数据		
}

8. remove(Object obj):从当前集合中删除一个指定数据，并可以返回一个布尔值表示是否删除成功
9. removeAll(Collection coll1):从当前集合中移除coll1中的所有元素

@Test
public void test3() {//remove(Object obj):从当前集合中删除一个指定数据，并可以返回一个布尔值表示是否删除成功Collection coll = new ArrayList();coll.add(123);coll.add(456);coll.add(new Person("Jerry",20));coll.add(new String("Tom"));coll.add(false);System.out.println(coll);coll.remove(123);System.out.println(coll);//removeAll(Collection coll1):从当前集合中移除coll1中的所有元素，即删除的是当前集合中和coll1中都有的元素，但coll1不删Collection coll1 = Arrays.asList(456,4657); //coll1中有456,4567coll.removeAll(coll1); //找coll中是否有456和4567,有的话删掉System.out.println(coll1); //打印之后发现456没了
}

10. retainAll():求两个集合的交集,本例中是获取coll和coll1中的交集，并返回给当前集合

@Test
public void test4() {Collection coll = new ArrayList();coll.add(123);coll.add(456);coll.add(new Person("Jerry",20));coll.add(new String("Tom"));coll.add(false);//retainAll():求两个集合的交集,本例中是获取coll和coll1中的交集，并返回给当前集合Collection coll1 = Arrays.asList(123,456,789); coll.retainAll(coll1);System.out.println(coll);
}

11. equals(Object obj):要想返回true，需要当前集合和形参集合的元素都相同。

@Test
public void test5() {Collection coll = new ArrayList();coll.add(123);coll.add(456);coll.add(new Person("Jerry",20));coll.add(new String("Tom"));coll.add(false);//equals(Object obj):要想返回true，需要当前集合和形参集合的元素都相同。Collection coll1 = new ArrayList();coll1.add(123);coll1.add(456);coll1.add(new Person("Jerry",20));coll1.add(new String("Tom"));coll1.add(false);System.out.println(coll.equals(coll1));
}

12. hashCode():返回当前对象的哈希值

13. 集合—>数组：toArray();
    数组 —> 集合:调用Arrays类的静态方法asList(),基本数据类型要写成包装类

14. iterator():返回Iterator接口的实例，用于遍历集合元素。

@Test
public void test6() {Collection coll = new ArrayList();coll.add(123);coll.add(456);coll.add(new Person("Jerry",20));coll.add(new String("Tom"));coll.add(false);//hashCode():返回当前对象的哈希值System.out.println(coll.hashCode());//集合--->数组：toArray()Object[] arr = coll.toArray();for(int i = 0;i < arr.length ;i++) {System.out.println(arr[i]);}//拓展：数组 ---> 集合:调用Arrays类的静态方法asList(),基本数据类型要写成包装类List<String> list = Arrays.asList(new String[] {"AA","BB","CC"});System.out.println(list);//基本数据类型数组的两种方式List arr1 = Arrays.asList(123,456);System.out.println(arr1);List arr2 = Arrays.asList(new Integer[] {123,456});System.out.println(arr2);
}

下面是自定义Person类的源码，上面代码演示时用到了一个Person类

public class Person {private String name;private int age;public Person() {super();}public Person(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;}@Overridepublic String toString() {return "Person [name=" + name + ", age=" + age + "]";}@Override public boolean equals(Object obj) {if (this == obj)return true;if (obj == null)return false;if (getClass() != obj.getClass())return false;Person other = (Person) obj;return age == other.age && Objects.equals(name, other.name);}}

---

迭代器Iterator的使用

内部的方法：hasNext()和next()

@Test
//集合元素的遍历操作，使用迭代器Iterator接口
public void test() {Collection coll = new ArrayList();coll.add(123);coll.add(456);coll.add(new String("Tom"));coll.add(false);Iterator iterator = coll.iterator();//方式1：一次取一个数据System.out.println(iterator.next());//方式2：for遍历（不推荐）for(int i = 0;i < coll.size() ; i++) {System.out.println(iterator.next());}//方式3：hasNext()判断是否还有元素可以取 -->推荐while(iterator.hasNext()) {System.out.println(iterator.next());}
}

1. hasNext()判断是否还有下一个元素
2. next()：①指针下移②将下移以后集合位置上的元素返回

---

remove()的使用

迭代器中remove()的使用：遍历时删除指定元素,此方法不同于集合直接调用remove()

@Test
public void test1() {Collection coll = new ArrayList();coll.add(123);coll.add(456);coll.add(new Person("Jerry",20));coll.add(new String("Tom"));coll.add(false);//删除集合中"Tom"这个数据Iterator iterator = coll.iterator();while(iterator.hasNext()) {Object obj = iterator.next();;if("Tom".equals(obj)) {iterator.remove();}}//删除后重头遍历集合，让指针重新指向这个集合的头部iterator = coll.iterator();while(iterator.hasNext()) {System.out.println(iterator.next());}
}

---

foreach循环遍历集合元素

Java5.0提供了foreach循环迭代访问Collection和数组，这种循环又叫增强for循环

✨格式：for(集合/数组元素类型 局部变量 : 集合/数组对象){}

例1：foreach循环迭代访问Collection

@Test
public void test() {Collection coll = new ArrayList();coll.add(123);coll.add(456);coll.add(new String("Tom"));coll.add(false);for(Object obj : coll) {System.out.println(obj);}
}

例2：foreach循环迭代访问数组

@Test
public void test1() {int [] arr = new int[] {1,2,3,4,5};for(int x : arr) {System.out.println(x);}
}

---

List接口框架

List：元素有序、可重复的集合

List不用关注长度够不够的问题，它动态帮我们把长度做了变化。所以可以看作一个“动态”数组，替换原有的数组

List接口的实现类主要有：ArrayList、LinkedList、Vector

面试题：ArrayList、LinkedList、Vector的异同

同：三个类都实现了List接口，存储数据的特点相同：存储有序的，可重复的数据

异：

1. ArrayList作为List接口的主要实现类，线程不安全的，效率高；底层使用Object[] elementData存储；扩容1.5倍
2. LinkedList:对于频繁的插入、删除操作，使用此类效率比ArrayList高；底层使用双向链表存储
3. Vector作为List接口的古老实现类，线程安全的，效率低；底层使用Object[] elementData存储；扩容2倍

---

ArrayList

每次创建ArrayList的对象，表示底层创建长度是10的Object[] 数组elementData；

可以向数组内添加数据，如果有一次的添加导致底层数组elementData容量不够，则扩容，默认情况下，扩容为原来的1.5倍，同时需要将原有数组中的数据复制到新的数组中

结论：建议开发中使用带参的构造器：ArrayList list = new ArrayList(int capacity) 指定创建初始数组的容量。

@Test
public void test() {ArrayList list = new ArrayList(); //底层创建了长度是10的Object[] 数组elementDatalist.add(123);  // elementData[0] = nwe Interger(123);list.add(11);
}

jdk 8中ArrayList的变化：

ArrayList list = new ArrayList(); //底层Object[] elementData初始化为{}，并没有创建长度为10的数组

list.add(123); //第一次调用add()时，底层才创建了长度为10的数组，并把123这个数据添加到elementData

后续的添加和扩容操作与jdk 7无异

小结：jdk 7中的ArrayList的对象创建类似于单例的饿汉式，而jdk 8中的ArrayList对象的创建类似于单例的懒汉式，延迟了数组创建，节省内存。

---

LinkedList

LinkedList list = new LinkedList();

内部声明了Node类型的first和last属性，默认值为null

list.add(213);//将123封装到Node中，创建了Node对象

其中Node定义为(源码)：体现了双向链表的说法

private static class Node<E> {E item;Node<E> next;Node<E> prev;Node(Node<E> prev, E element, Node<E> next) {this.item = element;this.next = next;this.prev = prev;}
}

---

List接口常用方法测试

1. void add(int index, Object ele):在index位置插入ele元素
2. boolean addAll(int index, Collection eles):从index位置开始将eles中的所有元素添加进来
3. Object get(int index):获取指定index位置的元素

@Test
public void test() {ArrayList list = new ArrayList(); //底层创建了长度是10的Object[] 数组elementDatalist.add(123);list.add(456);list.add("AA");list.add("BB");list.add("Tom");list.add(456);System.out.println(list);//1.void add(int index, Object ele):在index位置插入ele元素list.add(1,"BB");System.out.println(list);//2.boolean addAll(int index, Collection eles):从index位置开始将eles中的所有元素添加进来List list1 = Arrays.asList(1,2,3);//list.add(list1); //把list1当作一个整体插入到list里,size为7而不是9list.addAll(1,list1); //不写位置默认插入到最后System.out.println(list);//3.Object get(int index):获取指定index位置的元素System.out.println(list.get(0));		
}

4. int indexOf(Object obj):返回obj在集合中首次出现的位置
5. int lastIndexOf(Object obj):返回obj在当前集合中末次出现的位置
6. Object remove(int index):移除指定index位置的元素，并返回此元素
7. Object set(int index, Object ele):设置指定index位置的元素为ele
8. List subList(int fromIndex, int toIndex):返回从fromIndex到toIndex位置的子集合，左闭右开

@Test
public void test1() {ArrayList list = new ArrayList(); list.add(123);list.add(456);list.add("AA");list.add("BB");list.add("Tom");list.add(456);//4.int indexOf(Object obj):返回obj在集合中首次出现的位置,找不到返回-1int index = list.indexOf(456);System.out.println(index);		//System.out.println(list.indexOf(123));  //可以直接输出//5.int lastIndexOf(Object obj):返回obj在当前集合中末次出现的位置,找不到返回-1System.out.println(list.lastIndexOf(456));//6.Object remove(int index):移除指定index位置的元素，并返回此元素 注意这里是按照索引删除Object obj = list.remove(0); //返回指定位置被删除的元素System.out.println(obj);System.out.println(list);//7.Object set(int index, Object ele):设置index位置的元素为elelist.set(1, "CC");System.out.println(list);//8.List subList(int fromIndex, int toIndex):返回从fromIndex到toIndex位置的子集合List list1 = list.subList(2, 4);System.out.println(list1);
}

总结：常用方法

• 增：add(Object obj)
• 删：remove(int index) / remove(Object obj)
• 改：set(int index, Object ele)
• 查：get(int index)
• 插：add(int index, Object ele)
• 长度：size()
• 遍历：① Iterator迭代器方式
  ② 增强for循环
  ③ 普通的循环

@Test
public void test2() {ArrayList list = new ArrayList(); list.add(123);list.add(456);list.add("AA");//Iterator迭代器方式Iterator iterator = list.iterator();while(iterator.hasNext()) {System.out.println(iterator.next());}// 增强for循环for(Object obj : list) {System.out.println(obj);}// 普通for循环for(int i = 0;i < list.size() ;i++) {System.out.println(list.get(i));}
}

• 删除指定元素，要自己手动装箱比如remove(new Integer(2));

---

Set接口框架

元素无序、不可重复的集合

Set的实现类，比如：HashSet、LinkedHashSet、TreeSet

• HashSet：作为Set接口的主要实现类；线程不安全；可以存储null值
• LinkedHashSet：是HashSet的子类；遍历其内部数据时，可以按照添加的顺序遍历
• TreeSet：底层用红黑树存数据；可以确保集合元素处于排序状态；可以按照添加对象的指定属性，进行排序。

注：Set接口中没有额外定义新的方法，使用的都是Collection中声明过的方法。

✨下面解释Set集合两种特征

1. 无序性：并不是随机性，遍历这样集合的时候也会有一个固定顺序，只不过和你添加的顺序不一样。而是根据数据的哈希值决定的

@Test
public void test() {Set set = new HashSet();set.add(123);set.add(456);set.add("AA");set.add("BB");set.add("CC");Iterator iterator = set.iterator();while(iterator.hasNext()) {System.out.println(iterator.next());}
}

2. 不可重复性：保证添加的元素按照equals()判断时，不能返回true。即相同元素只能添加一个。

---

HashSet添加元素过程

HashSet底层是数组+链表的结构，初始容量为16

我们向HashSet添加元素a，首先调用元素a所在类的hashCode()方法，计算元素a的哈希值，此哈希值接着通过某种算法计算出在HashSet底层数组中的存放位置（即为：索引位置），判断数组再次位置上是否已经有元素；

如果此位置上没有其他元素，则元素a添加成功。

👇如果此位置上有其他元素b(或以链表形式存在的多个元素)，则比较a与元素b的hash值

如果hash值不相同，则元素a添加成功

👇如果hash值相同，进而需要调用元素a所在类的equals()方法

euqals()返回true，元素a添加失败

euqals()返回false，元素a添加成功

🎈总结：添加时先看这个位置上有没有元素，有的话就比较hash值，hash值一样就用equals()方法；

🎈要求：①向Set中添加的数据，其所在类一定要重写hashCode()和equals()
②重写的hashCode()和equals()方法尽量保持一致性

🎈对于要插入位置上已经有元素的情况而言：元素a 与 已经存在指定索引位置上数据以链表的方式存储。
存储方式，即指针谁指向谁看下面。

Jdk 7:元素a放到数组中，指向原来的元素。

Jdk 8:原来的元素在数组中，指向元素a。

（七上八下）

---

LinkedHashSet的使用

LinkedHashSet作为HashSet的子类，在添加数据的同时，每个数据还维护了两个引用，记录此数据前一个数据和后一个数据。

优点：对于频繁的遍历操作，LinkedHashSet效率要高于HashSet

---

TreeSet（*）

可以按照对象的指定属性，进行排序

排序有：自然排序（实现Comparable接口）和定制排序（Comparator）

• 自然排序中，比较两个对象是否相同的标准为：compareTo()返回0，不再是equals()
• 定制排序中，比较两个对象是否相同的标准为：compare()返回0，不再是equals()

🎈注意：

1. 向TreeSet中添加的数据，要求是相同类的对象
2. 对于基本数据类型还有String类型可进行从小到大排序

@Test
public void test() {TreeSet set = new TreeSet();set.add(123);set.add(456);
//	 set.add("AA"); //不能添加不同类的对象set.add(36);set.add(-11);Iterator iterator = set.iterator();while(iterator.hasNext()) {System.out.println(iterator.next());}}

3. 对于自定义类型，我们在自定义类重写compareTo()方法

比如下面的Person类就是一个自定义类

public class Person implements Comparable{//按照姓名从小到大进行排列@Overridepublic int compareTo(Object o) {if(o instanceof Person) {Person p = (Person)o;
//			return this.name.compareTo(p.name); //相同值会只返回一个,如果从大到小就-thisint compare = this.name.compareTo(p.name);if(compare != 0) {return compare;} else {return Integer.compare(this.age, p.age);}} else {throw new RuntimeException("输入的类型不匹配");}}private String name;private int age;public Person() {super();}public Person(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;}@Overridepublic String toString() {return "Person [name=" + name + ", age=" + age + "]";}@Overridepublic boolean equals(Object obj) {if (this == obj)return true;if (obj == null)return false;if (getClass() != obj.getClass())return false;Person other = (Person) obj;return age == other.age && Objects.equals(name, other.name);}	
}

测试类如下：

@Test
public void test1() {TreeSet set = new TreeSet();set.add(new Person("Jerry",32));set.add(new Person("Jim",22));set.add(new Person("Mike",26));set.add(new Person("Adobe",66));Iterator iterator = set.iterator();while(iterator.hasNext()) {System.out.println(iterator.next());}
}

4. 定制排序利用TreeSet带参构造器(Comparator comparator)，下面例子中。如果不在TreeSet()里加com就是自然排序，加上就是定制排序

@Test
public void test2() {Comparator com = new Comparator() {//按照年龄从小到大排序@Overridepublic int compare(Object o1,Object o2) {if(o1 instanceof Person && o2 instanceof Person) {Person p1 = (Person)o1;Person p2 = (Person)o2;return Integer.compare(p1.getAge(), p2.getAge());} else {throw new RuntimeException("输入的数据类型不匹配");}}};TreeSet set = new TreeSet(com);
}

---

Map接口

Map接口：双列集合，保存具有映射关系的“Key-value”的集合，即存储一对的数据（类似于高中的函数）

Map的实现类：

• HashMap:作为Map的主要实现类，线程不安全的，效率高；可存储null的Key-value；
  在JDK7之前底层时数组+链表；JDK8之后是数组+链表+红黑树

LinkedHashMap（HashMap的子类）：保证在遍历map元素时，可以按照添加的顺序实现遍历。原因：在原有的HashMap底层结构基础上，添加了一对指针，指向前一个和后一个元素；对于频繁的遍历操作，此类执行效率高于HashMap

• TreeMap：保证按照添加的key-value键值对进行排序，实现排序遍历（按照key来自然或定制排序），底层使用红黑树。
• Hashtable：作为古老的实现类，线程安全的，效率低；不能存储null的Key-value

Properties（Hashtable的子类）：常用来处理配置文件，key-value都是String类型

---

Map中键值对的注意事项：

• Map中的Key：无序的、不可重复的，使用Set存储所有的key -->key所在类要重写equals()和hashCode()方法

• Map中的value：无序的、可重复的，使用Collection存储所有的vaule -->key所在类要重写equals()

• 一个键值对：key-vaule构成了一个Entry对象。

• Map中的Entry：无序的、不可重复的，使用Set存储所有的Entry

---

Map中常用方法

1. 添加、删除、修改操作：

• Object put(Object key,Object value)：将指定key-value添加到(或修改)当前map对象中
• void putAll(Map m):将m中的所有key-value对存放到当前map中
• Object remove(Object key)：移除指定key的key-value对，并返回value（找不到key返回null）
• void clear()：清空当前map中的所有数据

@Test
public void test() {//1.put(Object key,Object value)：将指定key-value添加到(或修改)当前map对象中Map map = new HashMap();//添加map.put("AA", 123);map.put(66, 123);map.put("BB", 13);//修改，上面有过一个AA了，32会覆盖掉123map.put("AA", 32);System.out.println(map);//2.putAll(Map m):将m中的所有key-value对存放到当前map中Map map1 = new HashMap();map1.put("CC", 56);map1.put("DD", 99);map.putAll(map1);System.out.println(map);//3.remove(Object key)：移除指定key的key-value对，并返回valueObject value = map.remove("CC");System.out.println(value);System.out.println(map);//4.clear()：清空当前map中的所有数据map.clear();System.out.println(map.size());System.out.println(map);
}

2. 元素查询的操作：

• Object get(Object key)：获取指定key对应的value（找不到key返回null）
• boolean containsKey(Object key)：是否包含指定的key
• boolean containsValue(Object value)：是否包含指定的value
• int size()：返回map中key-value对的个数
• boolean isEmpty()：判断当前map是否为空
• boolean equals(Object obj)：判断当前map和参数对象obj是否相等

@Test
public void test3() {Map map = new HashMap();map.put("AA", 123);map.put(66, 123);map.put("BB", 13);//1.get(Object key)：获取指定key对应的valueSystem.out.println(map.get(66));//2.boolean containsKey(Object key)：是否包含指定的keyboolean isExist = map.containsKey("BB");System.out.println(isExist);//3.boolean containsValue(Object value)：是否包含指定的valueboolean b = map.containsValue(123);System.out.println(b);//4.int size()：返回map中key-value对的个数System.out.println(map.size());//5.boolean isEmpty()：判断当前map是否为空System.out.println(map.isEmpty());map.clear(); //清空mapSystem.out.println(map.isEmpty());
}

3. 元视图操作的方法：涉及如何遍历map中的key-value、key、value

• Set keySet()：返回所有key构成的Set集合
• Collection values()：返回所有value构成的Collection集合
• Set entrySet()：返回所有key-value对构成的Set集合

@Test
public void test() {Map map = new HashMap();map.put("AA", 123);map.put(66, 1234);map.put("BB", 13);//1.Set keySet()：返回所有key构成的Set集合Set set = map.keySet();Iterator iterator = set.iterator();while(iterator.hasNext()) {System.out.println(iterator.next());}//2.Collection values()：返回所有value构成的Collection集合Collection values = map.values();for(Object obj : values) {System.out.println(obj);}//3.Set entrySet()：返回所有key-value对构成的Set集合Set entrySet = map.entrySet();Iterator iterator1 = entrySet.iterator();while(iterator1.hasNext()) {Object obj = iterator1.next();Map.Entry entry = (Map.Entry)obj;System.out.println(entry.getKey() + "--->" + entry.getValue());//或者直接输出System.out.println(iterator1.next());}
}

总结：常用方法：

• 添加：put(Object key,Object value)
• 删除：remove(Object key)
• 修改：put(Object key,Object value)
• 查询：get(Object key)
• 长度：size()
• 遍历：keySet() / values() / entrySet()

---

HashMap底层实现原理

以JDK7为例，HashMap map = new HashMap();

在经过实例化之后，底层会创建一个长度为16的一维数组Entry[] table。如果涉及到扩容，则每一次扩容2倍，并将原来的数据拷贝过来给新数组。

然后以进行增加数据为例：

map.put(key1,value1);

首先，调用key1所在类的hashCode()方法计算key1的哈希值，此哈希值经过某种算法计算以后，得到Entry数组中的存放位置。

如果此位置上的数据为空，此时的key1-value1添加成功。

如果此位置上的数据不为空（意味着此位置上存在一个或多个数据（以链表形式存在）），比较当前key1和已经存在的一个或多个数据的哈希值。如果key1的哈希值于已经存在的数据都不一样，那么key1-value1添加成功。

如果key1和已经存在的某一个数据（key2-value2）的哈希值相同，继续比较：调用key1所在类的equals(key2)方法，比较：如果equals()返回false：key1-value1添加成功；

返回true：使用value1替换value2。

对于后两中添加成功的方式：key1-value1和原来的数据以链表的形式存储。

---

JDK8相比较于JDK7在底层实现方面的不同：

1. new HashMap():底层没有创建一个长度为16的数组
2. jdk8底层的数组是：Node[]，而非Entry[]数组
3. 首次调用put()方法时，底层创建长度为16的数组
4. jdk8中，当数组的某一个位置上的元素以链表的形式存在的数据个数 > 8 且数组长度 > 64时，此位置上的所有数据改为使用红黑树存储

---

• DEFAULT_INITIAL_CAPACITY : HashMap的默认容量，16
• DEFAULT_LOAD_FACTOR：HashMap的默认加载因子：0.75
• threshold：扩容的临界值，=容量*填充因子：16 * 0.75 => 12
• TREEIFY_THRESHOLD：Bucket中链表长度大于该默认值，转化为红黑树:8
• MIN_TREEIFY_CAPACITY：桶中的Node被树化时最小的hash表容量:64

---