list All elements are null 如何校验 list可以有null

转载

落笔成诗 2024-03-30 08:26:25

文章标签 java 学习 jvm ci 数组 文章分类 机器学习人工智能

ArrayList注意事项

1）ArrayList集合对象可以添加任意的元素，可以添加null元素，并且可以添加多个null元素；

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

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

package com.pero.list_;

import java.util.ArrayList;

/**
 * @author Pero
 * @version 1.0
 */
public class ArrayListDetail {
    public static void main(String[] args) {

        //ArrayList线程不安全，源码中方法没有用synchronized修饰
        /*
        * public boolean add(E e) {
            ensureCapacityInternal(size + 1);  // Increments modCount!!
            elementData[size++] = e;
            return true;
          }
        * */

        ArrayList arrayList = new ArrayList();

        //可以添加null
        arrayList.add(null);
        arrayList.add("jack");
        //可以添加多个null
        arrayList.add(null);
    }
}

ArrayList的底层操作机制和源码分析

1）ArrayList中维护了一个Object类型的数组elementData；

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

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

测试代码：

package com.pero.list_;

import java.util.ArrayList;

/**
 * ArrayList的底层操作机制
 *
 * @author Pero
 * @version 1.0
 */

public class ArrayListSource {
    public static void main(String[] args) {

        //使用无参构造器创建一个ArrayList对象
        ArrayList arrayList = new ArrayList();

        //使用带参数的构造器，给集合赋予初始的空间大小
        //ArrayList arrayList1 = new ArrayList(8);

        //使用for给arrayList集合添加1-10数据
        for (int i = 1; i <= 10; i++) {
            arrayList.add(i);
        }

        //使用for给arrayList集合添加11-15数据
        for (int i = 11; i <= 15; i++) {
            arrayList.add(i);
        }

        arrayList.add(100);
        arrayList.add(200);
        arrayList.add(null);


    }
}

执行步骤（无参构造器）：

步骤一：执行无参构造器（将一个空的Object类型的数组传给elementData）

public ArrayList() {
        this.elementData = DEFAULTCAPACITY_EMPTY_ELEMENTDATA;
    }

★elementData的定义：

transient Object[] elementData;

★DEFAULTCAPACITY_EMPTY_ELEMENTDATA的定义：

private static final Object[] DEFAULTCAPACITY_EMPTY_ELEMENTDATA = {};

步骤二：数据装箱（例如int类型转换成Integer类型）

public static Integer valueOf(int i) {
        if (i >= IntegerCache.low && i <= IntegerCache.high)
            return IntegerCache.cache[i + (-IntegerCache.low)];
        return new Integer(i);
    }

步骤三：执行arrayList.add(i)，添加元素

①执行add(E e)方法：（首先进入ensureCapacityInternal(int minCapacity)方法）

public boolean add(E e) {
        ensureCapacityInternal(size + 1);  //确认容量是否足够使用
        elementData[size++] = e;  //先将元素e添加进elementData[size]中，然后在执行size++
        return true;    //添加成功
    }

②执行ensureCapacityInternal(int minCapacity)方法：（将size + 1 的值以minCapacity形式传进calculateCapacity(Object[] elementData, int minCapacity)方法。）

private void ensureCapacityInternal(int minCapacity) {
        ensureExplicitCapacity(calculateCapacity(elementData, minCapacity));
    }

③执行calculateCapacity(Object[] elementData, int minCapacity)方法：（判断elementData是否为初始定义的空数组，如果是则对DEFAULT_CAPACITY与minCapacity进行比较返回最大的那个值；如果elementData不为初始定义的空数组，则直接返回minCapacity。并将结果传入ensureExplicitCapacity(int minCapacity)方法。）

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

private static final int DEFAULT_CAPACITY = 10;

④执行ensureExplicitCapacity(int minCapacity)方法：（首先执行modCount++，是记录集合当前被修改的次数，防止有多个线程同时去修改；然后执行判断minCapacity - elementData.length > 0，意思是如果当前所需求的最小的容量比elementData数组的值要大，那么就要执行grow(minCapacity)方法，对数组进行扩容。）

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

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

⑤执行grow(int minCapacity)方法：（第一，将原先的elementData数组长度保存为oldCapacity，第二，定义一个新的数组长度newCapacity，大小为老数组长度的1.5倍（oldCapacity + (oldCapacity >> 1)，数值右移一位表示原来的数除以二）；第三，进行判断newCapacity - minCapacity < 0，如果满足条件则对newCapacity进行重新赋值，例如：无参构造器的elementData初始数组长度为0，0+0/2的值依旧为0，经过判断newCapacity（值为0） - minCapacity（值为10）< 0，然后将minCapacity（值为10）赋值给newCapacity；第四，判断newCapacity的值是否大于MAX_ARRAY_SIZE（值为2147483647），如果满足条件则执行hugeCapacity(minCapacity)方法对newCapacity进行重新赋值，否则执行下一条语句；第五，执行Arrays.copyOf(elementData,newCapacity)方法进行数组拷贝，将原来数组中的数据和扩容后（扩容空间中添加null）再拷贝进elementData数组中。

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);
    }

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

