Java集合框架_四_List接口

1、List?

    Collection接口往下继承产生了三个接口，它们有各自的特色，本文要学习的是具备“有序可重复”特色的 List 接口，它也叫作列表。

    在列表中，这使得咱们可以精肯定位须要进行操做的元素，由于咱们有列表的索引，它和数组的索引一致，都是从0开始计数。在接下来要学习的方法中，咱们能够发现不少方法都提供了索引参数，有些方法的返回值则是元素的索引。

    List 接口也继承了 ListIterator 接口，这使得 List 中有两个继承而来的获取迭代器的方法，而 List 根据自身特色，又重载了一个方法来获取从列表中指定位置开始的迭代器。

2、Why are there so many methods!

    不要慌乱，虽然 List 接口提供了不少方法，而纵观这些方法，发现能够分类学习，更容易快速掌握。

    （一）自己

        一、int size()

            返回集合自己的大小。

        二、int hashCode()

            返回集合的哈希码值。

    （二）插入

        一、boolean add(E e)

            此方法在列表的尾端加入新元素 e。

            列表发生改变，则返回true。

        二、void add(int index, E element)

            在指定的索引位置插入指定的元素 element，该 element 抢占了指定的索引位置。而原来索引位置上的元素以及该索引之后的元素，索引值都+1。

            不返回任何值。

// 声明一个List
List<String> list = new ArrayList<String>();

// 添加元素
list.add("1");
list.add("2");
list.add("3");
list.add("4");
list.add("5");
list.add("6");

System.out.print("插入前：");
for(String str : list) {
	System.out.print(str + "->");
}

list.add(2, "I'm the new guy!");

System.out.print("\n插入后：");
for(String str : list) {
	System.out.print(str + "->");
}

结果：
插入前：1->2->3->4->5->6->
插入后：1->2->I'm the new guy!->3->4->5->6->

        三、boolean addAll(Collection<? extends E> c)

            将指定集合 c 中的全部元素插入到列表的结尾，而新插入的这些元素的顺序是由指定集合 c 中迭代器方法返回的顺序决定的。

            列表发生改变后，返回true。

        四、boolean addAll(int index, Collection<? extends E> c)

            抢占 index 索引位置，从该位置开始将指定集合 c 中全部元素插入，插入成功后，新列表的索引也天然而然。

            列表发生改变后，返回true。

    （三）删除

        一、boolean remove(Object o)

            删除列表中第一次出现的指定元素 o（若是列表中存在元素 o，返回true，不然返回false）。

            例如：

List<String> list = new ArrayList<String>();

list.add("1");
list.add("2");
list.add("3");
list.add("4");
		
System.out.println("删除元素【2】：" + list.remove("2"));
System.out.println("删除元素【5】：" + list.remove("5"));

System.out.print("删除后的列表：");
for(String str : list) {
    int index = list.indexOf(str);
    if(index != (list.size() - 1)) {
        System.out.print(str + "->");
    } else {
        System.out.print(str);
    }
}

结果：
删除元素【2】：true
删除元素【5】：false
删除后的列表：1->3->4

        二、boolean removeAll(Collection<?> c)

            移除列表中全部包含在指定集合 c 中的元素，至关于移除了列表和集合 c 的交集。

            若是列表因调用该方法而发生改变，则返回true。

        三、boolean retainAll(Collection<?> c)

            和 removeAll 方法相反，retainAll 方法保留的是列表中全部包含在指定集合 c 中的元素，至关于保留了列表和集合 c 的交集。

            若是列表因调用该方法而发生改变，则返回true。

        四、E remove(int index)

            移除指定索引位置上的元素。

            这个方法的返回值很特殊，它返回的是什么？看代码：

List<String> list = new ArrayList<String>();

list.add("1");
list.add("2");
list.add("3");
list.add("4");

System.out.println("删除索引位置为【1】的元素，返回结果为：" + list.remove(1));

结果以下：
删除索引位置为【1】的元素，返回结果为：2

        五、void clear()

            清空该列表。

    （四）访问

        一、E get(int index)

            返回列表中索引为 index 的元素。

        二、List<E> subList(int fromIndex, int toIndex)

            能够用开闭区间的方式来看，将索引位置在 [fromIndex, toIndex) 中的元素按照原顺序提取出来，组成一个新的列表。

            对该方法返回的新列表的任何操做都不会对原列表产生影响。

            新列表的元素个数 = toIndex - fromIndex。

    （五）修改

        一、E set(int index, E element)

            将指定索引位置上的元素替换为指定的元素 element。这个方法的返回值也比较特殊，和 remove(int index) 方法同样，都是返回替换以前的元素。

    （六）比较、判断方法

        一、boolean contains(Object o)

            判断列表中是否存在指定元素 o。

        二、boolean containsAll(Collection<?> c)

            判断列表中是否存在指定集合 c 中的全部元素，至关于判断集合 c 是否为列表的子集。

        三、boolean equals(Object o)

            比较列表和指定对象 o 是否相等，而相等的条件也比较苛刻，它要求指定对象也是一个列表，而两个列表要以相同的顺序包含相同的元素。

        四、boolean isEmpty()

            判断列表中是否有元素存在。

    （七）检索

        一、int indexOf(Object o)

            在列表中以正向顺序查找指定元素 o，返回第一个符合条件的元素索引。但若是列表中不存在该元素，那就返回-1.

        二、int lastIndexOf(Object o)

            和上一个方法相似，惟一的区别是：它返回的是最后一个符合条件的元素索引。

    （八）迭代器

        一、ListIterator<E> listIterator()

            返回列表迭代器，进而能够使用 ListIterator 接口中的方法。（ListIterator 接口在第二篇博客介绍过）

        二、ListIterator<E> listIterator(int index)

            也返回一个列表迭代器，可是迭代器的起始位置是列表的 index 索引位置。

            代码容易理解：

List<String> list = new ArrayList<String>();

list.add("1");
list.add("2");
list.add("3");
list.add("4");
list.add("5");

ListIterator<String> listIterator = list.listIterator(2);

for(; listIterator.hasNext(); ) {
    System.out.println(listIterator.next());
}

结果：
3
4
5

        三、Iterator<E> iterator()

            普通的返回迭代器的方法，该方法继承自 Iterable 接口。

    （九）转换

        一、Object[] toArray()

            将列表中的元素转换为由数组来存储，而元素的顺序能够按照特殊的要求来实现，通常状况是和列表的索引一一对应。

            该方法返回一个新数组，而对新数组的操做对原列表没有任何影响。

        二、<T> T[] toArray(T[] a)

            返回按适当顺序（从第一个元素到最后一个元素）包含列表中全部元素的数组；返回数组的运行时类型是指定数组的运行时类型。若是指定数组能容纳列表，则在其中返回该列表。不然，分配具备指定数组的运行时类型和此列表大小的新数组。此方法和 Collection 接口中的重名方法效果一致，能够在第三篇博客中阅读。