收集對象（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());
	}
}