List框架

List集合代表一个有序集合，集合中每个元素都有其对应的顺序索引。List集合允许使用重复元素，可以通过索引来访问指定位置的集合元素。

List接口继承于Collection接口，它可以定义一个允许重复的有序集合。因为List中的元素是有序的，所以我们可以通过使用索引（元素在List中的位置，类似于数组下标）来访问List中的元素，这类似于Java的数组。

List接口为Collection直接接口。List所代表的是有序的Collection，即它用某种特定的插入顺序来维护元素顺序。用户可以对列表中每个元素的插入位置进行精确地控制，同时可以根据元素的整数索引（在列表中的位置）访问元素，并搜索列表中的元素。实现List接口的集合主要有：ArrayList、LinkedList、Vector、Stack。

ArrayList底层实现原理

1.	Arraylist底层基于数组实现

private Object[] elementData;

2.	Arraylist底层默认数组初始化大小为10个object数组
public ExtArraylist() throws Exception {
	this(10);
}
public ExtArraylist(int initialCapacity) throws Exception {
	if (initialCapacity < 0) {
		throw new IllegalArgumentException("初始容量不能小于0 " + initialCapacity);
	}
	elementData = new Object[initialCapacity];
}

3. 添加元素后大于当前数组的长度，则进行扩容,将数组的长度增加原来数组的一半。
   // 增大数组空间

   private void grow(int minCapacity) {
   // overflow-conscious code
   int oldCapacity = elementData.length;
   int newCapacity = oldCapacity + (oldCapacity >> 1); // 在原来容量的基础上加上
   												// oldCapacity/2
   if (newCapacity - minCapacity < 0)
   	newCapacity = minCapacity; // 最少保证容量和minCapacity一样
   if (newCapacity - MAX_ARRAY_SIZE > 0)
   newCapacity = hugeCapacity(minCapacity); // 最多不能超过最大容量
   // minCapacity is usually close to size, so this is a win:
   elementData = Arrays.copyOf(elementData, newCapacity);
   }
   

Vector底层实现原理
Vector是线程安全的，但是性能比ArrayList要低。
ArrayList，Vector主要区别为以下几点：
（1）：Vector是线程安全的，源码中有很多的synchronized可以看出，而ArrayList不是。导致Vector效率无法和ArrayList相比；
（2）：ArrayList和Vector都采用线性连续存储空间，当存储空间不足的时候，ArrayList默认增加为原来的50%，Vector默认增加为原来的一倍；
（3）：Vector可以设置capacityIncrement，而ArrayList不可以，从字面理解就是capacity容量，Increment增加，容量增长的参数。

 private void grow(int minCapacity) {  
        // overflow-conscious code  
        int oldCapacity = elementData.length;  
        int newCapacity = oldCapacity + (oldCapacity >> 1); //扩充的空间增加原来的50%（即是原来的1.5倍）  
        if (newCapacity - minCapacity < 0) //如果容器扩容之后还是不够，那么干脆直接将minCapacity设为容器的大小  
            newCapacity = minCapacity;  
        if (newCapacity - MAX_ARRAY_SIZE > 0) //如果扩充的容器太大了的话，那么就执行hugeCapacity  
            newCapacity = hugeCapacity(minCapacity);  
        // minCapacity is usually close to size, so this is a win:  
        elementData = Arrays.copyOf(elementData, newCapacity);  
    }  

/**
 * 自定List接口<br>
 * 
 * @param <E>
 */
public interface ExtList<E> {
	public void add(E object);

	public void add(int index, E object);

	public Object remove(int index);

	public boolean remove(E object);

	public int getSize();

	public Object get(int index);
}


public class ExtArrayList<E> implements ExtList<E> {

	// 保存ArrayList中数据的数组
	private transient Object[] elementData;
	// ArrayList实际数量
	private int size;

	public ExtArrayList() {
		// 默认初始容量为10
		this(10);
	}

