Java容器---List

java.util 

接口 List<E>

所有超级接口：

Collection<E>， Iterable<E>

所有已知实现类：

AbstractList, AbstractSequentialList, ArrayList, AttributeList, CopyOnWriteArrayList, LinkedList, RoleList, RoleUnresolvedList, Stack, Vector

List的概念：

有序的 collection（也称为序列）。此接口的用户可以对列表中每个元素的插入位置进行精确地控制。用户可以根据元素的整数索引（在列表中的位置）访问元素，并搜索列表中的元素。

List与Set不同，List允许重复的元素；List 接口提供了 4 种对列表元素进行定位（索引）访问方法；

List 接口提供了特殊的迭代器，称为 ListIterator，除了允许 Iterator 接口提供的正常操作外，该迭代器还允许元素插入和替换，以及双向访问。还提供了一个方法来获取从列表中指定位置开始的列表迭代器。

几种数据结构的比较：

Array读取快，修改慢；

Linked修改快，读取慢；

Hash介于两者之间；

List的方法：

/*
*created by yangyinglong at 20180516
*List接口的学习
*/

import java.util.*;

public class ListTest {
	public static void main(String[] args) {
		List l1 = new LinkedList();
		List l2 = new LinkedList();
		List l3 = new ArrayList();

		// boolean add(E e) 向列表的尾部添加指定的元素（可选操作）。
		for (int i = 1; i <= 5; i ++ ) {
			l1.add("a"+i);			
		}
		System.out.println("循环添加元素到l1中，l1的值为: " + l1);

		// void add(int index, E element) 在列表的指定位置插入指定元素（可选操作）。
		l1.add(0, "a0");
		System.out.println("在l1的第0个位置添加元素a0之后的l1为: " + l1);
		// 循环添加元素到l1中，l1的值为: [a1, a2, a3, a4, a5]
		// 在l1的第0个位置添加元素a0之后的l1为: [a0, a1, a2, a3, a4, a5]


		// boolean	addAll(Collection<? extends E> c) 
		// 添加指定 collection 中的所有元素到此列表的结尾，顺序是指定 collection 的迭代器返回这些元素的顺序（可选操作）。
		l3.add("b0");
		System.out.println("l3的值为: " + l3);
		l3.addAll(l1);
		System.out.println("l3中addAll(l1)之后的l3为: " + l3);
		// l3的值为: [b0]
		// l3中addAll(l1)之后的l3为: [b0, a0, a1, a2, a3, a4, a5]


		// boolean	addAll(int index, Collection<? extends E> c) 
  		// 将指定 collection 中的所有元素都插入到列表中的指定位置（可选操作）。
  		l3.addAll(3, l1);
  		System.out.println("在l3中的第3个位置添加l1之后的l3为: " + l3);
  		// 在l3中的第3个位置添加l1之后的l3为: [b0, a0, a1, a0, a1, a2, a3, a4, a5, a2, a3, a4, a5]


  		// void clear() 从列表中移除所有元素（可选操作）。
  		l3.clear();
  		System.out.println("l3执行clear()方法之后为: " + l3);
  		// l3执行clear()方法之后为: []


  		// boolean	contains(Object o) 如果列表包含指定的元素，则返回 true。
  		boolean is_contains_a1 = l1.contains("a1");
  		System.out.println("l1 是否包含 a1 元素: " + is_contains_a1);
  		// l1 是否包含 a1 元素: true


  		// boolean	containsAll(Collection<?> c) 
        // 如果列表包含指定 collection 的所有元素，则返回 true。
        l3.add("a1");
        l3.add("a2");
        boolean is_containsAll_l3 = l1.containsAll(l3);
        System.out.println("l1为: " + l1);
        System.out.println("l3为: " + l3);
        System.out.println("l1是否包含l3所有的元素: " + is_containsAll_l3);
        // l1为: [a0, a1, a2, a3, a4, a5]
        // l3为: [a1, a2]
        // l1是否包含l3所有的元素: true


        // boolean	equals(Object o) 
        // 比较指定的对象与列表是否相等。
        boolean l1_is_equals_l3 = l1.equals(l3);
        System.out.println("l1为: " + l1);
        System.out.println("l3为: " + l3);
        System.out.println("l1 与 l3 是否相等: " + l1_is_equals_l3);
        // l1为: [a0, a1, a2, a3, a4, a5]
        // l3为: [a1, a2]
        // l1 与 l3 是否相等: false


        // E get(int index) 返回列表中指定位置的元素。
        Object get_index = l1.get(3);
        System.out.println("l1 第3个位置上的元素为: " + get_index);
        // l1 第3个位置上的元素为: a3


        // int	hashCode() 返回列表的哈希码值。


        // int	indexOf(Object o)
        // 返回此列表中第一次出现的指定元素的索引；如果此列表不包含该元素，则返回 -1。
        int index_a1 = l1.indexOf("a1");
        int index_a9 = l1.indexOf("a9");
        System.out.println("l1: " + l1);
        System.out.println("在l1中 a1的位置: " + index_a1 + " a9的位置: " + index_a9);
        // l1: [a0, a1, a2, a3, a4, a5]
        // 在l1中 a1的位置: 1 a9的位置: -1


        // int	lastIndexOf(Object o) 
        // 返回此列表中最后出现的指定元素的索引；如果列表不包含此元素，则返回 -1。


        // Iterator<E>	iterator() 返回按适当顺序在列表的元素上进行迭代的迭代器。
        // Iterator<String> iter = l1.iterator();
        // Iterator<Object> iter = l1.iterator();
        Iterator iter = l1.iterator();
        System.out.print("l1迭代输出为: ");
        while (iter.hasNext()) {
        	// String s = iter.next();
        	Object s = iter.next();
        	System.out.print(s + " ");
        }
        System.out.println();
        // l1迭代输出为: a0 a1 a2 a3 a4 a5


        // ListIterator<E>	listIterator() 返回此列表元素的列表迭代器（按适当顺序）。
        // l1.add(3, "a12");
        // l1.add(3, "a18");
        // System.out.println("l1: " + l1);
        // 前三行实验了ListIterator并不能对列表进行排序
        ListIterator<String> list_iter = l1.listIterator();
        int index = 0;
        while (list_iter.hasNext()) {
        	index ++;
        	if (index%3 == 0) {
        		Object s = list_iter.previous();
        		System.out.print("previous: " + s + " ");       		
        	} else {
        		Object s = list_iter.next();
        		System.out.print("next: " + s + " ");
        	}
        }
        System.out.println();
        // next: a0 next: a1 previous: a1 next: a1 next: a2 previous: a2 next: a2 
        // next: a3 previous: a3 next: a3 next: a4 previous: a4 next: a4 next: a5


        // ListIterator<E>	listIterator(int index) 
        // 返回列表中元素的列表迭代器（按适当顺序），从列表的指定位置开始。


        // E remove(int index) 
        // 移除列表中指定位置的元素（可选操作）。

        // boolean	remove(Object o) 
        // 从此列表中移除第一次出现的指定元素（如果存在）（可选操作）。

        // boolean	removeAll(Collection<?> c) 
        // 从列表中移除指定 collection 中包含的其所有元素（可选操作）。

        // boolean	retainAll(Collection<?> c) 
        // 仅在列表中保留指定 collection 中所包含的元素（可选操作）。

        // E set(int index, E element) 
        // 用指定元素替换列表中指定位置的元素（可选操作）。
        System.out.print("原来的l1为: " + l1 + " ");
        Object get_o = l1.set(1, "a99");
        System.out.print("修改过的l1为: " + l1 + " ");
        System.out.println("返回值为: " + get_o);
        // 原来的l1为: [a0, a1, a2, a3, a4, a5]
        // 修改过的l1为: [a0, a99, a2, a3, a4, a5] 
        // 返回值为: a1

        // int size() 
        // 返回列表中的元素数。
        System.out.println("l1的长度size()为: " + l1.size());

        // List<E>	subList(int fromIndex, int toIndex) 
        // 返回列表中指定的 fromIndex（包括 ）和 toIndex（不包括）之间的部分视图。
        List l4 = l1.subList(1, 5);
        System.out.println("截取l1从第1个位置到第5个位置的元素: " + l4);
        // 截取l1从第1个位置到第5个位置的元素: [a99, a2, a3, a4]

        // Object[]	toArray() 
        // 返回按适当顺序包含列表中的所有元素的数组（从第一个元素到最后一个元素)
        Object[] l1_to_array = l1.toArray();
        System.out.print("l1转成数组之后的输出: ");
        for (int i = 0; i < l1_to_array.length; i++ ) {
        	System.out.print(l1_to_array[i] + " ");        	
        }
        System.out.println();
        // l1转成数组之后的输出: a0 a99 a2 a3 a4 a5 

        // <T> T[] toArray(T[] a) 
        // 返回按适当顺序（从第一个元素到最后一个元素）包含列表中所有元素的数组；返回数组的运行时类型是指定数组的运行时类型。
        // l1.add(new Integer(111));
        // System.out.println(l1);
        // String[] a = {"a11", "a0", "a13", "a2"};
        // String[] l1_to_array_string = l1.toArray(new String[0]);	
        // l1.remove(new Integer(111));
        // System.out.print("<T> T[] toArray(T[] a) 的结果为: ");
        // for (int i = 0; i < l1_to_array_string.length; i++ ) {
        // 	System.out.print(l1_to_array_string[i] + " ");        	
        // }
        // error




		//复制 void copy(List dest, List src)  将src拷贝到dest
		//复制的时候，l2的长度size不会改变，所以会抛出越界异常，在复制的时候，要改变l2的长度
		// 它的capacity（容纳能力大小）可以指定（最好指定）。
		// 而初始化时size的大小永远默认为0，只有在进行add和remove等相关操作 时，size的大小才变化。
		// 然而进行copy()时候，首先做的是将desc的size和src的size大小进行比较，
		// 只有当desc的 size 大于或者等于src的size时才进行拷贝，
		// 否则抛出IndexOutOfBoundsException异常
		Collections.addAll(l2, new Object[l1.size()]);
		Collections.copy(l2, l1);
		System.out.println("l1拷贝到l2中,l2的值为: " + l2);


		// 随机排列顺序
		Collections.shuffle(l1);
		System.out.println("l1随机排序后为" + l1);
		// l1随机排序后为[a0, a4, a5, a2, a99, a3]

		//逆序 void reversee(List)  倒序
		Collections.reverse(l2);
		System.out.println("l1倒序之后为: " + l2);
		// l1倒序之后为: [a5, a4, a3, a2, a99, a0]

		//排序 sort(List)
		Collections.sort(l1);
		System.out.println("l1排序之后为: " + l1);
		// l1排序之后为: [a0, a2, a3, a4, a5, a99]


		//求交集
		l1.add("a10");
		l1.add("a11");
		l1.add("a12");
		System.out.println("l1为: " + l1);
		l1.retainAll(l2);
		System.out.println("l2为: " + l2);
		System.out.println("l1与l2的交集为: " + l1);
		// l1为: [a0, a2, a3, a4, a5, a99, a10, a11, a12]
		// l2为: [a5, a4, a3, a2, a99, a0]
		// l1与l2的交集为: [a0, a2, a3, a4, a5, a99]


		// 折半查找 int binarySearch(List, Object) 折半查找
		int index_ = Collections.binarySearch(l1, "a5");
		System.out.println("折半查找的位置为: " + index_);
		// 折半查找的位置为: 4

	}
}

