【黑马程序员】集合框架（四）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学习型技术博客、期待与您交流！ ----------