/**
     * A constant holding the maximum value an {@code int} can
     * have, 2的31次方-1.
     */
    @Native public static final int   MAX_VALUE = 0x7fffffff;（值为2147483647）

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

public static <T> T[] copyOf(T[] original, int newLength) {
        return (T[]) copyOf(original, newLength, original.getClass());
    }

⑥集合扩容完毕后开始添加元素，执行elementData[size++] = e；然后返回；在容量足够的情况下，执行循环语句。

public boolean add(E e) {
        ensureCapacityInternal(size + 1);  //确认容量是否足够使用
        elementData[size++] = e;  //先将元素e添加进elementData[size]中，然后在执行size++
        return true;    //添加成功
    }

步骤四：当集合空间不足时：进入集合扩容流程：执行ensureCapacityInternal(int minCapacity)方法 -> 执行calculateCapacity(Object[] elementData, int minCapacity)方法 -> 执行ensureExplicitCapacity(int minCapacity)方法 -> 执行grow(int minCapacity)方法（对elementData数组容量扩充为原来的1.5倍） -> 返回。

执行步骤（有参构造器）：

步骤一：执行有参构造器：（对传入实参的数值大小进行判断，如果大于0则创建一个实参数值大小空间的Object数组传给elementData；如果等于零则将EMPTY_ELEMENTDATA(数组空间为0)传给elementData；如果为其他则抛出异常：throw new IllegalArgumentException("Illegal Capacity: "+initialCapacity);）

public ArrayList(int initialCapacity) {
        if (initialCapacity > 0) {
            this.elementData = new Object[initialCapacity];
        } else if (initialCapacity == 0) {
            this.elementData = EMPTY_ELEMENTDATA;
        } else {
            throw new IllegalArgumentException("Illegal Capacity: "+
                                               initialCapacity);
        }
    }

步骤二：数据装箱（例如int类型转换成Integer类型）

public static Integer valueOf(int i) {
        if (i >= IntegerCache.low && i <= IntegerCache.high)
            return IntegerCache.cache[i + (-IntegerCache.low)];
        return new Integer(i);
    }

步骤三：执行arrayList.add(i)，添加元素

①执行add(E e)方法：（首先进入ensureCapacityInternal(int minCapacity)方法）

public boolean add(E e) {
        ensureCapacityInternal(size + 1);  //确认容量是否足够使用
        elementData[size++] = e;  //先将元素e添加进elementData[size]中，然后在执行size++
        return true;    //添加成功
    }

②执行ensureCapacityInternal(int minCapacity)方法：（将size + 1 的值以minCapacity形式传进calculateCapacity(Object[] elementData, int minCapacity)方法。）

private void ensureCapacityInternal(int minCapacity) {
        ensureExplicitCapacity(calculateCapacity(elementData, minCapacity));
    }

private static int calculateCapacity(Object[] elementData, int minCapacity) {
        if (elementData == DEFAULTCAPACITY_EMPTY_ELEMENTDATA) {
            return Math.max(DEFAULT_CAPACITY, minCapacity);
        }
        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);
    }

⑤执行grow(int minCapacity)方法：（第一，将原先的elementData数组长度保存为oldCapacity，第二，定义一个新的数组长度newCapacity，大小为老数组长度的1.5倍（oldCapacity + (oldCapacity >> 1)，数值右移一位表示原来的数除以二）；第三，进行判断newCapacity - minCapacity < 0，如果满足条件则对newCapacity进行重新赋值，例如：有参构造器指定集合空间为8，扩容后容量为8+4=12>0，不满足条件，执行下一条语句；第四，判断newCapacity的值是否大于MAX_ARRAY_SIZE（值为2147483647），如果满足条件则执行hugeCapacity(minCapacity)方法对newCapacity进行重新赋值，否则执行下一条语句；第五，执行Arrays.copyOf(elementData,newCapacity)方法进行数组拷贝，将原来数组中的数据和扩容后（扩容空间中添加null）再拷贝进elementData数组中。

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);
    }

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

/**
     * A constant holding the maximum value an {@code int} can
     * have, 2的31次方-1.
     */
    @Native public static final int   MAX_VALUE = 0x7fffffff;（值为2147483647）

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

public static <T> T[] copyOf(T[] original, int newLength) {
        return (T[]) copyOf(original, newLength, original.getClass());
    }

⑥集合扩容完毕后开始添加元素，执行elementData[size++] = e；然后返回；在容量足够的情况下，执行循环语句。

public boolean add(E e) {
        ensureCapacityInternal(size + 1);  //确认容量是否足够使用
        elementData[size++] = e;  //先将元素e添加进elementData[size]中，然后在执行size++
        return true;    //添加成功
    }