Java集合（3）--List概述

一、     List集合中的对象按照索引位置排序，可以有重复对象，允许按照对象在集合中的索引位置检索对象。List与数组有些相似。一个存储区只能存单一值元素。实现类主要有ArrayList，Vector、LinkedList，Stack，CopyOnWriteArrayList。

ArrayList是基于数组实现的，是一个数组队列。可以动态的增加容量。

LinkedList是基于链表实现的，是一个双向循环列表。可以被当做堆栈使用。

Vector是基于数组实现的，是一个矢量队列，是线程安全的。

Stack是基于数组实现的，是栈，它继承与Vector，特性是FILO（先进后出）。

CopyOnWriteArrayList是一种线程安全的ArrayList，顾名思义，它会利用写时拷贝技术，它对共享对象做只读操作的时候，大家都用一个共享对象，如果有可变的操作时，就会复制一份出来，然后在新的拷贝上进行操作。

二、     使用场景

在实际的应用中如果使用到队列，栈，链表，首先可以想到使用List。不同的场景下面使用不同的工具，效率才能更高！

1. 当集合中对插入元素数据的速度要求不高，但是要求快速访问元素数据，则使用ArrayList！

2. 当集合中对访问元素数据速度不做要求不高，但是对插入和删除元素数据速度要求高的情况，则使用LinkedList！

3.当集合中有多线程对集合元素进行操作时候，则使用Vector！但是现在BVector现在一般不再使用，如需在多线程下使用，可以用CopyOnWriteArrayList，在java.util.concurrent包下。

4.当集合中有需求是希望后保存的数据先读取出来，则使用Stack！

 

三、     ArrayList

 

四、     Vector

 

五、     LinkedList

LinkedList与ArrayList一样实现List接口，只是ArrayList是List接口的大小可变数组的实现，LinkedList是List接口链表的实现。基于链表实现的方式使得LinkedList在插入和删除时更优于ArrayList，而随机访问则比ArrayList逊色些。

LinkedList实现所有可选的列表操作，并允许所有的元素包括null。

除了实现 List 接口外，LinkedList 类还为在列表的开头及结尾 get、remove 和 insert 元素提供了统一的命名方法。这些操作允许将链接列表用作堆栈、队列或双端队列。

此类实现 Deque 接口，为 add、poll 提供先进先出队列操作，以及其他堆栈和双端队列操作。

所有操作都是按照双重链接列表的需要执行的。在列表中编索引的操作将从开头或结尾遍历列表（从靠近指定索引的一端）。

同时，与ArrayList一样此实现不是同步的。

六、     Stack

Stack是一个后进先出（last in first out，LIFO）的堆栈，在Vector类的基础上扩展5个方法而来。

 

七、     CopyOnWriteArrayList

CopyOnWriteArrayList是一种线程安全的ArrayList，顾名思义，它会利用写时拷贝技术，它对共享对象做只读操作的时候，大家都用一个共享对象，如果有可变的操作时，就会复制一份出来，然后在新的拷贝上进行操作。

所以可变操作的开销就会比较大，当然，在执行复制前，需要上独占锁，这样保证在复制的时候，不会出现不一致的情况，在复制完毕后，释放锁。而在做复制的时候，其它线程还是可以在原有的老的对象上进行只读操作，所以不会阻塞读操作。

当复制执行完之后，更改volatile引用，从而其它线程可以看到最新的修改结果。

