Java基础之集合框架(四)--Collections、Arrays、增强for循环、可变参数、静态导入

[java]  view plain copy

1. 集合框架的工具类。  
2. Collections:集合框架的工具类。里面定义的都是静态方法。  
3.   
4. Collections和Collection有什么区别？  
5. Collection是集合框架中的一个顶层接口，它里面定义了单列集合的共性方法。  
6.         它有两个常用的子接口，  
7.         List：对元素都有定义索引。有序的。可以重复元素。  
8.         Set：不可以重复元素。无序。  
9.   
10. Collections是集合框架中的一个工具类。该类中的方法都是静态的  
11.         提供的方法中有可以对list集合进行排序，二分查找等方法。  
12.         通常常用的集合都是线程不安全的。因为要提高效率。  
13.         如果多线程操作这些集合时，可以通过该工具类中的同步方法，将线程不安全的集合，转换成安全的。  
14.   
15. */  
16. import java.util.*;  
17. class  CollectionsDemo  
18. {  
19.     public static void main(String[] args)   
20.     {  
21.         sortDemo();  
22.   
23.     }  
24.   
25.   
26.   
27.     public static void binarySearchDemo()  
28.     {  
29.         List<String> list = new ArrayList<String>();  
30.   
31.         list.add("abcd");  
32.         list.add("aaa");  
33.         list.add("zz");  
34.         list.add("kkkkk");  
35.         list.add("qq");  
36.         list.add("z");  
37.         Collections.sort(list,new StrLenComparator());  
38.   
39.         sop(list);  
40.   
41.         //int index = Collections.binarySearch(list,"aaaa");  
42.         //int index = halfSearch(list,"cc");  
43.         int index = halfSearch2(list,"aaaa",new StrLenComparator());  
44.         sop("index="+index);  
45.     }  
46.   
47.     public static int halfSearch(List<String> list,String key)  
48.     {  
49.         int max,min,mid;  
50.         max = list.size()-1;  
51.         min = 0;  
52.   
53.         while(min<=max)  
54.         {  
55.             mid = (max+min)>>1;//  /2;  
56.   
57.             String str = list.get(mid);  
58.   
59.             int num = str.compareTo(key);  
60.             if(num>0)  
61.                 max = mid -1;  
62.             else if(num<0)  
63.                 min = mid + 1;  
64.             else  
65.                 return mid;  
66.         }  
67.         return -min-1;  
68.     }  
69.   
70.     public static int halfSearch2(List<String> list,String key,Comparator<String> cmp)  
71.     {  
72.         int max,min,mid;  
73.         max = list.size()-1;  
74.         min = 0;  
75.   
76.         while(min<=max)  
77.         {  
78.             mid = (max+min)>>1;//  /2;  
79.   
80.             String str = list.get(mid);  
81.   
82.             int num = cmp.compare(str,key);  
83.             if(num>0)  
84.                 max = mid -1;  
85.             else if(num<0)  
86.                 min = mid + 1;  
87.             else  
88.                 return mid;  
89.         }  
90.         return -min-1;  
91.     }  
92.   
93.     public static void maxDemo()  
94.     {  
95.         List<String> list = new ArrayList<String>();  
96.   
97.         list.add("abcd");  
98.         list.add("aaa");  
99.         list.add("zz");  
100.         list.add("kkkkk");  
101.         list.add("qq");  
102.         list.add("z");  
103.         Collections.sort(list);  
104.         sop(list);  
105.         String max = Collections.max(list/*,new StrLenComparator()*/);  
106.         sop("max="+max);  
107.     }  
108.   
109.     public static void sortDemo()  
110.     {  
111.         List<String> list = new ArrayList<String>();  
112.   
113.         list.add("abcd");  
114.         list.add("aaa");  
115.         list.add("zz");  
116.         list.add("kkkkk");  
117.         list.add("qq");  
118.         list.add("z");  
119.           
120.         sop(list);  
121.   
122.         //Collections.sort(list);  
123.         Collections.sort(list,new StrLenComparator());  
124.         //Collections.swap(list,1,2);  
125.         sop(list);  
126.           
127.     }  
128.   
129.     public static void sop(Object obj)  
130.     {  
131.         System.out.println(obj);  
132.     }  
133. }  
134.   
135.   
136. class StrLenComparator implements Comparator<String>  
137. {  
138.     public int compare(String s1,String s2)  
139.     {  
140.         if(s1.length()>s2.length())  
141.             return 1;  
142.         if(s1.length()<s2.length())  
143.             return -1;  
144.         return s1.compareTo(s2);  
145.     }  
146. }  
147. /* 
148. class Student 
149. { 
150. } 
151. list.add(new Student()); 
152.  
153. public static <T extends Comparable<? super T>> void sort(List<T> list) 
154. { 
155.      
156. } 
157. */  

