Collection的Queue接口与List接口的部分分析

Queue和ArrayList都继承自Collection，Collection有又成自Iterable,

Queue的方法却不如List的多，Queue常用的方法有offer，poll,peek;

Collection集合的大致结构：

实现List 接口的类：

ArrayList:
底层数据结构是数组，查询快，增删慢。
线程不安全，效率高。（快速失败机制）
Vector:
底层数据结构是数组，查询快，增删慢。
线程安全，效率低。（很少用了）
LinkedList:
底层数据结构是链表，查询慢，增删快。
线程不安全，效率高。

Queue接口的方法有：boolean add()\boolean offer()\E remove()\E poll()\E element()\E peek()。。。。

List接口的方法有;int size()\boolean isEmpty()\boolean contains(Object o)\Iterator iterator();\

Object toArray()\T[] toArray()\boolean add(E e);\boolean remove(Object o);\

boolean contaisAll(Collection<?> c)\boolean addAll(Collection<? extends E> c);

boolean addAll(int index, Collection<? extends E> c)\boolean removeAll(Collection<? extends E> c)

boolean retainAll(Collection<? > c)\default void raplaceAll(UnaryOperator< E> operator );

default void sort(Comparator<? super E> c);\void clear();\boolean equals(Object o);

int hashCode();\E get(int index);\E set(int index, E element );\void add(int index, E element);

E remove(int index);\int indexOf(Object o);\int lastIndexOf(Object o);

ListIterator< E> listIterator();\ListIterator< E > listIterator(int index );

List< E> subList(int fromIndex, int toIndex);\default Spliterator< E > spliterator();

接下来对Queue和List的详细分析：
1、ArrayDeque,DelayQueue,LinkedList直接间接的实现了Queue接口；
ArrayDeque和LinkedList都实现了Serializable和Cloneable接口，支持序列化和克隆操作；各自的方法大同小异

存储结构不同：
ArrayDeque实质是一个数组实现的循环队列
LinkedList是数组的思想，链表实现，每一个节点是一个Node类对象，对象里边有next、pre、value;

方法不同:
1.ArrayDeque：

size（）	//返回实际元素个数
isEmpty（）	//判断队列是否为空

contain（Object o）//判断是否包含Object o
clear（）//清空队列
Object[] toArray（new Object[size()]）//队列转数组
private T[] copyElements(T[] a) //复制元素到a数组里
clone（）//返回一个克隆的队列（副本）

writeObject(java.io.ObjectOutputStream s)//写入序列化
readObject(java.io.ObjectInputStream s)//读取序列化

addFirst（） 		push（E e）
addLast（）		 add（E e）时间复杂度：O(1)
offerFirst（）
offerLast（）		offer（E e）


pollFirst（）				poll（）
pollLast（）
removeFirst（）			remove（）		E pop（）
removeLast（）
getFirst（）				E element（）；时间复杂度：O(1)
getLast（）
peekFirst（）			peek（）
peekLast（）
removeFirstOcurrence（Object o）	remove（Object o）时间复杂度：O(n)
delete （int i）
boolean removeLastOcurrence（Object o）

2.LinkedList：

public void addFirst(E e)；
private void linkFirst(E e)头部添加节点
void linkLast(E e) 最后添加节点
public void addLast(E e)；
void linkBefore(E e, Node< E> succ)在succ前边链接e节点

 private E unlinkFirst(Node< E> f) 头部删除节点；
private E unlinkLast(Node< E> l) 尾部删除节点；

E unlink(Node< E> x)删除x节点

 public E getFirst()；获取头部节点；
 public E getLast()；获取尾部节点；
public E removeFirst() ；删除头部节点；
 public E removeLast() ；删除尾部节点；

 public boolean contains(Object o)
public int size()；
public boolean add(E e)；默认尾部添加；

 public boolean remove(Object o)；删除第一个出现o的节点；
public void clear() ；遍历把所有节点的前驱后驱和element置空

校验下标是否合法，有检查下标是否合法的函数
 public E get(int index);获取index节点的value值
 public E set(int index, E element) ；修改index位置节点的element值
public void add(int index, E element)；在节点队列满的话添加在队尾，不满添加在index节点前面
  public E remove(int index)；杀出下标index处的节点；   
 public int indexOf(Object o)；返回第一个o节点的下标值；
public int lastIndexOf(Object o)

public E peek()；获取第一个节点的item；
public E peekFirst()
 public E pollFirst()

public E peekLast()获取最后一个节点的item

public E poll()头部删除；
public E remove()

尾部删除
public E pollLast()

public boolean offer(E e)尾部添加
public boolean offerFirst(E e)头部添加
 public boolean offerLast(E e)尾部添加；

 public void push(E e)头部添加
 public E pop()尾部删除

public boolean removeFirstOccurrence(Object o)
public boolean removeLastOccurrence(Object o)

扩容方式不同:
LinkedList直接添加，不用预先申请空间
ArrayDeque,无参构造申请16个节点，无参构造需要计算申请多少个空间；以后添加空间不够时二倍扩容；