	public ExtArrayList(int initialCapacity) {
		if (initialCapacity < 0) {
			throw new IllegalArgumentException("Illegal Capacity: " + initialCapacity);
		}
		// 初始化数组容量
		elementData = new Object[initialCapacity];
	}

// 添加方法实现
public void add(Object object) {
	ensureExplicitCapacity(size + 1);
	elementData[size++] = object;
}

public void add(int index, Object object) {
	rangeCheck(index);
	ensureExplicitCapacity(size + 1);
	System.arraycopy(elementData, index, elementData, index + 1, size - index);
	elementData[index] = object;
	size++;
}

public void ensureExplicitCapacity(int minCapacity) {
	// 如果存入的数据,超出了默认数组初始容量 就开始实现扩容
	if (size == elementData.length) {
		// 获取原来数组的长度 2
		int oldCapacity = elementData.length;
		// oldCapacity >> 1 理解成 oldCapacity/2 新数组的长度是原来长度1.5倍
		int newCapacity = oldCapacity + (oldCapacity >> 1); // 3
		if (newCapacity < minCapacity) {
			// 最小容量比新容量要小的,则采用初始容量minCapacity
			newCapacity = minCapacity;
		}
		// System.out.println("oldCapacity:" + oldCapacity + ",newCapacity:"
		// + newCapacity);
		elementData = Arrays.copyOf(elementData, newCapacity);
	}
}
// public void add(Object object) {
// elementData[size++] = object;
// // 如果存入的数据,超出了默认数组初始容量 就开始实现扩容
// if (size == elementData.length) {
// // 新的数组容量
// int newCapacity = 2 * size;
// // 实现数组扩容
// Object[] newObjct = new Object[newCapacity];
// for (int i = 0; i < elementData.length; i++) {
// newObjct[i] = elementData[i];
// }
// elementData = newObjct;
// }
// }

// 获取数据
public Object get(int index) {
	rangeCheck(index);
	return elementData[index];
}

public Object remove(int index) {
	Object object = get(index);
	int numMoved = elementData.length - index - 1;
	if (numMoved > 0)
		System.arraycopy(elementData, index + 1, elementData, index, numMoved);
	elementData[--size] = null;
	return object;
}

public boolean remove(E object) {
	for (int i = 0; i < elementData.length; i++) {
		Object element = elementData[i];
		if (element.equals(object)) {
			remove(i);
			return true;
		}
	}
	return false;
}

private void rangeCheck(int index) {
	if (index >= size) {
		throw new IndexOutOfBoundsException("数组越界啦!");
	}
}

public int getSize() {
	return size;
	}

}

LinkeList原理
LinkedList 和 ArrayList 一样，都实现了 List 接口，但其内部的数据结构有本质的不同。LinkedList 是基于链表实现的（通过名字也能区分开来），所以它的插入和删除操作比 ArrayList 更加高效。但也是由于其为基于链表的，所以随机访问的效率要比 ArrayList 差。

LinkedList数据结构原理
LinkedList底层的数据结构是基于双向循环链表的，且头结点中不存放数据,如下：

既然是双向链表，那么必定存在一种数据结构——我们可以称之为节点，节点实例保存业务数据，前一个节点的位置信息和后一个节点位置信息，如下图所示：

数组和链表结构对比

数组　是将元素在内存中连续存放，由于每个元素占用内存相同，可以通过下标迅速访问数组中任何元素。但是如果要在数组中增加一个元素，需要移动大量元素，在内存中空出一个元素的空间，然后将要增加的元素放在其中。同样的道理，如果想删除一个元素，同样需要移动大量元素去填掉被移动的元素。如果应用需要快速访问数据，很少插入和删除元素，就应该用数组。

链表　中的元素在内存中不是顺序存储的，而是通过存在元素中的指针联系到一起，每个结点包括两个部分：一个是存储 数据元素 的　数据域，另一个是存储下一个结点地址的 指针。
　如果要访问链表中一个元素，需要从第一个元素开始，一直找到需要的元素位置。但是增加和删除一个元素对于链表数据结构就非常简单了，只要修改元素中的指针就可以了。如果应用需要经常插入和删除元素你就需要用链表。

