18-1，泛型-概述

1，泛型是JDK1.5出現的新技術，新技術的出現是為了解決問題。

2，泛型可以用於明確一個集合中儲存什麼型別的元素

ArrayList<String> al = new ArrayList<String>();
al.add("abc");//正確
//al.add(3);//編譯直接報錯
//在迭代器上加上泛型，下面取出來的時候就不用強轉了
Iterator<String> it = al.iterator();
while(it.hasNext()) {
	//在這裡不用強轉了，因為從it中取出的肯定是String
	String str = it.next();
	System.out.println(str);
}
 

3，好處

(1)將執行時間的問題ClassCastException轉到了編譯時期。

(2)避免了強制轉換的麻煩。

4，泛型什麼時候用呢？

當操作的引用資料型別不確定的時候，就用泛型，將要操作的引用資料型別寫在<>中即可。其實<>就是一個用於接收具體引用資料型別的引數範圍。

在程式中，只要用到了帶有<>的型別或者介面，就要明確傳入的具體引用資料型別。

也可以同時接受多個數據型別：

class Tool<e1,e2,e3,e4>
Tool<String,Demo,Person,Integer> t = new Tool<String,Demo,Person,Integer>();
 

18-2，泛型-擦除&補償

1，泛型解決了編譯時期的安全問題，是給編譯器使用的技術。

2，執行時，會將泛型去掉，生成的class檔案中是不帶有泛型的，這個稱為泛型的擦除。

為什麼要擦除呢？

因為為了相容執行時的類載入器，因為泛型是JDK1.5的新特性，如果class檔案中加上泛型的話，類載入器會不認識，若想要類載入器認識泛型，類載入器也要升級，為了避免升級類載入器的麻煩，泛型將交由編譯器處理，編譯通過後就會把他刪去，使之前的類載入器也能執行它。

3，泛型的補償：

擦除後，如果對元素進行取出的賦值動作，如：String str =it.next();是否需要加上強轉呢？答案是不用了，首先，加上泛型且編譯通過就能保證集合中的資料是指定的型別了，所以認為不會出現規定型別以外的元素。其實，在執行時，是自動添加了一步動作，通過用getClass()方法獲取元素的型別再對其進行一次轉換動作，就不用使用者在強制轉換了。

18-3，泛型-在集合中的應用

1，以TreeSet為例，TreeSet具備比較功能，但存入的型別必須實現Comparable介面並實現了裡面的compareTo方法才可以；或者定義一個比較器，實現Comparator介面並實現裡面的compare方法也可以。定義TreeSet時，如果不加泛型Eclipse等IDE會有黃色波浪線提示，加上泛型，黃色波浪線即可消失。

2，上一章提到的Person類實現Comparable介面時Comparable介面也需要指定泛型，如：Comparable<Person>，指定後，覆寫的compareTo方法中的引數就可以不寫Object了，直接寫Person就可以，方法體中的程式碼也不用強制向下轉型了。Comparator介面也要加上泛型，它裡面的compare方法的兩個引數也直接接受Person型別就可以了。例如：

class Person implements Comparable<Person> {
	...code...
	public int compareTo(Person p) {
		//Person p = (Person)p;//強轉可以省去，因為定義了泛型
		int temp = this.age = p.age;
		return temp == 0 ? this.name.compareTo(p.name) : temp;
	}
	...code...
}

18-4，泛型類

1，以前定義工具類的時候這麼定義：

public class Tool {
	private Object object;
	public Object getObject() {
		return object;
	}
	public void setObject(Object object) {
		this.object = object;
	}
}

別的類用這個工具類的時候，可以這樣做：

Tool tool = new Tool();
/*
這裡因為沒有Worker這個類，所以是錯誤的。
Worker為傳入的錯誤值，但編譯不會報錯，因為Tool中接收的是Object型別，
下面的語句必須做強轉才能匹配型別，因為把Worker向上提升為了Object。
*/
tool.setObject(new Worker());
Student stu = (Student)tool.getObject();