[java]  view plain copy

1. import java.util.*;  
2.   
3. class StrComparator implements Comparator<String>  
4. {  
5.     public int compare(String s1,String s2)  
6.     {  
7.         /* 
8.         int num = s1.compareTo(s2); 
9.         if(num>0) 
10.             return -1; 
11.         if( num<0) 
12.             return 1; 
13.         return num; 
14.         */  
15.   
16.         return s2.compareTo(s1);  
17.     }  
18. }  
19.   
20. class StrLenComparator implements Comparator<String>  
21. {  
22.     public int compare(String s1,String s2)  
23.     {  
24.         if(s1.length()>s2.length())  
25.             return 1;  
26.         if(s1.length()<s2.length())  
27.             return -1;  
28.         return s1.compareTo(s2);  
29.     }  
30. }  
31. class CollectionsDemo2   
32. {  
33.     public static void main(String[] args)   
34.     {  
35.         shuffleDemo();  
36.     }  
37.     public static void shuffleDemo()  
38.     {  
39.         List<String> list = new ArrayList<String>();  
40.   
41.         list.add("abcd");  
42.         list.add("aaa");  
43.         list.add("zz");  
44.         list.add("kkkkk");  
45.         list.add("qq");  
46.         list.add("z");  
47.   
48.         sop(list);  
49.         Collections.shuffle(list);  
50.         sop(list);  
51.     }  
52.     public static void orderDemo()  
53.     {  
54.         TreeSet<String> ts = new TreeSet<String>(Collections.reverseOrder(new StrLenComparator()));  
55.   
56.         ts.add("abcde");  
57.         ts.add("aaa");  
58.         ts.add("k");  
59.         ts.add("cc");  
60.   
61.         Iterator it = ts.iterator();  
62.         while(it.hasNext())  
63.         {  
64.             System.out.println(it.next());  
65.         }  
66.     }  
67.   
68.   
69.     public static void replaceAllDemo()  
70.     {  
71.   
72.   
73.         List<String> list = new ArrayList<String>();  
74.   
75.         list.add("abcd");  
76.         list.add("aaa");  
77.         list.add("zz");  
78.         list.add("kkkkk");  
79.   
80.         sop(list);  
81.   
82.         Collections.replaceAll(list,"aaa","pp");  
83.   
84.         sop(list);  
85.         Collections.reverse(list);  
86.   
87.         sop(list);  
88.     }  
89.   
90.   
91.     /* 
92.     练习。fill方法可以将list集合中所有元素替换成指定元素。 
93.     ，将list集合中部分元素替换成指定元素。 
94.  
95.     */  
96.     public static void fillDemo()  
97.     {  
98.         List<String> list = new ArrayList<String>();  
99.   
100.         list.add("abcd");  
101.         list.add("aaa");  
102.         list.add("zz");  
103.         list.add("kkkkk");  
104.           
105.         sop(list);  
106.         Collections.fill(list,"pp");  
107.         sop(list);  
108.   
109.     }  
110.     public static void sop(Object obj)  
111.     {  
112.         System.out.println(obj);  
113.     }  
114. }  

[java]  view plain copy

