Java基础 9.17

1.ArrayList注意事项

• permits all elements, including null, ArrayList可以加入null，并且多个
• ArrayList是由数组来实现数据存储的 
• ArrayList基本等同于Vector，除了ArrayList是线程不安全的（执行效率高），在多线程情况下，不建议使用ArrayList

2.ArrayList底层操作机制源码分析（重点，难点）

1. ArrayList中维护了一个Object类型的数组elementData transient Object[] elementData transient表示瞬间、暂时的，表示该属性不会被序列化
2. 当创建ArrayList对象时，如果使用的是无参构造器，则初始elementData容量为0，第一次添加，则扩容到10，如需再次扩容则扩容到原来容量的1.5倍
3. 如果使用的是指定大小的构造器，则初始elementData容量为指定大小，如果需要扩容，则直接扩容elementData为原来的1.5倍

3.Vector类的基本介绍

Vector类的定义说明

public class Vector<E>
    extends AbstractList<E>
    implements List<E>, RandomAccess, Cloneable, java.io.Serializable

• Vector底层也是一个对象组，protected Object[] elementData
• Vector是线程同步的，即线程安全，Vectoe类的操作方法带有synchronized
• 在开发中，需要线程同步安全时，考虑使用Vector

Vector底层结构和ArrayList比较

package com.logic.list_;

import java.util.Vector;

/**
 * @author logic
 * @version 1.0
 */
@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);
            }
         */
    }
}