javaSE——集合（二）
一、List接口
1、List接口
List接口是Collection接口的子接口，其中
-
List集合类中元素有序（即添加顺序和取出顺序一致）、且可重复
-
List集合中每个元素都有其对应的顺序索引，即支持索引
-
List容器中的元素都对应一个整数型的序号记载其在容器中的位置，可以根据序号存取容器中的元素
2、List接口常用方法
list接口继承了Collcetion接口，包含Collcetion中的所有方法。
| 方法 |
功能描述 |
| void add(int index,Object element) |
将元素elemet插入到List集合的index处 |
| boolean addAll(int index,Collection c) |
将集合c所包含的所有元素都插入到List集合的index处 |
| Object get(int index) |
返回集合index索引处的元素 |
| int indexOf(Object o) |
返回兑现那个o在List集合中第一次出现的位置索引 |
| int lastIndexOf(Object o) |
返回对象o在list集合中最后一次出现的位置索引 |
| Object remove(int index) |
返回并删除index索引处的元素 |
| Object set(int index,Object element) |
将index索引处的元素替换成element对象，返回被替换的旧元素 |
| List subList(int forIndex,int toIndex) |
返回从索引fromIndex（包含）到索引toIndex（不包含）处所有集合元素组成的子集合 |
| void replaceAll(UnaryOperator operator) |
根据operator指定的计算机规则重新设置List集合的所有元素 |
| void sort(Comparator c) |
根据Comparator参数对List集合的元素排序 |
此外，list还定义了两种方法
-
get(int int index)：获得指定索引位置的元素
-
set(int inedx,Object obj)：缉拿该集合中指定索引位置的对象修改为指定的对象
3、List三种遍历方式
（1）、使用Iterator
Iterator iterator = collection.iterator();
while (iterator.hasNext()) {
Object next = iterator.next();
}（2）、使用增强for
for (Object o : collection) {
}（3）、使用普通for
for (int i=0;i4、ArrayList
（1）简介
实现了可变的数组，允许保存所有元素，包括null，并可以根据索引位置对集合进行快速的随机访问；缺点是向指定的索引位置插入对象或删除对象的速度较慢
优点: 底层数据结构是数组，查询快，增删慢。
缺点: 线程不安全，效率高
（2）、ArrayList扩容机制
ArrayList中维护了一个Object类型的数据elementData；当创建ArrayList对象时，如果使用的是无参构造器，则初始elementData容量为0，第一次添加时，扩容elementData为10，如需要再次扩容，则扩容elementData为原来的1.5倍；如果使用的是指定大小的构造器，则初始elementData容量为指定大小，如果需要扩容，则直接扩容elementData为原来的1.5倍
public static void main(String[] args) {
List list = new ArrayList();
for (int i=1;i<=5;i++){
list.add(i);
}
for (int i=5;i<=10;i++){
list.add(i);
}
list.add(100);
list.add(200);
list.add(null);
Iterator iterator = list.iterator();
while (iterator.hasNext()) {
Object obj = iterator.next();
System.out.println("List="+obj);
}
}在执行for循环时，会把int装箱为Integer
点开ArrayList()方法：
调用此构造函数，返回了一个空的数组DEFAULTCAPACITY_EMPTY_ELEMENTDATA，点开此数组可看到长度为0
ArrayList()中主要的几个变量
//定义一个空元素数据
private static final Object[] EMPTY_ELEMENTDATA = {};
//也是一个空数组，跟上边的空数组不同之处在于，这个是在默认构造器时返回的，扩容时需要用到这个作判断
final Object[] DEFAULTCAPACITY_EMPTY_ELEMENTDATA = {};
/**
*transient用来表示一个域不是该对象序行化的一部分，当一个对象被序行化的时候，transient修饰的变量的值是不包括在序行化的表示中的。
* ArrayList在序列化的时候会调用writeObject，直接将size和element写入ObjectOutputStream；反序列化时调用readObject，从ObjectInputStream获取size和element，再恢复到elementData。
* elementData是一个缓存数组，它通常会预留一些容量，等容量不足时再扩充容量，那么有些空间可能就没有实际存储元素，采用上诉的方式来实现序列化时，就可以保证只序列化实际存储的那些元素，而不是整个数组，从而节省空间和时间。
*/
transient Object[] elementData;
//数组的长度，此参数是数组中实际的参数，区别于elementData.length
private int size;ArrayList有三个构造函数，不同的构造函数会影响后边的扩容机制判断：
1.默认的无参构造
调用此构造函数，返回了一个空的数组DEFAULTCAPACITY_EMPTY_ELEMENTDATA，此数组长度为0.
2.给定初始容量的构造函数
构造一个具有指定长度的空数组，当initialCapacity为0时，返回EMPTY_ELEMENTDATA
3.包含特定集合元素的构造函数
把传入的集合转换为数组，然后通过Arrays.copyOf方法把集合中的元素拷贝到elementData中。同样，若传入的集合长度为0，返回EMPTY_ELEMENTDATA
（3）、ArrayList扩容原理
扩容开始于集合添加元素方法，添加元素有两种方法
其中两个方法都调用了ensureCapacityInternal(size + 1)方法，把数组长度加1以确保能存下下一个数据,此方法会先判断elementData是不是一个空数组，如果是则赋值给他一个最小容量，最小容量则为 DEFAULT_CAPACITY 和 minCapacity 的最大值
可以看到DEFAULT_CAPACITY为10，minCapacity为1
若创建ArrayList时调用的是无参构造ArrayList()，此方法会返回DEFAULT_CAPACITY（值为10）和minCapacity的最大值，因此，最终会返回固定值10；若创建ArrayList时调用了有参构造ArrayList(6)，则此方法会返回1，注意这个
minCapacity变量只是第一次调用add方法时值为1，此后的调用需要根据实际的数组长度size+1。
然后调用ensureExplicitCapacity方法，
modCount++用来记录当前集合被修改的次数，此用到了快速失败机制：当多个线程对同一个集合进行操作的时候，某线程访问集合的过程中，该集合的内容被其他线程所改变(即其它线程通过add、remove、clear等方法，改变了modCount的值)，这时，就会抛出ConcurrentModificationException异常，产生fail-fast事件。
最小容量减去数组实际的大小，如果大于零则会调用grow方法进行扩容，比如当前容量为10，数组实际大小为0，则无法进行添加操作。即如果ArrayList给定了特定初始容量，则此处需要根据实际情况确定是否调用grow方法，即有可能不需要扩容。如果没有指定初始容量，第一次调用add则此处一定需要调用grow方法。
int newCapacity = oldCapacity + (oldCapacity >> 1)意为原数据大小加原先数组大小的1.5倍，oldCapacity为原来的容量，(oldCapacity >> 1)右移一位，即除以2
当第一次进行添加时，oldCapacity为0，所以进入if判断，判断newCapacity如果小于传入的minCapacity，则直接让newCapacity等于minCapacity，即不需要扩容计算（当无参构造时，elementData.length为0，所以oldCapacity也为0，minCapacity为10，因此最终newCapacity为10）。
然后判断newCapacity是否大于设定的MAX_ARRAY_SIZE，此处如果大于，则调用hugeCapacity方法
Arrays.copyOf即为数组的复制，把newCapacity复制给elementData
5、Vector
（1）、简介
底层数据结构是数组，查询快，增删慢，线程安全，效率低，可以存储重复元素
protected Object[] elementData;优点: 底层数据结构是数组，查询快，增删慢。
缺点: 线程安全，效率低
（2）、Vector扩容机制
public static void main(String[] args) {
Vector vector = new Vector();
for (int i=0;i<5;i++){
vector.add(i);
}
}点击Vector()方法，如果是无参的，默认大小为10
在执行for循环时，会把int装箱为Integer
添加数据到Vector集合，和ArrayList一样有修改计数器
确定是否需要扩容
按实际情况进行扩容，
当第一次进行添加时，oldCapacity为10，capacityIncrement为0，所以直接让newCapacity等于oldCapacity+oldCapacity，即为原来的两倍。
6、LinkedList
（1）、简介
LinkedList采用双向链表结构保存对象。优点是便于像集合中插入和删除对象；但对于随机访问集合中的对象，使用LinkedList类实现List集合的效率较低
优点: 底层数据结构是链表，查询慢，增删快。
缺点: 线程不安全，效率高
（2）、简单双向链表实现
public class LinkedMethod {
public static void main(String[] args) {
Node jack = new Node("jack");
Node tom = new Node("tom");
Node jun = new Node("jun");
jack.next=tom;
tom.next=jun;
jun.pre=tom;
tom.pre=jack;
//头尾结点
Node first = jack;
Node last = jun;
System.out.println("==从头到尾进行遍历==");
while(true){
if(first==null){
break;
}
//输出first信息
System.out.println(first);
first = first.next;
}
System.out.println("==从尾到头进行遍历==");
while(true){
if(last==null){
break;
}
//输出first信息
System.out.println(last);
last = last.pre;
}
}
}
class Node {
//Node节点对象
public Object item;
//指向后一个节点
public Node next;
//pre指向前一个节点
public Node pre;
public Node(Object name) {
this.item = name;
}
public String toString() {
return "Node name=" + item;
}
}（3）、LinkedList底层源码
add()方法
public static void main(String[] args) {
LinkedList linkedList = new LinkedList();
for (int i=1;i<=5;i++){
linkedList.add(i);
}
System.out.print("LinkedList="+linkedList);
}创建一个空数组
依旧是对int类型的装箱
add()方法
将新的结点加入到双向链表的最后；
new Node<>(l, e, null)意为上一个节点、本体、下一个节点；
当第一次添加时，此时last为空，first也为空，但都指向item，item为1；
当第二次添加元素时，要创建一个新的节点，此时l指向前一个元素，下一个结点指向新节点
