集合Collection——List

本文介绍集合中的List其实现方式及相关操作，其常用的实现子类有ArrayList、LinkedList、Vector及其子类Stack。

接口List<E>

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

ArrayList

• 简介

• List 接口的大小可变数组(动态数组)的实现。
• 实现了所有可选列表操作，并允许包括 null 在内的所有元素。
• 每个 ArrayList 实例都有一个容量。该容量是指用来存储列表元素的数组的大小。
• 它总是至少等于列表的大小。随着向 ArrayList 中不断添加元素，其容量也自动增长。
• 注意，此实现不是同步的。(线程不安全)
• 其他所有操作都以线性时间运行

•  常用方法

void add(int index, E element)  在指定角标index处添加元素element，开始最好从角标0添加元素 并且角标最好连续的

boolean addAll(int index, Collection<? extends E> c)  在指定角标处添加一个指定的集合中所有的元素

E get(int index)  返回列表当中指定角标index处的元素

int indexOf(Object o)  返回指定元素从左到右第一次出现的角标

int lastIndexOf(Object o) 返回指定元素从右到左第一次出现的角标

E remove(int index)  删除指定角标处index的元素 并返回该删除的元素

E set(int index, E element)  修改列表当中指定角标处index的元素为新元素element

List<E> subList(int fromIndex, int toIndex)  截取列表中[from,to)之间的元素 并且返回List

• 方法使用示例

public class ListDemo {
	public static void main(String[] args) {
		List<Integer> list1 = new ArrayList<Integer>();
		List<Integer> list2 = new ArrayList<Integer>();
		list1.add(0, 10);//类似于在列表头部添加元素
		list1.add(1, 20);//类似于在列表尾部添加元素
		list1.add(2, 30);//类似于在列表尾部添加元素
		list1.add(3, 40);//类似于在列表尾部添加元素
		list1.add(1, 50);//类似于插入的操作
		list1.add(0, 60);//类似于在列表头部添加元素
		list2.add(0,50);
		list2.add(1,20);
		list2.add(1,30);
		System.out.println(list1);
		System.out.println(list2);
		list1.addAll(3,list2);//将集合list2的元素全部插入list1
		System.out.println(list1);
		System.out.println(list1.get(3));//获取角标为3的元素
		System.out.println(list1.indexOf(50));//返回指定元素50第一次出现的角标
		System.out.println(list1.remove(3));//删除指定位置3的元素
		System.out.println(list1);
		List<Integer> list3 = list1.subList(1, 4);//截取list1中的1~4角标处的元素为一个新的列表
		System.out.println(list3);
		System.out.println(list1);//截取后并不改变list1
		list1.sort(new Comparator<Integer>() {

			@Override
			public int compare(Integer o1, Integer o2) {
				//o1 和 o2 是由前后关系的 
				//前 - 后 < 0 说明前者更靠前
				//后 - 前 < 0 说明后者更靠前
				//o1前 o2后  o1 - o2
				//o2前 o1后  o2 - o1
				return o2 - o1;
			}
		});
		System.out.println(list1);
	}
}

LinkedList

• 简介

• List 接口的链接列表实现。
• 除了实现了List的功能之外 还实现了Queue(Deque)队列接口。

• 该实现子类 可以当做列表、队列、栈、双端队列。

  扫描二维码关注公众号，回复： 11642415 查看本文章

• LinkedList本质上就是一个【双向循环链表】。

• 允许所有元素（包括 null）。

• LinkedList 类还为在列表的开头及结尾 get、remove 和 insert 元素提供了统一的命名方法。

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

• 注意，此实现不是同步的。(线程不安全)

•   常用方法

1.LinkedList当做双端队列去用(都是对头尾操作的)
void addFirst(E e)  将指定元素插入此列表的开头。
void addLast(E e)  将指定元素添加到此列表的结尾。
E removeFirst()  移除并返回此列表的第一个元素。
E removeLast()  移除并返回此列表的最后一个元素
E getFirst()  返回此列表的第一个元素。
E getLast()  返回此列表的最后一个元素。