内存存储区别
数组从栈中分配空间, 对于程序员方便快速,但自由度小。
链表从堆中分配空间, 自由度大但申请管理比较麻烦.　
逻辑结构区别
数组必须事先定义固定的长度（元素个数），不能适应数据动态地增减的情况。当数据增加时，可能超出原先定义的元素个数；当数据减少时，造成内存浪费。　
链表动态地进行存储分配，可以适应数据动态地增减的情况，且可以方便地插入、删除数据项。（数组中插入、删除数据项时，需要移动其它数据项）　
总结
1、存取方式上，数组可以顺序存取或者随机存取，而链表只能顺序存取；　
2、存储位置上，数组逻辑上相邻的元素在物理存储位置上也相邻，而链表不一定；　
3、存储空间上，链表由于带有指针域，存储密度不如数组大；　
4、按序号查找时，数组可以随机访问，时间复杂度为O(1)，而链表不支持随机访问，平均需要O(n)；　
5、按值查找时，若数组无序，数组和链表时间复杂度均为O(1)，但是当数组有序时，可以采用折半查找将时间复杂度降为O(logn)；　
6、插入和删除时，数组平均需要移动n/2个元素，而链表只需修改指针即可；　
7、空间分配方面：
　　数组在静态存储分配情形下，存储元素数量受限制，动态存储分配情形下，虽然存储空间可以扩充，但需要移动大量元素，导致操作效率降低，而且如果内存中没有更大块连续存储空间将导致分配失败；
链表存储的节点空间只在需要的时候申请分配，只要内存中有空间就可以分配，操作比较灵活高效；

相关代码

package com.itmayiedu;

public class LinkeList<E> {

// 第一个元素
private Node first;
// 最后一个元素
private Node last;
// 实际存放在长度
private int size;

class Node {
	// 上一个节点
	Node prev;
	// 节点内容
	Object object;
	// 下一个节点
	Node next;
}

public void add(E e) {
	// 创建新的节点
	Node node = new Node();
	// 节点内容
	node.object = e;
	if (first == null) {
		// // 上一个节点
		// node.prev = null;
		// // 下一个节点
		// node.next = null;
		// 第一个元素和最后一个元素都是为node
		first = node;
	} else {
		// 存放上一个节点内容
		node.prev = last;
		// 设置上一个节点的next为当前节点
		last.next = node;
	}
	last = node;
	size++;
}

public void add(int index, E e) {
	// 1.循环遍历到当前index位置Node
	// 2.新增当前节点
	Node newNode = new Node();
	newNode.object = e;
	// 获取原来的节点
	LinkeList<E>.Node olNode = getNode(index);
	// 获取原来上一个节点
	LinkeList<E>.Node olNodePrev = olNode.prev;

	// 4.新增节点的上一个还是当前Node节点的 上一个节点,下一个就是原来的节点
	// 原来上一个节点变为当前节点
	olNode.prev = newNode;
	if (olNodePrev == null)
		first = newNode;
	else
		// 原来上一个节点的下一个节点变为当前节点
		olNodePrev.next = newNode;

	// 新节点的下一个节点为原来节点
	newNode.next = olNode;
	size++;
}

public E get(int index) {
	LinkeList<E>.Node node = getNode(index);
	return (E) node.object;
}

public Node getNode(int index) {
	Node node = null;
	if (first != null) {
		node = first;
		for (int i = 0; i < index; i++) {
			node = node.next;
		}
	}
	return node;
}

public void remove(int index) {
	checkElementIndex(index);
	LinkeList<E>.Node node = getNode(index);
	if (node != null) {
		LinkeList<E>.Node prevNode = node.prev;
		LinkeList<E>.Node nextNode = node.next;
		// 设置上一个节点的next为当前删除节点的next
		if (prevNode != null) {
			prevNode.next = nextNode;
		}

		// 判断是否是最后一个节点
		if (nextNode != null) {
			nextNode.prev = prevNode;
		}

	}
	size--;
}

public static void main(String[] args) {
	LinkeList<String> linkeList = new LinkeList<String>();
	linkeList.add("张三");
	linkeList.add("李四");
	linkeList.add("wawngma");
	linkeList.add("wangai");
	linkeList.add(2, "ll");
	for (int i = 0; i < linkeList.size; i++) {
		System.out.println(linkeList.get(i));
	}
}

private boolean isElementIndex(int index) {
	return index >= 0 && index < size;
}

private void checkElementIndex(int index) {
	if (!isElementIndex(index))
		throw new IndexOutOfBoundsException("越界啦!");
	}
}