int size()  

返回列表中的元素数。如果列表包含多于 Integer.MAX_VALUE 个元素，则返回 Integer.MAX_VALUE。

boolean isEmpty() 

如果列表不包含元素，则返回 true。

boolean contains(Object o)  

如果列表包含指定的元素，则返回 true。更确切地讲，当且仅当列表包含满足 (o==null ? e==null : o.equals(e)) 的元素 e 时才返回 true。

Iterator<E> iterator()

返回按适当顺序在列表的元素上进行迭代的迭代器。

Object[] toArray()

返回按适当顺序包含列表中的所有元素的数组（从第一个元素到最后一个元素）。

由于此列表不维护对返回数组的任何引用，因而它将是“安全的”。（换句话说，即使数组支持此列表，此方法也必须分配一个新数组）。因此，调用者可以随意修改返回的数组。

此方法充当基于数组的 API 与基于 collection 的 API 之间的桥梁。

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

返回按适当顺序（从第一个元素到最后一个元素）包含列表中所有元素的数组；返回数组的运行时类型是指定数组的运行时类型。如果指定数组能容纳列表，则在其中返回该列表。否则，分配具有指定数组的运行时类型和此列表大小的新数组。

如果指定数组能容纳列表，并剩余空间（即数组的元素比列表的多），那么会将数组中紧随列表尾部的元素设置为 null。（只有 在调用者知道列表不包含任何 null 元素时此方法才能用于确定列表的长度）。

