Java集合常见面试题（二）

路上阡陌

已于 2024-02-15 00:34:32 修改

阅读量506

点赞数 4

分类专栏： # Java集合文章标签： java 数据结构面试

于 2023-01-16 09:09:49 首次发布

本文链接：https://blog.csdn.net/m0_51431003/article/details/128530081

版权

Java集合专栏收录该内容

6 篇文章 0 订阅

订阅专栏

Collection 子接口之 List

ArrayList 和 Vector 的区别?

ArrayList 是 List 的主要实现类，底层使用 Object[]存储，适用于频繁的查找工作，线程不安全；
Vector 是 List 的古老实现类，底层使用Object[] 存储，线程安全的。

Vector在关键性的方法前面都加了synchronized关键字，来保证线程的安全性。如果有多个线程会访问到集合，那最好是使用 Vector，因为不需要我们自己再去考虑和编写线程安全的代码。

ArrayList在底层数组不够用时在原来的基础上扩展0.5倍，Vector是扩展1倍，这样ArrayList就有利于节约内存空间。

ArrayList 与 LinkedList 区别?

是否保证线程安全： ArrayList 和 LinkedList 都是不同步的，也就是不保证线程安全。
底层数据结构： ArrayList 底层使用的是 Object 数组；LinkedList 底层使用的是双向链表数据结构。（JDK1.6 及之前为循环链表，JDK1.7 取消了循环。注意双向链表和双向循环链表的区别，下面有介绍到！）
插入和删除是否受元素位置的影响：
- ArrayList 采用数组存储，所以插入和删除元素的时间复杂度受元素位置的影响。比如：执行add(E e)方法的时候， ArrayList 会默认在将指定的元素追加到此列表的末尾，这种情况时间复杂度就是 O(1)。但是如果要在指定位置 i 插入和删除元素的话（add(int index, E element)）时间复杂度就为 O(n-i)。因为在进行上述操作的时候集合中第 i 和第 i 个元素之后的(n-i)个元素都要执行向后位/向前移一位的操作。
- LinkedList 采用链表存储，所以，如果是在头尾插入或者删除元素不受元素位置的影响（add(E e)、addFirst(E e)、addLast(E e)、removeFirst() 、 removeLast()），时间复杂度为 O(1)，如果是要在指定位置 i 插入和删除元素的话（add(int index, E element)，remove(Object o)），时间复杂度为 O(n) ，因为需要先移动到指定位置再插入。
是否支持快速随机访问： LinkedList 不支持高效的随机元素访问，而 ArrayList 支持。快速随机访问就是通过元素的序号快速获取元素对象(对应于get(int index)方法)。
内存空间占用： ArrayList 的空间浪费主要体现在在 list 列表的结尾会预留一定的容量空间，而 LinkedList 的空间花费则体现在它的每一个元素都需要消耗比 ArrayList 更多的空间（因为要存放直接后继和直接前驱以及数据）。

注意：LinkedList 仅仅在头尾插入或者删除元素的时候时间复杂度近似 O(1)，其他情况增删元素的时间复杂度都是 O(n) 。

双向链表和双向循环链表

双向链表： 包含两个指针，一个 prev 指向前一个节点，一个 next 指向后一个节点。
在这里插入图片描述

双向循环链表： 最后一个节点的 next 指针指向 head 节点，而 head 节点的 prev 指针指向最后一个节点，构成一个环。
在这里插入图片描述

RandomAccess 接口

public interface RandomAccess {
}

源码注释：
Marker interface used by List implementations to indicate that they support fast (generally constant time) random access. The primary purpose of this interface is to allow generic algorithms to alter their behavior to provide good performance when applied to either random or sequential access lists.

翻译：
List 实现使用的标记接口，以指示它们支持快速（通常是恒定时间）随机访问。这个接口的主要目的是允许通用算法改变它们的行为以在应用于随机或顺序访问列表时提供良好的性能。

从 RandomAccess 源码可以看出，这个接口什么都没有定义，结合源码注释我们可以认为 RandomAccess 接口仅仅起到标识作用，表示这个接口的实现类支持快速（通常是恒定时间）随机访问。

Array 和 ArrayList 有什么区别？什么时候该应 Array 而不是 ArrayList 呢？

