【黑馬程序員】集合框架（四）Collections 第十八天

-------  android培訓、java培訓、java學習型技術博客、期待與您交流！ ----------

知識點

10）Collections（Sort）

/*
 * sort(List<T> list)：根據元素的【自然順序】 對指定列表按升序進行排序。
 * sort(List<T> list, Comparator<? super T> c)：根據指定【比較器】產生的順序對指定列表進行排序。
 */
public class Collections_SortDemo {
	public static void sop(Object obj){
		System.out.println(obj);
	}
	public static void main(String[] args) {
		method_sort();
	}
	public static void method_sort(){
		List<String> list = new ArrayList<String>();
		list.add("af");
		list.add("fddf");
		list.add("rtyr");
		list.add("mgf");
		list.add("jgh");
		list.add("mgf");
		sop("原集合：" + list);//打印集合。
		Collections.sort(list);//自帶的排序功能。
		sop("排序     ：" + list);
		Collections.sort(list, new strLen());//傳入比較器，按長度排序。
		sop("比較器：" + list);
	}
}
class strLen implements Comparator<String>{
	public int compare(String s1, String s2){
		if (s1.length() > s2.length())
			return 1;
		if (s1.length() < s2.length())
			return -1;
		return s1.compareTo(s2);
	}
}

運行結果如下圖所示：

11）Collections（Max）

/*
 * max(Collection<?> coll)：根據元素的自然順序，返回給定 collection 的最大元素。
 * max(Collection<?> coll, Comparator<? super T> comp)：根據指定比較器產生的順序，返回給定 collection 的最大元素。
 * min(Collection<?> coll)：根據元素的自然順序 返回給定 collection 的最小元素。
 * min(Collection<?> coll, Comparator<? super T> comp)：根據指定比較器產生的順序，返回給定 collection 的最小元素。
 * 
 */
import java.util.*;

public class Colls_MaxDemo {
	public static void sop(Object obj){
		System.out.println(obj);
	}
	public static void main(String[] args) {
		method_Max();
	}
	public static void method_Max(){
		List<String> list = new ArrayList<String>();
		list.add("af");
		list.add("fddf");
		list.add("rtyr");
		list.add("mgfvv");
		list.add("jgh");
		list.add("mgf");
		String max1 = Collections.max(list);
		sop("原集合：" + list);
		sop("（排序前）Max1： " + max1);
		Collections.sort(list, new strLen_max());//傳入比較器，按長度排序。
		sop("比較器：" + list);
		String max2 = Collections.max(list, new strLen_max());
		sop("（排序後）Max2： " + max2);//按字符串長度
	}
}
class strLen_max implements Comparator<String>{
	public int compare(String s1, String s2){
		if (s1.length() > s2.length())
			return 1;
		if (s1.length() < s2.length())
			return -1;
		return s1.compareTo(s2);
	}
}

運行結果如下圖所示：

12）Collections（binarySearch）

/*
 * int binarySearch(List<? extends Comparable<? super T>> list, T key)：
 * 			如果搜索鍵包含在列表中，則返回搜索鍵的索引；否則返回 (-(插入點) - 1)。
 */
public class Colls_binarySearchDemo {
	public static void sop(Object obj){
		System.out.println(obj);
	}
	public static void main(String[] args) {
		method_binarySearch();
	}
	public static void method_binarySearch(){
		List<String> list = new ArrayList<String>();
		list.add("aa");
		list.add("fddf");
		list.add("rtyr");
		list.add("mgfvv");
		list.add("jgh");
		list.add("mgf");
		Collections.sort(list);
		sop("list: " + list);
		int index1 = Collections.binarySearch(list, "aa");//獲取下標。
		sop("index1: " + index1);
		int index2 = Collections.binarySearch(list, "aaa");//如果集合中無需要查找的元素，返回 (-(插入點)-1)。
		sop("index2: " + index2);
	}
}
class strLen_binSea implements Comparator<String>{
	public int compare(String s1, String s2){
		if (s1.length() > s2.length())
			return 1;
		if (s1.length() < s2.length())
			return -1;
		return s1.compareTo(s2);
	}
}

運行結果如下圖所示：

13）Collections（替換反轉）

/*
 * void reverse(List<?> list)：反轉指定列表中元素的順序。
 * void replaceAll(List<T> list, T oldVal, T newVal)：使用另一個值替換列表中出現的所有某一指定值。
 * void swap(List<?> list, int i, int j)：在指定列表的指定位置處交換元素
 */
public class Colls_fillDemo {
	public static void sop(Object obj){
		System.out.println(obj);
	}
	public static void main(String[] args) {
		method_fill();
	}
	public static void method_fill(){
		List<String> list = new ArrayList<String>();
		list.add("aa");
		list.add("fddf");
		list.add("rtyr");
		list.add("mgfvv");
		list.add("jgh");
		list.add("jgh");
		list.add("jgh");
		list.add("1mgf");
		sop("原 = " + list);
		Collections.replaceAll(list, "jgh", "2haha");//替換指定的全部元素。
		sop("replaceAll = " + list);
		Collections.reverse(list);//反轉。
		sop("reverse = " + list);
		Collections.swap(list, 0, 1);//置換
		sop("swap = " + list);
		Collections.fill(list, "cc");//將集合中的元素全部替換。
		sop("fill = " + list);
	}
}