工具類是針對所有型別的，而任何一個類都是Object的子類，所以根據多型的特性，通過將引數定義成Object我們就可以使這個方法接收所有型別的引數，在沒有泛型的時候我們就只能這麼做。

在JDK1.5之後，使用泛型來接收類中要操作的引用資料型別，這就是泛型類。

泛型類什麼時候用呢？

當類中的操作的引用資料型別不確定的時候，就是用泛型來表示。

例如：

public class Tool<Q> {
	private  Q q;
	public Q getObect() {
		return q;
	}
	public void setObject(Q object) {
		this.q = object;
	}
}

有泛型後，在別的類用到工具類的時候，可以這麼做：

Tool<Student> tool = new Tool<Student>();
//tool.setObject(new Worker());//編譯報錯，因為有了泛型指定的Student，所以別的不能進入集合。
tool.setObject(new Student());
Student stu = tool.getObject();

18-5，泛型方法

1，在18-4中有泛型的Tool類中加入泛型方法，Tool<QQ>

public class Tool<Q> {
	private  Q q;
	public Q getObect() {
		return q;
	}
	public void setObject(Q object) {
		this.q = object;
	}
	/*
	如果方法不加泛型會報錯，因為Tool明確只能接收QQ型別，
	所以不能操作W型別，要想讓其中一個方法操作W型別，
	必須在返回值型別前加上泛型<W>。
	*/
	public <W> void show(W str) {
		System.out.println("show" + str.toString());
	}
	/*
	另外，print接收的是字串，那麼能不能列印字串的長度呢？
	答案是不能的，因為QQ str = "abc"(這裡假設傳入abc)，將"abc"提升為QQ型別，
	QQ型別不知道String型別中的特有方法length()，所以不能列印。但由於QQ也
	繼承自Object，所以可以使用Object中的方法。
	*/
	public void print(QQ str) {
		System.out.println("print" + str);
	}
}

呼叫的時候：

Tool<String> tool = new Tool<String>();
tool.show(new Integer(4));//因為show加了泛型，所以可以接受Tool定義的String以外的型別。
tool.show("abc");//符合Tool的泛型。
tool.print("haha");//print方法沒有加泛型，直接匹配。

2，當方法靜態時，不能訪問類上定義的泛型，如果靜態方法是用泛型，只能將泛型定義在方法上。

如果在Tool<QQ>中定義方法：

//如果此方法上不加泛型，引數Y obj會編譯報錯，泛型需要物件來明確，
//如Tool<String> tool = new Tool<String>();靜態是不需要物件的，所以必須在void前加泛型。
public static <Y> void method(Y obj) {
	System.out.println("method" + obj);
}

呼叫這個方法的時候：

Tool.method("bcd");//bcd
Tool.method(new Integer(9));//9

18-6，泛型介面

1，泛型介面就是將泛型定義在介面上。

//定義泛型時一般不明確具體型別，可以接受任意指定型別的物件，在建立物件的時候明確。
interface Inter<T> {
	public void show(T t);
}
//實現介面可以明確要操作的型別，那麼在這個類上直接加上指定型別的泛型即可。
class ImterImpl<String> implements Inter<String> {
	public void show(String str) {
		System.out.println("show:" + str);
	}
}

呼叫show方法時：

InterImpl in = new InterImpl();//這樣new物件時就不用加泛型了。
in.show("abc");//這樣呼叫就行

2，在實現介面的類中還是不能明確使用的型別：

class InterImpl<Q> implements Inter<Q> {
	public void show(Q q) {
		System.out.println("show:" + q);
	}
}

在new這個InterImpl類的時候才能明確使用的型別，那麼就定義成上述的樣子，在new物件的時候再明確其泛型。

InterImpl<Integer> in = new InterImpl<Integer>();
in.show(5);

這樣一來，in物件就只能接收Integer型別的物件了。

18-7，泛型的界定-上限

1，有多個集合，要想用Iterator取出多個集合中的資料，這時不要定義多個Iterator，要提高程式碼的複用性，就要單獨定義一個方法來進行迭代。例如有這麼兩個集合：