1. /* 
2. 集合变数组。 
3. Collection接口中的toArray方法。 
4.  
5.  
6. */  
7. import java.util.*;  
8. class  CollectionToArray  
9. {  
10.     public static void main(String[] args)   
11.     {  
12.         ArrayList<String> al = new ArrayList<String>();  
13.   
14.         al.add("abc1");  
15.         al.add("abc2");  
16.         al.add("abc3");  
17.           
18.         /* 
19.         1,指定类型的数组到底要定义多长呢？ 
20.         当指定类型的数组长度小于了集合的size，那么该方法内部会创建一个新的数组。长度为集合的size。 
21.         当指定类型的数组长度大于了集合的size，就不会新创建了数组。而是使用传递进来的数组。 
22.         所以创建一个刚刚好的数组最优。 
23.          
24.  
25.         2,为什么要将集合变数组？ 
26.         为了限定对元素的操作。不需要进行增删了。 
27.  
28.         */  
29.   
30.         String[] arr = al.toArray(new String[al.size()]);  
31.   
32.         System.out.println(Arrays.toString(arr));  
33.   
34.   
35.   
36.     }  
37. }  

Arrays类：

[java]  view plain copy

1. /* 
2. Arrays:用于操作数组的工具类。 
3. 里面都是静态方法。 
4.  
5.  
6. asList:将数组变成list集合 
7. */  
8.   
9. import java.util.*;  
10. class  ArraysDemo  
11. {  
12.     public static void main(String[] args)   
13.     {  
14. //      int[] arr = {2,4,5};  
15. //  
16. //      System.out.println(Arrays.toString(arr));  
17.   
18.   
19.   
20.         String[] arr = {"abc","cc","kkkk"};  
21.   
22.   
23.         //把数组变成list集合有什么好处？  
24.         /* 
25.         可以使用集合的思想和方法来操作数组中的元素。 
26.  
27.         注意：将数组变成集合，不可以使用集合的增删方法。 
28.         因为数组的长度是固定。 
29.         contains。 
30.         get 
31.         indexOf() 
32.         subList(); 
33.  
34.         如果你增删。那么会反生UnsupportedOperationException, 
35.  
36.         */  
37.         List<String> list = Arrays.asList(arr);  
38.         //sop("contains:"+list.contains("cc"));  
39.         //list.add("qq");//UnsupportedOperationException,  
40.   
41.         //sop(list);  
42.   
43.         //int[] nums = {2,4,5};  
44.         Integer[] nums = {2,4,5};  
45.   
46.           
47.         List<Integer> li = Arrays.asList(nums);  
48.   
49.   
50.   
51.         /* 
52.         如果数组中的元素都是对象。那么变成集合时，数组中的元素就直接转成集合中的元素。 
53.         如果数组中的元素都是基本数据类型，那么会将该数组作为集合中的元素存在。 
54.         */  
55.         sop(li);  
56.   
57.   
58.   
59.     }  
60.     public static boolean myContains(String[] arr,String key)  
61.     {  
62.         for(int x=0;x<arr.length; x++)  
63.         {  
64.             if(arr[x].equals(key))  
65.                 return true;  
66.         }  
67.         return false;  
68.     }  
69.       
70.     public static void sop(Object obj)  
71.     {  
72.         System.out.println(obj);  
73.     }  
74.   
75. }  

增强for循环：

[java]  view plain copy

1. /* 
2. 高级for循环 
3.  
4. 格式： 
5. for(数据类型 变量名 : 被遍历的集合(Collection)或者数组) 
6. { 
7.      
8. } 
9.  
10. 对集合进行遍历。 
11. 只能获取集合元素。但是不能对集合进行操作。 
12.  
13. 迭代器除了遍历，还可以进行remove集合中元素的动作。 
14. 如果是用ListIterator，还可以在遍历过程中对集合进行增删改查的动作。 
15.  
16. 传统for和高级for有什么区别呢？ 
17.  
18. 高级for有一个局限性。必须有被遍历的目标。 
19.  
20. 建议在遍历数组的时候，还是希望是用传统for。因为传统for可以定义脚标。 
21.  
22.  
23. */  
24.   
25. import java.util.*;  
26.   
27. class ForEachDemo   
28. {  
29.     public static void main(String[] args)   
30.     {  
31.   
32.           
33.         ArrayList<String> al = new ArrayList<String>();  
34.   
35.         al.add("abc1");  
36.         al.add("abc2");  
37.         al.add("abc3");  
38.   
39.   
40.         for(String s : al)  
41.         {  
42.             //s = "kk";  
43.             System.out.println(s);  
44.         }  
45.   
46.         System.out.println(al);  
47.         /* 
48.         Iterator<String> it = al.iterator(); 
49.  
50.         while(it.hasNext()) 
51.         { 
52.             System.out.println(it.next()); 
53.         } 
54.         */  
55.   
56.         int[] arr = {3,5,1};  
57.   
58.         for(int x=0; x<arr.length; x++)  
59.         {  
60.             System.out.println(arr[x]);  
61.         }  
62.         for(int i : arr)  
63.         {  
64.             System.out.println("i:"+i);  
65.         }  
66.   
67.   
68.         HashMap<Integer,String> hm = new HashMap<Integer,String>();  
69.   
70.         hm.put(1,"a");  
71.         hm.put(2,"b");  
72.         hm.put(3,"c");  
73.   
74.         Set<Integer> keySet = hm.keySet();  
75.         for(Integer i : keySet)  
76.         {  
77.             System.out.println(i+"::"+hm.get(i));  
78.         }  
79.   
80. //      Set<Map.Entry<Integer,String>> entrySet = hm.entrySet();  
81. //      for(Map.Entry<Integer,String> me : entrySet)  
82.   
83.         for(Map.Entry<Integer,String> me : hm.entrySet())  
84.         {  
85.             System.out.println(me.getKey()+"------"+me.getValue());  
86.         }  
87.   
88.     }  
89. }  