Array 可以包含基本类型和对象类型，ArrayList 只能包含对象类型。
Array 大小是固定的，ArrayList 的大小是动态变化的。
ArrayList 提供了更多的方法和特性，比如：addAll()，removeAll()，iterator() 等等。

ArrayList 简介

ArrayList 的底层是数组队列，相当于动态数组。与 Java 中的数组相比，它的容量能动态增长。在添加大量元素前，应用程序可以使用ensureCapacity 操作来增加 ArrayList 实例的容量。这可以减少递增式再分配的数量。

ArrayList继承于 AbstractList ，实现了 List, RandomAccess, Cloneable, java.io.Serializable 这些接口。

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

}

RandomAccess 是一个标志接口，表明实现这个接口的 List 集合是支持快速随机访问的。在 ArrayList 中，我们即可以通过元素的序号快速获取元素对象，这就是快速随机访问。
ArrayList 实现了 Cloneable 接口，即覆盖了函数clone()，能被克隆。
ArrayList 实现了 java.io.Serializable接口，这意味着ArrayList支持序列化，能通过序列化去传输。

ArrayList 扩容机制

先来看一看 ArrayList 的构造函数

    /**
     * 默认初始容量大小
     */
    private static final int DEFAULT_CAPACITY = 10;

    /**
     * 空数组（用于空实例的共享空数组实例）
     */
    private static final Object[] EMPTY_ELEMENTDATA = {};

    /**
     * 用于默认大小的空实例的共享空数组实例。
     * 我们将其与 EMPTY_ELEMENTDATA 区分开来，以了解添加第一个元素时要膨胀多少
     */
    private static final Object[] DEFAULTCAPACITY_EMPTY_ELEMENTDATA = {};

    /**
     * 保存ArrayList数据的数组
     */
    transient Object[] elementData; // non-private to simplify nested class access

    /**
     *ArrayList 所包含的元素个数
     */
    private int size;

  	/**
     *带初始容量参数的构造函数（用户可以在创建ArrayList对象时自己指定集合的初始大小）
     */
	public ArrayList(int initialCapacity) {
		//如果传入的参数大于0，创建initialCapacity大小的数组
        if (initialCapacity > 0) {
            this.elementData = new Object[initialCapacity];
        } else if (initialCapacity == 0) {
        	//如果传入的参数等于0，创建空数组
            this.elementData = EMPTY_ELEMENTDATA;
        } else {
        	//其他情况，抛出异常
            throw new IllegalArgumentException("Illegal Capacity: "+
                                               initialCapacity);
        }
    }

   	/**
     *默认无参构造函数
     *DEFAULTCAPACITY_EMPTY_ELEMENTDATA 为0.
     *初始化为10，也就是说初始其实是空数组 当添加第一个元素的时候数组容量才变成10 (后续会介绍)
     */
    public ArrayList() {
        this.elementData = DEFAULTCAPACITY_EMPTY_ELEMENTDATA;
    }

    /**
     * 构造一个包含指定集合的元素的列表，按照它们由集合的迭代器返回的顺序。
     */
    public ArrayList(Collection<? extends E> c) {
    	//将指定集合转换为数组
        elementData = c.toArray();
         //如果elementData数组的长度不为0
        if ((size = elementData.length) != 0) {
            // 如果elementData不是Object类型数据（c.toArray可能返回的不是Object类型的数组所以加上下面的语句用于判断）
            if (elementData.getClass() != Object[].class)
            	 //将原来不是Object类型的elementData数组的内容，赋值给新的Object类型的elementData数组
                elementData = Arrays.copyOf(elementData, size, Object[].class);
        } else {
            // 其他情况，用空数组代替
            this.elementData = EMPTY_ELEMENTDATA;
        }
    }

通过观察源码可以发现：以无参数构造方法创建 ArrayList 时，实际上初始化赋值的是一个空数组。当真正对数组进行添加元素操作时，才真正分配容量。即向数组中添加第一个元素时，数组容量扩为 10。

扩容机制核心

