Java中的容器

1、ArrayList 和 Vector 和 LinkedList 的区别是什么？

ArrayList底层是通过数组实现的，数组是一段连续的内存区域， 只需要进行[基地址+元素大小*k] 就能找到第k个元素的地址，支持下标访问比较快，但是插入删除移动元素较多。

Vector与ArrayList一样，底层都是通过数组实现的，但它支持线程同步（add和remove方法等都有synchronized修饰），即某一时刻只有一个线程可以写Vector，避免多线程引起不一致性。由于同步，所以它比ArrayList慢

LinkedList底层是通过链表实现的，链表是不连续的内存区域，要访问第k个元素，需要先访问第k-1个元素，找到其next指针偏移量，再将next指针作为地址取得值，这就需要从第一个元素查起。

2、java中的Collection和Collections的区别？

java.util.Collection是一个集合接口，它提供了对集合进行基本操作的通用接口方法，其直接继承接口有List，Set，Vector。

Collections是集合类的一个工具类，其中提供了一系列静态方法，用于对集合元素进行排序，搜索以及线程安全等各种操作。

• sort(List list)方法，对指定列表元素进行升序排列，列表中的所有元素都必须实Comparable接口。
• reverse（List list）：反转
• copy(newList,oldList):接收两个参数，分别为目标列表和源列表
• min(List list):找到一个集合中的最小元素
• max(List list)：找到一个集合中的最大元素

3、List、Set和Map

List：

• 允许重复元素，
• 可以插入多个null元素
• 集合内部有序。主要的实现类有ArrayList，LinkedList，Vector

Set：

• 不允许重复对象
• 无序容器。但TreeSet通过Comparator或者Comparable维护了一个排序顺序。
• 最多只包含一个null元素
• 主要实现类有HashSet和TreeSet。HashSet子类还有LinkedHashSet。

Map：

• 是一个接口，是一种key-value容器
• Map中可以有随意个null值，但最多只能有一个null键
• 主要的实现类有HashMap（子类LinkedHashMap），HashTable，TreeMap

4、Array和ArrayList区别？

• （1）Array数组可以包含基本类型和对象类型，ArrayList只能包含对象类型。
• （2）Array数组存放的是同一类型的数据类型，但ArrayList就不一定了，因为它可以存放Object类型。
• （3）Array数组的空间大小是固定的，ArrayList的空间是动态增长的，如果空间不够，会创建一个比原空间大0.5倍（原来的1.5倍）的数组。

5、ArrayList和Vector的扩容规则：

ArrayList的扩容：

 private void grow(int minCapacity) {
        // overflow-conscious code
        int oldCapacity = elementData.length;
        int newCapacity = oldCapacity + (oldCapacity >> 1); // 扩大为原来的1.5倍
        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);
    }

Vector扩容：

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

6、Iterator迭代器：

6.1、ListIterator 和 Iterator区别

Iterator只提供了删除元素的方法remove，如果要想在遍历的时候添加元素的话，就用到了ListIterator。

ListIterator接口继承了Iterator接口，它允许程序员按照任一方向遍历列表，迭代期间修改列表，并获得迭代器在列表中的当前位置。

ListIterator主要提供了几个方法：

• add(E e):添加元素
• hasNext()：正向遍历列表时，如果列表迭代器有多个元素，返回true
• hasPrevious()：逆向遍历列表时，如果有列表迭代器有多个元素，返回true
• next()：返回列表的下一个元素
• previous()：返回列表的前一个元素
• remove():移除元素

public static void main(String[] args) {
		List<String> list = new ArrayList<>();
		list.add("111");
		list.add("222");
		System.out.println("添加前："+list);
		
		ListIterator<String> listIterator = list.listIterator();
		
		if(listIterator.hasNext()){
			if(listIterator.next() == "111"){
				// 添加元素
				listIterator.add("aaa");
			}
		}
		System.out.println("添加后："+list);
		
		
	}

运行结果：

添加前：[111, 222]
添加后：[111, aaa, 222]

6.2、ArrayList 的 Iterator实现

在ArrayList中，它的修改操作（add/remove）都会对modCount这个字段进行+1操作，modCount可以看做一个版本号。

ArrayList中有一个内部类Itr实现了Iterator接口。

 private class Itr implements Iterator<E> {
        int cursor;       // index of next element to return
        int lastRet = -1; // index of last element returned; -1 if no such
		// 初始时，设置expectedModCount = modCount
        int expectedModCount = modCount;

        public boolean hasNext() {
            return cursor != size;
        }

        @SuppressWarnings("unchecked")
        public E next() {
            checkForComodification();
            int i = cursor;
            if (i >= size)
                throw new NoSuchElementException();
            Object[] elementData = ArrayList.this.elementData;
            if (i >= elementData.length)
                throw new ConcurrentModificationException();
            cursor = i + 1;
            return (E) elementData[lastRet = i];
        }

        public void remove() {
            if (lastRet < 0)
                throw new IllegalStateException();
            checkForComodification();

            try {
                ArrayList.this.remove(lastRet);
                cursor = lastRet;
                lastRet = -1;
				// 删除元素之后，还修改expectedModCount和modCount的值为同步
                expectedModCount = modCount;
            } catch (IndexOutOfBoundsException ex) {
                throw new ConcurrentModificationException();
            }
        }
}

在删除元素之前，会先调用checkForComodification方法：

// 当调用迭代器的remove方法的时候，会先判断modCount和expectedModCount是否相等。
// 不相等抛出异常
 final void checkForComodification() {
	if (modCount != expectedModCount)
		throw new ConcurrentModificationException();
 }