最后：
ArrayDeque：循环队列，线程不安全，性能高于LinkedList，不允许插入null元素
LinkedList：双端队列，线程不安全，首尾元素操作效率高，低效随机访问

3、DelayQueue
主要是加入了模块：
参考博客：https://www.cnblogs.com/wuhan729/p/8601108.html

lock.lock（）；
try{
。。。
}catch{
。。。
}finally{
lock.unlock（）；
}

2、ArrayList,LinkedList，Vector直接间接实现了List接口；

//ArrayList与LinkedList

1、非快速失败机制

1）、fail-fast机制，是一种错误检测机制。它只能被用来检测错误，因为JDK并不保证fail-fast机制一定会发生。若在多线程环境下使用fail-fast机制的集合，使用“java.util.concurrent包下的类”去取代“java.util包下的类”。
将代码：
List list = new ArrayList<>();
替换为：
List list = new CopyOnWriteArrayList<>();

2)、CopyOnWriteArrayList与ArrayList不同：

(1) 、和ArrayList继承于AbstractList不同，CopyOnWriteArrayList没有继承于AbstractList，它仅仅只是实现了List接口。
(2) 、ArrayList的iterator()函数返回的Iterator是在AbstractList中实现的；而CopyOnWriteArrayList是自己实现Iterator。
(3) 、ArrayList的Iterator实现类中调用next()时，会“调用checkForComodification()比较‘expectedModCount’和‘modCount’的大小”（这也是快速失败机制的关键）；但是，CopyOnWriteArrayList的Iterator实现类中，没有所谓的checkForComodification()，更不会抛出ConcurrentModificationException异常！
虽然，获取到了更新后的ArrayList的大小；但是，当前迭代的结果并不是更新后的arrayList；

2、ArrayList：
01）、关键字解释：transient。 （序列化里用到）
Java的serialization提供了一种持久化对象实例的机制。当持久化对象时，可能有一个特殊的对象数据成员，我们不想用serialization机制来保存它。为了在一个特定对象的一个域上关闭serialization，可以在这个域前加上关键字transient。

 02）、构造方法： 

ArrayList提供了三种方式的构造器，可以构造一个默认初始容量为10的空列表、构造一个指定初始容量的空列表以及构造一个包含指定collection的元素的列表，这些元素按照该collection的迭代器返回它们的顺序排列的。

// ArrayList带容量大小的构造函数。    
    public ArrayList(int initialCapacity) {    
        super();    
        if (initialCapacity < 0)    
            throw new IllegalArgumentException("Illegal Capacity: "+    
                                               initialCapacity);    
        // 新建一个数组    
        this.elementData = new Object[initialCapacity];    
    }    
   
    // ArrayList无参构造函数。默认容量是10。    
    public ArrayList() {    
        this(10);    
    }    
   
    // 创建一个包含collection的ArrayList    
    public ArrayList(Collection<? extends E> c) {    
        elementData = c.toArray();    
        size = elementData.length;    
        if (elementData.getClass() != Object[].class)    
            elementData = Arrays.copyOf(elementData, size, Object[].class);    
    }

03）、 元素存储：
 ArrayList提供了set(int index, E element)、add(E e)、add(int index, E element)、addAll(Collection<? extends E> c)、addAll(int index, Collection<? extends E> c)这些添加元素的方法。

04）、元素直接读取
public E get(int index)

05）、元素删除：
E remove(int index); boolean remove(Object o); void fastRemove(int index);removeRange(int fromIndex,int toIndex)

2、对于ArrayList而言，它实现List接口、底层使用数组保存所有元素。其操作基本上是对数组的操作。其实，Vector也基本上是对数组的操作；
1）、相似之处：
（01）、Vector和ArrayList的实现方式可以看出非常的类似，增删改查方法相似，同样有快速失败机制
（02）、扩充容量的方法ensureCapacityHelper。
与ArrayList相同，Vector在每次增加元素（可能是1个，也可能是一组）时，都要调用该方法来确保足够的容量。当容量不足以容纳当前的元素个数时，就先看构造方法中传入的容量增长量参数CapacityIncrement是否为0，如果不为0，就设置新的容量为就容量加上容量增长量，如果为0，就设置新的容量为旧的容量的2倍，如果设置后的新容量还不够，则直接新容量设置为传入的参数（也就是所需的容量），而后同样用Arrays.copyof()方法将元素拷贝到新的数组。
（03）、同样在查找给定元素索引值等的方法中，两者都将该元素的值分为null和不为null两种情况处理，Vector中也允许元素为null。

2）、关于ArrayList和Vector区别如下：
（01）、ArrayList在内存不够时默认是扩展0.5倍，Vector是默认扩展1倍。
（02）、Vector提供indexOf(obj, start)接口，ArrayList没有。
（03）、Vector属于线程安全级别的，但是大多数情况下不使用Vector，因为线程安全需要更大的系统开销（很多方法加了synchronized同步语句，来保证线程安全；如元素获取方法public synchronized E get(int index)）。