Java集合-List(Collection子接口)及其子类(ArrayList、Vector、LinkedList)

    List接口是 Collection接口的子接口。

1、List集合类中数据有序， 即添加顺序和取出顺序有序，而且可以重复。

2、List集合类中每个元素都有其对应的顺序索引，即支持索引。例，list.get(2)；取第三个元素。

3、实现类有很多，介绍ArrayList、Vector、LinkedList三种。

常用方法：

    其方法相当于在父接口Collection中加入了索引，可以根据索引进行增删改查。

1、void add(int index, Object ele)

        将指定的元素插入此列表中的指定位置（可选操作）。

        该位置之后的元素则依次往后移一位。

2、boolean addAll(int index, Collection eles)

        从index位置开始，将eles中的所有元素添加进来。

3、Object get(int index)

        获取index位置的元素。

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，相当于用ele 替换原来元素。注意，index位置必须有元素，否则抛出异常。

8、List subList(int formIndex, int toIndex)

        返回从 formIndex 到 toIndex 的子集合。

遍历方式：

    因为其是Collection的子接口，所以方法1和方法2与Collection一致。

    但是其可以有索引，因此通过索引访问，因此可以通过方法3，普通for循环通过索引访问。

1、使用迭代器Iterator

2、使用增强for

3、使用普通for

一、ArrayList

1、ArrayList可以添加null，并且可以添加多个。

2、ArrayList是由数组来实现数据存储的。

3、ArrayList基本等同于Vector，除了ArrayList是线程不安全的，多线程不建议使用ArrayList。

底层源码：

1、ArrayList 中维护了一个 Object 类型的数组 elementData[].

transient关键字：即被其修饰的属性不会被序列化。

    

2、创建ArrayList对象逻辑分析。

        如果使用无参构造器，则elementData[]的容量为0；

            第一次添加则扩容为10，如果需要再次扩容，则扩容为原来的1.5倍。

        如果使用指定大小的构造器，则elementData[]的容量为指定大小，

            如果需要扩容，则直接扩容为1.5倍。

①使用无参构造器创建对象：

    给elementData赋初值 DEFAULTCAPACITY_EMPTY_ELEMENTDATA ，即第二张图：空数组。

指定大小创建对象：(需要看完无参构造创建对象的四个步骤再看)

    即使用有参构造器ArrayList(int initialCapacity)，

        如果给定的值大于0，则直接给elementData赋值一个对应大小的数组

        如果等于0，则跟使用无参一样。

        否则抛出异常。

所以，只要使用无参构造器，所有的ArrayList的elementData属性都是同一个：

    

②第一次执行add()

    

    先使用ensureCapacityInternal()函数判断容量够不够

    然后在进行添加元素。

③确定容量是否足够

    调用ensureCapacityInternal()函数，

        调用calculateCapacity()函数返回一个最小容量。

        得到最小容量后调用ensureExplicitCapacity()判断是否需要扩容。

详情如下：

ensureCapacityInternal()函数：

            

calculateCapacity()函数：

    先确定elementData[]是否是最开始的空数组DEFAULTCAPACITY_EMPTY_ELEMENTDATA，

    如果是，就返回 DEFAULT_CAPACITY 和 minCapacity 中较大的那个，

        其中DEFAULT_CAPACITY初始值为10.(定义如下图二)

    否则直接返回minCapacity。

    

ensureExplicitCapacity()：

        第一步modCount++,是记录当前集合被操作次数。

        第二步判断最小容量 - 当前容量是否大于0，

            如果>0，说明实际容量比最小容量要小，则容量不够了，需要进行扩容。

            则调用grow()方法去扩容。

    

④使用grow()去扩容

    先获取newCapacity的值，即新数组的容量，

    然后使用Arrays.copyOf()函数获得新数组。

详细过程：

    oldCapacity接收未扩容前的容量；

    newCapacity的值为oldCapacity的1.5倍，即 newCapacity = oldCapacity + (oldCapacity >> 1);

    因为第一次old为0，所以new也为0，因此需要判断一下：

        当new - min < 0时，即新的容量小于最小容量，则直接将min赋值给new

    如果新的容量比最大容量大，则进行hugeCapacity()方法

        最大容量MAX_ARRAY_SIZE定义在图二

    最后使用 Arrays.copyOf()函数获得新数组。

    

    

二、Vector

1、vector也是使用数组来实现存储的。

2、vector是线程同步的，即线程安全。