1. CopyOnWriteArrayList的“动态数组”机制 -- 它内部有个“volatile数组”(array)来保持数据。在“添加/修改/删除”数据时，都会新建一个数组，并将更新后的数据拷贝到新建的数组中，最后再将该数组赋值给“volatile数组”。这就是它叫做CopyOnWriteArrayList的原因！CopyOnWriteArrayList就是通过这种方式实现的动态数组；不过正由于它在“添加/修改/删除”数据时，都会新建数组，所以涉及到修改数据的操作，CopyOnWriteArrayList效率很
低；但是单单只是进行遍历查找的话，效率比较高。
2. CopyOnWriteArrayList的“线程安全”机制 -- 是通过volatile和互斥锁来实现的。(01) CopyOnWriteArrayList是通过“volatile数组”来保存数据的。一个线程读取volatile数组时，总能看到其它线程对该volatile变量最后的写入；就这样，通过volatile提供了“读取到的数据总是最新的”这个机制的
保证。(02) CopyOnWriteArrayList通过互斥锁来保护数据。在“添加/修改/删除”数据时，会先“获取互斥锁”，再修改完毕之后，先将数据更新到“volatile数组”中，然后再“释放互斥锁”；这样，就达到了保护数据的目的。 

 

1、        java中，List在遍历的时候，如果被修改了会抛出java.util.ConcurrentModificationException错误。

import java.util.ArrayList;

import java.util.List;

 

public class Resource3 {

 

      publicstatic void main(String[] args) throws InterruptedException {

           List<String>a = new ArrayList<String>();

           a.add("a");

           a.add("b");

           a.add("c");

           finalArrayList<String> list = new ArrayList<String>(

                      a);

           Threadt = new Thread(new Runnable() {

                 intcount = -1;

 

                 @Override

                 publicvoid run() {

                      while(true) {

                            list.add(count+++ "");

                      }

                 }

           });

           t.setDaemon(true);

           t.start();

           Thread.currentThread().sleep(3);

           for(String s : list) {

                 System.out.println(s);

           }

      }

}

这段代码运行的时候就会抛出java.util.ConcurrentModificationException错误。这是因为主线程在遍历list的时候，子线程在向list中添加元素。

那么有没有办法在遍历一个list的时候，还向list中添加元素呢？办法是有的。就是java concurrent包中的CopyOnWriteArrayList。

先解释下CopyOnWriteArrayList类。

CopyOnWriteArrayList类最大的特点就是，在对其实例进行修改操作（add/remove等）会新建一个数据并修改，修改完毕之后，再将原来的引用指向新的数组。这样，修改过程没有修改原来的数组。也就没有了ConcurrentModificationException错误。

 

2、        CopyOnWriteArrayList

package com.sc.collections;

 

import java.util.List;

import java.util.Random;

importjava.util.concurrent.CopyOnWriteArrayList;

importjava.util.concurrent.ExecutorService;

import java.util.concurrent.Executors;

 

public classCopyOnWriteArrayListHelloWorld{

     

      privatefinal ExecutorService threadPool;

     

      publicCopyOnWriteArrayListHelloWorld(){

           threadPool= Executors.newFixedThreadPool(10);

      }

     

      publicstatic void main(String[] args) {

           CopyOnWriteArrayListHelloWorlddemo = new CopyOnWriteArrayListHelloWorld();

       try {

                 demo.doExec(5);

           }catch (InterruptedException e) {

                 e.printStackTrace();

           }

      }

     

      publicvoid doExec(int num) throws InterruptedException {

       List<Integer> list = new CopyOnWriteArrayList<>();

       for (int i = 0; i < 6; i++){

           threadPool.execute(new Writer("Writer thread>"+i,list));

       }

       for (int i = 0; i < 100; i++){

           threadPool.execute(new Reader("Readthread>"+(i*100),list));

       }

       //关闭线程池

       threadPool.shutdown();

    }

     

}

 

class Writer implements Runnable{

      privateString threadName;

      privateList<Integer> list;

      publicWriter(String threadName,List<Integer> list){

           this.threadName=threadName;

           this.list=list;

      }

      publicvoid run() {

           for(int i = 0; i < 20; i++) {

                 this.list.add(newRandom().nextInt(1000));

                 System.out.println(this.getThreadName()+",WriteResult>"+this.toString());

           }

      }

      publicString getThreadName() {

           returnthreadName;

      }

      publicvoid setThreadName(String threadName) {

           this.threadName= threadName;

      }

     

