java（19）：数据结构（2）--List

日期：2017/11/11

二、List接口

java.util 
接口 List<E>

所有超级接口：

Collection<E>, Iterable<E>

所有已知实现类：

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

       List 接口，成为有序的 Collection 也就是序列。该接口可以对列表中的每一个元素的插入位置进行精确的控制，同时用户可以根据元素的整数索引（在列表中的位置）访问元素，并搜索列表中的元素。 下图是 List 接口的框架图：

      通过上面的框架图，可以对 List 的结构了然于心，其各个类、接口如下：

      Collection：Collection 层次结构 中的根接口。它表示一组对象，这些对象也称为 collection 的元素。对于 Collection 而言，它不提供任何直接的实现，所有的实现全部由它的子类负责。

      AbstractCollection：提供 Collection 接口的骨干实现，以最大限度地减少了实现此接口所需的工作。对于我们而言要实现一个不可修改的 collection，只需扩展此类，并提供 iterator 和 size 方法的实现。但要实现可修改的 collection，就必须另外重写此类的 add 方法（否则，会抛出 UnsupportedOperationException），iterator 方法返回的迭代器还必须另外实现其 remove 方法。

      Iterator：迭代器。

      ListIterator：系列表迭代器，允许程序员按任一方向遍历列表、迭代期间修改列表，并获得迭代器在列表中的当前位置。

      List：继承于 Collection 的接口。它代表着有序的队列。

      AbstractList：List 接口的骨干实现，以最大限度地减少实现“随机访问”数据存储（如数组）支持的该接口所需的工作。

      Queue：队列。提供队列基本的插入、获取、检查操作。

      Deque：一个线性 collection，支持在两端插入和移除元素。大多数 Deque 实现对于它们能够包含的元素数没有固定限制，但此接口既支持有容量限制的双端队列，也支持没有固定大小限制的双端队列。

      AbstractSequentialList：提供了 List 接口的骨干实现，从而最大限度地减少了实现受“连续访问”数据存储（如链接列表）支持的此接口所需的工作。从某种意义上说，此类与在列表的列表迭代器上实现“随机访问”方法。

      LinkedList：List 接口的链接列表实现。它实现所有可选的列表操作。

      ArrayList：List 接口的大小可变数组的实现。它实现了所有可选列表操作，并允许包括 null 在内的所有元素。除了实现 List 接口外，此类还提供一些方法来操作内部用来存储列表的数组的大小。
      Vector：实现可增长的对象数组。与数组一样，它包含可以使用整数索引进行访问的组件。

      Stack：后进先出（LIFO）的对象堆栈。它通过五个操作对类 Vector 进行了扩展 ，允许将向量视为堆栈。

      Enumeration：枚举，实现了该接口的对象，它生成一系列元素，一次生成一个。连续调用 nextElement 方法将返回一系列的连续元素。

代码例子1：