1、定义

    

其在底层也维护了一个Object类型的数组，用来存储数据：

    可见没有transient关键字，即可以序列化。

    

其线程安全：

    其方法都有synchronized关键字修饰。

    

2、与ArrayList比较：

    

3、创建对象逻辑分析（源码）

①无参

    第一步：调用自身的有参构造器，默认赋值为10；

    

②add()

     add()方法和ArrayList类似，只是将modCount++放在了最开始，

    然后执行ensureCapacityHelper()方法确定容量是否足够。

    如果不够则执行grow()方法

    够则直接添加数据。

详细：

add()：

   

ensureCapacityHelper()：

    

grow()：

    可见与ArrayList不同:int newCapacity = oldCapacity + ((capacityIncrement > 0) ? capacityIncrement : oldCapacity);

    先判断属性capacityIncrement是否大于0，若不大于0，则new = old +old，即扩容为2倍。

    属性capacityIncrement作用在有参构造中使用，其默认值为0；

  

③有参

    如下如，Vector的三个构造器，源码如下：

    可见其为相互调用，第三个则为最终构造器。

        第一个参数为初始容量

        第二个参数最终赋给capacityIncrement属性，作用为说明每次容量满时，增加多少，如上图grow()函数。

        即不给此变量赋值则增长为2倍。

      

    

   

    

三、LinkedList

1、底层实现了双向链表和双端队列。

2、可以添加任意元素，包括null。

3、线程不安全，没有实现同步。

1、底层操作机制：

    1、底层维护了一个双向链表

    2、维护两个属性first和last，分别指向首节点和尾节点。

        

    3、每个节点(Node对象)，里面维护了prev、next和item三个属性，分别是前驱，后驱和值。

        注意Node为LinkedList的内部类。

        

    4、因此LinkedList元素的删除添加不是通过数组完成，效率更高。

            即不用新建数组，然后复制原数组到救数组。

2、与ArrayList对比

3、源码分析：

1、new()：创建对象

①无参：

    可见无参构造器什么也不做。

    即仅仅做一个初始化。

        其中first = null;  last = null;  size = 0;

    

②有参：

    有参则先创建一个无参的，然后向里面添加对象。

2、add()：增加对象

    此处介绍没有index参数的增加，即向链表最后添加。

    首先执行add()方法

    然后执行linkLast()方法，将元素添加到链表最后。

        

    分析linkLast()方法：

        ①用 l 来存储 last节点

        ②新建一个newNode

            该节点的prev = l，item = e, next = null，即新建节点前驱为插入前的last节点，值为传进来的值，后驱节点为null；

        ③将last节点指向newNode

        ④判断：

            若l = null，即第一次插入(因为只有第一次插入之前，last和first都为null)，将first也指向newNode

            若i ≠ null，说明之前依旧插入过，该链表当中已经有元素存在，则将l.next指向newNode，即 l 节点也就是原末节点变成了现末节点的前驱。

        ⑤最后把size加一，把modcount加一。

        

3、remove()删除对象

    此处介绍没有参数的删除，即删除第一个元素。

    首先 调用removeFirst()函数，本函数用来判断是否为null，

    然后执行unlinkFirst()函数删除第一个元素。

    

    可见， removeFirst()函数首先判断first是否为null，为空则抛出异常；

            不为空则调用unlinkFirst()方法，并将f传进去。

    

    首先，将节点f 的item赋给element，用以最后返回

                              next赋给next，用来作为新的first。

              将节点f 的item 和 next均置为null，此时gc会判断其为垃圾，将其回收。

    然后，让first指向next，即指向原来的第二个元素；

    判断：

        如果next = null，即原来就只有一个元素，删除的不仅是第一个元素，也是Last所指向的元素，所以需要将last也指向null。

        如果next ≠ null，说明被移除的结点不是最后一个结点，此时被移除的结点的后一个结点对象持有的prev需要指向null，这样就断开了对移除结点的引用。   

    最后将size减一，将modCount加一。

       

有参数删除remove(int index):

    有参数int的话，会先调用checkElementIndex(index)函数判断对应节点是否存在(通过isElementIndex()判断index是否在0和size之间)

    然后调用unlink(node(index))函数去删除，先使用node(index)函数以此获取到第index位置的节点

    然后使用unlink(Node<E> x)函数删除对应元素。

4、set()修改和get()查询

        这两个函数都是调用node()函数得到对应的节点然后进行操作，与上述remove()一致。