java学习--集合框架（4）

10）Collections（Sort）

[java] view plain copy

1. /* 
2.  * sort(List<T> list)：根据元素的【自然顺序】 对指定列表按升序进行排序。 
3.  * sort(List<T> list, Comparator<? super T> c)：根据指定【比较器】产生的顺序对指定列表进行排序。 
4.  */  
5. public class Collections_SortDemo {  
6.     public static void sop(Object obj){  
7.         System.out.println(obj);  
8.     }  
9.     public static void main(String[] args) {  
10.         method_sort();  
11.     }  
12.     public static void method_sort(){  
13.         List<String> list = new ArrayList<String>();  
14.         list.add("af");  
15.         list.add("fddf");  
16.         list.add("rtyr");  
17.         list.add("mgf");  
18.         list.add("jgh");  
19.         list.add("mgf");  
20.         sop("原集合：" + list);//打印集合。  
21.         Collections.sort(list);//自带的排序功能。  
22.         sop("排序     ：" + list);  
23.         Collections.sort(list, new strLen());//传入比较器，按长度排序。  
24.         sop("比较器：" + list);  
25.     }  
26. }  
27. class strLen implements Comparator<String>{  
28.     public int compare(String s1, String s2){  
29.         if (s1.length() > s2.length())  
30.             return 1;  
31.         if (s1.length() < s2.length())  
32.             return -1;  
33.         return s1.compareTo(s2);  
34.     }  
35. }  

运行结果如下图所示：

11）Collections（Max）

[java] view plain copy

1. /* 
2.  * max(Collection<?> coll)：根据元素的自然顺序，返回给定 collection 的最大元素。 
3.  * max(Collection<?> coll, Comparator<? super T> comp)：根据指定比较器产生的顺序，返回给定 collection 的最大元素。 
4.  * min(Collection<?> coll)：根据元素的自然顺序 返回给定 collection 的最小元素。 
5.  * min(Collection<?> coll, Comparator<? super T> comp)：根据指定比较器产生的顺序，返回给定 collection 的最小元素。 
6.  *  
7.  */  
8. import java.util.*;  
9.   
10. public class Colls_MaxDemo {  
11.     public static void sop(Object obj){  
12.         System.out.println(obj);  
13.     }  
14.     public static void main(String[] args) {  
15.         method_Max();  
16.     }  
17.     public static void method_Max(){  
18.         List<String> list = new ArrayList<String>();  
19.         list.add("af");  
20.         list.add("fddf");  
21.         list.add("rtyr");  
22.         list.add("mgfvv");  
23.         list.add("jgh");  
24.         list.add("mgf");  
25.         String max1 = Collections.max(list);  
26.         sop("原集合：" + list);  
27.         sop("（排序前）Max1： " + max1);  
28.         Collections.sort(list, new strLen_max());//传入比较器，按长度排序。  
29.         sop("比较器：" + list);  
30.         String max2 = Collections.max(list, new strLen_max());  
31.         sop("（排序后）Max2： " + max2);//按字符串长度  
32.     }  
33. }  
34. class strLen_max implements Comparator<String>{  
35.     public int compare(String s1, String s2){  
36.         if (s1.length() > s2.length())  
37.             return 1;  
38.         if (s1.length() < s2.length())  
39.             return -1;  
40.         return s1.compareTo(s2);  
41.     }  
42. }  

运行结果如下图所示：

12）Collections（binarySearch）

[java] view plain copy

1. /* 
2.  * int binarySearch(List<? extends Comparable<? super T>> list, T key)： 
3.  *          如果搜索键包含在列表中，则返回搜索键的索引；否则返回 (-(插入点) - 1)。 
4.  */  
5. public class Colls_binarySearchDemo {  
6.     public static void sop(Object obj){  
7.         System.out.println(obj);  
8.     }  
9.     public static void main(String[] args) {  
10.         method_binarySearch();  
11.     }  
12.     public static void method_binarySearch(){  
13.         List<String> list = new ArrayList<String>();  
14.         list.add("aa");  
15.         list.add("fddf");  
16.         list.add("rtyr");  
17.         list.add("mgfvv");  
18.         list.add("jgh");  
19.         list.add("mgf");  
20.         Collections.sort(list);  
21.         sop("list: " + list);  
22.         int index1 = Collections.binarySearch(list, "aa");//获取下标。  
23.         sop("index1: " + index1);  
24.         int index2 = Collections.binarySearch(list, "aaa");//如果集合中无需要查找的元素，返回 (-(插入点)-1)。  
25.         sop("index2: " + index2);  
26.     }  
27. }  
28. class strLen_binSea implements Comparator<String>{  
29.     public int compare(String s1, String s2){  
30.         if (s1.length() > s2.length())  
31.             return 1;  
32.         if (s1.length() < s2.length())  
33.             return -1;  
34.         return s1.compareTo(s2);  
35.     }  
36. }  