可 变参数：

[java]  view plain copy

1. /* 
2. JDK1.5版本出现的新特性。 
3.  
4. 方法的可变参数。 
5. 在使用时注意：可变参数一定要定义在参数列表最后面。 
6.  
7. */  
8.   
9. class  ParamMethodDemo  
10. {  
11.     public static void main(String[] args)   
12.     {  
13.         //show(3,4);  
14.         /* 
15.         //虽然少定义了多个方法。 
16.         但是每次都要定义一个数组。作为实际参数。 
17.  
18.         int[] arr = {3,4}; 
19.         show(arr); 
20.  
21.         int[] arr1 = {2,3,4,5}; 
22.         show(arr1); 
23.         */  
24.   
25.         /* 
26.         可变参数。 
27.         其实就是上一种数组参数的简写形式。 
28.         不用每一次都手动的建立数组对象。 
29.         只要将要操作的元素作为参数传递即可。 
30.         隐式将这些参数封装成了数组。 
31.  
32.         */  
33.         show("haha",2,3,4,5,6);  
34.         //show(2,3,4,5,6,4,2,35,9,"heh");  
35.         //show();  
36.   
37.     }  
38.     public static void show(String str,int... arr)  
39.     {  
40.         System.out.println(arr.length);  
41.     }  
42.     /* 
43.     public static void show(int[] arr) 
44.     { 
45.          
46.     } 
47.     */  
48.     /* 
49.     public static  void show(int a,int b) 
50.     { 
51.         System.out.println(a+","+b); 
52.     } 
53.     public static  void show(int a,int b,int c) 
54.     {} 
55.     */  
56. }  

静态导入：

[java]  view plain copy

1. /* 
2. StaticImport  静态导入。 
3.  
4. 当类名重名时，需要指定具体的包名。 
5. 当方法重名是，指定具备所属的对象或者类。 
6. */  
7.   
8. import java.util.*;  
9. import static  java.util.Arrays.*;//导入的是Arrays这个类中的所有静态成员。  
10. import static java.util.Collections.*;  
11. /* 
12. packa/Demo.class  
13. packb/Demo.class 
14.  
15. import packa.*; 
16. import packb.*; 
17. */  
18.   
19. import static  java.lang.System.*;//导入了System类中所有静态成员。  
20.   
21. class  StaticImport //extends Object  
22. {  
23.     public static void main(String[] args)   
24.     {  
25.   
26.         out.println("haha");  
27.         int[] arr = {3,1,5};  
28.   
29.         sort(arr);  
30.         int index = binarySearch(arr,1);  
31.         out.println(Arrays.toString(arr));  
32.         System.out.println("Index="+index);  
33.   
34.         ArrayList al = new ArrayList();  
35.         al.add(1);  
36.         al.add(3);  
37.         al.add(2);  
38.   
39.         out.println(al);  
40.   
41.         sort(al);  
42.         out.println(al);  
43.     }  
44. }