收集对象（Collection-->List、Set、Queue）

在 Java SE中，提供了数个收集对象的类，能够直接取用这些类，而不用从新打造相似的API。

一、Collection架构

Java SE提供了知足各类需求的API，在使用些API前，建议先了解其继承与接口操做架构，才能了解什么时候该采用哪一个类，以及类之间如何彼此合做，而不会沦于死背API或抄写范例的窘境。 针对收集对象的需求， Java SE提供了 Collection API：

收集对象的行为，像是新增对象的add()方法、移除对象的remove()方法等，都是定义在java.util.Collection中。既然能够收集对象，也要能逐一取得对象，这就是java.lang.Iterable定义的行为，它定义了 iterator（）方法返回java.uti1. Iterator操做对象，可让你逐一取得收集的对象，详细操做方式，下一篇再作说明 收集对象的共同行为定义在collection中，然而收集对象会有不一样的需求。若是但愿收集时记录每一个对象的索引顺序，并可依索引取回对象，这样的行为定义在java.util.List接口中。若是但愿收集的对象不重复，具备集合的行为，则由java.util.Set定义。若是但愿收集对象时以队列方式，收集的对象加入至尾端，取得对象时从前端，则可使用java.util.Queue。若是但愿对Queue的两端进行加入、移除等操做，则可使用java util. Deque。
收集对象时，会依需求使用不一样的接口操做对象。举例来讲，若是想要收集时具备索引顺序，操做方式之一就是使用数组，而以组操做List的就是java.util.Arraylist。高度自定义的Java提供了AbstractCollection、AbstractList等，必要时能够继承AbstractCollection，操做本身的Collection，其余的API也相似。

二、List

List是一种Collection，能够收集对象，并以索引方式保留收集的对象顺序。 操做类有ArrayList，LinkedList。
一、ArrayList
数组在内存中会是连续的线性空间，根据索引随机存取时速度快，若是操做上有这类需求时，像是排序，就可以使用 Arraylist，可获得较好的速度表现。 数组在内存中会是连续的线性空间，若是须要调整索引顺序时，会有较差的表现。例如若在已收集100对象的Arraylist中，使用可指定索引的add（）方法，将对象新增到索引0位置，那么原先索引0的对象必须调整至索引1，索引1的对象必须调整至索引2，索引的对象必须调整至索引3。依此类推，使用 Arraylist作这类操做并不经济。 数组的长度固定也是要考虑的问题，在Arraylist内部数组长度不够时，会创建新数组，并将旧数组的参考指定给新数组，这也是必须耗费时间与内存的操做。为此， Arraylist有个可指定容量（Capacity）的构造函数，若是大体知道将收集的对象范围，事先创建足够长度的内部数组，能够节省以上所描述的成本。

2. Linkedlist

linkedlist在操做List接口时，采用了连接link结构。参考下面的能够更好理解link结构：

package coll_map;

public class LinkedListDemo {
	private class Node {
		Node(Object o) {
			this.o = o;
		}

		Object o;
		Node next;
	}

	private Node first;

	public void add(Object elem) {
		Node node = new Node(elem);
		if (first == null) {
			first = node;
		} else {
			append(node);
		}
	}

	private void append(Node node) {
		// TODO 自动生成的方法存根
		Node last = first;
		while (last.next != null) {
			last = last.next;
		}
		last.next = node;
	}

	private int size() {
		int count = 0;
		Node last = first;
		while (last != null) {
			last = last.next;
			count++;
		}
		return count;
	}

	public Object get(int index) {
		checkSize(index);
		return findElemOf(index);
	}

	private void checkSize(int index) throws IndexOutOfBoundsException {
		int size = size();
		if (index >= size) {
			throw new IndexOutOfBoundsException(String.format("Index：%d，Size：%d", index, size));
		}
	}
	
	private Object findElemOf(int index) {
		int count = 0;
		Node last = first;
		while (count < index) {
			last = last.next;
			count++;
		}
		return last.elem;//？？？
	}
}

在 simplelinkedlist内部使用Node封装新增的对象0，每次add（）新增对象以后，将会造成链状结构目。 因此每次add（）对象时，才会创建新的Node来保存对象，不会事先耗费内存，若调用size（），则从第一个对象，逐一参考下一个对象并计数，则可取得收集的对象长度。若想调用get（）指定索引取得对象，则从第一个对象，逐一参考下一个对象并计数，则可取得指定索引的对象。 能够看出，想要指定索引随机存取对象时，连接方式都得使用从第一个元素开始查找下一个元素的方式，会比较没有效率，像排序就不适合使用连接操做的List。若是排序时，恰好必须将索引0与索引10000的素调换，效率就不高。 连接的每一个元素会参考下一个元素，这有利于调整索引顺序。例如，若在已收集100对象的 simplelinkedlist中，操做可指定索引的add（）方法，将对象新增到索引0位置。 新增的对象将创建Node实例封装，而frst（或上一节点的next）从新参考至新建的Node对象，新建Node的next则参考至下一node对象。所以，若收集的对象常常会有变更索引的状况，也许考虑连接方式操做的List会比较好，像是随时会有客户端登陆或注销的客户端List，使用 Linkedlist会有比较好的效率

三、内容不重复的Set

一样是收集对象，在收集过程当中如有相同对象，则再也不重复收集，如有这类需求，可使用set接口的操做对象。收集不重复单词：

package coll_map;

import java.util.*;

public class WordFind {
	public static void main(String[] args) {
		Scanner scan=new Scanner(System.in);
		
		System.out.println("输入英文");
		Set words =tokenSet(scan.nextLine());//调用tokenSet返回的是HashSet全部能够直接这样
		System.out.printf("不重单词%d个：%s%n", words.size(),words);
	}

