java集合整理-List篇

接下来会整理一下集合的几个分支，List，Set和Map。
主要从以下几点分别整理：
1.内部结构是怎样的
2.数据如何存储，如何确定存放元素的位置，存储的时候是否会自动进行排序
3.对null值的处理，
4.是否支持手动排序，如何排序
5.如何扩容
6.是否线程安全，查找和存储的优缺点
7.如何遍历和修改元素内容
8.一些特殊的方法
9.适用场景

List家族

List接口继承于Collection 接口，主要实现有ArrayList 、 LinkList、Vector 3个实现类

ArryList

 1.内部结构是怎样的

从ArrayList 的源码，我们可以知道内部数据结构是数据，所有的数据是存放在一个数组里

 transient Object[] elementData 
 这是一个不可序列化的数组
 我们直接生成ArrayList对象时
  public ArrayList() {
        this.elementData = DEFAULTCAPACITY_EMPTY_ELEMENTDATA;
    }
    private static final Object[] DEFAULTCAPACITY_EMPTY_ELEMENTDATA = {};
    是一个空数组，所以我们初始化的时候，只给这个ArrayList对象分配了一个空数组

2.数据如何存储，如何确定存放元素的位置，存储的时候是否会自动进行排序
   请参看第5条

3.对null值的处理
支持null ,并且可以存储多个 null值

 4.是否支持手动排序，如何排序

因为元素本身就是有顺序的，按照插入顺序进行排序的

 5.如何扩容

很多人都知道ArrayList容量的事，都说初始容量是10，这样说是准确，又不是准确的
ArryList有一个属性叫 int Size,没有设置初始值，因为int类型的初始值是0，所以一开始容量是0，
但是当我们往ArrayList里添加元素时

public boolean add(E e) {
        ensureCapacityInternal(size + 1);  // Increments modCount!!
        elementData[size++] = e;
        return true;
    }
private void ensureCapacityInternal(int minCapacity) {
        if (elementData == DEFAULTCAPACITY_EMPTY_ELEMENTDATA) {
            minCapacity = Math.max(DEFAULT_CAPACITY, minCapacity);
        }

        ensureExplicitCapacity(minCapacity);
    }
    private static final int DEFAULT_CAPACITY = 10;

如果当前对象是个空集合，那么就会设置 10 和 1之间选取一个最大值，也就是10作为 容量
如果当前对象不是空集合，那么就会判断一下加了这个元素之后的 Size 是否大于容量，如果大于现有容量，那么就会扩容0.5倍

private void grow(int minCapacity) {
        // overflow-conscious code
        int oldCapacity = elementData.length;
        //新容量
        int newCapacity = oldCapacity + (oldCapacity >> 1);
        
        if (newCapacity - minCapacity < 0)
            newCapacity = 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);
    }

6.是否线程安全，查找和存储的优缺点

源码中的添加、删除操作都没有进行同步控制，是线程不安全的

7.如何遍历和修改元素内容

根据下标取值即可，修改元素提供了 set 方法，先检查下标，然后设置新值，并返回原先的值

 public E set(int index, E element) {
        rangeCheck(index);

        E oldValue = elementData(index);
        elementData[index] = element;
        return oldValue;
    }

关于移除元素，list中有一个 modCount 参数，只要集合结构发生变化（增加、删除元素）都会使 modCount ++ ，如果在遍历的过错中执行 remove（Object） / remove(Index) 操作都会报
java.util.ConcurrentModificationException 就是因为 expectedModCount 不等于 modCount
，但是如果使用迭代器 Itertor 进行元素移除时，则不会有这个问题，因为在remove时会将 expectedModCount 赋值给 modCount

public void remove() {
            if (lastRet < 0)
                throw new IllegalStateException();
            checkForComodification();

            try {
                ArrayList.this.remove(lastRet);
                cursor = lastRet;
                lastRet = -1;
                expectedModCount = modCount;
            } catch (IndexOutOfBoundsException ex) {
                throw new ConcurrentModificationException();
            }
        }

8.一些特殊的方法

iterator() 迭代器可以移除对象
listIterator() 迭代器可以移除、设置对象、获取下一个对象的下标

？？？很多人会好奇，为什么

System.out.println(list); 
会把list的内容都打印出来 [0, 1, 2, 3, 4, 5, 6, 7, 8, 10, 11, null, null, null]
这是因为ArrayList 继承了 AbstractList ，AbstractList 继承了AbstractCollection
AbstractCollection 中 重写了 toString()方法
public String toString() {
        Iterator<E> it = iterator();
        if (! it.hasNext())
            return "[]";

        StringBuilder sb = new StringBuilder();
        sb.append('[');
        for (;;) {
            E e = it.next();
            sb.append(e == this ? "(this Collection)" : e);
            if (! it.hasNext())
                return sb.append(']').toString();
            sb.append(',').append(' ');
        }
    }

LinkedList

LinkedList 内部结构是链表，

transient int size = 0;

    /**
     * Pointer to first node.
     * Invariant: (first == null && last == null) ||
     *            (first.prev == null && first.item != null)
     */
    transient Node<E> first;

    /**
     * Pointer to last node.
     * Invariant: (first == null && last == null) ||
     *            (last.next == null && last.item != null)
     */
    transient Node<E> last;

private static class Node<E> {
        E item;
        Node<E> next;
        Node<E> prev;

        Node(Node<E> prev, E element, Node<E> next) {
            this.item = element;
            this.next = next;
            this.prev = prev;
        }
    }

数据查找时，越界检查过后，看index 在链表中间的左边还是在右边，如果是左边则从头开始查找，如果是在右边，则从尾部开始查找。

Node<E> node(int index) {
        // assert isElementIndex(index);

        if (index < (size >> 1)) {
            Node<E> x = first;
            for (int i = 0; i < index; i++)
                x = x.next;
            return x;
        } else {
            Node<E> x = last;
            for (int i = size - 1; i > index; i--)
                x = x.prev;
            return x;
        }
    }

Vector

跟ArrayList 类似，只不过是线程安全的