一方面， 面向对象语言对事物的体现都是以对象的形式，为了方便对多个对象 的操作，就要对对象进行存储。另一方面，使用Array 存储对象方面具有 一些弊 端 ，而 Java 集合就像一种容器，可以 动态地 把多个对象的引用放入容器中。

数组在内存存储方面的特点：

数组初始化以后，长度就确定了。

数组声明的类型，就决定了进行元素初始化时的类型

数组在存储数据方面的弊端：

数组初始化以后，长度就不可变了，不便于扩展

数组中提供的属性和方法少，不便于进行添加、删除、插入等操作，且效率不高。

同时无法直接获取存储元素的个数

数组存储的数据是有序的、可以重复的。---->存储数据的特点单一

Java 集合类可以用于存储数量不等的多个对象，还可用于保存具有映射关系的

关联数组。

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

Collection接口：单列数据，定义了存取一组对象的方法的集合

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

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

 Map接口：双列数据，保存具有映射关系“key-value对”的集合

Collection 接口

Collection 接口是 List、Set 和 Queue 接口的父接口，该接口里定义的方法 既可用于操作 Set 集合，也可用于操作 List 和 Queue 集合。

JDK不提供此接口的任何直接实现，而是提供更具体的子接口(如：Set和List) 实现。

在 Java5 之前，Java 集合会丢失容器中所有对象的数据类型，把所有对象都 当成 Object 类型处理；从 JDK 5.0 增加了泛型以后，Java 集合可以记住容 器中对象的数据类型。

Collection 接口方法

Iterator迭代器接口

使用 Iterator 接口遍历集合元素

Iterator 对象称为迭代器 ( 设计模式的一种 ) ，主要用于遍历 Collection 集合中的元素。   GOF 给迭代器模式的定义为：提供一种方法访问一个容器 (container) 对象中各个元素，而又不需暴露该对象的内部细节。 迭代器模式，就是为容器而生。 类似于“公 交车上的售票员”、“火车上的乘务员”、“空姐”。 Collection 接口继承了 java.lang.Iterable 接口，该接口有一个 iterator() 方法，那么所 有实现了Collection 接口的集合类都有一个 iterator() 方法，用以返回一个实现了 Iterator接口的对象。

Iterator 仅用于遍历集合，Iterator 本身并不提供承装对象的能力。如果需要创建

Iterator 对象，则必须有一个被迭代的集合。

 集合对象每次调用iterator()方法都得到一个全新的迭代器对象，默认游标都在集合

的第一个元素之前

看下下面的题你就可能理解了：

public class ForTest {
public static void main(String[] args) {
String[] str = new String[5];
for (String myStr : str) {
myStr = "atguigu";
System.out.println(myStr);
}
for (int i = 0; i < str.length; i++) {
System.out.println(str[i]);
} }
}

输出结果：

atguigu

atguigu

atguigu

atguigu

atguigu

null

null

null

null

null

Collection子接口之一：List接口

下面来看一个踩坑题吧

public class list{
  public static void main(String[] args) {
    List aList=new ArrayList();
    aList.add(1);
    aList.add(2);
    aList.add(3);
    aList.remove(2);
    System.out.println(aList);
  }
}

输出结果：[1, 2]

public class list{
  public static void main(String[] args) {
    List aList=new ArrayList();
    aList.add(1);
    aList.add(2);
    aList.add(3);
    aList.remove(2);
    aList.remove(2);
    System.out.println(aList);
  }
}

错误：

Exception in thread "main" java.lang.IndexOutOfBoundsException: Index 2 out of bounds for length 2

   at java.base/jdk.internal.util.Preconditions.outOfBounds(Preconditions.java:64)

   at java.base/jdk.internal.util.Preconditions.outOfBoundsCheckIndex(Preconditions.java:70)

   at java.base/jdk.internal.util.Preconditions.checkIndex(Preconditions.java:266)

   at java.base/java.util.Objects.checkIndex(Objects.java:359)

   at java.base/java.util.ArrayList.remove(ArrayList.java:504)

   at list.main(list.java:313)

那么要如何删去2呢？很简单包装类：

public class list{
  public static void main(String[] args) {
    List aList=new ArrayList();
    aList.add(1);
    aList.add(2);
    aList.add(3);
    aList.remove(2);
    aList.remove(new Integer(2));
    System.out.println(aList);
  }
}

输出结果：[1]

Set接口

Set接口是Collection的子接口，set接口没有提供额外的方法

Set 集合不允许包含相同的元素，如果试把两个相同的元素加入同一个 Set 集合中，则添加操作失败。

Set 判断两个对象是否相同不是使用 == 运算符，而是根据 equals() 方法

向 HashSet 中添加元素的过程：