運行結果如下圖所示：

14）Collections（reverseOrder）

/*
 * void reverseOrder()：返回一個比較器，它強行逆轉實現了 Comparable 接口的對象 collection 的自然順序。
 */
public class Colls_reverseOrderDemo {
	public static void sop(Object obj){
		System.out.println(obj);
	}
	public static void main(String[] args) {
		method_revOder();
	}
	public static void method_revOder(){
		TreeSet<String> ts = new TreeSet<String>(Collections.reverseOrder());
		ts.add("a");
		ts.add("aa");
		ts.add("bb");
		ts.add("ccc");
		ts.add("ddd");
		for (Iterator<String> it = ts.iterator(); it.hasNext();){
			sop(it.next());
		}
	}
}

運行結果如下圖所示：

15）Collections（shuffle）

/*
 * void shuffle(List<?> list)：使用默認隨機源對指定列表進行置換。
 */
public class Colls_shuffleDemo {
	public static void sop(Object obj){
		System.out.println(obj);
	}
	public static void main(String[] args) {
		method_shuffle();
	}
	public static void method_shuffle(){
		List<String> list = new ArrayList<String>();
		list.add("a");
		list.add("aa");
		list.add("bb");
		list.add("ccc");
		list.add("ddd");
		sop("原： " + list);
		Collections.shuffle(list);//將集合中的運算隨機置換位置。
		sop("隨機： " + list);
	}
}

運行結果如下圖所示：

16）Arrays

/*
 * Arrays：用於操作數組的工具類。
 * asList(T... a)：將數組變成List集合。
 * int binarySearch(Object[] a, Object key)：使用二分搜索法來搜索指定數組，以獲得指定對象。
 * ?[] copyOfRange(?[] original, int from, int to)：將指定數組的指定範圍複製到一個新數組。
 * 						original：將要從其複製一個範圍的數組。
 * 【?】==【數據類型】		from：要複製的範圍的初始索引（包括）。
 * 						to：要複製的範圍的最後索引（不包括）。（此索引可以位於數組範圍之外）。 
 * 		包含取自原數組指定範圍的新數組，截取或用 0 填充以獲得所需長度 。
 * 
 * boolean equals(?[] a, ?[] a2)：如果兩個數組相等，則返回 true
 * boolean deepEquals(Object[] a1, Object[] a2)：如果兩個指定數組彼此是深層相等 的，則返回 true。
 * 
 * void sort(？[] a)：對指定的？型數組按數字升序進行排序。
 * void sort(？[] a, int fromIndex, int toIndex)：對指定？型數組的【指定範圍】按數字升序進行排序。
 * 
 * String toString(?[] a)：返回指定數組內容的字符串表示形式。
 */
public class ArraysDemo {
	public static void sop(Object obj){
		System.out.println(obj);
	}
	public static void main(String[] args) {
		method_toString();
	}
	public static void method_toString(){
		int[] arr = {1, 2, 3, 4, 5};
		sop("toString:" + Arrays.toString(arr));
		
		String[] str = {"aa", "bbb", "cc", "ddd", "ee"};
		/*
		 * 將數組變成集合的好處：可以使用集合的思想和方法來操作數組中的元素。
		 * 注意：將數組變成的集合，是不可以使用集合的增刪方法的。因爲數組的長度是固定的。
		 */
		List<String> list = Arrays.asList(str);
		sop("contains:" + list.contains("cc"));
//		list.add("abc");//不正確的操作異常：UnsupportedOperationException
		sop("<String>asList:" + list);
		
		/*
		 * 如果數組的元素都是對象，那麼變成集合時，數組中的元素就能直接轉換成集合中的元素。
		 * 如果都是基本數據類型，那麼將會直接將該數組作爲集合中的元素。
		 */
		Integer[] arr_int = {5, 4, 3, 2, 1};
		List<?> li = Arrays.asList(arr_int);
		sop("<Integer>asList:" + li);
	}
}

運行結果如下圖所示：

17）Collections（toArray）

/*
 * Object[] toArray()：包含此 collection 中所有元素的數組。
 * <T> T[] toArray(T[] a)：返回包含此 collection 中所有元素的數組；返回數組的運行時類型與指定數組的運行時類型相同。
 * 				注意：如果指定的數組能容納 collection，並有剩餘空間（即數組的元素比 collection 的元素多），
 * 						那麼會將數組中緊接 collection尾部的元素設置爲 null。
 */