ArrayList<String> al = newArrayList<String>();

ArrayList<Integer> al2 = newArrayList<Integer>();

假如這兩個集合中已經有了資料，這時要取出裡面的資料，定義一個迭代方法：

//這裡接收的是Collection，所以可以迭代List,Set等所有集合，但這裡也定義了泛型，所以只能接受String了。
public static void printCollection(Collection<String> al) {
	Iterator<String> it = al.iterator();
	while(it.hasNext()) {
		System.out.println(it.next());
	}
}

這是要考慮到接收的集合中的元素型別是不確定的，怎樣接收不同型別的元素呢？可以用泛型萬用字元表示。

2，泛型的萬用字元---?，表示未知型別。

public static void printCollection(Collection<?> al) {
	Iterator<?> it = al.iterator();
	while(it.hasNext()) {
		//由於引數型別不確定，所以直接用it.next()就OK了。
		System.out.println(it.next());
	}
}

也可以在方法上加上泛型：

public static <T> void printCollection(Collection<T> al)
Iterator<T> it = al.iterator();
while(it.hasNext()) {
	T str = it.next();
	System.out.println(str);
}

但是這麼做有些麻煩。但也有另外的好處，如果這麼寫：

public static <T> T printCollection(Collection<T> al) {
	Iterator<T> it = al.iterator();
	T t = it.next();
	return t;
}

這樣就可以對傳入的T返回其物件，並進行操作，不過主要還是用萬用字元--?。

3，需求：迭代方法中，只能接收Person及其子類。

分析：首先？就不行了，因為不能接受所有物件。

例如Person的子類有Worker,Student，若要迭代這兩個而不能迭代Person以外的類(例如String)，可以這麼寫：

//<? extends Person>表示泛型定義是所有繼承Person的型別或Person型別
public static void printCollection(Collection<? extends Person> al){
	Iterator<? extends Person> it = al.iterator();
	while(it.hasNext()) {
		Person p = it.next();//已經可以明確接收的是Person或其子類
		System.out.println(p.getName() + ":" + p.getAge());
	}
}

若想用此方法迭代String型別的物件，則在編譯時會直接報錯，因為String不是Person的子類，這就是泛型的上限，其實，泛型寫<?>是<? extends Object>的縮略。

18-8，下限

1，定義方式：<? super E>表示指定的型別必須是E或E的父類。

例如Student和Worker都是Person的子類，

定義了三個集合：

ArrayList<Person> al1 = new ArrayList<Person>();
ArrayList<Student> al2 = new ArrayList<Student>();
ArrayList<Worker> al3 = new ArrayList<Worker>();

然後定義一個方法：

public static void printCollection(Collection<? super Student> al) {
	Iterator<? super Student> it = al.iterator();
	while(it.hasNext()) {
		System.out.println(it.next());
	}
}

這時一個迭代集合元素的方法，泛型型別指的是Student或Student的父類，由於Student繼承自Person，Worker也繼承自Person，所以這裡如果傳入Worker是不行的，會報錯。這就是泛型的下限。

18-9，選擇使用集合的技巧

1，幾何元素需要唯一麼？

    |--需要：用Set

       |--需要指定順序麼？

           |--需要：TreeSet

           |--不需要：HashSet

           |--但是想要一個和儲存一致的順序(有序):LinkedHashSet

    |--不需要：用List

       |--需要頻繁增刪麼？

           |--需要：LinkedList

           |--不需要：ArrayList

2，如何記住每個容器的結構和所屬的體系呢？看名字！

List

 |--ArrayList

 |--LinkedList

Set

 |--HashSet

 |--TreeSet

字尾名就是該集合所屬的體系。

字首名就是該集合的資料結構。

看到array：就要想到陣列，查詢快，有角標。

看到Link：就要想到連結串列，增刪快，想到add、get、remove方法。

看到hash：就要想到雜湊表，唯一性，就要想到元素需要覆蓋hashCode和equals方法。

