2021年JAVA面试~初识集合List

​​​​​​​​​​​​​​​

不合口？，试试下面这个独一无二的咖啡。

前言

不出意外，出去面试java开发，面试官一定会询问集合。

这篇只是简单介绍一下，各位大神各位大佬可以直接跳过，不浪费你们时间，
可能有聪明的小哥会说你这不是直接粘贴源码和注释吗

刚出来实习的小伙伴们，可能会问你什么是集合？
在java中泛指java.util.Collection中的这个接口，
作用：在Java 类库中有很多具体的实现为其提供了对集合对象进行基本操作的通用接口方法及为各种具体的集合提供了最大化的统一操作方式，例如List、Set。
下面我们会慢慢聊。

集合

我们以jdk1.8版本为例，俗话说的好，讲集合不讲版本，都是耍流氓。

在java中说到集合一般都会提到Collection接口，至于Map我或许会在下一篇文章中说明，
我们先来看下面这张图

Collection

1.实现的主要方法有

public interface Collection<E> extends Iterable<E> {
  		   /**
		    * 返回当前集合的个数，如果超过2147483647
		    * （即Integer的最大值）后也只能返回这个数值）
		    */
		    int size();
		    
		    // 判断当前集合是否为空，如果为空就返回true
	        boolean isEmpty();
	        
	        // 判断当前集合是否包含输入参数对象
            boolean contains(Object o);
            
            // 迭代器（至于迭代的时候的顺序，要看你当前的集合，例如List可以保证顺序）
            Iterator<E> iterator();
			
			// 将集合转化为数组
			Object[] toArray();
			
			// 在集合中新增一个元素
			boolean add(E e);
			
			// 删除一个元素，这里提供的方法有个坑，后面再提
			boolean remove(Object o);
			
			//  判断当前集合是否包含另一个集合
   		    boolean containsAll(Collection<?> c);
			
			//  在当前集合里新增输入的集合元素
			boolean addAll(Collection<?> c);

   			// 在当前集合里删除输入的集合元素
   			boolean removeAll(Collection<?> c);

			// 通过迭代器的方式删除元素
			default boolean removeIf(Predicate<? super E> filter) {
		       Objects.requireNonNull(filter);
		       boolean removed = false;
		       final Iterator<E> each = iterator();
		       while (each.hasNext()) {
		           if (filter.test(each.next())) {
		               each.remove();
		               removed = true;
		           }
		       }
		       return removed;
		   }
			
		   /**
			*  判断当前集合和对比的集合是否有交集，对比之后会显示具体的交集
			*  例如A里有 1,2,3,4 B中有3,4,5,6
			*  存在交集就会返回true，并且A中也只会留下3,4，让你知道具体的交集是啥 
			*/
		    retainAll(Collection<?> c);	
			
			// 清空集合
			void clear();
			
			// 比较两个集合是否相等，后面可以再出一期关于equals 和 hashcode的说明，挖坑
			boolean equals(Object o);
			
			// 返回当前集合的哈希码值，可以通过哈希码值比较两个集合
			boolean hashCode(Object o);
			
			// 这是1.8里为了并行遍历数据源中的元素而设计的迭代器
			default Spliterator<E> spliterator() {
       		 	return Spliterators.spliterator(this, 0);
    		}
			
			// 1.8新特性，stream，将集合转化为串行流
			default Stream<E> stream() {
        		return StreamSupport.stream(spliterator(), false);
   		    }
			
			// 1.8新特性，stream，将集合转化为并行流
			default Stream<E> parallelStream() {
      		    return StreamSupport.stream(spliterator(), true);
		    }
}

List

List接口是继承Collection的，可以使用Collection中的方法，
其中部分会重写，例如spliterator方法。
List是有序的，可重复的，
例如我们常见的ArrayList实现类

		List<String> data = new ArrayList<>();
		data.add("jia");
		data.add("jia");
		for (String s : data) {
			System.out.println("可重复："+s);
		}
		data.add(2,"第三个元素");
		data.add(3,"第四个元素");
		for (String s : data) {
			System.out.println("有序："+s);
		}

打印结果
可重复：jia
可重复：jia
有序：jia
有序：jia
有序：第三个元素
有序：第四个元素

public interface List<E> extends Collection<E> {
		  // 大致与Collection接口方法一致，下面只说明不同之处
		  // 排序
		  default void sort(Comparator<? super E> c) {
		       Object[] a = this.toArray();
		       Arrays.sort(a, (Comparator) c);
		       ListIterator<E> i = this.listIterator();
		       for (Object e : a) {
		           i.next();
		           i.set((E) e);
		       }
		   }
		
		 // 获取集中指定位置的元素
		 get(int index);

		// 将集合中指定位置的元素替换为输入的元素
		set(int index, E element);