像 toArray() 方法一样，此方法充当基于数组的 API 与基于 collection 的 API 之间的桥梁。更进一步说，此方法允许对输出数组的运行时类型进行精确控制，在某些情况下，可以用来节省分配开销。

假定 x 是只包含字符串的一个已知列表。以下代码用来将该列表转储到一个新分配的 String 数组：

String[] y = x.toArray(new String[0]);

注意，toArray(new Object[0]) 和 toArray() 在功能上是相同的。

boolean add(E e)

向列表的尾部添加指定的元素（可选操作）。

支持该操作的列表可能对列表可以添加的元素有一些限制。特别是某些列表将拒绝添加 null 元素，其他列表将在可能添加的元素类型上施加限制。List 类应该在它们的文档中明确指定有关添加元素的所有限制。

boolean remove(Object o)

从此列表中移除第一次出现的指定元素（如果存在）（可选操作）。如果列表不包含元素，则不更改列表。更确切地讲，移除满足 (o==null ? get(i)==null : o.equals(get(i))) 的最低索引 i 的元素（如果存在这样的元素）。如果此列表已包含指定元素（或者此列表由于调用而发生更改），则返回 true。

boolean containsAll(Collection<?> c)

如果列表包含指定 collection 的所有元素，则返回 true。

boolean addAll(Collection<? extends E> c)