package com.colection;import java.util.ArrayList;import java.util.Iterator;import java.util.List;/* * 练习：用List集合存储自定义并遍历。 * Student:name,age */public class ListDemo2 {public static void main(String[] args){List  list = new ArrayList();// 创建学生对象Student s1 = new Student("潘金莲", 21);Student s2 = new Student("孙二娘", 19);Student s3 = new Student("扈三娘", 20);Student s4 = new Student("李师师", 21);// 把元素添加到集合list.add(s1);list.add(s2);list.add(s3);list.add(s4);//匿名对象//list.add(new String("mmb"));list.add(new Student("aaa",22));Iterator  it = list.iterator();while(it.hasNext()){Student s = (Student) it.next();System.out.println(s.getName()+"---"+s.getAge());}}}

代码例子2：

package com.colection;import java.util.ArrayList;import java.util.List;import java.util.ListIterator;/* * ListIterator listIterator() * 虽然有逆向遍历功能这样的特有功能，但是没什么意义，因为，它需要先正向遍历，才能逆向遍历。 */public class ListDemo7 {public static void main(String[] args) {// 创建集合对象List list = new ArrayList();// 测试功能list.add("hello");list.add("world");list.add("java");// 正向遍历ListIterator lit = list.listIterator(); while (lit.hasNext()) { String s = (String) lit.next(); System.out.println(s); }System.out.println("---------------");System.out.println(lit.hasPrevious());while(lit.hasPrevious()){String s = (String) lit.previous();System.out.println(s);}}}

     ---------------------------------------------------------------------------------------------------------------------------

     下面介绍实现List接口的三个

     2.1 ArrayList

java.util 
类 ArrayList<E>

java.lang.Object  java.util.AbstractCollection<E>      java.util.AbstractList<E>          java.util.ArrayList<E>

所有已实现的接口：

Serializable, Cloneable, Iterable<E>, Collection<E>, List<E>, RandomAccess

直接已知子类：

AttributeList, RoleList, RoleUnresolvedList

---

public class ArrayList<E>
extends AbstractList<E>
implements List<E>, RandomAccess, Cloneable, Serializable

例子2.1.1，arraylist+itetator：

package com.colection.ArrayList_Vector_LinkedList;import java.util.ArrayList;import java.util.Iterator;/* * List: * ArrayList: * 底层数据结构是数组，查询快，增删慢 * 线程不安全，效率高 * Vector: * 底层数据结构是数组，查询快，增删慢 * 线程安全，效率低 * LinkedList: * 底层数据结构是链表，查询慢，增删快 * 线程不安全，效率高 *  * 面试题：ArrayList，Vector和LinkedList的各自特点? *  * 思考题：ArrayList，Vector和LinkedList我们到底使用谁呢? * 看情况 *  * 要安全吗? * 要：Vector(这个现在也不常用，在Collections里面有新的方式) * 不要：ArrayList和LinkedList * 查询多：ArrayList * 增删多：LinkedList *  * 不知道用哪个，就用ArrayList。 *  * 需求：用ArrayList存储字符串并遍历 */public class ArrayListDemoi {public static void main(String [] args){ArrayList<String> arr = new ArrayList();ArrayList ss = new ArrayList();arr.add("Hello");arr.add("world");arr.add("java");ss.add("mmb");//Error:arr has been dedicated to store String partern//类型 ArrayList<String> 中的方法 add（int, String）对于参数（int）不适用//arr.add(1000);//IteratorIterator it = arr.iterator();while(it.hasNext()){String s = (String) it.next();System.out.println(s);}System.out.println("-----------");//forfor(int i=0;i<arr.size();i++){String s = arr.get(i);System.out.println(s);}System.out.println("-----------");System.out.println(ss);}}

package com.colection.ArrayList_Vector_LinkedList;public class Student {private String name;private int age;public Student() {super();}public Student(String name, int age) {super();this.name = name;this.age = age;}public String getName() {return name;}public void setName(String name) {this.name = name;}public int getAge() {return age;}public void setAge(int age) {this.age = age;}}

例子2.1.2，arraylist+Listitetator（list_iterator动态数组的专用迭代器，因为多态的使用，Collection接口只能产生iterator）：

package com.colection.ArrayList_Vector_LinkedList;import java.util.ArrayList;import java.util.ListIterator;/* * 去除集合中字符串的重复值(字符串的内容相同) * 举例： * hello,world,java,android,world,java,javaee,java,java,java,android * 结果： * hello,world,java,android,javaee *  * 创建新集合的方式： * A:定义集合，存储带重复的元素 * B:创建新集合 * C:遍历旧集合，获取到旧集合中的每一个元素 * D:那旧集合的每一个元素到新集合中去找，看有没有 * 有：就不添加(不搭理它) * 木有：就添加 * E:遍历新集合 */public class ArrayListTest2 {public static void main(String[] args) {ArrayList list = new ArrayList();ArrayList list2 = new ArrayList();String[] a ={"dfasf","asdfgasdga","adfaf","asdgertcv","asdfgasdga","adfaf","d8f97asg84"}; list.add("hello");list.add("world");list.add("java");list.add("android");list.add("world");list.add("java");list.add("javaee");list.add("java");list.add("java");list.add("java");list.add("android");list.add(a);//两个迭代器ListIterator it = list.listIterator();ListIterator it2 = list2.listIterator();System.out.println("list: "+list);for(int i =0; i<list.size();i++){System.out.println(list.get(i));try{String temp = (String) list.get(i); System.out.println(temp);}catch ( java.lang.ClassCastException e){e.printStackTrace();String[] temp = (String[]) list.get(i);System.out.println(temp);}//if( ! list2.contains(temp)){//list2.add(temp);//}}}}

例子2.1.3 可以使用for循环迭代，ArrayList有特点--能根据具体索引处理元素：

package com.colection.ArrayList_Vector_LinkedList;import java.util.ArrayList;import java.util.Iterator;public class ArrayListTest3 {public static void main(String[] args) {ArrayList array = new ArrayList();array.add("hello");array.add("world");array.add("java");array.add("android");array.add("world");array.add("java");array.add("javaee");array.add("java");array.add("java");array.add("java");array.add("android");for(int i=0; i<array.size(); i++){for(int y=i+1; y<array.size();y++){if(array.get(i).equals(array.get(y))){array.remove(y);}}}// 遍历集合Iterator it = array.iterator();while (it.hasNext()) {String s = (String) it.next();System.out.println(s);}}}

例子2.1.4，ArrayList的元素为对象，因此当然可以存放ArrayList作为元素了：

package com.colection.ArrayList_Vector_LinkedList;import java.util.ArrayList;/* * 需求：四大名著 * 三国演义 * 吕布，典韦，赵云 * 红楼梦 * 贾宝玉，林黛玉，王熙凤，秦可卿 * 水浒传 * 武松，鲁智深，李逵，卢俊义，索超，吴用 * 西游记 * 白骨精，观音姐姐，孙悟空，牛魔王，红孩儿 *  * 我国有四大名著，每部名著里有很多代表性角色。 */public class ArrayListTest5 {public static void main(String[] args) {ArrayList<String> sgyy = new ArrayList<String>();sgyy.add("吕布");sgyy.add("典韦");sgyy.add("赵云");ArrayList<String> hlm = new ArrayList<String>();hlm.add("贾宝玉");hlm.add("林黛玉");hlm.add("王熙凤");hlm.add("秦可卿");// 水浒传小集合ArrayList<String> shz = new ArrayList<String>();shz.add("武松");shz.add("鲁智深");shz.add("李逵");shz.add("卢俊义");shz.add("索超");shz.add("吴用");// 西游记小集合ArrayList<String> xyj = new ArrayList<String>();xyj.add("白骨精");xyj.add("观音姐姐");xyj.add("孙悟空");xyj.add("牛魔王");xyj.add("红孩儿");ArrayList<ArrayList<String>> sdmz = new ArrayList<ArrayList<String>>();sdmz.add(hlm);sdmz.add(xyj);sdmz.add(shz);sdmz.add(sgyy);for(int i = 0; i<sdmz.size();i++){System.out.println("__________");ArrayList<String> temp = sdmz.get(i);for(int k = 0; k<temp.size();k++){System.out.println(temp.get(k));}}// 遍历集合for (ArrayList<String> array : sdmz) {for (String s : array) {System.out.print(s + " ");}System.out.println();}}}

     2.2 Vector

java.util 
类 Vector<E>

java.lang.Object  java.util.AbstractCollection<E>      java.util.AbstractList<E>          java.util.Vector<E>

所有已实现的接口：

Serializable, Cloneable, Iterable<E>, Collection<E>, List<E>, RandomAccess

直接已知子类：

Stack

---

public class Vector<E>
extends AbstractList<E>
implements List<E>, RandomAccess, Cloneable, Serializable

        Vector 类可以实现可增长的对象数组。与数组一样，它包含可以使用整数索引进行访问的组件。但是，Vector 的大小可以根据需要增大或缩小，以适应创建 Vector 后进行添加或移除项的操作。

        每个向量会试图通过维护 capacity 和 capacityIncrement 来优化存储管理。capacity 始终至少应与向量的大小相等；这个值通常比后者大些，因为随着将组件添加到向量中，其存储将按 capacityIncrement 的大小增加存储块。应用程序可以在插入大量组件前增加向量的容量；这样就减少了增加的重分配的量。

        由 Vector 的 iterator 和 listIterator 方法所返回的迭代器是快速失败的：如果在迭代器创建后的任意时间从结构上修改了向量（通过迭代器自身的 remove 或 add 方法之外的任何其他方式），则迭代器将抛出 ConcurrentModificationException。因此，面对并发的修改，迭代器很快就完全失败，而不是冒着在将来不确定的时间任意发生不确定行为的风险。Vector 的 elements 方法返回的 Enumeration 不是 快速失败的。

        注意，迭代器的快速失败行为不能得到保证，一般来说，存在不同步的并发修改时，不可能作出任何坚决的保证。快速失败迭代器尽最大努力抛出 ConcurrentModificationException。因此，编写依赖于此异常的程序的方式是错误的，正确做法是：迭代器的快速失败行为应该仅用于检测 bug。

        从 Java 2 平台 v1.2 开始，此类改进为可以实现 List 接口，使它成为 Java Collections Framework 的成员。与新 collection 实现不同，Vector 是同步的。

      ArrayList是非线程安全，Vector是线程安全的。

      例子2.2.1,下面是接口多态的使用：

package com.colection.ArrayList_Vector_LinkedList;import java.util.Collection;import java.util.Enumeration;import java.util.Iterator;import java.util.List;import java.util.ListIterator;import java.util.Vector;/* * 特有功能： * A:添加元素 * public void addElement(Object obj)--add(Object obj) * B:获取元素 *public Object elementAt(int index)--get(int index) *public Enumeration elements()--Iterator iterator() *hasMoreElements()hasNext() *nextElement()next() * *JDK版本升级： *A:安全 *B:效率 *C:简化书写 */public class VectorDemo {public static void main(String [] args){// 创建集合对象 Collection c = new Vector(); List list = new Vector();Vector v = new Vector();v.addElement("Hello");v.addElement("dadf");v.addElement("world");v.addElement("java");//没有为类型 List 定义方法 addElement（String），多态，addelement是Vector独有的方法//list.addElement("Hello");list.add(0, "mmb");ListIterator li = list.listIterator();System.out.println("li.next(): "+li.next());//没有为类型 Collection 定义方法 addElement（String），同理//c.addElement("dadf");c.add("mmb");Iterator it = c.iterator();System.out.println("it.next(): "+it.next()); //public Object elementAt(int index) System.out.println(v.elementAt(0)); System.out.println(v.elementAt(1)); System.out.println(v.elementAt(2));// 普通for for (int x = 0; x < v.size(); x++) { String s = (String) v.elementAt(x); System.out.println(s); } System.out.println("-----------------"); Enumeration en = v.elements(); while(en.hasMoreElements()){ String s = (String) en.nextElement(); System.out.println(s); }}}

     2.3 LinkedList

java.util 
类 LinkedList<E>

java.lang.Object  java.util.AbstractCollection<E>      java.util.AbstractList<E>          java.util.AbstractSequentialList<E>              java.util.LinkedList<E>

类型参数：

E - 在此 collection 中保持的元素的类型

所有已实现的接口：

Serializable, Cloneable, Iterable<E>, Collection<E>, Deque<E>, List<E>, Queue<E>

---

public class LinkedList<E>
extends AbstractSequentialList<E>
implements List<E>, Deque<E>, Cloneable, Serializable

List 接口的链接列表实现。实现所有可选的列表操作，并且允许所有元素（包括 null）。除了实现 List 接口外，LinkedList 类还为在列表的开头及结尾 get、remove 和 insert 元素提供了统一的命名方法。这些操作允许将链接列表用作堆栈、队列或双端队列。

此类实现 Deque 接口，为 add、poll 提供先进先出队列操作，以及其他堆栈和双端队列操作。

所有操作都是按照双重链接列表的需要执行的。在列表中编索引的操作将从开头或结尾遍历列表（从靠近指定索引的一端）。

注意，此实现不是同步的。如果多个线程同时访问一个链接列表，而其中至少一个线程从结构上修改了该列表，则它必须 保持外部同步。（结构修改指添加或删除一个或多个元素的任何操作；仅设置元素的值不是结构修改。）这一般通过对自然封装该列表的对象进行同步操作来完成。如果不存在这样的对象，则应该使用 Collections.synchronizedList 方法来“包装”该列表。最好在创建时完成这一操作，以防止对列表进行意外的不同步访问，如下所示：

List list = Collections.synchronizedList(new LinkedList(...));

此类的 iterator 和 listIterator 方法返回的迭代器是快速失败 的：在迭代器创建之后，如果从结构上对列表进行修改，除非通过迭代器自身的 remove 或 add 方法，其他任何时间任何方式的修改，迭代器都将抛出 ConcurrentModificationException。因此，面对并发的修改，迭代器很快就会完全失败，而不冒将来不确定的时间任意发生不确定行为的风险。

注意，迭代器的快速失败行为不能得到保证，一般来说，存在不同步的并发修改时，不可能作出任何硬性保证。快速失败迭代器尽最大努力抛出 ConcurrentModificationException。因此，编写依赖于此异常的程序的方式是错误的，正确做法是：迭代器的快速失败行为应该仅用于检测程序错误。

此类是 Java Collections Framework 的成员。

例子2.3.1，LinkedList的增删改查：

package com.colection.ArrayList_Vector_LinkedList;import java.util.LinkedList;/* * LinkedList的特有功能： * A:添加功能 * void addFirst() * void addLast() * B:移除功能 * Object removeFirst() * Object removeLast() * C:获取功能 * Object getFirst() * Object getLast() */public class LinkedListDemo {public static void main(String[] args) {LinkedList<String> link = new LinkedList<String>();link.add("hello");link.add("world");link.add("java");link.add("白夜");System.out.println(link);// void addFirst()// void addLast()link.addFirst("first");link.addLast("last");System.out.println(link);// Object removeFirst()// Object removeLast()System.out.println("removeFirst:" + link.removeFirst());System.out.println("removeFirst:" + link.removeLast());System.out.println(link);// Object getFirst()// Object getLast()System.out.println("getFirst:" + link.getFirst());System.out.println("getLast:" + link.getLast());System.out.println(link);}}

例子2.3.2 ，LinkedList 的 使用于堆栈：

package com.colection.ArrayList_Vector_LinkedList;import java.util.Iterator;import java.util.LinkedList;import java.util.Stack;public class LinkedListDemoTest {public static void main(String[] args) {// 创建集合对象 LinkedList link = new LinkedList(); // 添加元素 link.addFirst("hello"); link.addFirst("world"); link.addFirst("java"); Iterator it = link.iterator(); while (it.hasNext()) { String s = (String) it.next(); System.out.println(s); } System.out.println("----------");MyStack my = new MyStack();//添加元素my.add("hello");my.add("world");my.add("java");//获取try{System.out.println(my.gete());System.out.println(my.gete());System.out.println(my.gete());System.out.println(my.gete());}catch( java.util.NoSuchElementException e){System.out.println("null");}while(!my.isEmpty()){System.out.println(my.gete());}}}

package com.colection.ArrayList_Vector_LinkedList;import java.util.LinkedList;/* * 定义自己的集合类 */public class MyStack {private LinkedList link;public MyStack(){link = new LinkedList();}public void add(Object obj){link.addFirst(obj);}public Object gete(){return  link.removeFirst();}public boolean isEmpty(){return link.isEmpty();}}

        LinkedList与ArrayList一样实现List接口，只是ArrayList是List接口的大小可变数组的实现，LinkedList是List接口链表的实现。基于链表实现的方式使得LinkedList在插入和删除时更优于ArrayList，而随机访问则比ArrayList逊色些。

      2.4 Stack

      在Java中Stack类表示后进先出（LIFO）的对象堆栈。栈是一种非常常见的数据结构，它采用典型的先进后出的操作方式完成的。每一个栈都包含一个栈顶，每次出栈是将栈顶的数据取出，如下：

Stack通过五个操作对Vector进行扩展，允许将向量视为堆栈。这个五个操作如下：

            操作                                          说明

empty()

测试堆栈是否为空。

peek()

查看堆栈顶部的对象，但不从堆栈中移除它。

pop()

移除堆栈顶部的对象，并作为此函数的值返回该对象。

push(E item)

把项压入堆栈顶部。

search(Object o)

返回对象在堆栈中的位置，以 1 为基数。

Stack继承Vector，他对Vector进行了简单的扩展。