		// 将集合中指定位置的元素添加输入的元素
		void add(int index, E element);

		// 返回集合中元素第一次出现的索引，如果此集合不包含元素，则为-1。
		int indexOf(Object o);

		// 返回集合中元素最后一次出现的索引，如果此集合不包含元素，则为-1。
		int lastIndexOf(Object o);
		
		// 加了一些新功能，
		ListIterator<E> listIterator(int index);

		// 集合截取，subList(0, 3)截取下标为0到2的元素,不包含下标为3的元素
		// 听说有的猛男用这个做分页，嘿嘿
		List<E> subList(int fromIndex, int toIndex);
		
		// 表示迭代器需要按照其ORDERED原始顺序迭代
	    @Override
    	default Spliterator<E> spliterator() {
        	return Spliterators.spliterator(this, Spliterator.ORDERED);
  		}
}

补充说明
Iterator和ListIterator区别
我们在使用List，Set的时候，为了实现对其数据的遍历，我们经常使用到了Iterator(迭代器)。使用迭代器，你不需要干涉其遍历的过程，只需要每次取出一个你想要的数据进行处理就可以了。
但是在使用的时候也是有不同的。List和Set都有iterator()来取得其迭代器。
对List来说，你也可以通过listIterator()取得其迭代器，两种迭代器在有些时候是不能通用的，Iterator和ListIterator主要区别在以下方面：
（1）ListIterator有add()方法，可以向List中添加对象，而Iterator不能
（2）ListIterator和Iterator都有hasNext()和next()方法，可以实现顺序向后遍历，但是ListIterator有hasPrevious()和previous()方法，可以实现逆向（顺序向前）遍历。Iterator就不可以。
（3）ListIterator可以定位当前的索引位置，nextIndex()和previousIndex()可以实现。Iterator没有此功能。
（4）都可实现删除对象，但是ListIterator可以实现对象的修改，set()方法可以实现。Iierator仅能遍历，不能修改。
转载链接：https://blog.csdn.net/weixin_39241397/article/details/79687789

ArrayList

ArrayList是List接口最常用的一个实现类， 下图为继承关系

初始化

	// 初始默认长度10
    private static final int DEFAULT_CAPACITY = 10;
    // 共享的空数组，作用：不需要创建新的数组，节省空间
    private static final Object[] EMPTY_ELEMENTDATA = {};
	
    private static final Object[] DEFAULTCAPACITY_EMPTY_ELEMENTDATA = {};
	
	transient Object[] elementData;
	
	// 构造具有指定初始容量的空列表，本质是通过Object[]数组的方式实现ArraryList
    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);
        }
    }
	
	// 无参初始化的时候给的是空数组且与有参的EMPTY_ELEMENTDATA区分
    public ArrayList() {
        this.elementData = DEFAULTCAPACITY_EMPTY_ELEMENTDATA;
    }
	
	// 通过复制的形式将元素放入此列表的集合
    public ArrayList(Collection<? extends E> c) {
        elementData = c.toArray();
        if ((size = elementData.length) != 0) {
            // c.toArray might (incorrectly) not return Object[] (see 6260652)
            if (elementData.getClass() != Object[].class)
                elementData = Arrays.copyOf(elementData, size, Object[].class);
        } else {
            // replace with empty array.
            this.elementData = EMPTY_ELEMENTDATA;
        }
    }

添加元素

    public boolean add(E e) {
        // 增加modCount
        ensureCapacityInternal(size + 1);  // Increments modCount!!
        // 将新的元素添加到数组最后面
        elementData[size++] = e;
        return true;
    }
	
    private void ensureCapacityInternal(int minCapacity) {
        ensureExplicitCapacity(calculateCapacity(elementData, minCapacity));
    }
	
	// 如果是空数组，数组长度扩容到10
    private static int calculateCapacity(Object[] elementData, int minCapacity) {
        if (elementData == DEFAULTCAPACITY_EMPTY_ELEMENTDATA) {
            return Math.max(DEFAULT_CAPACITY, minCapacity);
        }
        return minCapacity;
    }
	
	// 超过默认值10就需要扩容
    private void ensureExplicitCapacity(int minCapacity) {
        modCount++;

        // overflow-conscious code
        if (minCapacity - elementData.length > 0)
            grow(minCapacity);
    }
	
	// 扩容1.5倍，方式：Arrays.copyOf，数组复制
    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);
    }

那么为啥要增加modCount?
因为modCount是记录list修改的次数的，当写入完之后如果发现修改次数和开始序列化前不一致就会抛出异常，序列化失败。
这样就保证了序列化过程中是未经修改的数据,保证了序列化安全。

小结

ArrayList是有序，可重复集合，初始化默认10长度，超过这个长度就会触发一次扩容，扩容1.5倍长度，扩容方式为数组复制，其中modCount可以保证序列化时候的安全性问题。