public class Colls_toArrayDemo {
	public static void sop(Object obj){
		System.out.println(obj);
	}
	public static void main(String[] args) {
		method();
	}
	public static void method(){
		ArrayList<String> al = new ArrayList<String>();
		al.add("abc");
		al.add("bcde");
		al.add("cdefg");
		sop("al:\t\t" + al);
		
		/*
		 * 1：集合中的數組到底要定義多少長度呢？
		 * 當指定類型的數組長度小於了集合的size，那麼該方法內部會創建一個新的數組。長度爲集合的size。
		 * 當大於集合的size時，該方法就不會創建新的數組，而是使用傳遞進來的數組。
		 * 所以創建一個剛剛好長度的數組最優。
		 */
		String[] arr_size = al.toArray(new String[al.size()]);
		sop("arr_size:\t" + Arrays.toString(arr_size));
		String[] arr_zdy = al.toArray(new String[5]);//多出的元素地址將存放null。
		sop("arr_zdy:\t" + Arrays.toString(arr_zdy));
		
		/*
		 * 2：爲什麼要將集合變數組？
		 * 爲了限定對元素的操作。不需要用戶進行增刪操作。
		 */
	}
}

運行結果如下圖所示：

18）高級for循環

/*
 * 高級for循環。
 * 格式：
 * for (數據類型 變量名： 被遍歷的集合（）或者數組){
 * 		語句。
 * }
 * 對集合進行遍歷的侷限性：只能獲取元素，但不能對集合進行操作。
 * 而迭代器除了可以遍歷，還可以進行remove集合中元素的動作，能改變集合中的元素。
 * 如果使用ListIterator，還可以在遍歷過程中進行（增刪改查）的動作。
 * 
 * 傳統for循環與高級for循環的區別：
 * 		高級for有侷限性：必須有被遍歷的目標。
 * 建議：在遍歷數組的時候，還是希望使用傳統for循環。因爲傳統for循環可以
 */
public class ForeachDemo {
	public static void sop(Object obj){
		System.out.println(obj);
	}
	public static void main(String[] args) {
		method();
	}
	public static void method(){
		ArrayList<String> al = new ArrayList<String>();
		al.add("abc");
		al.add("bcde");
		al.add("cdefg");
		for (String s : al){
			sop("（原）?.next = " + s);//（1）打印
			s = "hah";//（2）修改
			sop("（改）?.next = " + s);//（3）打印（2）修改後的值。
		}
		sop("（原）al:" + al);//原集合。
		System.out.println("-------------------------");
		
		int[] arr = {3, 2, 1,};
		for (int i : arr){
			sop("i: " + i);
		}
		System.out.println("-------------------------");
		
		HashMap<Integer, String> hs = new HashMap<Integer, String>();
		hs.put(1, "a");
		hs.put(2, "b");
		hs.put(3, "c");
		for (Integer i: hs.keySet()){
			sop("keySet: " + i + "::" + hs.get(i));
		}
		for (Map.Entry<Integer, String> me: hs.entrySet()){
			sop("entrySet: " + me.getKey() + "----" + me.getValue());
		}
	}
}

運行結果如下圖所示：

19）可變參數。

/*
 * 方法的可變參數。
 * 例：method(int... arr);
 * 在使用時注意：可變參數一定要定義在參數列表的最後面。
 */
public class ParamMethodDemo {
	public static void sop(Object obj){
		System.out.println(obj);
	}
	public static void main(String[] args) {
		method();
	}
	private static void method(){
		/*
		 * 可變參數其實就是new數組的簡寫形式。
		 * 不用每一次都手動的建立數組對象，只要將要操作的元素作爲參數傳遞即可。
		 * 隱式的將這些參數封裝成了數組。
		 */
		String[] s = {"第一個字符串", "第二個字符串"};
		show(s, 1, 2, 4, 6);
		show(s, 1, 2, 5, 4, 6);
	}
	private static void show(String[] s, int... arr){
		sop("（字符串）s=" + s.length + "...（int型數組）=" + arr.length);
	}
}

運行結果如下圖所示：

20）靜態導入

/*
 * StaticImport：靜態導入
 * import static java.util.Arrays.*;//導入的是Arrays這個類中的所有靜態成員。
 * 當類名重名時，需要指定具體的包名。
 * 當方法重名時，要指定具體所屬的對象或者類。
 */
public class StaticImportDemo {
	public static void sop(Object obj){
		out.println(obj);
	}
	public static void main(String[] args) {
		method();
	}
	public static void method(){
		int[] arr = {3, 5, 6, 5};
		String[] str = {"a", "bb", "ccc"};
		sort(arr);//Arrays這個類的所以靜態成員已經被導入。
		sop("toString: " + Arrays.toString(arr));//當方法重名時，要指定具體所屬的對象或者類。
		sop("（arr）index: " + binarySearch(arr, 3));
		sort(str);
		sop("（str）index: " + binarySearch(str, "bb"));
	}
}

運行結果如下圖所示：

附言：我是Java新人，如有錯誤的地方請指出。

                              每天學習一點點，糾錯一點點，進步很大點。

-------  android培訓、java培訓、java學習型技術博客、期待與您交流！ ----------