boolean offerFirst(E e)  在此列表的开头插入指定的元素。
boolean offerLast(E e)  在此列表末尾插入指定的元素。
E pollFirst()  获取并移除此列表的第一个元素；如果此列表为空，则返回 null。
E pollLast()   获取并移除此列表的最后一个元素；如果此列表为空，则返回 null。
E peekFirst()  获取但不移除此列表的第一个元素；如果此列表为空，则返回 null。
E peekLast()  获取但不移除此列表的最后一个元素；如果此列表为空，则返回 null。

2.LinkedList用作队列
boolean offer(E e)  入队一个元素 将指定元素添加到此列表的末尾（最后一个元素）。
E poll()  出队 获取并移除此列表的头（第一个元素）
E element()  获取当前队列的头元素

3.LinkedList用作栈
void push(E e)  将元素推入此列表所表示的堆栈。
E pop() 从此列表所表示的堆栈处弹出一个元素。
E peek()  获取但不移除此列表的头（第一个元素）。

•  方法使用示例

public class LinkedListDemo {
	public static void main(String[] args) {
		/*
		 如果LinkedList当做双端队列去看，操作主要在head和rear身上
		 在head的地方可以进行增删
		 在rear的地方可以进行增删
		 head ———————————————— rear
		 */
		LinkedList<Integer> deque = new LinkedList<Integer>();
		deque.addFirst(1);	//1
		deque.addFirst(2);	//2 1
		deque.addLast(3);	//2 1 3
		deque.addLast(4);	//2 1 3 4
		System.out.println(deque); //[2, 1, 3, 4]
		deque.removeFirst();//1,3,4
		deque.removeLast();//1,3
		System.out.println(deque);//[1,3]
		System.out.println(deque.offerFirst(0));//true
		System.out.println(deque.offerLast(4));//true
		System.out.println(deque);//[0,1,3,4]
		deque.pollFirst();//0
		deque.pollLast();//4
		System.out.println(deque);//[1,3]
		System.out.println(deque.peekFirst());//1
		System.out.println(deque.peekLast());//3
		
		
		
		 /*如果LinkedList当做队列去看，操作主要在head和rear身上
		 在head的地方只能进行出队
		 在rear的地方只能进行入队
		 head ———————————————— rear
		 */
		LinkedList<Integer> queue = new LinkedList<Integer>();
		queue.offer(1);	//1
		queue.offer(2);	//1 2
		queue.offer(3);	//1 2 3
		System.out.println(queue);//[1, 2, 3]
		System.out.println(queue.poll());// 1
		System.out.println(queue);//[2, 3]
		System.out.println(queue.element());//2
		
		/*
		 如果LinkedList当做栈去看，操作主要在head身上
		 在head的地方可以进行入栈和出栈
		 head ———————————————— rear
		 */
		LinkedList<Integer> stack = new LinkedList<Integer>();
		stack.push(1);//1
		stack.push(2);//2 1
		stack.push(3);//3 2 1
		System.out.println(stack);//[3, 2, 1]
		System.out.println(stack.pop());
		System.out.println(stack);//[2, 1]
		System.out.println(stack.peek());//2
	}
}

Vector

• 简介

• Vector 类可以实现可增长的对象数组。

• 与数组一样，它包含可以使用整数索引进行访问的组件。

• 此实现是同步的。(线程安全)

• 一般被ArrayList替代，故不做详细介绍。

Stack

• 简介

• 是Vector的一个子类，表示的是栈。
• 一般而言被LinkedList替代。

• 常用方法

• boolean empty() 测试堆栈是否为空。
• E peek()  查看栈顶对象，但不移除。
• E pop()  移除栈顶对象，并返回。
• E push()  把项压入堆栈顶部。

• 方法使用示例

public class StackDemo {
	public static void main(String[] args) {
		Stack<Integer> stack = new Stack<Integer>();
		stack.push(1);
		stack.push(2);
		stack.push(3);
		stack.push(4);
		System.out.println(stack);//[1,2,3,4]
		System.out.println(stack.pop());//4
		System.out.println(stack.peek());//3
		System.out.println(stack);//[1,2,3]
	}
	
}