Java基础视频教程第17天_Collections、Arrays、1.5新特性

十、集合 —— Collections-sort 

	1、 Collections(集合框架工具类) 中的方法都是静态的，不能创建对象。

	2、 List 集合可以不用保证唯一，但是不能排序。 Set 集合刚好相反。 
		当需要一个集合既不需要元素唯一，但又需要对集合中的元素进行排序时，就需要使用 Collections 了。
		Collections 就是专门对集合进行操作的工具类。 

	3、排序一: 
		static <T extends Comparable<? super T>> void sort(List<T> list)；使用该方法时，集合内的元素必须具备比较性。
			<T extends Comparable<? super T>>表示该泛型 T 必须具备比较性，也就是Comparable的子类；
			Comparable<? super T>表示 T 在实现Comparable时，定义的泛型可以是 T 或者 T的父类。
		代码：
			Collections.sort(list);

	4、排序二：
		当集合中的元素不具备比较性，或者具备的比较性不是所需要的时，可定义一个比较器：
		static <T> void sort(List<T> list, Comparator<? super T> c);

	5、代码：
	import java.util.*;
	class CollectionsDemo 
	{
		public static void main(String[] args) 
		{
			sortDemo();
		}
		public static void sortDemo()
		{
			List<String> list = new ArrayList<String>();

			list.add("abcd");
			list.add("aaa");
			list.add("z");
			list.add("kkkkk");
			list.add("qq");
			list.add("zz");

			sop(list);//[abcd, aaa, z, kkkkk, qq, zz]

			Collections.sort(list,new StrLenComparator());
			sop(list);//[z, qq, zz, aaa, abcd, kkkkk]

			/*
			当不传入比较器时：
			Collections.sort(list);
			sop(list);
			结果：[aaa, abcd, kkkkk, qq, z, zz]
			*/
		}
		public static void sop(Object obj)
		{
			System.out.println(obj);
		}
	}

	class StrLenComparator implements Comparator<String>
	{
		public int compare(String s1, String s2)
		{
			int num = s1.length()-s2.length();
			if(num==0)
				return s1.compareTo(s2);
			return num;
		}
	}
十一、集合 —— Collections-max 
	1、根据集合中元素的自然顺序求最大元素：
		static <T extends Object & Comparable<? super T>> T max(Collection<? extends T> coll);

		代码：
			String max = Collections.max(list);
		用该方法求最大元素时，该元素自身必须具备比较性。

	2、根据比较器产生的顺序，返回集合中的最大元素：
		static <T> T max(Collection<? extends T> coll, Comparator<? super T> comp);

	3、求最大值——功能代码示例：
		public static void maxDemo()
		{
			List<String> list = new ArrayList<String>();
			list.add("abcd");
			list.add("aaa");
			list.add("zz");
			list.add("kkkkk");
			list.add("qq");
			list.add("z");

			Collections.sort(list);
			sop(list);//[aaa, abcd, kkkkk, qq, z, zz]

			String max = Collections.max(list);
			sop("max="+max);//max=zz
		}
	4、求最小元素方法min()同理。

十二、集合 —— Collections-binarySearch 
	=====注意：在进行二分查找前，请先用sort方法排序

	1、对集合进行二分查找：
		static <T> int binarySearch(List<? extends Comparable<? super T>> list, T key);

		代码示例：
		int index = Collections.binarySearch(list,"aaa");

		注意：
			如果查找的元素不存在，则返回(-(插入点) - 1)：
			该方法查找时，该集合中的元素自身必须具备比较性。

	2、如果元素自身不具备比较性，则传入一个比较器：
		static <T> int binarySearch(List<? extends T> list, T key, Comparator<? super T> c);

	3、查找——功能代码：
	public static void binarySearchDemo()
	{
		List<String> list = new ArrayList<String>();

		list.add("abcd");
		list.add("aaa");
		list.add("z");
		list.add("kkkkk");
		list.add("qq");
		list.add("zz");

		Collections.sort(list,new StrLenComparator());
		sop(list);//[z, qq, zz, aaa, abcd, kkkkk]

		int index = Collections.binarySearch(list,"qq",new StrLenComparator());
		sop("index="+index);//index=1
	}