运行结果如下图所示：

13）Collections（替换反转）

[java] view plain copy

1. /* 
2.  * void reverse(List<?> list)：反转指定列表中元素的顺序。 
3.  * void replaceAll(List<T> list, T oldVal, T newVal)：使用另一个值替换列表中出现的所有某一指定值。 
4.  * void swap(List<?> list, int i, int j)：在指定列表的指定位置处交换元素 
5.  */  
6. public class Colls_fillDemo {  
7.     public static void sop(Object obj){  
8.         System.out.println(obj);  
9.     }  
10.     public static void main(String[] args) {  
11.         method_fill();  
12.     }  
13.     public static void method_fill(){  
14.         List<String> list = new ArrayList<String>();  
15.         list.add("aa");  
16.         list.add("fddf");  
17.         list.add("rtyr");  
18.         list.add("mgfvv");  
19.         list.add("jgh");  
20.         list.add("jgh");  
21.         list.add("jgh");  
22.         list.add("1mgf");  
23.         sop("原 = " + list);  
24.         Collections.replaceAll(list, "jgh", "2haha");//替换指定的全部元素。  
25.         sop("replaceAll = " + list);  
26.         Collections.reverse(list);//反转。  
27.         sop("reverse = " + list);  
28.         Collections.swap(list, 0, 1);//置换  
29.         sop("swap = " + list);  
30.         Collections.fill(list, "cc");//将集合中的元素全部替换。  
31.         sop("fill = " + list);  
32.     }  
33. }  

运行结果如下图所示：

14）Collections（reverseOrder）

[java] view plain copy

1. /* 
2.  * void reverseOrder()：返回一个比较器，它强行逆转实现了 Comparable 接口的对象 collection 的自然顺序。 
3.  */  
4. public class Colls_reverseOrderDemo {  
5.     public static void sop(Object obj){  
6.         System.out.println(obj);  
7.     }  
8.     public static void main(String[] args) {  
9.         method_revOder();  
10.     }  
11.     public static void method_revOder(){  
12.         TreeSet<String> ts = new TreeSet<String>(Collections.reverseOrder());  
13.         ts.add("a");  
14.         ts.add("aa");  
15.         ts.add("bb");  
16.         ts.add("ccc");  
17.         ts.add("ddd");  
18.         for (Iterator<String> it = ts.iterator(); it.hasNext();){  
19.             sop(it.next());  
20.         }  
21.     }  
22. }  

运行结果如下图所示：

15）Collections（shuffle）

[java] view plain copy

1. /* 
2.  * void shuffle(List<?> list)：使用默认随机源对指定列表进行置换。 
3.  */  
4. public class Colls_shuffleDemo {  
5.     public static void sop(Object obj){  
6.         System.out.println(obj);  
7.     }  
8.     public static void main(String[] args) {  
9.         method_shuffle();  
10.     }  
11.     public static void method_shuffle(){  
12.         List<String> list = new ArrayList<String>();  
13.         list.add("a");  
14.         list.add("aa");  
15.         list.add("bb");  
16.         list.add("ccc");  
17.         list.add("ddd");  
18.         sop("原： " + list);  
19.         Collections.shuffle(list);//将集合中的运算随机置换位置。  
20.         sop("随机： " + list);  
21.     }  
22. }  

运行结果如下图所示：

16）Arrays

[java] view plain copy

