Java复习基础------List集合

最新推荐文章于 2021-02-19 23:56:50 发布

weixin_42391173

最新推荐文章于 2021-02-19 23:56:50 发布

阅读量105

点赞数

本文链接：https://blog.csdn.net/weixin_42391173/article/details/103034833

版权

List

ArrayList：线程不安全的可变数组
LinkedList：包含头尾指针的双向链表结构
Vector ：线程安全的可变数组

ArrayList源码分析：

类中的属性：

// 默认开辟容量10
private static final int DEFAULT_CAPACITY = 10;  
// 一个空的数组
private static final Object[] EMPTY_ELEMENTDATA = {};   
// 一个默认容量的空数组
private static final Object[] DEFAULTCAPACITY_EMPTY_ELEMENTDATA = {};
// 元素数组
transient Object[] elementData;

构造方法：

空参构造函数：public ArrayList()；

/** * Constructs an empty list with an initial capacity of ten. */ 
//初始化elementData[],默认容量大小为10 ?? 详解在扩容机制
public ArrayList() { 
    //隐藏了super() 父类的无参构造方法,是空的
    this.elementData = DEFAULTCAPACITY_EMPTY_ELEMENTDATA;
}

传入自定义容量的有参构造函数： public ArrayList(int initialCapacity)；

public ArrayList(int initialCapacity) {
    // super()
    if (initialCapacity > 0) {
        // 初始化大小为capacity容量的elementData[]
        this.elementData = new Object[initialCapacity];
    } else if (initialCapacity == 0) {
        // 如果自定义容量等于0,则将elementData[]初始化为空的元素数组
        this.elementData = EMPTY_ELEMENTDATA; 
    } else {  
        // 如果自定义容量小于0,则抛出异常
        throw new IllegalArgumentException("Illegal Capacity: "+ initialCapacity);
    }
}

传入一个Collection集合的有参构造函数：public ArrayList(Collection<? extends E> c)；

public ArrayList(Collection<? extends E> c) {
    // 将Collection集合转为一个数组赋值给elementData[]
    elementData = c.toArray();
    if ((size = elementData.length) != 0) {
        // c.toArray might (incorrectly) not return Object[] (see 6260652)
        //这里判断是因为：每个集合的toArray()方法的实现可能不一样,得到的数组类型可能不是Object[].class,如果不是则需要改为Object[]
        if (elementData.getClass() != Object[].class)
            elementData = Arrays.copyOf(elementData, size, Object[].class);
    } else {
        // 如果element[]的长度为0,则将elementData[]初始化为空的元素数组
        this.elementData = EMPTY_ELEMENTDATA;  
    }
}

添加方法：

在末尾添加元素，返回一个布尔类型： public boolean add(E e)；

public boolean add(E e) {
    // 检查是否需要扩容
    ensureCapacityInternal(size + 1);
    // 在末尾添加元素
    elementData[size++] = e;
    return true;
}

在任意位置上添加元素，没有返回值类型：public void add(int index, E element)；

public void add(int index, E element) {
    // 检查index是否在[0,size]范围上
    rangeCheckForAdd(index);
    // 检查是否需要扩容
    ensureCapacityInternal(size + 1); 
    // 将index位置及以后的元素向后挪一位
    System.arraycopy(elementData, index, elementData, index + 1,
                     size - index);
    // 将新的元素覆盖index位置上的元素
    elementData[index] = element;
    size++;
}

删除方法：

删除指定位置上的元素，返回删除的元素：public E remove(int index) ；

public E remove(int index) {
    //检查要删除的元素是否在[0,sieze-1范围上
    rangeCheck(index);
    modCount++;
    // 获取当前位置的元素
    E oldValue = elementData(index);
    int numMoved = size - index - 1;
    //判断是否删除的是最后一个元素，如果不是则将[index+1,size-1]上的元素往前挪一位
    if (numMoved > 0)
        System.arraycopy(elementData, index+1, elementData, index,
                         numMoved);
    //不管是否挪动过将size-1上的位置置空
    elementData[--size] = null;
    return oldValue;
}

删除指定元素，返回布尔类型true代表删除成功：public boolean remove(Object o)；

// 大致上与remove(int index)一致，通过找到该元素第一次出现的下表，然后删除
// 另外一点就是可以看到ArrayList可以存储null值
public boolean remove(Object o) {
    if (o == null) {
        for (int index = 0; index < size; index++)
            if (elementData[index] == null) {
                fastRemove(index);
                return true;
            }
    } else {
        for (int index = 0; index < size; index++)
            if (o.equals(elementData[index])) {
                fastRemove(index);
                return true;
            }
    }
    return false;
}