十三、集合 —— Collections - 替换、反转 
	1、替换全部元素
		static <T> void fill(List<? super> list, T obj);使用指定元素obj替换指定列表中的所有元素。
		功能代码：
		public static void fillDemo()
		{
			List<String> list = new ArrayList<String>();

			list.add("abcd");
			list.add("aaa");
			list.add("z");
			list.add("kkkkk");

			sop(list);
			Collections.fill(list,"pp");
			sop(list);//[pp, pp, pp, pp]
		}
	2、替换部分元素
		static <T> boolean replaceAll(List<T> list, T oldVal, T newVal);使用另一个值替换列表中出现的所有某一指定值。
		功能代码：
		public static void replaceAllDemo()
		{
			List<String> list = new ArrayList<String>();

			list.add("abcd");
			list.add("aaa");
			list.add("zz");
			list.add("kkkkk");

			sop(list);

			sop(Collections.replaceAll(list,"aaa","bbb"));//true
			sop(list);//[abcd, bbb, zz, kkkkk]
		}
	3、反转
		static void reverse(List<list>);反转指定列表中元素的顺序。
		功能代码：
		public static void reverseDemo()
		{
			List<String> list = new ArrayList<String>();

			list.add("abcd");
			list.add("aaa");
			list.add("zz");
			list.add("kkkkk");

			sop(list);//[abcd, aaa, zz, kkkkk]
			Collections.reverse(list);
			sop(list);//[kkkkk, zz, aaa, abcd]
		}
十四、集合 —— Collections-reverseOrder 
	1、reverseOrder——逆转自然顺序
		static <T> Comparator<T> reverseOrder();返回一个比较器，它强行逆转了实现 Comparable 接口的对象 collection 的自然顺序。
		注意：他返回的是一个比较器。

		功能代码：
		public static void orderDemo()
		{
			TreeSet<String> ts = new TreeSet<String>(Collections.reverseOrder());//该处调用方法

			ts.add("abcde");
			ts.add("aaa");
			ts.add("k");
			ts.add("cc");

			sop(ts);//[k, cc, abcde, aaa]
		}
	2、reverseOrder——逆转比较器顺序
		static <T> Comparator<T> reverseOrder(Comparator<T> cmp);返回一个比较器，它强行逆转指定比较器的顺序。
		功能代码示例：
		public static void orderDemo()
		{
			//TreeSet<String> ts = new TreeSet<String>(Collections.reverseOrder());//该处调用方法
			TreeSet<String> ts = new TreeSet<String>(Collections.reverseOrder(new StrLenComparator()));

			ts.add("abcd");
			ts.add("aaa");
			ts.add("zz");
			ts.add("kkkkk");
			ts.add("qq");
			ts.add("z");

			sop(ts);//[kkkkk, abcd, aaa, zz, qq, z]
		}
十五、集合 —— Collections-SynchronizedList
	(1)线程同步
		static <T> List<T> synchronizedList(List<T> list);返回指定列表支持的同步（线程安全的）列表。
		也就是说：给我一个线程不同步的集合，我返回一个线程同步的集合。
		代码：略

	(2)集合中，元素位置置换 
		static void swap(List<?> list, int i, int j);在指定列表的指定位置处交换元素。
		功能代码：
		public static void swapDemo()
		{
			List<String> list = new ArrayList<String>();

			list.add("abcd");
			list.add("aaa");
			list.add("zz");
			list.add("kkkkk");
			

			sop(list);//[abcd, aaa, zz, kkkkk]

			Collections.swap(list,1,3);
			sop(list);//[abcd, kkkkk, zz, aaa]
		}
	(3)集合中，元素位置随机排列(使用默认随机源)
		static void shuffle(List<?> list);使用默认随机源对指定列表进行置换。
		功能代码：
		public static void shuffleDemo()
		{
			List<String> list = new ArrayList<String>();

			list.add("abcd");
			list.add("aaa");
			list.add("zz");
			list.add("kkkkk");
			list.add("z");
			list.add("qq");
			
			Collections.sort(list);
			sop(list);//[aaa, abcd, kkkkk, qq, z, zz]

			Collections.shuffle(list);
			sop(list);//每次出现的顺序都不一样。
		}
	(4)集合中，元素位置随机排列(使用指定随机源)
		static void shuffle(List<?> list, Random rnd);使用指定的随机源对指定列表进行置换。 
		代码：略