1. /* 
2.  * Arrays：用于操作数组的工具类。 
3.  * asList(T... a)：将数组变成List集合。 
4.  * int binarySearch(Object[] a, Object key)：使用二分搜索法来搜索指定数组，以获得指定对象。 
5.  * ?[] copyOfRange(?[] original, int from, int to)：将指定数组的指定范围复制到一个新数组。 
6.  *                      original：将要从其复制一个范围的数组。 
7.  * 【?】==【数据类型】      from：要复制的范围的初始索引（包括）。 
8.  *                      to：要复制的范围的最后索引（不包括）。（此索引可以位于数组范围之外）。  
9.  *      包含取自原数组指定范围的新数组，截取或用 0 填充以获得所需长度 。 
10.  *  
11.  * boolean equals(?[] a, ?[] a2)：如果两个数组相等，则返回 true 
12.  * boolean deepEquals(Object[] a1, Object[] a2)：如果两个指定数组彼此是深层相等 的，则返回 true。 
13.  *  
14.  * void sort(？[] a)：对指定的？型数组按数字升序进行排序。 
15.  * void sort(？[] a, int fromIndex, int toIndex)：对指定？型数组的【指定范围】按数字升序进行排序。 
16.  *  
17.  * String toString(?[] a)：返回指定数组内容的字符串表示形式。 
18.  */  
19. public class ArraysDemo {  
20.     public static void sop(Object obj){  
21.         System.out.println(obj);  
22.     }  
23.     public static void main(String[] args) {  
24.         method_toString();  
25.     }  
26.     public static void method_toString(){  
27.         int[] arr = {1, 2, 3, 4, 5};  
28.         sop("toString:" + Arrays.toString(arr));  
29.           
30.         String[] str = {"aa", "bbb", "cc", "ddd", "ee"};  
31.         /* 
32.          * 将数组变成集合的好处：可以使用集合的思想和方法来操作数组中的元素。 
33.          * 注意：将数组变成的集合，是不可以使用集合的增删方法的。因为数组的长度是固定的。 
34.          */  
35.         List<String> list = Arrays.asList(str);  
36.         sop("contains:" + list.contains("cc"));  
37. //      list.add("abc");//不正确的操作异常：UnsupportedOperationException  
38.         sop("<String>asList:" + list);  
39.           
40.         /* 
41.          * 如果数组的元素都是对象，那么变成集合时，数组中的元素就能直接转换成集合中的元素。 
42.          * 如果都是基本数据类型，那么将会直接将该数组作为集合中的元素。 
43.          */  
44.         Integer[] arr_int = {5, 4, 3, 2, 1};  
45.         List<?> li = Arrays.asList(arr_int);  
46.         sop("<Integer>asList:" + li);  
47.     }  
48. }  

运行结果如下图所示：

17）Collections（toArray）

[java] view plain copy

1. /* 
2.  * Object[] toArray()：包含此 collection 中所有元素的数组。 
3.  * <T> T[] toArray(T[] a)：返回包含此 collection 中所有元素的数组；返回数组的运行时类型与指定数组的运行时类型相同。 
4.  *              注意：如果指定的数组能容纳 collection，并有剩余空间（即数组的元素比 collection 的元素多）， 
5.  *                      那么会将数组中紧接 collection尾部的元素设置为 null。 
6.  */  
7. public class Colls_toArrayDemo {  
8.     public static void sop(Object obj){  
9.         System.out.println(obj);  
10.     }  
11.     public static void main(String[] args) {  
12.         method();  
13.     }  
14.     public static void method(){  
15.         ArrayList<String> al = new ArrayList<String>();  
16.         al.add("abc");  
17.         al.add("bcde");  
18.         al.add("cdefg");  
19.         sop("al:\t\t" + al);  
20.           
21.         /* 
22.          * 1：集合中的数组到底要定义多少长度呢？ 
23.          * 当指定类型的数组长度小于了集合的size，那么该方法内部会创建一个新的数组。长度为集合的size。 
24.          * 当大于集合的size时，该方法就不会创建新的数组，而是使用传递进来的数组。 
25.          * 所以创建一个刚刚好长度的数组最优。 
26.          */  
27.         String[] arr_size = al.toArray(new String[al.size()]);  
28.         sop("arr_size:\t" + Arrays.toString(arr_size));  
29.         String[] arr_zdy = al.toArray(new String[5]);//多出的元素地址将存放null。  
30.         sop("arr_zdy:\t" + Arrays.toString(arr_zdy));  
31.           
32.         /* 
33.          * 2：为什么要将集合变数组？ 
34.          * 为了限定对元素的操作。不需要用户进行增删操作。 
35.          */  
36.     }  
37. }  

运行结果如下图所示：

18）高级for循环

[java] view plain copy

