Java List 接口

List 接口

List 接口的定义

List 是 Collection 的常用子接口，可以存储一组有序，不唯一的对象，List 接口在继承 Collection 接口的基础上进行了扩展，常用的扩展方法如表：

方法	描述
E get(int index)	通过下标获取集合中指定位置的元素
E set(int index,E element)	替换集合中指定位置的元素
void add(int index,E element)	向集合中的指定位置添加元素
E remove(int index)	通过下标删除集合中指定位置的元素
int indexOf(Object o)	查找某个对象在集合中的位置
int lastIndexOf(Object o)	从后向前查找某个对象在集合中的位置
ListIterator listIterator()	实例化 ListIterator 接口
List subList(int fromIndex,int toIndex)	获取集合中的子集

---

List 接口的实现类

ArrayList

ArrayList 是开发中经常使用到的实现类，实现了长度可变的数组。可以在内存中分配连续的空间，底层是给予索引的数据结构，所以访问元素效率较高。使用索引查询元素课快速访问到对应的元素，但缺点是若添加或者删除元素，需要移动兄弟元素的位置，效率较低。

ArrayList 的具体实践代码：

import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;

public class TestArrayList {
	public static void main(String[] args) {
		ArrayList list = new ArrayList();
		list.add("Hello");
		list.add("World");
		list.add("JavaSE");
		list.add("JavaME");
		list.add("JavaEE");
		System.out.println("list:"+list);
		System.out.println("list 的长度："+list.size());
		System.out.println("list 是否包含 Java："+list.contains("Java"));
		Iterator iter = list.iterator();
		while(iter.hasNext()) {
			System.out.print(iter.next()+",");
		}
		System.out.println();
		for(int i = 0; i < list.size(); i++) {
			System.out.print(list.get(i)+",");
		}
		System.out.println();
		System.out.println("---------------删除元素--------------------------");
		list.remove("Hello");
		list.remove(0);
		for(int i = 0; i < list.size(); i++) {
			System.out.print(list.get(i)+",");
		}
		System.out.println();
		System.out.println("----------------添加元素--------------------------");
		list.add(1,"我爱学 Java");
		for(int i = 0; i < list.size(); i++) {
			System.out.print(list.get(i)+",");
		}
		System.out.println();
		System.out.println("----------------替换元素--------------------------");
		list.set(2, "ArrayList详解");
		for(int i = 0; i < list.size(); i++) {
			System.out.print(list.get(i)+",");
		}
		System.out.println();
		System.out.println("JavaEE在集合中的下标："+list.indexOf("JavaEE"));
		List list2 = list.subList(1, 3);
		System.out.println(list2);
		
	}
}

运行结果：

Vector

Vector 是一个早期的 List 实现类，用法基本与 ArrayList 一致

public class TestVector {
	public static void main(String[] args) {
		Vector vector = new Vector();
		vector.addElement("Hello");
		vector.add("Java");
		for (int i = 0; i < vector.size(); i++) {
			System.out.println(vector.get(i));
		}
	}
}

运行结果：

Stack

Stack 是 Vector 的子类，实现了一个 ”后进先出“ 的栈

public class TestStack {
	public static void main(String[] args) {
		Stack stack = new Stack();
		stack.push("Hello");
		stack.push("JavaSE");
		stack.push("JavaME");
		stack.push("JavaEE");
		System.out.println(stack);
		for(int i = 0; i < stack.size(); i++) {
			System.out.print(stack.get(i)+",");
		}
		System.out.println();
		System.out.println("栈顶元素："+stack.peek());
		for(int i = 0; i < stack.size(); i++) {
			System.out.print(stack.get(i)+",");
		}
		System.out.println();
		System.out.println("弹出栈顶元素："+stack.pop());
		for(int i = 0; i < stack.size(); i++) {
			System.out.print(stack.get(i)+",");
		}
	}
}

运行结果：

LinkedList

LinkendList 实现了一个 ”先进先出“ 的队列，采用链表的形式存储分散的内存空间。元素和元素之间通过存储彼此的位置信息来形成连接关系，通过位置信息找到前后节点的关系。所以添加或删除元素的效率更高，因为只需要修改前后节点信息即可。LinkedList 不但要保存每个节点的数据，还需要保存前后节点的位置信息，所以它需要更多的内存空间。正因为如此，在索引检索时会很慢，需要从第一个元素开始遍历，查村元素效率低是其缺点。

public class TestLinkList {
	public static void main(String[] args) {
		LinkedList list = new LinkedList();
		list.add("Hello");
		list.add("World");
		list.add("Java");
		System.out.println(list);
		list.offer("JavaSE");
		list.addLast("JavaSE2");
		System.out.println(list);
		list.push("JavaME");
		list.addFirst("JavaME2");
		System.out.println(list);
		System.out.println("第一个元素："+list.peekFirst());
		System.out.println("访问第一个元素之后的集合"+list);
		System.out.println("最后一个元素："+list.peekLast());
		System.out.println("访问最后一个元素之后的集合"+list);
		System.out.println(list.pop());
		System.out.println("取出第一个元素之后的集合"+list);
		System.out.println(list.pollLast());
		System.out.println("取出最后一个元素之后的集合"+list);
		
		
	}
}

运行结果：

LinkedList 和 Stack 都有 pop() 方法，都是去除集合的第一个元素，到那时可以看到两者的顺序恰好是相反的。Stack 采用的是 “后进先出” 的方式，是栈的形式；LinkedList 采用的是 “先进先出” 的方式，是队列的形式。因为 LinkedList 定义时实现了 Deque 接口，而 Deque 时 Queue 的子接口，Queue 又继承自 Collection，它在底层实现了队列的数据结构。

PriorityQueue

• 在世纪开发中，不能直接实例化 Queue 来完成操作，需要实例化其实现类。Queue 的实现类是 AbstractQueue 。同时 AbstractQueue 又是一个抽象类，开发中需要对其子类 PriorityQueue 进行实例化。
• PriorityQueue 在使用时需要注意，添加到该队列中的数据必须是有序的，即对象具备排序的功能，下面演示一个错误的例子：

class A{
    private int num;
    public A(int num){
        this.num = num;
    }
}

public class Test{
    public static void main(String[] args){
        PriorityQueue queue = new PriorityQueue();
        queue.add(new A(2));
        queue.add(new A(1));
        System.out.println(queue);
    }
}

尝试运行这个会报错，错误原因是 A 的实例化对象无法进行排序，解决方法是让 A 实现 Comparable 接口，并重写 compareTo 方法，再来完成具体的比较逻辑

class A implements Comparable{
	private int num;
	public A(int num) {
		this.num = num;
	}
	
	@Override
	public int compareTo(Object o) {
		/**
		 * A.compareTo(B)
		 * 返回值：
		 * 1 表示 A 大于 B
		 * 0 表示 A 等于 B
		 * -1 表示 A 小于 B
		 * 
		 * */
		A a = (A) o;
		if(this.num > a.num) {
			return 1;
		}else if(this.num == a.num) {
			return 0;
		}else {
			return -1;
		}
	}
	
	@Override
	public String toString() {
		return "A [num=" + num + "]";
	}
}

public class TestPriorityQueue {
	public static void main(String[] args) {
		PriorityQueue queue = new PriorityQueue();
		queue.add(new A(2));
		queue.add(new A(1));
		System.out.println(queue);
	}
}

运行结果：

从结果可以看出来 PriorityQueue 会对元素进行比较，并按照升序进行排序，即自然排序。同时，PriorityQueue 不允许添加 null 元素