添加指定 collection 中的所有元素到此列表的结尾，顺序是指定 collection 的迭代器返回这些元素的顺序（可选操作）。如果在操作正在进行中修改了指定的 collection，那么此操作的行为是不确定的（注意，如果指定的 collection 是此列表，并且它是非空的，则会发生这种情况。）

boolean addAll(int index,

               Collection<? extends E> c)

将指定 collection 中的所有元素都插入到列表中的指定位置（可选操作）。将当前处于该位置的元素（如果有的话）和所有后续元素向右移动（增加其索引）。新元素将按照它们通过指定 collection 的迭代器所返回的顺序出现在此列表中。如果在操作正在进行中修改了指定的 collection，那么该操作的行为是不确定的（注意，如果指定的 collection 是此列表，并且它是非空的，则会发生这种情况。）

boolean removeAll(Collection<?> c)

从列表中移除指定 collection 中包含的其所有元素（可选操作）。

boolean retainAll(Collection<?> c)

仅在列表中保留指定 collection 中所包含的元素（可选操作）。换句话说，该方法从列表中移除未包含在指定 collection 中的所有元素。也就是求交集。

void clear()

从列表中移除所有元素（可选操作）。此调用返回后该列表将是空的。

boolean equals(Object o)

比较指定的对象与列表是否相等。当且仅当指定的对象也是一个列表、两个列表有相同的大小，并且两个列表中的所有相应的元素对相等 时才返回 true（ 如果 (e1==null ? e2==null :e1.equals(e2))，则两个元素 e1 和 e2 是相等 的）。换句话说，如果所定义的两个列表以相同的顺序包含相同的元素，那么它们是相等的。该定义确保了 equals 方法在 List 接口的不同实现间正常工作。