十六、集合 —— Arrays  
	Arrays: 用于操作数组的工具类，其内部都是静态方法。 

	1、常见方法：
		(1)二分查找：
		static int binarySearch(int[] arr, int key);
		
		(2)其他常见方法
		copyOf();复制数组
		copyOfRange();复制数组
		equals();比较是否相等
		fill();填充
		sort();排序
		toString();转为字符串

	重点掌握:
		static <T> List<T> asList(T... a);
			将数组变成集合；

	代码：
	import java.util.*;
	class ArraysDemo 
	{
		public static void main(String[] args) 
		{
			//int[] arr = {2,4,6};
			//System.out.println(Arrays.toString(arr));//[2,4,6]

			String[] arr = {"abc","cc","kkkk"};

			List<String> list = Arrays.asList(arr);

			System.out.println("contains: "+list.contains("cc"));
		}
	}
	好处：
	可以使用集合的思想和方法来操作数组中的元素。

	注意：
		将数组变成集合，不可以使用集合的增删方法。因为数组的长度是固定的。否则会发生 UnsupportedOperationException 不支持操作异常。

	可用方法有：
		contains();
		get();
		indexOf();
		subList();

	如果数组中的元素都是对象，那么变成集合时，数组中的元素就直接转成集合中的元素。
	如果数组中的元素都是基本数据类型，会将该数组作为集合中的元素存在。

	示例一：
		int[] nums = {2,4,5};
		List<int[]> list = Arrays.asList(nums);
		sop(list);//打印的是内存地址值

	示例二：
		Integer[] nums = {2,4,5};
		List<Integer> list = Arrays.asList(nums);
		sop(list);//[2, 4, 5]

十七、集合——集合转成数组 
	Collection 接口中的有两个重载的 toArray()方法;

	1、 Object[] toArray()
		返回包含此 collection 中所有元素的数组。 
	2、 <T> T[] toArray(T[] a) 
		返回包含此 collection 中所有元素的数组；返回数组的运行时类型与指定数组的运行时类型相同。 

	3、指定类型的数组到底要定义多长呢？
	当指定类型的数组长度小于了集合的size，那么该方法内部会创建一个新的数组。长度为集合的size。
	当指定类型的数组长度大于了集合的size，就不会新创建了数组。而是使用传递进来的数组。集合长度小于数组长度时，空白处用null补充。
	所以创建一个刚刚好的数组最优。

	4、为什么要将集合变数组？
	为了限定对元素的操作。如：禁止增删了。

	代码示例：
	import java.util.*;
	class Demo
	{
		public static void main(String[] args)
		{
			ArrayList<String> al = new ArrayList<String>();
			al.add("abc1");
			al.add("abc2");
			al.add("abc3");

			String[] arr = al.toArray(new String[al.size()]);

			System.out.println(Arrays.toString(arr));//[abc1, abc2, abc3]
		}
	}
十八、集合——增强for循环 
	高级for循环是JDK1.5版本后出现的新特性
	格式：
	for(数据类型 变量名: 被遍历的集合(Collection)或者数组)
	{  }
	对集合进行遍历，只能获取元素，不能对集合进行操作。

	传统for循环和高级for循环有什么区别？
	高级for有一个局限性，必须有被遍历的目标。也就是说被遍历的是一个集合或者数组。

	代码：
	import java.util.*;
	class ForEachDemo 
	{
		public static void main(String[] args) 
		{
			forEachDemo();
		}

		public static void forEachDemo()
		{
			ArrayList<String> al = new ArrayList<String>();

			al.add("abc1");
			al.add("abc2");
			al.add("abc3");

			for(String s : al)
			{
				s = "kk"; 
				System.out.println(s);//kk  kk  kk
			}//高级for循环只能取出，不能修改。
			System.out.println(al);//[abc1, abc2, abc3]

			int[] arr = {2,5,7};
			for(int i : arr)
			{
				System.out.println(i);//2  5  7 
			}
		}
	}
