List、ArrayList、LinkedList

List：（注意是Util包下的List，而不是awt包下的）

特点：

1.有序：存储和取出的元素顺序一致

2.有索引：可通过索引操作元素

3.可重复：存储的元素可以重复

Collection<String> s = new ArrayList();

List<String>  s  = new ArrayList();

以上都是多态，后面直接可以写

ArrayList<String> s = new ArrayList();

LinkedList<String> s = new LinkedList();

因为都是接口的实现类，方法都可以用，但注意每个实现类或接口都有自己的特有方法

特有方法：（成员方法）

void add(int index, E element)	在此集合中的指定位置插入指定的元素
E remove(int index)	删除指定索引处的元素，返回被删除的元素
E set(int index , E element)	修改指定索引处的元素，返回被修改的元素
E get(int index)	返回指定索引处的元素

List集合中有两个remve删除方法

E remove(int index)删除指定索引处的元素，返回被删除的元素

boolean remove(Object o) 删除指定元素，返回删除是否成功

数据结构：

含义：数据结构是计算机存储、组织数据的方式。是指相互之间存在一种或多种特定关系的元素的集合

作用：合适的数据结构，可以带来更高的运行或者存储效率

栈	类似弹夹，先进后出。进：压栈、出：弹栈，栈内存
队列	类似排队，先进先出
数组	查询快：通过地址值和索引定位 增删慢：元素增删后，其他元素需要整体迁移或后移
链表	分为单向链表、双向链表（优势都是相对数组而言） 增删快（只需把节点地址值替换即可） 查询慢（每个节点地址值都是独立的，需要从head头节点开始查） 单向链表： head+^：head代表头节点，第二个开始变成数据，^代表关联地址值位置 每一个节点自身有一个地址值，例如b节点的地址值是：001 而上一个节点的^记录的是下一个节点b的地址值：001 双向链表： 在节点中新增了^在前面，记录上一个节点， 即： 单向：只记录下一个节点地址 双向：上一个节点地址和下一个节点地址都会被记录 双向的优势在于：可以从两端开始查，判断离哪一端近

ArrayList:(底层原码)

ArrayList底层数据结构是数组，查询快，增删慢

List<String> s= new ArrayList();----空参创建的是一个长度为0的数组

当s.add("a")，添加元素时，arraylist会创建一个长度为10的数组

每一个elementData都为null

且size有两层含义：（size是一个变量）

1.表示下一个要操作的索引 

2.表示数组元素个数【s.size()  0~(size-1) 】

s.get(3)，当传入的索引值大于等于size（传入的索引会进行判断），就会报错

当10个索引都装满了，arraylist会自动扩容1.5倍，将原来的10个元素装进来后，size向后指向下一个索引（再扩容一次15的1.5倍是22.5那0.5是怎么算？）

源码很复杂，不是很理解，学完再回来看这个

transient Object[] elementData;

private static final Object[] DEFAULTCAPACITY_EMPTY_ELEMENTDATA = {};

public ArrayList() {
    this.elementData = DEFAULTCAPACITY_EMPTY_ELEMENTDATA;
即：Object[] this = {};证明arraylist的空参构造创建的是一个0数组
}

当添加元素时

public boolean add(E e) {//(String "a")
    ensureCapacityInternal(size + 1); //(0+1) // Increments modCount!!
    elementData[size++] = e;
    return true;
}

private void ensureCapacityInternal(int minCapacity) {
    ensureExplicitCapacity(calculateCapacity(elementData, minCapacity));
//(elementDate,1) = 10
}

private static int calculateCapacity(Object[] elementData, int minCapacity) {
    if (elementData == DEFAULTCAPACITY_EMPTY_ELEMENTDATA) {//elementData == {} ?
        return Math.max(DEFAULT_CAPACITY, minCapacity);//return 10
    }
    return minCapacity;
}

private static final int DEFAULT_CAPACITY = 10;

private void ensureExplicitCapacity(int minCapacity) {
    modCount++;

    // overflow-conscious code
    if (minCapacity - elementData.length > 0)
        grow(minCapacity);
}

private void grow(int minCapacity) {//10
    // overflow-conscious code
    int oldCapacity = elementData.length;//0
    int newCapacity = oldCapacity + (oldCapacity >> 1);//0
    if (newCapacity - minCapacity < 0)//0-10<0
        newCapacity = minCapacity;//newCapacity = 10;
    if (newCapacity - MAX_ARRAY_SIZE > 0)//10-(-8)=18
        newCapacity = hugeCapacity(minCapacity); newCapacity = 0
    // minCapacity is usually close to size, so this is a win:
    elementData = Arrays.copyOf(elementData, newCapacity);
}

private static final int MAX_ARRAY_SIZE = Integer.MAX_VALUE - 8;

@Native public static final int   MAX_VALUE = 0x7fffffff;

private static int hugeCapacity(int minCapacity) {
    if (minCapacity < 0) // overflow
        throw new OutOfMemoryError();
    return (minCapacity > MAX_ARRAY_SIZE) ? //10>-8 return 0
        Integer.MAX_VALUE :
        MAX_ARRAY_SIZE;
}

LinkedList：

public void addFirst(E e)	在该列表开头插入指定元素
public void addLast(E e)	将指定的元素追加到此列表的末尾
public E getFirst()	返回此列表中的第一个元素
public E getLast()	返回此列表中的最后一个元素
public E removeFirst()	从此列表中删除并返回 第一个元素
public E removeLast()	从此列表中删除并返回 最后一个元素

linked的一般应用场景？？

快捷键：

Ctrl+N：搜源代码（双击Shift是全局搜索）

Alt+7：调大纲

Ctrl+F12：搜索