Java List集合知多少？

List集合在开发中可谓是最经常使用的了，从第一次使用到“爱不释手”。有用的没用的都整理了一下。

1.基本概念

List：Collection集合的子接口，List是有序集合，允许元素重复，List中的元素都对应着一个整数型的序号，记载其在容器中的位置，可以根据序号存取容器中的元素。
###2.常用方法

(1).添加功能

    // 向滚动列表的末尾添加指定的项
	void add(String item)
	// 向滚动列表中索引指示的位置添加指定的项
	void add(String item, int index)

	    List list = new ArrayList();
		// 添加元素
		list.add("A");
		// 添加元素并指定位置
		list.add(1, "B");
		list.add(0, "C");
		// 添加自定义对象
		list.add(new User("--", 11));
		System.out.println(list);// [C, A, B, User [name=--, age=11]]

(2).删除功能

    // 从此滚动列表中移除指定位置处的项
	void remove(int position)
	// 从列表中移除项的第一次出现
	void remove(String item)
	// 从此列表中移除所有项
	void removeAll()

        List list = new ArrayList();
		// 添加
		list.add("A");
		// 添加元素并指定位置
		list.add("B");
		list.add("C");
		list.add("B");
		System.out.println(list);// [A, B, C, B]
		//根据index删除元素
		list.remove(0);
		System.out.println(list);// [B, C, B]
		//根据元素对象删除元素
		list.remove("B");
		System.out.println(list);// [C, B]
		//删除全部元素
		list.removeAll(list);
		System.out.println(list);// []

(3).获取功能

    // 获取与指定索引关联的项
	Object list.get(int index)
	// 获取列表中的项
	int list.size();

	    List list = new ArrayList();
		// 添加
		list.add("A");
		// 添加元素并指定位置
		list.add("B");
		list.add("C");
		list.add("B");
		System.out.println(list.get(0));// A
		System.out.println(list.get(3));// B
		System.out.println(list.size());// 4

(4).修改功能

    // 用指定元素替换列表中指定位置的元素
	// E set(int index, E element)

	    List<String> list = new ArrayList<String>();
		// 添加
		list.add("A");
		// 添加元素并指定位置
		list.add("B");
		list.add("B");
		System.out.println(list);// [A, B, B]
		// 替换位置index为2的元素
		list.set(2, "C");
		System.out.println(list);// [A, B, C]

(5).迭代器使用

图示：

通用迭代器:

    //如果仍有元素可以迭代，则返回true
	 boolean hasNext()
	//返回迭代的下一个元素
     E next()
     //从迭代器指向的collection中移除迭代器返回的最后一个元素
	 void remove()

        List list = new ArrayList();
		// 添加
		list.add("A");
		// 添加元素并指定位置
		list.add("B");
		list.add("C");
		list.add("D");
		// 普通迭代器
		Iterator iterator = list.iterator();
		while (iterator.hasNext()) {
			System.out.println(iterator.next());// ABCD
		}
		// 删除一个元素
		iterator.remove();
		System.out.println(list);// ABC

列表迭代器：

    // 将指定的元素插入列表
	 void add(E e)
	// 以正向遍历列表时，如果列表迭代器有多个元素，则返回true
	 boolean hasNext()
	// 如果以逆向遍历列表，列表迭代器有多个元素，则返回true
	 boolean hasPrevious()
	// 返回列表中的下一个元素
	 E next()
	// 返回对next的后续调用所返回元素的索引
	 int nextIndex()
	// 返回列表中的前一个元素
	 E previous()
	// 返回对previous的后续调用所返回元素的索引
	 int previousIndex()
	// 从列表中移除由next或previous返回的最后一个元素
	 void remove()
	// 用指定元素替换next或previous返回的最后一个元素
	 void set(E e)

		List list = new ArrayList();
		// 添加
		list.add("A");
		// 添加元素并指定位置
		list.add("B");
		list.add("C");
		list.add("D");
		// 列表迭代器
		ListIterator listIterator = list.listIterator();
		while (listIterator.hasNext()) {
			System.out.print(listIterator.next());// ABCD
		}
		while (listIterator.hasPrevious()) {
			//返回列表中的前一个元素
			System.out.println(listIterator.previous());// DCBA
		}

