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