看到tree：就要想到二叉樹，想到需要排序，兩個介面，Comparable,Comparator。

而且通常這些常用的集合容器都是不同步的。

18-10，工具類-Collections排序

1，java.util.Collections

此類完全由在Collection上進行操作或返回Collection的靜態方法組成。

2，Collections是集合框架的工作類，裡面的方法都是靜態的。

static <T extendsComparable<?  super T>> voidsort(List<T> list)

根據元素的自然排序，對指定列表進行升序排序，列表中的所有元素都必須實現Comparable介面，列表中的所有元素都必須是相互可以比較的，即型別必須相互匹配才行。

演示排序方法示例：

public static void demo_1() {
	List<String> list = new ArrayList<String>();
	list.add("abcde");
	list.add("cba");
	list.add("aa");
	list.add("zzz");
	list.add("cba");
	list.add("nbaa");
	System.out.println(list);
	//排序
	Collections.sort(list);//String實現了Comparable介面，具備可比性
	System.out.println(list);
}

若要按照長度排序，可以通過sort(List<T>list,Comparator<? Super T> c)帶比較器的sort方法實現，這需要定義一個類，並實現Comparator介面，並實現裡面的compare方法。例如：

public class ComparatorByLength implements Comarator<String> {
	public int compare(String o1,String o2) {
		int temp = o1.length() - o2.length();
		return temp == 0 ? o1.compareTo(o2) : temp;
	}
}

然後呼叫方法Collections.sort(list,newComparatorByLength());即可。

18-11，折半&最值

1，static <T> int binarySearch(List<?extends Comparable<? super T>> list, T key)

這個方法是使用二進位制搜尋法來搜尋指定列表，以獲得指定物件，在進行此呼叫之前，必須根據列表元素的自然順序對列表進行升序排序，其實就是二分查詢法。

2，static <T> int binarySearch(List<?extends T> list,T key,Comparator<? super T> c)

與上面的方法的不同之處在於，用指定的比較器對集合中的元素進行升序排序。

3，折半：

public class Demo {
	public static void main(String[] args) {
		List<String> list = new ArrayList<String>();
		list.add("abcde");
		list.add("cba");
		list.add("aa");
		list.add("zzz");
		list.add("cba");
		list.add("nbaa");
		//排序
		Collections.sort(list);
		int index = Collections.binarySearch(list,"cba");//index是2
	}
}

4，最大值

static T max(Collection<? extendsT> coll)

根據元素的自然順序，返回給定collection的最大元素，collection中的元素必須具備比較功能，該方法是依據Comparable比較的。

static T max(Collection<? extendsT> coll,Comparator<? super T> comp)

根據指定的比較器產生的順序，返回給定collection的最大值。

例如：

String max = Collections.max(list,newComparatorByLength())

返回最長的字串。

18-12，逆序&替換

1，static <T> Comparator<T>reverseOrder()

返回一個比較器，它強行反轉實現Comparable介面那些物件collection上的自然順序，他是根據Comparable比較的。

TreeSet<String> ts = new TreeSet<String>(Collections.reverseOrder(newComparatorByLength()))

這個方法強行反轉比較器指定排序後的反轉。

2，替換

public class Demo {
	public static void main(String[] args) {
		List<String> list = new ArrayList<String>();
		list.add("abcde");
		list.add("cba");
		list.add("aa");
		//將list集合中的"cba"替換成"nba"
		//原理：list.set(indexOf("cba"),"nba")
		Collections.replaceAll(list,"cba","nba");
	}
}

18-13，其他方法，將非同步集合轉成同步集合的方法

1，fill方法，可將集合中的所有的值都重新賦值（重新初始化）

public class Demo {
	public static void main(String[] args) {
		List<String> list = new ArrayList<String>();
		list.add("abcde");
		list.add("cba");
		list.add("aa");
		Collections.fill(list, "cc");
		System.out.println(list);//[cc,cc,cc] 將所有元素初始化為cc
	}
}