public boolean add(E e) {
		
		
		/**
    	  *首先调用 ensureCapacityInternal()方法
	      *判断是否可以容纳e，若能，则直接添加在末尾；若不能，则进行扩容，然后再把e添加在末尾
    	  */
        ensureCapacityInternal(size + 1);  // Increments modCount!!
        
        //将e添加到数组末尾
        elementData[size++] = e;
        return true;
}


/**
  *每次在add()一个元素时，arraylist都需要对这个list的容量进行一个判断。
  *通过ensureCapacityInternal()方法确保当前ArrayList维护的数组具有存储新元素的能力，
  *经过处理之后将元素存储在数组elementData的尾部
  *
  *minCapacity 最小容量: 添加元素前 ArrayList 元素个数加1,即新添加一个元素 ArrayList 需要的最小容量
  */
private void ensureCapacityInternal(int minCapacity) {
		
        ensureExplicitCapacity(calculateCapacity(elementData, minCapacity));
}


/**
  * 计算容量
  */
private static int calculateCapacity(Object[] elementData, int minCapacity) {
		/**
  		  * 使用无参构造函数创建的 ArrayList 其 elementData = DEFAULTCAPACITY_EMPTY_ELEMENTDATA
  		  */
        if (elementData == DEFAULTCAPACITY_EMPTY_ELEMENTDATA) {
        	//选取默认的容量和最小容量的较大值 这里对应前面（向数组中添加第一个元素时，数组容量扩为 10）
            return Math.max(DEFAULT_CAPACITY, minCapacity);
        }
        return minCapacity;
}



//判断是否需要扩容
private void ensureExplicitCapacity(int minCapacity) {
        modCount++;

        /**
          * 如果需要的最小容量 minCapacity 小于此时 elementData 数组的长度，则需要调用 grow() 函数进行扩容
          * 否则 ensureCapacityInternal() 函数执行结束,直接将新元素添加到 elementData 数组的末尾
          */ 
        if (minCapacity - elementData.length > 0)
            grow(minCapacity);
}


private void grow(int minCapacity) {
        // 旧容量 oldCapacity , 数组 elementData 的长度
        int oldCapacity = elementData.length;
        // 新容量 newCapacity , 数组 elementData 长度的1.5倍
        int newCapacity = oldCapacity + (oldCapacity >> 1);
        
       	//然后检查新容量是否大于最小需要容量，若还是小于最小需要容量，那么就把最小需要容量当作数组的新容量，
        if (newCapacity - minCapacity < 0)
            newCapacity = minCapacity;
            
        /**
          * 如果新容量大于 MAX_ARRAY_SIZE,进入(执行) hugeCapacity() 方法来比较 minCapacity 和 MAX_ARRAY_SIZ
          */
        if (newCapacity - MAX_ARRAY_SIZE > 0)
            newCapacity = hugeCapacity(minCapacity);
        elementData = Arrays.copyOf(elementData, newCapacity);
}


/**
  * 如果 minCapacity 大于最大容量 , 则新容量则为 Integer.MAX_VALUE 
  * 否则,新容量大小则为 MAX_ARRAY_SIZE 即为 Integer.MAX_VALUE - 8
  */
private static int hugeCapacity(int minCapacity) {
        if (minCapacity < 0) // overflow
            throw new OutOfMemoryError();
            
        return (minCapacity > MAX_ARRAY_SIZE) ?
            Integer.MAX_VALUE :
            MAX_ARRAY_SIZE;
}

System.arraycopy() 和 Arrays.copyOf() 方法

System.arraycopy() 方法


public void add(int index, E element) {
		//越界检查
        rangeCheckForAdd(index);

        ensureCapacityInternal(size + 1);  // Increments modCount!!
        System.arraycopy(elementData, index, elementData, index + 1,
                         size - index);
        elementData[index] = element;
        size++;
}

private void rangeCheckForAdd(int index) {
        if (index > size || index < 0)
            throw new IndexOutOfBoundsException(outOfBoundsMsg(index));
}


/**
  * System.arraycopy()
  * 
  * src – the source array. 
  * srcPos – starting position in the source array. 
  * dest – the destination array. 
  * destPos starting position in the destination data. 
  * length – the number of array elements to be copied.
  *
  * 将 src 数组 从 srcPos 位置开始的元素复制到 dest 数组 desPos 位置,复制元素长度为 length
  */