LinkedList

LinkedList是链表结构，它的继承关系

初始化

LinkedList由一个头节点，一个尾节点和一个默认为0的size构成，可见其是双向链表。

	// 集合元素个数
    transient int size = 0;
    // 头节点引用
	transient Node<E> first;
	// 尾结点引用
    transient Node<E> last;
	
    public LinkedList() {
    }
	
    public LinkedList(Collection<? extends E> c) {
        this();
        addAll(c);
    }

    public boolean addAll(Collection<? extends E> c) {
        return addAll(size, c);
    }
	
    private void checkPositionIndex(int index) {
        if (!isPositionIndex(index))
            throw new IndexOutOfBoundsException(outOfBoundsMsg(index));
    }
	
    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;
        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);
            if (pred == null)
                first = newNode;
            else
                pred.next = newNode;
            pred = newNode;
        }

        if (succ == null) {
            last = pred;
        } else {
            pred.next = succ;
            succ.prev = pred;
        }

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

新增元素

    public void add(int index, E element) {
    	// 与初始化的方法一致，检查下标是否合法
        checkPositionIndex(index);
		 
        if (index == size)
            linkLast(element);
        else
            linkBefore(element, node(index));
    }
    
	// 尾插法
    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++;
    }
	
	// 链表中部插入
    void linkBefore(E e, Node<E> succ) {
        // assert succ != null;
        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 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;
        }
    }

通过下标定位时先判断是在链表的上半部分还是下半部分，如果是在上半部分就从头开始找起，如果是下半部分就从尾开始找起，因此通过下标的查找和修改操作的时间复杂度是O(n/2),且查询和修改都需要遍历整个链表进行元素定位。
这也是为什么查询LinkList比ArrayList慢的原因但是基于链表结构的体系在插入数据方面有一定优势。

小结

LinkList是基于双链表实现的相比ArrayList在插入数据方便有优势，但是查询就会略逊一筹，且链表没有制定初始大小。

Vector

Vector与ArrayList和LinkList的不同在于，它保证了线程安全性。

初始化

	// 可见vector与arrayList一样都是基于数组实现
	protected Object[] elementData;
	// 有效元素数量
    protected int elementCount;
	// 扩容系数
    protected int capacityIncrement;
	// 指定Vector初始大小和增长系数的构造函数
    public Vector(int initialCapacity, int capacityIncrement) {
        super();
        if (initialCapacity < 0)
            throw new IllegalArgumentException("Illegal Capacity: "+
                                               initialCapacity);
        this.elementData = new Object[initialCapacity];
        this.capacityIncrement = capacityIncrement;
    }
	// 指定初始容量的构造函数
    public Vector(int initialCapacity) {
        this(initialCapacity, 0);
    }
	
	// 默认长度10
    public Vector() {
        this(10);
    }
	
    public Vector(Collection<? extends E> c) {
        elementData = c.toArray();
        elementCount = elementData.length;
        // c.toArray might (incorrectly) not return Object[] (see 6260652)
        if (elementData.getClass() != Object[].class)
            elementData = Arrays.copyOf(elementData, elementCount, Object[].class);
    }

新增|删除元素

    public synchronized boolean add(E e) {
        modCount++;
        ensureCapacityHelper(elementCount + 1);
        elementData[elementCount++] = e;
        return true;
    }
	
    public void add(int index, E element) {
        insertElementAt(element, index);
    }
    
    public boolean remove(Object o) {
        return removeElement(o);
    }
    
    public synchronized E remove(int index) {
        modCount++;
        if (index >= elementCount)
            throw new ArrayIndexOutOfBoundsException(index);
        E oldValue = elementData(index);

        int numMoved = elementCount - index - 1;
        if (numMoved > 0)
            System.arraycopy(elementData, index+1, elementData, index,
                             numMoved);
        elementData[--elementCount] = null; // Let gc do its work

        return oldValue;
    }

可以看到Vector所有方法上面都有一个synchronized 关键字来保证线程安全。

小结

Vector是基于数组形式，初始默认值是10，扩容的时候会增加设定的系数的量，关键点是它是线程安全的，因为每个方法都使用synchronized。

Stack

Stack是栈的实现，故其主要操作为push入栈和pop出栈

初始化及出栈入栈

	// 创建一个空栈
    public Stack() {
    
    }
	//入栈，使用的是Vector的addElement方法。    
	public E push(E item) {
	       addElement(item);
	       return item;
	   }
    //出栈，找到数组最后一个元素，移除并返回。
    public synchronized E pop() {
        E       obj;
        int     len = size();
        obj = peek();
        removeElementAt(len - 1);
        return obj;
    }

小结

Stack继承于Vector实现类，因此它也是线程安全的，不同于Vector数组机构，而是意外的使用栈来存储。

最后的最后