可以看到在添加和删除的过程中，都需要将元素进行向前向后移动，所以效率很慢

查找方法：

通过下标查找，所以查找的时间复杂度为o(1)

public E get(int index) {
    rangeCheck(index);

    return elementData(index);
}

扩容机制：

// 确定数组的容量的入口方法
private void ensureCapacityInternal(int minCapacity) {
    ensureExplicitCapacity(calculateCapacity(elementData, minCapacity));
}

//计算容量
private static int calculateCapacity(Object[] elementData, int minCapacity) {
    //这里就解释了为什么调用无参构造方法,默认的容量是10
    //调用无参构造时,elementData[]会指向DEFAULTCAPACITY_EMPTY_ELEMENTDATA这个默认空数组
    if (elementData == DEFAULTCAPACITY_EMPTY_ELEMENTDATA) {
        return Math.max(DEFAULT_CAPACITY, minCapacity);
    }
    return minCapacity;
}

private void ensureExplicitCapacity(int minCapacity) {
    modCount++;
    //判断时候需要扩容
    if (minCapacity - elementData.length > 0)
        grow(minCapacity);
}

//扩容的核心方法
private void grow(int minCapacity) {
    // overflow-conscious code
    // 拿到元素数组的长度
    int oldCapacity = elementData.length;
    // 扩容1.5倍
    int newCapacity = oldCapacity + (oldCapacity >> 1);
    //如果扩容后容量比需要的最小容量还小，则将需要的最小容量作为扩容后的容量
    if (newCapacity - minCapacity < 0)
        newCapacity = minCapacity;
    //如果扩容后的容量比数组允许的最大容量还大，则给出允许的值
    if (newCapacity - MAX_ARRAY_SIZE > 0)
        newCapacity = hugeCapacity(minCapacity);
    // 复制数组，改变容量
    elementData = Arrays.copyOf(elementData, newCapacity);
}

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

总结：ArrayList是动态可变的数组，底层维护了一个Object[]的数组，当构造时不传入任何参数时，它默认的容量是10，这在添加第一个元素的时候会做相应的扩容。对于ArrayList来说，它的查询效率高，但是增删效率低。另外，在遍历数组的时候不能有添加或者删除的操作，否则会抛出异常，如果需要的话，要用迭代器遍历，这时候在遍历时可以添加或删除。

LinkedList源码分析：

类中的属性：

// 记录链表的大小
transient int size = 0;
// 记录头节点
transient Node<E> first;
// 记录尾节点
transient Node<E> last;

//私有内部类Node就是集合的元素
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;
    }
}

构造方法：

// 空参构造器没有任何实现
public LinkedList() {
}

// 把Collection集合添加到链表中
public LinkedList(Collection<? extends E> c) {
this();
addAll(c);
}

添加方法：

添加一个集合：

public boolean addAll(Collection<? extends E> c) {
    return addAll(size, c);
}

public boolean addAll(int index, Collection<? extends E> c) {
    checkPositionIndex(index);   //检查是否在范围上

    Object[] a = c.toArray();     
    int numNew = a.length;
    // 如果集合为空就无需继续操作
    if (numNew == 0)				
        return false;

    Node<E> pred, succ;
    // 如果index是最后一个元素的后一个位置，那么是在尾部插入
    // 否则succ指向当前要插入的位置元素，从当前元素的前一个位置插入集合
    if (index == size) { 
        succ = null;
        pred = last;
    } else {
        succ = node(index);
        pred = succ.prev;
    }

    for (Object o : a) {
        @SuppressWarnings("unchecked") E e = (E) o;
        Node<E> newNode = new Node<>(pred, e, null);
        //如果pred == null，表示当前链表为空,让这一个第一个节点作为头部，把集合连接起来
        if (pred == null)
            first = newNode;
        else
            pred.next = newNode;
        pred = newNode;
    }
	// 如果succ == null,表示在尾部插入
    if (succ == null) {
        last = pred;
    } else {
        // oldNode --- succ --- (······)   ->  oldNode---(Collection) --- succ --- (···)
        pred.next = succ;
        succ.prev = pred;
    }

    size += numNew;
    modCount++;
    return true;
}

添加一个元素：默认在尾部添加

public boolean add(E e) {
    linkLast(e);
    return true;
}

void linkLast(E e) {
    final Node<E> l = last;
    final Node<E> newNode = new Node<>(l, e, null);
    last = newNode;
    if (l == null)
        first = newNode;
    else
        l.next = newNode;
    size++;
    modCount++;
}