public static native void arraycopy(Object src,  int  srcPos,
                                        Object dest, int destPos,
                                        int length);

Arrays.copyOf() 方法


/**
  * Arrays.copyOf()
  * 
  * original – the array to be copied 
  * newLength – the length of the copy to be returned 
  * newType – the class of the copy to be returned
  *
  * 以正确的顺序返回一个包含 original 列表中所有元素的数组（从第一个到最后一个元素）
  * 返回的数组的运行时类型是指定数组的运行时类型——newType
  */

public static <T,U> T[] copyOf(U[] original, int newLength, Class<? extends T[]> newType) {
        @SuppressWarnings("unchecked")
        T[] copy = ((Object)newType == (Object)Object[].class)
            ? (T[]) new Object[newLength]
            : (T[]) Array.newInstance(newType.getComponentType(), newLength);
        System.arraycopy(original, 0, copy, 0,
                         Math.min(original.length, newLength));
        return copy;
}

联系：看两者源代码可以发现 copyOf() 内部实际调用了 System.arraycopy() 方法

区别： arraycopy() 需要目标数组，将原数组拷贝到你自己定义的数组里或者原数组，而且可以选择拷贝的起点和长度以及放入新数组中的位置 copyOf() 是系统自动在内部新建一个数组，并返回该数组。

ensureCapacity方法

ArrayList 源码中有一个 ensureCapacity 方法不知道大家注意到没有，这个方法 ArrayList 内部没有被调用过，所以很显然是提供给用户调用的，那么这个方法有什么作用呢？

/**
    如有必要，增加此 ArrayList 实例的容量，以确保它至少可以容纳由minimum capacity参数指定的元素数。
     *
     * @param   minCapacity   所需的最小容量
     */
    public void ensureCapacity(int minCapacity) {
        int minExpand = (elementData != DEFAULTCAPACITY_EMPTY_ELEMENTDATA)
            // any size if not default element table
            ? 0
            // larger than default for default empty table. It's already
            // supposed to be at default size.
            : DEFAULT_CAPACITY;

        if (minCapacity > minExpand) {
            ensureExplicitCapacity(minCapacity);
        }
    }

理论上来说，最好在向 ArrayList 添加大量元素之前用 ensureCapacity 方法，以减少增量重新分配的次数

我们通过下面的代码实际测试以下这个方法的效果：

public class EnsureCapacityTest {
	public static void main(String[] args) {
		ArrayList<Object> list = new ArrayList<Object>();
		final int N = 10000000;
		long startTime = System.currentTimeMillis();
		for (int i = 0; i < N; i++) {
			list.add(i);
		}
		long endTime = System.currentTimeMillis();
		System.out.println("使用ensureCapacity方法前："+(endTime - startTime));

	}
}

运行结果：

使用ensureCapacity方法前：2971

public class EnsureCapacityTest {
    public static void main(String[] args) {
        ArrayList<Object> list = new ArrayList<Object>();
        final int N = 10000000;
        long startTime1 = System.currentTimeMillis();
        list.ensureCapacity(N);
        for (int i = 0; i < N; i++) {
            list.add(i);
        }
        long endTime1 = System.currentTimeMillis();
        System.out.println("使用ensureCapacity方法后："+(endTime1 - startTime1));
    }
}

运行结果：

使用ensureCapacity方法后：2665

通过运行结果，我们可以看出向 ArrayList 添加大量元素之前使用ensureCapacity 方法可以提升性能。不过，这个性能差距几乎可以忽略不计。而且，实际项目根本也不可能往 ArrayList 里面添加这么多元素。

路上阡陌

关注

4
点赞
踩
5

收藏

觉得还不错? 一键收藏
打赏
0
评论
Java集合常见面试题（二）

ArrayList 的底层是数组队列，相当于动态数组。与 Java 中的数组相比，它的容量能动态增长。在添加大量元素前，应用程序可以使用ensureCapacity操作来增加 ArrayList 实例的容量。这可以减少递增式再分配的数量。ArrayList继承于 AbstractList ，实现了 List, RandomAccess, Cloneable, java.io.Serializable 这些接口。
复制链接

扫一扫