1. /* 
2.  * 高级for循环。 
3.  * 格式： 
4.  * for (数据类型 变量名： 被遍历的集合（）或者数组){ 
5.  *      语句。 
6.  * } 
7.  * 对集合进行遍历的局限性：只能获取元素，但不能对集合进行操作。 
8.  * 而迭代器除了可以遍历，还可以进行remove集合中元素的动作，能改变集合中的元素。 
9.  * 如果使用ListIterator，还可以在遍历过程中进行（增删改查）的动作。 
10.  *  
11.  * 传统for循环与高级for循环的区别： 
12.  *      高级for有局限性：必须有被遍历的目标。 
13.  * 建议：在遍历数组的时候，还是希望使用传统for循环。因为传统for循环可以 
14.  */  
15. public class ForeachDemo {  
16.     public static void sop(Object obj){  
17.         System.out.println(obj);  
18.     }  
19.     public static void main(String[] args) {  
20.         method();  
21.     }  
22.     public static void method(){  
23.         ArrayList<String> al = new ArrayList<String>();  
24.         al.add("abc");  
25.         al.add("bcde");  
26.         al.add("cdefg");  
27.         for (String s : al){  
28.             sop("（原）?.next = " + s);//（1）打印  
29.             s = "hah";//（2）修改  
30.             sop("（改）?.next = " + s);//（3）打印（2）修改后的值。  
31.         }  
32.         sop("（原）al:" + al);//原集合。  
33.         System.out.println("-------------------------");  
34.           
35.         int[] arr = {3, 2, 1,};  
36.         for (int i : arr){  
37.             sop("i: " + i);  
38.         }  
39.         System.out.println("-------------------------");  
40.           
41.         HashMap<Integer, String> hs = new HashMap<Integer, String>();  
42.         hs.put(1, "a");  
43.         hs.put(2, "b");  
44.         hs.put(3, "c");  
45.         for (Integer i: hs.keySet()){  
46.             sop("keySet: " + i + "::" + hs.get(i));  
47.         }  
48.         for (Map.Entry<Integer, String> me: hs.entrySet()){  
49.             sop("entrySet: " + me.getKey() + "----" + me.getValue());  
50.         }  
51.     }  
52. }  

运行结果如下图所示：

19）可变参数。

[java] view plain copy

1. /* 
2.  * 方法的可变参数。 
3.  * 例：method(int... arr); 
4.  * 在使用时注意：可变参数一定要定义在参数列表的最后面。 
5.  */  
6. public class ParamMethodDemo {  
7.     public static void sop(Object obj){  
8.         System.out.println(obj);  
9.     }  
10.     public static void main(String[] args) {  
11.         method();  
12.     }  
13.     private static void method(){  
14.         /* 
15.          * 可变参数其实就是new数组的简写形式。 
16.          * 不用每一次都手动的建立数组对象，只要将要操作的元素作为参数传递即可。 
17.          * 隐式的将这些参数封装成了数组。 
18.          */  
19.         String[] s = {"第一个字符串", "第二个字符串"};  
20.         show(s, 1, 2, 4, 6);  
21.         show(s, 1, 2, 5, 4, 6);  
22.     }  
23.     private static void show(String[] s, int... arr){  
24.         sop("（字符串）s=" + s.length + "...（int型数组）=" + arr.length);  
25.     }  
26. }  

运行结果如下图所示：

20）静态导入

[java] view plain copy

1. /* 
2.  * StaticImport：静态导入 
3.  * import static java.util.Arrays.*;//导入的是Arrays这个类中的所有静态成员。 
4.  * 当类名重名时，需要指定具体的包名。 
5.  * 当方法重名时，要指定具体所属的对象或者类。 
6.  */  
7. public class StaticImportDemo {  
8.     public static void sop(Object obj){  
9.         out.println(obj);  
10.     }  
11.     public static void main(String[] args) {  
12.         method();  
13.     }  
14.     public static void method(){  
15.         int[] arr = {3, 5, 6, 5};  
16.         String[] str = {"a", "bb", "ccc"};  
17.         sort(arr);//Arrays这个类的所以静态成员已经被导入。  
18.         sop("toString: " + Arrays.toString(arr));//当方法重名时，要指定具体所属的对象或者类。  
19.         sop("（arr）index: " + binarySearch(arr, 3));  
20.         sort(str);  
21.         sop("（str）index: " + binarySearch(str, "bb"));  
22.     }  
23. }  

运行结果如下图所示：