当向 HashSet 集合中存入一个元素时， HashSet 会调用该对象的 hashCode() 方法

来得到该对象的 hashCode 值，然后根据 hashCode 值，通过某种散列函数决定该对象

在 HashSet 底层数组中 的存储位置。（这个散列函数会与底层数组的长度相计算得到在

数组中的下标，并且这种散列函数计算还尽可能保证能均匀存储元素，越是散列分布，

该散列函数设计的越好）

如果两个元素的 hashCode() 值相等，会再继续调用 equals 方法，如果 equals 方法结果为 true ，添加失败；如果为 false ，那么会保存该元素，但是该数组的位置已经有元素了，那么会通过 链表的方式 继续链接。

如果两个元素的 equals() 方法返回 true ，但它们的 hashCode() 返回值不相 等，hashSet 将会把它们存储在不同的位置，但依然可以添加成功。

Map接口

HashMap 源码中的重要常量

DEFAULT_INITIAL_CAPACITY : HashMap 的默认容量， 16

MAXIMUM_CAPACITY ： HashMap 的最大支持容量， 2^30

DEFAULT_LOAD_FACTOR ： HashMap 的默认加载因子

TREEIFY_THRESHOLD ： Bucket 中链表长度大于该默认值，转化为红黑树

UNTREEIFY_THRESHOLD ： Bucket 中红黑树存储的 Node 小于该默认值，转化为链表

MIN_TREEIFY_CAPACITY ： 桶中的 Node 被树化时最小的 hash 表容量。（当桶中 Node 的

数量大到需要变红黑树时，若 hash 表容量小于 MIN_TREEIFY_CAPACITY 时，此时应执行

resize 扩容操作这个 MIN_TREEIFY_CAPACITY 的值至少是 TREEIFY_THRESHOLD 的 4

倍。）

table ： 存储元素的数组，总是 2 的 n 次幂

entrySet ： 存储具体元素的集

size ： HashMap 中存储的键值对的数量

modCount ： HashMap 扩容和结构改变的次数。

threshold ： 扩容的临界值， = 容量 * 填充因子

loadFactor ： 填充因子

HashMap 的扩容

当 HashMap 中的元素越来越多的时候， hash 冲突的几率也就越来越高，因为数组的 长度是固定的。所以为了提高查询的效率，就要对HashMap 的数组进行扩容，而在 HashMap数组扩容之后，最消耗性能的点就出现了：原数组中的数据必须重新计算 其在新数组中的位置，并放进去，这就是resize 。

那么 HashMap 什么时候进行扩容呢？

当 HashMap 中的元素个数超过数组大小 ( 数组总大小 length, 不是数组中个数 size)*loadFactor 时 ， 就 会 进 行 数 组 扩 容 ， loadFactor 的默认 值 (DEFAULT_LOAD_FACTOR ) 为 0.75 ，这是一个折中的取值。也就是说，默认情况 下，数组大小( DEFAULT_INITIAL_CAPACITY ) 为 16 ，那么当 HashMap 中元素个数 超过16*0.75=12 （这个值就是代码中的 threshold 值，也叫做临界值）的时候，就把 数组的大小扩展为 2*16=32 ，即扩大一倍，然后重新计算每个元素在数组中的位置，

而这是一个非常消耗性能的操作， 所以如果我们已经预知 HashMap 中元素的个数， 那么预设元素的个数能够有效的提高HashMap 的性能。

那么 HashMap 什么时候进行扩容和树形化呢？

当 HashMap 中的元素个数超过数组大小 ( 数组总大小 length, 不是数组中个数 size)*loadFactor 时 ，就会进行数组扩容 ， loadFactor 的默认 值 (DEFAULT_LOAD_FACTOR ) 为 0.75 ，这是一个折中的取值。也就是说，默认 情况下，数组大小( DEFAULT_INITIAL_CAPACITY ) 为 16 ，那么 HashMap 中 元素个数超过16*0.75=12 （这个值就是代码中的 threshold 值，也叫做临界值） 的时候，就把数组的大小扩展为 2*16=32 ，即扩大一倍，然后重新计算每个元 素在数组中的位置，而这是一个非常消耗性能的操作，所以如果我们已经预知

HashMap 中元素的个数，那么预设元素的个数能够有效的提高 HashMap 的性能。 当HashMap 中的其中一个链的对象个数如果达到了 8 个，此时如果 capacity 没有 达到64 ，那么 HashMap 会先扩容解决，如果已经达到了 64 ，那么这个链会变成 树，结点类型由Node 变成 TreeNode 类型。当然，如果当映射关系被移除后， 下次resize 方法时判断树的结点个数低于 6 个，也会把树再转为链表