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"));//truesop(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);}}