一方面， 面向对象语言对事物的体现都是以对象的形式，为了方便对多个对象 的操作，就要对对象进行存储。另一方面，使用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 个，也会把树再转为链表

 Collections工具类