	private static Set tokenSet(String line) {
		String[] tokens=line.split(" ");//根据空白切割出字符串，返回的是Spring[]
		return new HashSet(Arrays.asList(tokens));
	}
}

Arrays.asList ()方法返回List，而工List是一种Collection，于是可传给Hashset接受 Collection实例的构造函数,因为set的特性是不重复，所以如有相同单词，则不会再重复加入，最后只要调用set的size（）方法，就能够知道收集的字符串个数， Hashset的 toString（）操做，则会包括收集的字符串。

package coll_map;

import java.util.*;

class Student {
	private String name;
	private int ID;

	Student(String name, int ID) {
		this.name = name;
		this.ID = ID;
	}

	@Override
	public String toString() {
		// TODO 自动生成的方法存根
		return String.format("(%s,%s)", name, ID);
	}
}

public class Students {
	public static void main(String[] args) {
		Set<Student> stus=new HashSet<>();
		stus.add(new Student("gg1", 2017));
		stus.add(new Student("gg2", 2018));
		stus.add(new Student("gg3", 2019));
		stus.add(new Student("gg2", 2018));
		
		System.out.println(stus);
	}
}

set没有将重复学生数据排除，由于你并无告诉set，什么样的 Student实例才算是重复，以 Hashset为例，会使用对象的 hashcode（）与 equals（）来判断对象是否相同。 Hashset的操做概念是，在内存中开设空间，每一个空间会有个哈希编码（ Hash Code）。
这些空间称为哈希桶（ Hash Bucket），若是对象要加入 Hashset，则会调用对象的 hashcode）取得哈希码，并尝试放入对应号码的哈希桶中，若是哈希桶中没对象，则直接放入，若是哈希桶中有对象会再调用对象的equa1s（）进行比较。 若是同一个哈希桶中已有对象，调用该对象 equals（）与要加入的对象比较，结果为 false，则表示两个对象非重复对象，能够收集，若是是true，表示两个对象是重复对象，则不予收集事实上不仅有 Hashset，Java中许多要判断对象是否重复时，都会调用 hashcode（）与 equals（）方法，所以规格书中建议，两个方法必须同时操做。之前面范例而言，若操做了 hashcode与 equals方法，则重复的 Student将不会被收集。IDE通常能够自动生成。
四、Queue
若是但愿收集对象时以队列方式，收集的对象加入至尾端，取得对象时从前端，则可 add以使用 Queue接口的操做对象。 Queue继承自 collection，因此也具备 collection的 remove）、 element（）等方法，然而 Queue定义了本身的 offer（）、poll（）与peek（）等方法，最主要的差异之一在于，add（）、 remove（）、element（）等方法操做失败时会抛出异常，而offer、poll（）、（）与peek（）等方法操做失败时会返回特定值。 若是对象有操做 Queue，并打算以队列方式使用，且队列长度受限，一般建议使用 offer（）、po1l（）与peek（）等方法。 offer（）方法用来在队列后端加入对象，成功会返回true失败则返回 false。Poll方法用来取出队列前端对象，若队列为空则返回null，peek用来取得（但不取出）队列前端对象，若队列为空则返回null。 前面提过 Linkedlist它不只操做了List接口，也操做了 Queue的行为，因此可将 linkedlist看成队列来使用。Queue<T> name = new LinkedList<>();

package coll_map;

import java.util.*;

interface Request {
	void execute();
}

public class RequestQueue {
	public static void main(String[] args) {
		Queue<Request> requests = new LinkedList<>();
		offerRequestTo(requests);
		process(requests);
	}

	static void offerRequestTo(Queue<Request> requests) {
		for (int i = 1; i <= 5; i++) {

			requests.offer(() -> System.out.printf("模拟产生数据：%f%n", Math.random())); // ----Lambda表达式----
		}
	}

	private static void process(Queue<Request> requests) {
		while (requests.peek() != null) {
			Request request = requests.poll();
			request.execute();
		}
	}
}

Deque
想对队列的前端与尾端进行操做，在前端加入对象与取出对象，在尾端加入对象与取出对象，Queue的子接口Deque就定义了这类行为。 Deque中定义 addfirst（） removeFirst（）、 getFirst（）、 addlast（）、 removelast（）、 getLast（ 等方法，操做失败时会抛出异常，而 offerfirst（）、 polifirst（、 peekpirst（）、 offerlast（）、 polllast（）、 peeklast（）等方法，操做失败时会返回特定值 Qeue的行为与 Deque的行为有所重复，有几个操做是等义的：

Queue	Deque
add	addLast
offer	offerLast
remove	removeFirst
poll	pollFirst
element	getFirst
peek	peekFirst

使用ArrayDeque操做有限堆栈：

package coll_map;

import java.util.*;

public class Stack {
	private Deque<Object> elems=new ArrayDeque<>();
	private int capacity;
	
	public Stack(int capacity) {
		this.capacity=capacity;
	}
	
	public  boolean push(Object o) {
		if(isFull()) {
			return false;
		}
		return elems.offerLast(o);
	}
	
	private boolean isFull() {
		return elems.size()+1>capacity;
	}
	public Object pop() {
		return  elems.peekLast();
	}
	public int size() {
		return elems.size();
	}
	public static void main(String[] args) {
		Stack stack=new Stack(5);
		stack.push("one");
		stack.push("two");
		stack.push("three");
		System.out.println(stack.pop());
		System.out.println(stack.pop());
		System.out.println(stack.pop());
	}
}