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

最新推荐文章于 2021-04-12 14:26:11 发布

后台技术汇

最新推荐文章于 2021-04-12 14:26:11 发布

阅读量341

点赞数

CC 4.0 BY-SA版权

分类专栏： Java Java基础与积累

本文链接：https://blog.youkuaiyun.com/qq_29166327/article/details/78505507

Java 同时被 2 个专栏收录

66 篇文章

订阅专栏

Java基础与积累

66 篇文章

订阅专栏

本文详细介绍了 Java 中 List 接口的概念及其主要实现类 ArrayList、LinkedList 和 Vector 的特性与应用场景，通过实例演示了各实现类的具体使用方法。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

日期：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 接口的框架图：

fig.1

  通过上面的框架图，可以对 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);
		
		//Iterator
		Iterator it = arr.iterator();
		while(it.hasNext()){
			String s = (String) it.next();
			System.out.println(s);
		}
		System.out.println("-----------");
		
		//for
		for(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）的对象堆栈。栈是一种非常常见的数据结构，它采用典型的先进后出的操作方式完成的。每一个栈都包含一个栈顶，每次出栈是将栈顶的数据取出，如下：

2014070800001_thumb

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

操作	说明
`empty()`	测试堆栈是否为空。
`peek()`	查看堆栈顶部的对象，但不从堆栈中移除它。
`pop()`	移除堆栈顶部的对象，并作为此函数的值返回该对象。
`push(E item)`	把项压入堆栈顶部。
`search(Object o)`	返回对象在堆栈中的位置，以 1 为基数。