注：使用previous()方法的时候，需要先向后遍历，才能逆向遍历输出。

并发修改异常：

      	// 并发修改异常
		List list = new ArrayList();
		// 添加
		list.add("A");
		// 添加元素并指定位置
		list.add("B");
		list.add("C");
		list.add("D");

		// java.util.ConcurrentModificationException
		for (Object object : list) {
			// 这里改变了集合 相对于改变了循环条件，所以有异常
			list.remove(0);
		}

注：使用迭代器如果有类似写法也会出现并发修改异常。

3.遍历集合

(1)使用获取方法

	    List list = new ArrayList();
		// 添加
		list.add("A");
		// 添加元素并指定位置
		list.add("B");
		list.add("C");
		list.add("D");

		for (int i = 0; i < list.size(); i++) {
			String str = (String) list.get(i);
			System.out.print(" " + str);// A B C D
		}

(2)使用迭代器

        ListIterator iterator = list.listIterator();
		while (iterator.hasNext()) {
			String str = (String) iterator.next();
			System.out.print(" " + str);// A B C D
		}

(3)使用增强for

       for (Object object : list) {
			String str = (String) object;
			System.out.print(" " + str);// A B C D
		}

4.*主要实现类

(1)ArrayList:

是线性顺序存储的，是一种线性表，可以存储重复数据，可以看成动态数组。底层数据结构是数组，查询快，增删慢。线程不安全，效率高。

(2)LinkedList:

List接口的链接列表实现底层数据结构是链表，查询慢，增删快。线程不安全，效率高。
常用方法：

添加方法：
    // 将指定元素插入此列表的开头
	 void addFirst(E e)
	// 将指定元素添加到此列表的结尾
	 void addLast(E e)
删除方法：
    // 移除并返回此列表的第一个元素
	 E removeFirst()
	// 移除并返回此列表的最后一个元素
	 E removeLast()
获取方法：
    // 返回此列表的第一个元素。
	 E getFirst()
	// 返回此列表的最后一个元素
	 E getLast()

        LinkedList<String> linkedList = new LinkedList<String>();
		// 添加到集合最开头
		linkedList.addFirst("A");
		linkedList.add("B");
		// 添加到集合最末尾
		linkedList.addLast("C");
		System.out.println(linkedList);// [A, B, C]

		linkedList.removeFirst();
		linkedList.removeLast();
		System.out.println(linkedList);// [B]

		System.out.println(linkedList.getFirst());// B
		System.out.println(linkedList.getLast());// B

(3)Vector:

动态数组，可以根据需要动态伸缩。底层数据结构是数组，查询快，增删慢。线程安全，效率低。
常用方法：

添加方法：
    // 将指定的组件添加到此向量的末尾，将其大小增加 1
     void addElement(E obj)
删除方法：
    // 从此向量中移除全部组件，并将其大小设置为零
	 void removeAllElements()
	// 从此向量中移除变量的第一个（索引最小的）匹配项
	 boolean removeElement(Object obj)
	// 删除指定索引处的组件
	 void removeElementAt(int index)
获取方法：
    // 返回指定索引处的组件
	 E elementAt(int index)
	// 返回此向量的组件的枚举
	 Enumeration<E> elements()
	// 返回此向量的第一个组件
	 E firstElement()
	// 返回此向量的最后一个组件
	 E lastElement()

	 	Vector<String> vector = new Vector<String>();
		//添加元素
		vector.addElement("A");
		vector.addElement("B");
		vector.addElement("C");
		vector.addElement("D");
		System.out.println(vector);//[A, B, C, D]
		
		//移除元素
		vector.removeElementAt(0);
		vector.removeElement("D");
		System.out.println(vector);//[B, C]
		
		System.out.println(vector.firstElement());//B
		System.out.println(vector.lastElement());//C
		// Enumeration类似于迭代器
		Enumeration<String> element= vector.elements();
		while (element.hasMoreElements()) {
			System.out.print(" "+element.nextElement());// B C
		}

注：更多方法查看API