2，Collections.shuffle(list);//將集合中的元素隨機重新排列

3，static <T> ArrayList<T>list(Enumeration<T> e)

返回一個數組列表，它按返回順序包含指定列舉返回的元素，將列舉轉換成ArrayList。

4，static <T> Enumeration<T>enumeration(Collection<T> c)

將指定集合轉成列舉。

5，static <T> Enumeration<T>synchronizedList(List<T> list)

返回指定列表支援的（執行緒安全的）列表。

除此之外可以將Collection、Map、Set，等轉成執行緒安全的。

實現原理：

List list = new ArrayList();//是非同步的

list = MyCollections.synList(list);//返回一個同步的list

給非同步的集合加鎖：

//保證在新增時不能刪除，刪除時不能新增
class MyCollections {
	public static List synList(List list) {
		return new MyList(list);
	}
	private class MyList implements List {
		private List list;
		private static final Object lock = new Object();
		MyList(List list) {
			this.list = list;
		}
		public boolean add(Object obj) {
			synchronized(lock) {
				return list.add(obj);
			}
		}
		public boolean remove(Object obj) {
			synchronized(lock) {
				return list.remove(obj);
			}
		}
	}
}

18-14，Arrays陣列工具類方法介紹

1，binarySearch(...)二分查詢法，返回索引。

2，equals(...)覆寫了Object中的equals，比較內容是否相同，即長度相同且對應位上的元素相同。

3，static void fill(byte[] a,byte val)將val賦給byte[]中的每一個位置。

4，sort(...)將傳入的陣列排序。

5，toString(),覆寫了Object中的toString()，直接列印陣列中的元素。

6，toString()的經典實現：

public static String myToString(int[] a) {
	int iMax = a.length - 1;
	if(iMax == -1) {
		return "[]";
	}
	StringBuilder b = new StringBuilder();
	b.append('[');
	for(int i=0;;i++) {
		b.append(a[i]);
		if(i == iMax) {
			return b.append(']').toString();
		}
		b.append(",");
	}
}

18-15，Arrays-asList方法

1，static<T> List<T> asList(T... a)

返回一個受指定陣列支援的固定大小的列表。

用asList的原因：Arrays中提供的方法也是相當有限的，如果把陣列轉換成集合操作就方便多了，比如判斷一個元素是否在陣列中，Arrays中沒有這個方法，就需要自己寫一個判斷方法，但是如果將這個陣列轉換成List就可以直接用contains判斷了。

2，好處：可以使用集合中的方法運算元組中的元素。

注意：陣列的長度是固定的，所以對於集合的增刪方法是不能使用的，否則會發生UnsupportedOperationException異常，只要不改變集合長度的方法都可以使用。

但是可以使用set方法用指定元素替換指定的元素。

3，如果陣列中的元素是物件，那麼轉成集合時，直接將陣列中的元素作為集合中的元素進行儲存。如果陣列中的資料是基本資料型別，那麼會將該陣列作為集合中的元素進行儲存。

例如：

int[] arr = {31,11,51,61};

List<int[]> list =Arrays.asList(arr);

System.out.prtinln(list);//[[[email protected]

這時list集合的長度是1，列印結果是列印陣列物件。

但是如果定義一個Integer型別陣列，即非基本資料型別陣列：

Integer[] arr = {31,11,51,61};

List<int[]> list =Arrays.asList(arr);

System.out.println(list);//列印[31,11,51,61]

說明，如果存入非基本資料型別資料，列印的是每個物件的toString()。

18-16，Collection-->toArray方法

1，如何將集合轉化成陣列呢？

使用的是Collection介面中的toArray方法。

2，集合轉成陣列：可以對集合中的元素操作的方法進行限定，不允許對其進行增刪。

3，toArray方法需要傳入一個指定型別的陣列。

長度該如何定義呢？

如果長度小於集合的size，那麼該方法會建立一個同類型並和集合相同size的陣列。

如果長度大於集合的size，那麼該方法就會使用指定的陣列，儲存集合的元素，其他位置預設為null。