      @Override

      publicString toString() {

           StringBufferbuffer=new StringBuffer();

           for(int i = 0; i < this.list.size(); i++) {

                 buffer.append(this.list.get(i)+",");

           }

           returnbuffer.toString();

      }

      publicList<Integer> getList() {

           returnlist;

      }

      publicvoid setList(List<Integer> list) {

           this.list= list;

      }

}

 

class Reader implements Runnable{

      privateString threadName;

      privateList<Integer> list;

      publicReader(String threadName,List<Integer> list){

           this.setThreadName(threadName);

           this.list=list;

      }

      publicvoid run() {

           System.out.println(this.getThreadName()+",ReadResult>"+this.toString());

      }

      publicString getThreadName() {

           returnthreadName;

      }

      publicvoid setThreadName(String threadName) {

           this.threadName= threadName;

      }

     

      @Override

      publicString toString() {

           StringBufferbuffer=new StringBuffer();

           for(int i = 0; i < this.list.size(); i++) {

                 buffer.append(this.list.get(i)+",");

           }

           returnbuffer.toString();

      }

}

 

3、        CopyOnWriteArrayList的使用场景

通过上面的分析，CopyOnWriteArrayList有几个缺点：

1、由于写操作的时候，需要拷贝数组，会消耗内存，如果原数组的内容比较多的情况下，可能导致young gc或者full gc

2、不能用于实时读的场景，像拷贝数组、新增元素都需要时间，所以调用一个set操作后，读取到数据可能还是旧的,虽然CopyOnWriteArrayList 能做到最终一致性,但是还是没法满足实时性要求；

CopyOnWriteArrayList 合适读多写少的场景，不过这类慎用

因为谁也没法保证CopyOnWriteArrayList到底要放置多少数据，万一数据稍微有点多，每次add/set都要重新复制数组，这个代价实在太高昂了。在高性能的互联网应用中，这种操作分分钟引起故障。

 

八、     ArrayList，Vector主要区别

ArrayList，Vector主要区别为以下几点：

（1）：Vector是线程安全的，源码中有很多的synchronized可以看出，而ArrayList不是。导致Vector效率无法和ArrayList相比；

（2）：ArrayList和Vector都采用线性连续存储空间，当存储空间不足的时候，ArrayList默认增加为原来的50%，Vector默认增加为原来的一倍；

（3）：Vector可以设置capacityIncrement，而ArrayList不可以，从字面理解就是capacity容量，Increment增加，容量增长的参数。

 

九、     ArrayList和LinkedList的区别

1、ArrayList是实现了基于动态数组的数据结构，LinkedList基于链表的数据结构。 （LinkedList是双向链表，有next也有previous）

2、对于随机访问get和set，ArrayList觉得优于LinkedList，因为LinkedList要移动指针。

3、对于新增和删除操作add和remove，LinedList比较占优势，因为ArrayList要移动数据。

4、对ArrayList和LinkedList而言，在列表末尾增加一个元素所花的开销都是固定的。对ArrayList而言，主要是在内部数组中增加一项，指向所添加的元素，偶尔可能会导致对数组重新进行分配；而对LinkedList而言，这个开销是统一的，分配一个内部Entry对象。

5、在ArrayList的中间插入或删除一个元素意味着这个列表中剩余的元素都会被移动；而在LinkedList的中间插入或删除一个元素的开销是固定的。

6、LinkedList不支持高效的随机元素访问。

7、ArrayList的空间浪费主要体现在在list列表的结尾预留一定的容量空间，而LinkedList的空间花费则体现在它的每一个元素都需要消耗相当的空间。

可以这样说：当操作是在一列数据的后面添加数据而不是在前面或中间,并且需要随机地访问其中的元素时,使用ArrayList会提供比较好的性能；当你的操作是在一列数据的前面或中间添加或删除数据,并且按照顺序访问其中的元素时,就应该使用LinkedList了。

 

十、