ArrayList和Vector

ArrayList

ArrayList的注意实现

1.ArrayList可以加入null，并且多个

2.ArrayList是由数组来实现数据存储的

3.ArrayList基本等同于Vector，除了ArrayList是线程不安全（执行效率高）。在多线程情况下，不建议使用ArrayList

ArryList的底层操作机制源码分析

1.arrayList中维护了一个Object类型的数组elementData。【debug看源码】transient Object[] elementData;//transient 表示瞬间，短暂的，表示该属性不会被序列化

2.当创建ArrayList对象时，如果使用无参构造器，则初始elementData容量为0，第一次添加，则扩容elementData为10，如果需要再次扩容，则扩容elementData为1.5倍

3.如果使用的是指定大小的构造器，则初始elementData容量指定大小，如果需要扩容，则直接扩容elementData为1.5倍。

debug调试以下代码，查看源码

import java.util.ArrayList;

@SuppressWarnings({"all"})
public class ArrayListSource {
    public static void main(String[] args) {
//解读源码
//注意，注意，注意，Idea 默认情况下，Debug 显示的数据是简化后的，如果希望看到完整的数据
//需要做设置. //使用无参构造器创建 ArrayList 对象
//ArrayList list = new ArrayList();
        ArrayList list = new ArrayList(8);
//使用 for 给 list 集合添加 1-10 数据
        for (int i = 1; i <= 10; i++) {
            list.add(i);
        }
//使用 for 给 list 集合添加 11-15 数据
        for (int i = 11; i <= 15; i++) {
            list.add(i);
        }
        list.add(100);
        list.add(200);
        list.add(null);
    }
}

Vector

Vector介绍

1.Vector类的定义说明：

public class Vector<E> extens AbstractList<E> implements List<E>,RandomAccess,Cloneable,Serializable

2.Vector 底层也是一个对象数组

3.Vector是线程同步的，即线程安全，Vector类的操作方法带有 synchronized

4.在开发中，需要线程同步安全时，考虑使用Vector

package List_.Vector_;

import java.util.Vector;
@SuppressWarnings({"all"})
public class Vector_ {
    public static void main(String[] args) {
//无参构造器
//有参数的构造
        Vector vector = new Vector(8);
        for (int i = 0; i < 10; i++) {
            vector.add(i);
        }
        vector.add(100);
        System.out.println("vector=" + vector);
        //解读源码
        //1. new Vector() 底层
        /*
            public Vector() {
                this(10);
            }
        补充：如果是 Vector vector = new Vector(8);
        走的方法:
            public Vector(int initialCapacity) {
                this(initialCapacity, 0);
            }
          2. vector.add(i)
          2.1 //下面这个方法就添加数据到 vector 集合
             public synchronized boolean add(E e) {
                modCount++;
                ensureCapacityHelper(elementCount + 1);
                elementData[elementCount++] = e;
                return true;
             }
          2.2 //确定是否需要扩容 条件 ： minCapacity - elementData.length>0
                private void ensureCapacityHelper(int minCapacity) {
                    // overflow-conscious code
                    if (minCapacity - elementData.length > 0
                    grow(minCapacity);
                }
            2.3 //如果 需要的数组大小 不够用，就扩容 , 扩容的算法
                //newCapacity = oldCapacity + ((capacityIncrement > 0) ?
                // capacityIncrement : oldCapacity);
                //就是扩容两倍. 
                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);
                 }
*/
    }
}

ArrayList和Vector的比较

ArrayList和Vector的比较