所以建議，最好將長度指定為集合的size。

List<String> list = new ArrayList<String>();
list.add("abc1");
list.add("abc2");
list.add("abc3");
String[] arr = list.toArray(new String[list.size()]);
System.out.println(Arrays.toString(arr));

18-17，JDK1.5新特性-ForEach迴圈

1，Collection的父介面是Iterable介面，該介面中只有一個iterator迭代器方法，在JDK1.5才出現，因為以後還有可能出現像Collection的頂層父類，都希望他們具備迭代功能，所以抽取出來，提高了擴充套件性。

2，ForEach迴圈，增強For迴圈

格式：for(型別 變數 :Collection集合或陣列){...}

傳統for和高階for的區別：

(1)傳統for可以完成對語句執行很多次，因為可以定義控制迴圈的增量和條件。

(2)高階for是一種簡化形式，它必須有被遍歷的目標。該目標要麼是陣列，要麼是Collection單列集合。

對陣列的遍歷如果僅僅是獲取陣列中的元素，可以使用高階for。

如果要對陣列的角標進行操作建議使用傳統for。

可以使用高階for遍歷map集合麼？

不能直接用，但是可以將map轉換成單列的set就可以使用了。

4，例項：

public class Demo1 {
	public static void main(String[] args) {
		List<String> list = new ArrayList<String>();
		list.add("abc1");
		list.add("abc2");
		list.add("abc3");
		for(String s : list) {//簡化了書寫，底層其實是iterator
			System.out.println(s);
		}
	}
}

public class Demo2 {
	public static void main(String[] args) {
		int[] arr = {3,1,5,7,4};
		for(int i : arr) {
			System.out.println(i);
		}
	}
}

遍歷Map示例：

public class Demo3 {
	public static void main(String[] args) {
		Map<Integer,String> map = new HashMap<Integer,String>();
		map.put(3,"zhangsan");
		map.put(1,"wangyi");
		map.put(5,"wangcai");
		map.put(7,"xiaoqiang");
		for(Integer key : map.keySet()) {
			String value = map.getKey();
			System.out.println(key + "::" + value);
		}
		for(Map.Entry<Integer,String> me : map.entrySet()) {
			Integer key = me.getKey();
			String value = me.getValue();
			System.out.println(key + ":" + value);
		}
	}
}

18-18，JDK1.5新特性-函式的可變引數

1，其實就是一個數組，但是接收的是陣列的元素。自動將這些元素封裝成陣列。簡化了呼叫者的書寫。

注意：可變引數型別，必須定義在引數列表的結尾。

public static newAdd(int... arr) {
	int sum = 0;
	for(int i=0;i<arr.length;i++) {
		sum += arr[i];
	}
	return sum;
}
int sum = newAdd(5,1,7,4,3,6);//可以傳入任意長度的引數
System.out.println(sum);
int sum = newAdd(7,4,6,5,1,8,97,6);
System.out.println(sum);

注意：

public static newAdd(int... arr,int a)

{ ... code ...} //寫法錯誤，傳入的引數會全都賦給arr，a會沒有值

public static newAdd(int a,int... arr)

{ ... code ...} //寫法正確，第一個值傳給a，後面的傳給arr

18-19，JDK1.5新特新-靜態匯入

靜態匯入，其實匯入的類中的靜態成員。

在import後面加上static，示例如下：

import java.util.ArrayList;
import java.util.Collections;
import static java.util.Collections.*;//匯入Collections中的所有的靜態成員，可簡化書寫
import static java.lang.System.*;//匯入System中的所有靜態成員
public class Demo {
	public static void main(String[] args) {
		List<String> list = new ArrayList<String>();
		list.add("abc3");
		list.add("abc7");
		list.add("abc1");
		out.println(list);//out是System類中的靜態成員，靜態匯入System後，就不用通過System呼叫了
		sort(list);//Collections中的靜態方法
		out.println(list);
		String max = max(list);//Collections中的靜態方法
		out.println("max = " + max);
	}
}