十九、集合——可变参数
	Java1.5增加了新特性：可变参数：适用于参数个数不确定，类型确定的情况，java把可变参数当做数组处理。
	注意：
		(1)可变参数必须位于最后一项。
		(2)当可变参数个数多余一个时，必将有一个不是最后一项，所以只支持有一个可变参数。
		(3)因为参数个数不定，所以当其后边还有相同类型参数时，java无法区分传入的参数属于前一个可变参数还是后边的参数，所以只能让可变参数位于最后一项。

	可变参数的特点：
		(1) 只能出现在参数列表的最后； 
		(2) ...位于变量类型和变量名之间，前后有无空格都可以；
		(3) 调用可变参数的方法时，编译器为该可变参数隐含创建一个数组，在方法体中会以数组的形式访问可变参数。

	例如：
		public static void show(int... arr, String str)//编译错误
		public static void show(String str, int... arr)//OK

	代码：
	class ParamMethodDemo 
	{
		public static void main(String[] args) 
		{
			//method();
			show(2,5,6,7);
			show();//结果为sum=0
		}

		//JDK1.5版本后出现的新特性：可变参数
		public static void show(int... arr)//自动封装成数组。
		{
			System.out.println("arr.length="+arr.length);
			int sum = 0;
			for (int x=0 ;x<arr.length ;x++ )
			{
				sum = arr[x] + sum;
			}
			System.out.println("sum="+sum);
		}

		//1.5版本以前使用的方法，该方法需要自己创建数组
		public static void method()
		{
			int[] arr = {3,4};
			show_1(arr);

			int[] arr1 = {5,6,8};
			show_1(arr1);
		}
		public static void show_1(int[] arr)
		{
			int sum = 0;
			for (int x=0 ;x<arr.length ;x++ )
			{
				sum = arr[x] + sum;
			}
			System.out.println("sum="+sum);
		}
	}
二十、集合——静态导入 
	静态导入也是JDK5.0引入的新特性。
	在入包时写上代码: import java.util.*; java.util包中的类就都导入到了该代码文件中；
	那么在该代码文件中使用该包中的任意类时，就不需要写包名，而是直接写类名即可。
	静态导入和导入包也是一样的效果：
		当一个类中有很多静态方法时，调用这些方法直接用 包名.类名.方法 调用；
		那么也可以使用导入包的方法，导入一个类；
		例如：
			import static java.util.Arrays.*;
			那么在该代码文件中，使用Arrays类中的静态方法时，就不需要写类名，而是直接写方法名即可。

	静态导入注意事项：
		1、代码格式: import static java.xxx.xxx.*; 需要加static
		2、当一个类中有两个或者两个以上同名方法时，不要在方法名上加上类名.

	代码示例：
	import java.util.*;//导入类

	import static java.util.Arrays.*;//导入Arrays类中的所有成员

	import static java.lang.System.*;//导入System类中的所有成员

	class StaticImport 
	{
		public static void main(String[] args) 
		{
			//method();
			show();
		}

		//静态导入
		public static void show()
		{
			int[] arr = {3,1,5};

			sort(arr);
			int index = binarySearch(arr,5);

			out.println(Arrays.toString(arr));//toString()方法与本类中的方法重名，所有需指定方法所属的对象或者类。

			out.println(new StaticImport().toString());//Object中的toString方法没有参数。

			System.out.println("index="+index);
		}

		//非静态导入
		public static void method()
		{
			int[] arr = {3,1,5,9};

			Arrays.sort(arr);
			int index = Arrays.binarySearch(arr,5);

			System.out.println(Arrays.toString(arr));
			System.out.println("index="+index);
		}
	}