Java-集合-ArrayList-基本知识解析

4. ArrayList：（二维数组等。。）
   I. 数组结构（实现）存储，查询快，增删慢。//注册（1次）-> 查询（N次）
   初始容量 JDK6的时候是10 JDK7的时候是0
   （原来new出来就有10个连续空间，后来变为0的长度数组。
   当你首次添加的时候，才帮你做一个实际空间的分配，并存入新值----可以节省空间）
   II. JDK 1.2发布，执行效率快，线程不安全。
   List接口的大小可变数组的实现。实现了所有课选列表操作，并允许包括null在内的所有元素。除了实现List接口外，此类还提供一些方法来操作内部用来存储列表的数组的大小。（此类大致上等同于vector类，除了此类是不同步的。）
   size、isEmpty、get、set、iterator和listItreator操作都以固定时间运行。add操作以分摊的固定时间运行，也就是说，添加n个元素需要O(n)时间。其他所有操作都以线性时间运行（大体上讲）。与用于LinkedList实现的常数因子相比，此实现的常数因子较低。
   每个ArrayList实例都有一个容量。该容量是指用来寻存储列表元素的数组的大小。它总是至少等于列表的大小。随着向ArrayList中不断添加元素，其容量也自动增长。并未指定增长策略的细节，因为这不只是添加元素会带来分摊固定时间开销那样简单。
   在添加大量元素前，应用程序可以使用ensureCapacity操作来增加ArrayList实例的容量。这样可以减少递增式再分配的数量。
   注意：此实现不是同步的。如果多个线程同时访问一个ArrayList实例，而其中至少一个线程从结构上修改了列表，那么它必须保持外部同步。（结构上的修改是指任何添加或删除一个或多个元素的操作，或是显示调整底层数组的大小，仅仅设置元素的值不是结构上的修改。）这一般通过对自然封装该列表的对象进行同步操作来完成。如果不存在这样的对象，则应该使用Collections.synchronizedList方法将该列表“包装”起来。这最好在创建时完成，以防止意外对列表进行不同步的访问：
   此类是Java Collections Framework的成员。
   main(){
   ArrayList list = new ArrayList();
   list.add(“A”); //set 存
   list.add(“B”);
   list.add(“0,D”);//基于下标插入元素
   list.get(0); //查看
   list.remove(“A”);//get 取，走
   list.clear();//清空

for(int i = 0 ; i < list.size(); i++){ // 数组的长度
System.out.println(list.get(i));//通过get返回集合
}
Object[] objs = list.toArray();
// toArray() 按适当顺序（从第一个到最后一个元素）返回包含此列表中所有元素的数组
}
源码： private static final int DEFAULT_CAPACITY = 10; //JDK1.6 容量数组默认为10
无参构造源码： public ArrayList(){
super();
this.elementData = EMPTY_ELEMENTDATA;//常量 }
private transient Object[] elementData;//实例变量
private static final Object[] EMPTY_ELEMENTDATA = { }；//常量 地址 JDK1.7

源码：public Boolean add(E e){
ensureCapacityInternal(size + 1); // Increments modCount!! 扩容
elementData[size++] = e; //size有效元素计数器
return ture; }
private int size;

有参构造源码：

public ArrayList(int initialCapacity){
super();
if(initialCapacity < 0)
throw new IllegalArgumentException(“Illegal Capacity:”+ initialCapacity);
this.elementData = new Object[initialCapacity];//创建Object数组 }

源码：public int size(){//存多少返回多少
	return size;

}
源码：public void add(int index,E element){
rangeCheckForAdd(index);
ensureCapacityInternal(size + 1); // Increments modCount!!
System.arraycopy(elementData, index , elementData, index +1, size - index);
//复制，将原来下标的元素，放在下一个下标上， 移动次数
elementData[index] = element;
size++;
}
源码： public void clear(){
modCount++;
//clear to let GC do its work
for(int i = 0; i <size ;i++){
elmenetData[i] = null;}
size = 0;
}
源码：public Object[] toArray(){
return Arrays.copyOf(elementData, size);
//需要的是elementData里面元素 但不可以修改 所以要
//复制给一个长度为size的元素数组
}

例子：
main(){
ArrayList scores = new ArrayList();
scores.add(99D);
scores.add(97D);
scores.add(96D);
scores.add(99D);
double sum = 0;
for(int i = 0;i < scores.size(); i++){
sum += (double)scores.get(i); // get原本是Object类型要强制转换成double类型
}
System.out.ptintln(sum/scores.size());
}
5. Vector：
I. 数组结构（实现）存储，查询快，增删慢。
II. JDK 1.0发布，执行效率慢，线程安全。

Vector类可以实现可增长的对象数组。与数组一样，它包含可以使用整数索引进行访问的组件。但是，Vector的大小可以根据需要增大或缩小，以适应创建Vector后进行添加或移除项的操作
每个向量会试图通过维护capacity和capacityIncrement来优化存储管理。capacity始终至少应与向量的大小相等；这个值通常比后者大些，因为随着将组件添加到向量中，其存储将按capacityIncrement的大小增加存储块，应用程序可以在插入大量组件前增加向量的容量；这样就减小了增加的重分配的量。

由Vector的iterator和listIterator方法所返回的迭代器是快速失败的；如果在迭代器后的任意时间从结构上修改了向量（通过迭代器自身的remove或add方法之外的任何其他方式），则迭代器将抛出ConcurrentModificationException。因此，面对并发的修改，迭代器很快就完全失败，而不是冒着在将来不确定的时间任意发生不确定行为的风险。Vector的elements方法返回的Enumeration不是快速失败的，
注意：迭代器的快速失败行为不能得到保证，一般来说，存在不同步的并发修改时，不可能作出任何坚决的保证。快速失败迭代器尽最大的努力抛出ConcurrentModificationException。因此，编写依赖于此异常的程序的方式是错误的，正确的做法是：迭代器的快速失败行为应该仅用于检测bug。
从Java2平台v1.2开始，此类改进为可实现List接口，是它成为 Java Collection Framework的成员。与新collection实现不同，Vector是同步的。

源码：public class Vector extends AbstractList
public synchronized Boolean add(E e){ //synchronized 同步
modCount++;
ensureCapacityHelper(elementCount + 1);
elementData[elementCount++] = e;
return true;
}

6. LinkedList：
   I. 链表（链接列表）结构存储，查询慢、增删快。
   II. 了解：Queue接口：队列、双端队列
   III. 了解：栈结构Last In First Out（后进先出）
   IV. 了解：队列结构First In First Out（先进先出）

万物皆对象，一切皆工具
List接口的链接列表实现、实现所有可选的列表操作，并且允许所有元素（包括null）。除了实现List接口外，LinkedList类还为在列表的开头及结尾get、remove和insert元素提供了统一的命名方法。这些操作允许将链接列表用作堆栈、队列或双端队列。
此类实现Deque接口，为add、poll提供先进先出队列操作，以及其他堆栈和双端队列操作。
所有操作都是按照双重链接列表的需要执行的。在列表中编索引的操作将从开头或结尾遍历一遍（从靠近指定索引的一端）
LinkedList list = new LinkedList();

addFirst addLast getFirst getLast
public class LinkedList extends AbstractSequentialList
implements list, Deque,Cloneable,java.io.Serializable{ }
public interface Deque extends Queue{ //队列-- }