在指定位置添加一个元素：

public void add(int index, E element) {
    checkPositionIndex(index);

    if (index == size)
        linkLast(element);
    else
        linkBefore(element, node(index));
}

// linkBefore原理和addAll方法相似
void linkBefore(E e, Node<E> succ) {
    final Node<E> pred = succ.prev;
    final Node<E> newNode = new Node<>(pred, e, succ);
    succ.prev = newNode;
    if (pred == null)
        first = newNode;
    else
        pred.next = newNode;
    size++;
    modCount++;
}

删除方法：

移除一个元素：默认移除表头

public E remove() {
    return removeFirst();
}

public E removeFirst() {
    final Node<E> f = first;
    if (f == null)
    throw new NoSuchElementException();
    return unlinkFirst(f);
}

private E unlinkFirst(Node<E> f) {
    // 获取当前头节点的值作为返回值
    final E element = f.item;  
    // 获取头节点的下一个元素
    final Node<E> next = f.next;
    // 将头节点的信息移除
    f.item = null;
    f.next = null; // help GC
    first = next;
    // 如果next为null 表明链表中只有一个节点(即头节点)
    if (next == null)
        last = null;
    else
        next.prev = null;
    size--;
    modCount++;
    return element;
}

删除指定位置的元素

public E remove(int index) {
    checkElementIndex(index);
    return unlink(node(index));
}

E unlink(Node<E> x) {
    final E element = x.item;
    // 获取当前结点的前后指针
    final Node<E> next = x.next;
    final Node<E> prev = x.prev;
	// 如果prev为null，表明删除的元素是头节点
    if (prev == null) {
    	first = next;
    } else {
    	prev.next = next;
    	x.prev = null;
    }
	// 如果next为null，表明删除的元素是尾节点
    if (next == null) {
    	last = prev;
    } else {
    	next.prev = prev;
    	x.next = null;
    }

    x.item = null;
    size--;
    modCount++;
    return element;
}

删除指定元素

// 当要删除指定元素节点的时候避免不了要遍历链表，查找它的位置
// 另外LinkedList也可以存储null值
public boolean remove(Object o) {
    if (o == null) {
        for (Node<E> x = first; x != null; x = x.next) {
            if (x.item == null) {
                unlink(x);
                return true;
            }
        }
    } else {
        for (Node<E> x = first; x != null; x = x.next) {
            if (o.equals(x.item)) {
                unlink(x);
                return true;
            }
        }
    }
    return false;
}

查找方法：

public E get(int index) {
    checkElementIndex(index);
    return node(index).item;
}

//查找元素的位置如果小于链表大小的一半，那么就从头部开始遍历，否则就从尾部开始遍历
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;
    }
}

其他方法：
1. poll()：返回头节点，并移除头节点
2. offer(): 等同于add()，在尾部添加节点
3. peek()：返回头节点
4. push(): 在头节点处添加元素
5. pop(): 移除头节点

总结： LinkedList底层的数据结构是双向链表，它可以作为栈使用，也可以作为队列使用，默认的添加是在尾部添加，默认的移除实在头部移除，可以存储null值，在多线程下也是不安全的。

Vector源码分析：

与Arraylist的底层实现大致相同，底层也维护了一个Object[]数组，默认大小为10，由以下几点不同：

Vector的方法都由synchronized关键字修饰，保证了原子性操作；
Vector在调用构造器就初始化为10，而ArrayList在添加第一个元素的时候才默认初始化为10

Vector比ArrayList多了一个构造方法，可以传入一个容量增值

public Vector(int initialCapacity, int capacityIncrement) {
    super();
    if (initialCapacity < 0)
        throw new IllegalArgumentException("Illegal Capacity: "+
                                           initialCapacity);
    this.elementData = new Object[initialCapacity];
    this.capacityIncrement = capacityIncrement;
}

扩容机制，当容量增量为0时候，则扩容两倍，否则，则扩容为原来大小+增量，再去判断是否移除操作

private void grow(int minCapacity) {
    // overflow-conscious code
    int oldCapacity = elementData.length;
    int newCapacity = oldCapacity + ((capacityIncrement > 0) ?
                                     capacityIncrement : oldCapacity);
    if (newCapacity - minCapacity < 0)
        newCapacity = minCapacity;
    if (newCapacity - MAX_ARRAY_SIZE > 0)
        newCapacity = hugeCapacity(minCapacity);
    elementData = Arrays.copyOf(elementData, newCapacity);
}