int hashCode()

返回列表的哈希码值。列表的哈希码定义为以下计算的结果：

  int hashCode = 1;
  Iterator<E> i = list.iterator();
  while (i.hasNext()) {
      E obj = i.next();
      hashCode = 31*hashCode + (obj==null ? 0 : obj.hashCode());
  }
 

这确保了 list1.equals(list2) 意味着对于任何两个列表 list1 和 list2 而言，可实现 list1.hashCode()==list2.hashCode()，正如 Object.hashCode() 的常规协定所要求的。

返回：此列表的哈希码值

E get(int index)

返回列表中指定位置的元素。返回：列表中指定位置的元素

E set(int index,  E element)

用指定元素替换列表中指定位置的元素（可选操作）。返回：以前在指定位置的元素

void add(int index,  E element)

在列表的指定位置插入指定元素（可选操作）。将当前处于该位置的元素（如果有的话）和所有后续元素向右移动（在其索引中加 1）。

E remove(int index)

移除列表中指定位置的元素（可选操作）。将所有的后续元素向左移动（将其索引减 1）。返回从列表中移除的元素。

参数：index - 要移除的元素的索引

返回：以前在指定位置的元素

int indexOf(Object o)

返回此列表中第一次出现的指定元素的索引；如果此列表不包含该元素，则返回 -1。更确切地讲，返回满足 (o==null ? get(i)==null : o.equals(get(i))) 的最低索引 i；如果没有这样的索引，则返回 -1。

参数：o - 要搜索的元素

返回：此列表中第一次出现的指定元素的索引，如果列表不包含该元素，则返回 -1

int lastIndexOf(Object o)

返回此列表中最后出现的指定元素的索引；如果列表不包含此元素，则返回 -1。更确切地讲，返回满足 (o==null ? get(i)==null : o.equals(get(i))) 的最高索引 i；如果没有这样的索引，则返回 -1。

参数：o - 要搜索的元素

返回：列表中最后出现的指定元素的索引；如果列表不包含此元素，则返回 -1

ListIterator<E> listIterator()

返回此列表元素的列表迭代器（按适当顺序）。

返回：此列表元素的列表迭代器（按适当顺序）

ListIterator<E> listIterator(int index)

返回列表中元素的列表迭代器（按适当顺序），从列表的指定位置开始。指定的索引表示 next 的初始调用所返回的第一个元素。previous 方法的初始调用将返回索引比指定索引少 1 的元素。

参数：index - 从列表迭代器返回的第一个元素的索引（通过调用 next 方法）

返回：此列表中元素的列表迭代器（按适当顺序），从列表中的指定位置开始

List<E> subList(int fromIndex,

                int toIndex)

返回列表中指定的 fromIndex（包括 ）和 toIndex（不包括）之间的部分视图。（如果 fromIndex 和 toIndex 相等，则返回的列表为空）。返回的列表由此列表支持，因此返回列表中的非结构性更改将反映在此列表中，反之亦然。返回的列表支持此列表支持的所有可选列表操作。

此方法省去了显式范围操作（此操作通常针对数组存在）。通过传递 subList 视图而非整个列表，期望列表的任何操作可用作范围操作。例如，下面的语句从列表中移除了元素的范围：

            list.subList(from, to).clear();
 
可以对 indexOf 和 lastIndexOf 构造类似的语句，而且 Collections 类中的所有算法都可以应用于 subList。
如果支持列表（即此列表）通过任何其他方式（而不是通过返回的列表）从结构上修改，则此方法返回的列表语义将变为未定义（从结构上修改是指更改列表的大小，或者以其他方式打乱列表，使正在进行的迭代产生错误的结果）。


参数：
fromIndex - subList 的低端（包括）

toIndex - subList 的高端（不包括）

返回：
列表中指定范围的视图