黑马程序员——集合（二） .

黑马程序员--集合（二）

------Java培训、Android培训、iOS培训、.Net培训、期待与您交流！ -------

一、泛型

1、定义
泛型（generic）：一般的。JDK1.5版本以后出现的新特性。用于解决安全问题，是一个类型安全机制。
格式：通过<>来定义要操作的引用数据类型。<>就是用来接收类型的。

PS:
由来：借鉴数组的定义和操作。
JDK1.5之前定义Object来完成扩展（存在强制问题），现在定义泛型来完成扩展。
2、好处：
2.1 将运行时期出现问题,转移到了编译时期。方便于程序员解决问题，让运行时期问题减少，安全。
2.2 避免了强制转换麻烦。

一般方法：

[java] view plaincopyprint?

1. import java.util.*;  
2. class GenericDemo1  
3. {  
4.     public static void main(String[] args)  
5.     {  
6.         ArrayList al = new ArrayList();  
7.   
8.         al.add("abc01");  
9.         al.add("abc0234");  
10.         al.add("abc012");  
11.   
12.         //同时存入字符串和数字时，存在类型转换异常。   
13.         al.add(4);  
14.   
15.         for(Iterator it = al.iterator();it.hasNext();)  
16.         {  
17.             //向下转型。使用自定义内容。   
18.             String s = (String)it.next();  
19.             System.out.println(s+".."+s.length());  
20.         }  
21.     }  
22. }  

import java.util.*;class GenericDemo1{public static void main(String[] args){ArrayList al = new ArrayList();al.add("abc01");al.add("abc0234");al.add("abc012");//同时存入字符串和数字时，存在类型转换异常。al.add(4);for(Iterator it = al.iterator();it.hasNext();){//向下转型。使用自定义内容。String s = (String)it.next();System.out.println(s+".."+s.length());}}}

运行结果：

泛型方法：

[java] view plaincopyprint?

1. import java.util.*;  
2. class GenericDemo  
3. {  
4.     public static void main(String[] args)  
5.     {  
6.         /* 
7.         在集合定义时就定义数据类型，这样就把不同类型的数据区分开，防止类型转换异常。 
8.         这样的做法借鉴了数组格式。有利于将运行时期出现问题，转移到编译时期。 
9.         */  
10.         ArrayList<String> al = new ArrayList<String>();  
11.   
12.         al.add("abc01");  
13.         al.add("abc0234");  
14.         al.add("abc012");  
15.   
16.         //同时存入字符串和数字时，存在类型转换异常。   
17.         al.add(4);//al.add(new Integer(4));  
18.   
19.         //指定迭代器类型，避免强转问题。   
20.         for(Iterator<String> it = al.iterator();it.hasNext();)  
21.         {  
22.             String s = it.next();  
23.   
24.             System.out.println(s+".."+s.length());  
25.         }  
26.     }  
27. }  

import java.util.*;class GenericDemo{public static void main(String[] args){/*在集合定义时就定义数据类型，这样就把不同类型的数据区分开，防止类型转换异常。这样的做法借鉴了数组格式。有利于将运行时期出现问题，转移到编译时期。*/ArrayList<String> al = new ArrayList<String>();al.add("abc01");al.add("abc0234");al.add("abc012");//同时存入字符串和数字时，存在类型转换异常。al.add(4);//al.add(new Integer(4));//指定迭代器类型，避免强转问题。for(Iterator<String> it = al.iterator();it.hasNext();){String s = it.next();System.out.println(s+".."+s.length());}}}

运行结果：

3、应用：
3.1 定义在集合框架中。通常在集合框架中很常见。只要见到<>就要定义泛型。
3.2 定义在接口上
3.3 定义在类中。当类中要操作的引用数据类型不确定的时候（注意：基本数据不确定无法自定义）。
3.3.1 泛型类存在局限性。因为方法接收的对象类型依据是对象定义的类型，所以一旦对象定义好类型，
方法接收的对象类型也将被固定。
3.3.2 泛型定义在方法上：可操作不同数据类型。它可以避免泛型类的局限性。
格式：放在返回值类型前、修饰符后。
3.3.3 静态方法不可以访问类上定义的泛型。因为它优先于对象加载。
如果静态方法操作的应用数据类型不确定，可以将泛型定义在方法上。

[java] view plaincopyprint?

1. //泛型类。适用于当类中要操作的引用数据类型不确定的时候（注意：基本数据不确定无法自定义）。  
2. class Demo<T>   
3. {  
4.     public void show(T t)  
5.     {  
6.         System.out.println("show:"+t);  
7.     }  
8.     //方法上定义泛型：可操作不同数据类型。   
9.     public <Q> void print(Q q)  
10.     {  
11.         System.out.println("print:"+q);  
12.     }  
13.     //将泛型定义在静态方法上   
14.     public static <W> void method(W t)  
15.     {  
16.         System.out.println("method:"+t);  
17.     }  
18. }  
19. class GenericDemo2  
20. {  
21.     public static void main(String[] args)  
22.     {  
23.         Demo<Integer> d = new Demo<Integer>();  
24.         //泛型类的局限性   
25.         //d.show("hah");   
26.         d.show(4);  
27.   
28.         d.print("hehe");  
29.         d.print(4);  
30.       
31.         //调用静态方法   
32.         Demo.method("dhdh");  
33.     }  
34. }  

//泛型类。适用于当类中要操作的引用数据类型不确定的时候（注意：基本数据不确定无法自定义）。class Demo<T> {public void show(T t){System.out.println("show:"+t);}//方法上定义泛型：可操作不同数据类型。public <Q> void print(Q q){System.out.println("print:"+q);}//将泛型定义在静态方法上public static <W> void method(W t){System.out.println("method:"+t);}}class GenericDemo2{public static void main(String[] args){Demo<Integer> d = new Demo<Integer>();//泛型类的局限性//d.show("hah");d.show(4);d.print("hehe");d.print(4);//调用静态方法Demo.method("dhdh");}}

运行结果：

3.4 ? 通配符。可理解为占位符。它用于定义泛型未明确的类型。
3.4.1泛型的高级应用
泛型限定 作用：用于功能扩展。
？ extends E：可接收E类型或E的子类型。 上限。
？ super E:可接收E类型或E的父类型。 下限。

[java] view plaincopyprint?

1. //泛型限定   
2. import java.util.*;  
3. class Person  
4. {  
5.     private String name;  
6.     Person(String name)  
7.     {  
8.         this.name = name;  
9.     }  
10.     public String getName()  
11.     {  
12.         return name;  
13.     }  
14. }   
15. class Student extends Person  
16. {  
17.     Student(String name)  
18.     {  
19.         super(name);  
20.     }      
21. }  
22. //泛型下限应用，扩展了数据类型   
23. class Comp implements Comparator<Person>//<? super E>  
24. {  
25.     public int compare(Person s1,Person s2)  
26.     {  
27.         return s1.getName().compareTo(s2.getName());  
28.     }  
29. }  
30. class GenericDemo3  
31. {  
32.     public static void main(String[] args)  
33.     {  
34.         ArrayList<Person> al = new ArrayList<Person>();  
35.   
36.         al.add(new Person("abc1"));  
37.         al.add(new Person("abc2"));  
38.         al.add(new Person("abc3"));  
39.   
40.         //printColl(al);   
41.   
42.         ArrayList<Student> al1 = new ArrayList<Student>();  
43.   
44.         al1.add(new Student("abc---1"));  
45.         al1.add(new Student("abc---2"));  
46.         al1.add(new Student("abc---3"));  
47.   
48.         printColl(al1);   
49.   
50.         TreeSet<Student> ts = new TreeSet<Student>(new Comp());  
51.         ts.add(new Student("abc1"));  
52.         ts.add(new Student("abc2"));  
53.         ts.add(new Student("abc3"));  
54.   
55.         //下限-->只接受Student及其父类。  
56.         for(Iterator<? super Student> it = ts.iterator();it.hasNext();)  
57.         {  
58.             System.out.println(it.next());  
59.         }  
60.     }  
61.     //上限-->只接受Person及其子类。   
62.     public static void printColl(ArrayList<? extends Person> al)  
63.     {  
64.         for(Iterator<? extends Person> it = al.iterator();it.hasNext();)  
65.         {  
66.             System.out.println(it.next().getName());  
67.         }  
68.     }  
69. }  

//泛型限定import java.util.*;class Person{private String name;Person(String name){this.name = name;}public String getName(){return name;}} class Student extends Person{Student(String name){super(name);} }//泛型下限应用，扩展了数据类型class Comp implements Comparator<Person>//<? super E>{public int compare(Person s1,Person s2){return s1.getName().compareTo(s2.getName());}}class GenericDemo3{public static void main(String[] args){ArrayList<Person> al = new ArrayList<Person>();al.add(new Person("abc1"));al.add(new Person("abc2"));al.add(new Person("abc3"));//printColl(al);ArrayList<Student> al1 = new ArrayList<Student>();al1.add(new Student("abc---1"));al1.add(new Student("abc---2"));al1.add(new Student("abc---3"));printColl(al1); TreeSet<Student> ts = new TreeSet<Student>(new Comp());ts.add(new Student("abc1"));ts.add(new Student("abc2"));ts.add(new Student("abc3"));//下限-->只接受Student及其父类。for(Iterator<? super Student> it = ts.iterator();it.hasNext();){System.out.println(it.next());}}//上限-->只接受Person及其子类。public static void printColl(ArrayList<? extends Person> al){for(Iterator<? extends Person> it = al.iterator();it.hasNext();){System.out.println(it.next().getName());}}}

运行结果:

二、Map集合

1、Map集合：双列集合，该集合存储键值对。必须保证键的唯一性。Collection单列集合，一次添加一个元素。
2、常用方法：
2.1 添加
value put(key,value):返回前一个和key关联的值，如果没有返回null。
putAll(Map<? extends K,? extends V> m)
2.2 删除
void clear()：清空集合。
value remove(Object key)：根据指定的key删除这个键值对。
2.3 判断
boolean containsValue(Object value);
boolean containsKey(Object key);
boolean isEmpty();
2.4 获取
value get(Object key)：通过获取值，如果没有该键返回null。
int size()：获取键值对个数。

Collection<> Values():返回键值对值。

[java] view plaincopyprint?

1. //Map集合常见用法：   
2. import java.util.*;  
3. class MapDemo  
4. {  
5.     public static void main(String[] args)  
6.     {  
7.         Map<String,String> map = new HashMap<String,String>();  
8.   
9.         //put()返回值为V,add()返回值为boolean。添加相同的键时，后添加的值会覆盖并返回  
10.   
11. 原有键对应值。  
12.         sop("put:"+map.put("01","dou"));  
13.         sop("put:"+map.put("01","bi"));  
14.         map.put("02","ni");  
15.         map.put("03","zhen");  
16.         map.put("04","dour");  
17.           
18.         //删除   
19.         sop("remove:"+map.remove("01"));  
20.         sop("map:"+map);  
21.   
22.         //判读键是否存在   
23.         sop("containsKey:"+map.containsKey("022"));  
24.         //判读值是否存在   
25.         sop("containsValue:"+map.containsValue("ni"));  
26.   
27.         //获取键对应的值   
28.         sop("get:"+map.get("02"));  
29.   
30.         //可通过get方法的返回值判断键是否存在。一次取一个值。   
31.         map.put("0192",null);  
32.         sop("get:"+map.get("0192"));          
33.           
34.         //获取map集合中所有的值。   
35.         Collection<String> coll = map.values();  
36.   
37.         sop(coll);  
38.         sop("map:"+map);  
39.     }  
40.     public static void sop(Object obj)  
41.     {  
42.         System.out.println(obj);  
43.     }  
44. }  

//Map集合常见用法：import java.util.*;class MapDemo{public static void main(String[] args){Map<String,String> map = new HashMap<String,String>();//put()返回值为V,add()返回值为boolean。添加相同的键时，后添加的值会覆盖并返回原有键对应值。sop("put:"+map.put("01","dou"));sop("put:"+map.put("01","bi"));map.put("02","ni");map.put("03","zhen");map.put("04","dour");//删除sop("remove:"+map.remove("01"));sop("map:"+map);//判读键是否存在sop("containsKey:"+map.containsKey("022"));//判读值是否存在sop("containsValue:"+map.containsValue("ni"));//获取键对应的值sop("get:"+map.get("02"));//可通过get方法的返回值判断键是否存在。一次取一个值。map.put("0192",null);sop("get:"+map.get("0192"));//获取map集合中所有的值。Collection<String> coll = map.values();sop(coll);sop("map:"+map);}public static void sop(Object obj){System.out.println(obj);}}

运行结果：

Map集合的两种取出方式：
Set<K> keySet:将Map中所有的键存入到Set集合。一次可取出多个值。
Set<Map.Entry<k,v>> entrySet:将Map集合中的映射关系存入到set集合中，而这个关系的数据类型就是：Map.Entry。
Entry是Map接口的一个内部接口。

[java] view plaincopyprint?

1. /* 
2. 每一个学生都有对应的归属地。 
3. 学生Student,地址String. 
4. 学生属性：姓名，年龄。 
5. 注意：姓名和年龄相同的视为同一个学生。 
6. 保证学生的唯一性。 
7.  
8. 思路： 
9. 1. 描述学生。//描述事物时，系统默认比较哈希地址值。所以要注意按元素自身条件判断唯一性。 
10.         //具体做法：复写hashCode、equals方法。 
11.         //同时需要注意数据排序，这可以方便数据多时的整理。 
12.     总结：数据多时，必须做：实现、覆盖两方法。 
13. 2. 定义map容器。将学生作为键，地址作为值存入。 
14. 3. 获取map集合中的元素。 
15. */  
16. import java.util.*;  
17. //同时创建多个对象备用时，实现和复写必须要进行。   
18. class Student implements Comparable<Student>  
19. {  
20.     private String name;  
21.     private int age;  
22.     Student(String name,int age)  
23.     {  
24.         this.name = name;  
25.         this.age = age;  
26.     }  
27.     public int compareTo(Student s)  
28.     {  
29.         int num = new Integer(this.age).compareTo(new Integer(s.age));  
30.   
31.         if(num==0)  
32.             return this.name.compareTo(s.name);  
33.         return num;  
34.     }  
35.   
36.     public int hashCode()  
37.     {  
38.         return name.hashCode()+age*23;  
39.     }  
40.     public boolean equals(Object obj)  
41.     {  
42.         if(!(obj instanceof Student))  
43.             throw new ClassCastException("类型不匹配");  
44.   
45.         Student s = (Student)obj;  
46.   
47.         return this.name.equals(s.name) && this.age == s.age;  
48.     }  
49.     public String getName()  
50.     {  
51.         return name;  
52.     }  
53.     public int getAge()  
54.     {  
55.         return age;  
56.     }  
57.     public String toString()  
58.     {  
59.         return name+":"+age;  
60.     }  
61. }  
62. class MapTest  
63. {  
64.     public static void main(String[] args)  
65.     {  
66.         HashMap<Student,String> hm = new HashMap<Student,String>();  
67.   
68.         hm.put(new Student("lisi1",21),"beijing");  
69.         hm.put(new Student("lisi2",22),"nanjing");  
70.         hm.put(new Student("lisi3",23),"tianjin");  
71.         hm.put(new Student("lisi4",24),"shanghai");  
72.   
73.         //第一种取出方式 keySet       
74.         Set<Student> keySet = hm.keySet();  
75.   
76.         for(Iterator<Student> it = keySet.iterator();it.hasNext();)  
77.         {  
78.             Student stu = it.next();  
79.             String addr = hm.get(stu);  
80.             System.out.println("学生信息："+stu+",地址"+addr);  
81.         }  
82.   
83.         //第二种取出方式 entrySet   
84.         Set<Map.Entry<Student,String>> entrySet = hm.entrySet();  
85.   
86.         for(Iterator<Map.Entry<Student,String>> it = entrySet.iterator();it.hasNext();)  
87.         {  
88.             Map.Entry<Student,String> me = it.next();  
89.             Student stu = me.getKey();  
90.             String addr = me.getValue();  
91.             System.out.println(stu+"........"+addr);  
92.         }  
93.     }  
94. }  

/*每一个学生都有对应的归属地。学生Student,地址String.学生属性：姓名，年龄。注意：姓名和年龄相同的视为同一个学生。保证学生的唯一性。思路：1. 描述学生。//描述事物时，系统默认比较哈希地址值。所以要注意按元素自身条件判断唯一性。//具体做法：复写hashCode、equals方法。//同时需要注意数据排序，这可以方便数据多时的整理。总结：数据多时，必须做：实现、覆盖两方法。2. 定义map容器。将学生作为键，地址作为值存入。3. 获取map集合中的元素。*/import java.util.*;//同时创建多个对象备用时，实现和复写必须要进行。class Student implements Comparable<Student>{private String name;private int age;Student(String name,int age){this.name = name;this.age = age;}public int compareTo(Student s){int num = new Integer(this.age).compareTo(new Integer(s.age));if(num==0)return this.name.compareTo(s.name);return num;}public int hashCode(){return name.hashCode()+age*23;}public boolean equals(Object obj){if(!(obj instanceof Student))throw new ClassCastException("类型不匹配");Student s = (Student)obj;return this.name.equals(s.name) && this.age == s.age;}public String getName(){return name;}public int getAge(){return age;}public String toString(){return name+":"+age;}}class MapTest{public static void main(String[] args){HashMap<Student,String> hm = new HashMap<Student,String>();hm.put(new Student("lisi1",21),"beijing");hm.put(new Student("lisi2",22),"nanjing");hm.put(new Student("lisi3",23),"tianjin");hm.put(new Student("lisi4",24),"shanghai");//第一种取出方式 keySetSet<Student> keySet = hm.keySet();for(Iterator<Student> it = keySet.iterator();it.hasNext();){Student stu = it.next();String addr = hm.get(stu);System.out.println("学生信息："+stu+",地址"+addr);}//第二种取出方式 entrySetSet<Map.Entry<Student,String>> entrySet = hm.entrySet();for(Iterator<Map.Entry<Student,String>> it = entrySet.iterator();it.hasNext();){Map.Entry<Student,String> me = it.next();Student stu = me.getKey();String addr = me.getValue();System.out.println(stu+"........"+addr);}}}

运行结果：

PS：
1、Map和Set很像，因为Set底层使用了Map集合。
2、Map集合的取出原理：将Map集合转成set集合，再通过迭代器取出。

三、工具类

1、Collections类
Collections: 是集合框架的工具类，它的方法都是静态的。无对外提供构造函数，不需要封装对象。
sort(List<?> list):根据元素的自然顺序 对指定列表按升序进行排序。
max():获取对象中最大元素。 
binarySearch():二分搜索法。必须是有序集合。包含索引键，返回索引；不含，返回“插入点-1”。
replaceAll(List<T> list,T oldVal,T newVal)：使用另一个值替换列表中出现的所有某一指定值。
swap(List<?> list,i,j)：在指定列表的指定位置处交换元素。
shuffle(List<?> list)：随机重置元素位置。
reverse(List<?> list)：反转指定列表中元素的顺序。

fill(List<? super T> list,T obj)：使用指定元素替换指定列表中的所有元素。

[java] view plaincopyprint?

1. //Collections: 集合工具类   
2. import java.util.*;  
3. class CollectionsDemo  
4. {  
5.     public static void main(String[] args)  
6.     {  
7.         collsDemo();  
8.     }  
9.     public static void collsDemo()  
10.     {  
11.         List<String> list = new ArrayList<String>();  
12.   
13.         list.add("adss");  
14.         list.add("sdfd");  
15.         list.add("sfd");  
16.         list.add("cc");  
17.         list.add("w");  
18.         list.add("sfd");  
19.   
20.         sop(list);  
21.   
22.         //1、sort 接收自定义比较器，按长度比较。只能给List排序。  
23.         Collections.sort(list,new StrLenComparator());  
24.         sop("sort1:"+list);  
25.         //自然排序   
26.         Collections.sort(list);  
27.         sop("sort2:"+list);  
28.   
29.         //2、max 获取最大元素   
30.         String max = Collections.max(list);   
31.         sop("max="+max);  
32.   
33.         //3、binarySearch 二分查找，必须是自然排序  
34.         int index = Collections.binarySearch(list,"cc");  
35.         sop("index="+index);  
36.   
37.         //4、replaceAll 替换指定元素。等效于list.set(index,"pp");  
38.         Collections.replaceAll(list,"cc","pp");  
39.         sop("replaceAll:"+list);  
40.   
41.         //5、swap 置换指定位置元素   
42.         Collections.swap(list,1,2);  
43.         sop("swap:"+list);  
44.   
45.         //6、shuffle 随机排序（验证码）   
46.         Collections.shuffle(list);  
47.         sop("shuffle:"+list);  
48.   
49.         //7、reverse 反转   
50.         Collections.reverse(list);  
51.         sop("reverse:"+list);  
52.   
53.         //8、fill 把集合中值全换成pp。   
54.         Collections.fill(list,"pp");  
55.         sop("fill:"+list);  
56.     }  
57.     public static void sop(Object obj)  
58.     {  
59.         System.out.println(obj);  
60.     }  
61. }  
62. //自定义比较器   
63. class StrLenComparator implements Comparator<String>  
64. {  
65.     public int compare(String s1,String s2)  
66.     {  
67.         if(s1.length()>s2.length())  
68.             return 1;  
69.         if(s1.length()<s2.length())  
70.             return -1;  
71.         return s1.compareTo(s2);  
72.     }  
73. }  

//Collections: 集合工具类import java.util.*;class CollectionsDemo{public static void main(String[] args){collsDemo();}public static void collsDemo(){List<String> list = new ArrayList<String>();list.add("adss");list.add("sdfd");list.add("sfd");list.add("cc");list.add("w");list.add("sfd");sop(list);//1、sort 接收自定义比较器，按长度比较。只能给List排序。Collections.sort(list,new StrLenComparator());sop("sort1:"+list);//自然排序Collections.sort(list);sop("sort2:"+list);//2、max 获取最大元素String max = Collections.max(list);sop("max="+max);//3、binarySearch 二分查找，必须是自然排序int index = Collections.binarySearch(list,"cc");sop("index="+index);//4、replaceAll 替换指定元素。等效于list.set(index,"pp");Collections.replaceAll(list,"cc","pp");sop("replaceAll:"+list);//5、swap 置换指定位置元素Collections.swap(list,1,2);sop("swap:"+list);//6、shuffle 随机排序（验证码）Collections.shuffle(list);sop("shuffle:"+list);//7、reverse 反转Collections.reverse(list);sop("reverse:"+list);//8、fill 把集合中值全换成pp。Collections.fill(list,"pp");sop("fill:"+list);}public static void sop(Object obj){System.out.println(obj);}}//自定义比较器class StrLenComparator 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);}}

运行结果：

PS:
SynchronizedList(List<T> list)：返回指定列表支持的同步（线程安全的）列表。存在线程不安全问题是集合的共同特点。
2、Arrays类
Arrays:用于操作数组的工具类。里面都是静态方法。
equals()：比较两个数组中内容是否相同。
deepEquals():比较两个数组及其内部内容是否相同。
2.1 List asList:将数组变成list集合。
优点：可以使用集合的思想和方法来操作数组中的元素，更加便捷。
缺点：集合不可以增删数组内容，因为数组的长度固定。否则发生UnsupportedOperationException。
如果数组中的元素都是对象，那么变成集合时，"数组中的元素"就直接转成集合中的元素。
如果数组中的元素都是基本数据类型，那么会将"该数组"作为集合中的元素存在。
2.2 集合变数组
操作：使用Collection接口中的toArray方法。可对集合中的元素操作的方法进行限定，不允许对其增删。
指定类型的数组到底要定义多长？
如果长度小于集合的size，那么该方法内部会创建一个新的数组。
如果长度大于集合的size，就不会创建一个新的数组。使用传递进来的数组，其他位置默认为null。
所以创建一个刚刚好的数组内存处置最优。

[java] view plaincopyprint?

1. //Arrays:用于操作数组的工具类。   
2. import java.util.*;  
3. class ArraysDemo  
4. {  
5.     public static void main(String[] args)  
6.     {  
7.         int[] arr1 = {2,4,5};  
8.   
9.         System.out.println(Arrays.toString(arr1));  
10.   
11.         String[] arr2 = {"abc","cc","kkkk"};  
12.   
13.         List<String> list = Arrays.asList(arr2);  
14.         sop("contains:"+list.contains("cc"));  
15.         //注意打印的是list，不是arr.   
16.         sop(list);  
17.   
18.         //将数组中的对象转成集合   
19.         Integer[] nums1 = {2,4,5};  
20.         List<Integer> list1 = Arrays.asList(nums1);  
21.         sop("数组对象："+list1);  
22.   
23.         //基本数据类型转成集合   
24.         int[] nums2 = {2,4,5};  
25.         List<int[]> list2 =Arrays.asList(nums2);  
26.         sop("基本数据类型："+list2);  
27.           
28.         List<String> list3 = new ArrayList<String>();  
29.         list3.add("abc1");  
30.         list3.add("abc2");  
31.         list3.add("abc3");  
32.   
33.         //集合转数组   
34.         String[] arr = list3.toArray(new String[2]);  
35.         sop(Arrays.toString(arr));  
36.     }  
37.     public static void sop(Object obj)  
38.     {  
39.         System.out.println(obj);  
40.     }  
41. }  

//Arrays:用于操作数组的工具类。import java.util.*;class ArraysDemo{public static void main(String[] args){int[] arr1 = {2,4,5};System.out.println(Arrays.toString(arr1));String[] arr2 = {"abc","cc","kkkk"};List<String> list = Arrays.asList(arr2);sop("contains:"+list.contains("cc"));//注意打印的是list，不是arr.sop(list);//将数组中的对象转成集合Integer[] nums1 = {2,4,5};List<Integer> list1 = Arrays.asList(nums1);sop("数组对象："+list1);//基本数据类型转成集合int[] nums2 = {2,4,5};List<int[]> list2 =Arrays.asList(nums2);sop("基本数据类型："+list2);List<String> list3 = new ArrayList<String>();list3.add("abc1");list3.add("abc2");list3.add("abc3");//集合转数组String[] arr = list3.toArray(new String[2]);sop(Arrays.toString(arr));}public static void sop(Object obj){System.out.println(obj);}}

运行结果：

3、System类

System类中的方法和属性都是静态的。out:标准输出，默认是控制台。in:标准输入，默认是键盘。
常见方法：
long currentTimeMillis():获取当前时间的毫秒值。作用：检测程序的执行时间。
Properties getProperties()：获取系统属性信息。Properties集合中存储的都是String类型的键和值。
最好使用它自己的存储和取出的方法来完成元素的操作。
Windows系统中换行为\r\n两个转义字符，Linux只有一个\n。

[java] view plaincopyprint?

1. //System:类中的方法和属性都是静态的。   
2. import java.util.*;  
3. class SystemDemo  
4. {  
5.     public static void main(String[] args)  
6.     {  
7.         long l1 = System.currentTimeMillis();  
8.         sop("计时开始："+l1);  
9.         Properties prop = System.getProperties();  
10.   
11.         //因为Properties是Hashtable的子类，也就是Map集合的一个子类对象。  
12.         //那么可以通过map的方法取出该集合中的元素。   
13.         //该集合中存储都是字符串，没有泛型定义。   
14.   
15.         //获取指定属性信息   
16.         String value = System.getProperty("os.name");  
17.         sop("value="+value);  
18.   
19.         sop("转义字符\r\n:"+"hello-\r\n world");  
20.         //定义跨系统信息   
21.         final String LINE_SEPARATOR = System.getProperty("line.separator");  
22.         sop("hello"+LINE_SEPARATOR+"java");  
23.   
24.         long l2 = System.currentTimeMillis();  
25.         sop("共用时："+(l2-l1));      
26.     }  
27.     public static void sop(Object obj)  
28.     {  
29.         System.out.println(obj);  
30.     }  
31. }  

//System:类中的方法和属性都是静态的。import java.util.*;class SystemDemo{public static void main(String[] args){long l1 = System.currentTimeMillis();sop("计时开始："+l1);Properties prop = System.getProperties();//因为Properties是Hashtable的子类，也就是Map集合的一个子类对象。//那么可以通过map的方法取出该集合中的元素。//该集合中存储都是字符串，没有泛型定义。//获取指定属性信息String value = System.getProperty("os.name");sop("value="+value);sop("转义字符\r\n:"+"hello-\r\n world");//定义跨系统信息final String LINE_SEPARATOR = System.getProperty("line.separator");sop("hello"+LINE_SEPARATOR+"java");long l2 = System.currentTimeMillis();sop("共用时："+(l2-l1));}public static void sop(Object obj){System.out.println(obj);}}

运行结果：

4、Runtime类

每个Java应用程序都有一个Runtime类实例，使应用程序能和其运行的环境相连接。应用程序不能创建自己的Runtime类实例。
该类并没有提供构造函数。说明不可以创建对象。那么该类中的方法应该都是静态的。但发现该类中还有非静态方法。
说明该类肯定会提供静态方法获取本类对象。而且只有一个，说明该类使用了单例设计模式。
static Runtime  getRuntime()：获取Runtime类。

[java] view plaincopyprint?

1. //Runtime对象        
2. class RuntimeDemo  
3. {  
4.     public static void main(String[] args) throws Exception  
5.     {  
6.         Runtime r = Runtime.getRuntime();  
7.   
8.         //exec:在单独的进程中执行指定的字符串命令。   
9.         Process p = r.exec("notepad.exe StaticImport.java");  
10.   
11.         Thread.sleep(4000);  
12.         //杀进程   
13.         p.destroy();  
14.     }  
15. }  

//Runtime对象     class RuntimeDemo{public static void main(String[] args) throws Exception{Runtime r = Runtime.getRuntime();//exec:在单独的进程中执行指定的字符串命令。Process p = r.exec("notepad.exe StaticImport.java");Thread.sleep(4000);//杀进程p.destroy();}}

5、Math类

该类提供了静态的操作数学运算的方法。
常用方法：
ceil()：返回大于参数的最小整数。
floor()：返回小于参数的最大整数。
round()：返回四舍五入的整数。
pow(a,b)：a的b次方。

[java] view plaincopyprint?

1. //Math类   
2. import java.util.*;  
3. class MathDemo  
4. {  
5.     public static void main(String[] args)  
6.     {  
7.         show();  
8.         //返回大于或等于 0.0 但小于 1.0 的伪随机 double 值。  
9.         Random r = new Random();  
10.         for(int x=0; x<10;x++)  
11.         {  
12.             //强转成int类型数值   
13.             int d = (int)(Math.random()*10+1);  
14.             System.out.print(d+" ");  
15.         }  
16.         System.out.println();  
17.   
18.         for(int x=0; x<10;x++)  
19.         {  
20.             int d1 = r.nextInt(10)+1;  
21.             System.out.print(d1+" ");  
22.         }  
23.         System.out.println();  
24.     }  
25.     public static void show()  
26.     {  
27.         //ceil返回大于指定数据的最小整数。   
28.         double d = Math.ceil(16.34);  
29.   
30.         //floor返回小于指定数据的最大整数。   
31.         double d1 = Math.floor(14.78);  
32.       
33.         //四舍五入   
34.         long l = Math.round(12.5);  
35.         sop("ceil:"+d);  
36.         sop("floor:"+d1);  
37.         sop("round:"+l);  
38.   
39.         //返回2^4。   
40.         double d2 = Math.pow(2,4);  
41.         sop("pow:"+d2);  
42.     }  
43.     public static void sop(Object obj)  
44.     {  
45.         System.out.println(obj);  
46.     }  
47. }  

//Math类import java.util.*;class MathDemo{public static void main(String[] args){show();//返回大于或等于 0.0 但小于 1.0 的伪随机 double 值。Random r = new Random();for(int x=0; x<10;x++){//强转成int类型数值int d = (int)(Math.random()*10+1);System.out.print(d+" ");}System.out.println();for(int x=0; x<10;x++){int d1 = r.nextInt(10)+1;System.out.print(d1+" ");}System.out.println();}public static void show(){//ceil返回大于指定数据的最小整数。double d = Math.ceil(16.34);//floor返回小于指定数据的最大整数。double d1 = Math.floor(14.78);//四舍五入long l = Math.round(12.5);sop("ceil:"+d);sop("floor:"+d1);sop("round:"+l);//返回2^4。double d2 = Math.pow(2,4);sop("pow:"+d2);}public static void sop(Object obj){System.out.println(obj);}}

运行结果：

6、Date、DateFormat类
日期对象和毫秒值间的转换：
a 毫秒值-->日期对象 new Date(); setTime();
b 日期对象-->毫秒值 getTime();
c 对日期对象进行格式化：使用DateFormat类中的format方法。

[java] view plaincopyprint?

1. import java.util.*;  
2. import java.text.*;  
3.   
4. class DateDemo  
5. {  
6.     public static void main(String[] args)  
7.     {  
8.         Date d = new Date();  
9.         sop(d);  
10.   
11.         sop("将日期对象转成毫秒值:"+d.getTime());  
12.   
13.         //将模式封装到SimpleDateFormat对象中。  
14.         SimpleDateFormat sdf = new SimpleDateFormat("yyyy年MM月dd日E hh:mm:ss");  
15.   
16.         //调用format方法让模式格式化指定Date对象。   
17.         String time = sdf.format(d);  
18.   
19.         sop("time="+time);  
20.     }  
21.     public static void sop(Object obj)  
22.     {  
23.         System.out.println(obj);  
24.     }  
25. }  

import java.util.*;import java.text.*;class DateDemo{public static void main(String[] args){Date d = new Date();sop(d);sop("将日期对象转成毫秒值:"+d.getTime());//将模式封装到SimpleDateFormat对象中。SimpleDateFormat sdf = new SimpleDateFormat("yyyy年MM月dd日E hh:mm:ss");//调用format方法让模式格式化指定Date对象。String time = sdf.format(d);sop("time="+time);}public static void sop(Object obj){System.out.println(obj);}}

运行结果：

7、Calendar类

该类是一个抽象类，它为特定瞬间与一组诸如YREA、MONTH、DAY_OF_MONTH、HOUR等日历字段之间的转换
提供了一些方法，并为操作日历字段提供了一些方法。
add(int field,int amount):依据日历规则，为指定日历字段指定添加或减去指定的时间量。

[java] view plaincopyprint?

1. /* 
2. 1,获取任意年的二月有多少天。 
3.     思路：根据指定年设置一个时间就是 
4.     c.set(year,3,1)//某一年的3月1日。 
5.     c.add(Calendar.DAY_OF_MONTH,-1);//3月1日前一天就是2月最后一天。 
6. 2，获取昨天的现在这个时刻。 
7.     c.add(Calendar.DAY_OF_MONTH,-1); 
8. */  
9. import java.util.*;  
10. class CalendarDemo  
11. {  
12.     public static void main(String[] args)  
13.     {  
14.   
15.         Calendar c = Calendar.getInstance();  
16.   
17.         c.set(2012,3,1);  
18.   
19.         c.add(Calendar.MONTH,-1);  
20.   
21.         c.add(Calendar.DAY_OF_MONTH,-1);  
22.   
23.         printlnCalendar(c);  
24.     }  
25.     public static void printlnCalendar(Calendar c)  
26.     {  
27.         String[] mons = {"一月","二月","三月","四月"  
28.                 ,"五月","六月","七月","八月"  
29.                 ,"九月","十月","十一月","十二月"};  
30.   
31.         String[] weeks = {"","星期日","星期一","星期二","星期三"  
32.                     ,"星期四","星期五","星期六"};  
33.   
34.         int index = c.get(Calendar.MONTH);  
35.   
36.         int index1 = c.get(Calendar.DAY_OF_WEEK);  
37.   
38.   
39.         sop(c.get(Calendar.YEAR)+"年");  
40.   
41.         //sop((c.get(Calendar.MONTH)+1)+"月");  
42.         sop(mons[index]);  
43.   
44.         sop(c.get(Calendar.DAY_OF_MONTH)+"日");  
45.   
46.         //sop("星期"+c.get(Calendar.DAY_OF_WEEK));  
47.         sop(weeks[index1]);       
48.     }  
49.     public static void sop(Object obj)  
50.     {  
51.         System.out.println(obj);  
52.     }  
53. }  

/*1,获取任意年的二月有多少天。思路：根据指定年设置一个时间就是c.set(year,3,1)//某一年的3月1日。c.add(Calendar.DAY_OF_MONTH,-1);//3月1日前一天就是2月最后一天。2，获取昨天的现在这个时刻。c.add(Calendar.DAY_OF_MONTH,-1);*/import java.util.*;class CalendarDemo{public static void main(String[] args){Calendar c = Calendar.getInstance();c.set(2012,3,1);c.add(Calendar.MONTH,-1);c.add(Calendar.DAY_OF_MONTH,-1);printlnCalendar(c);}public static void printlnCalendar(Calendar c){String[] mons = {"一月","二月","三月","四月","五月","六月","七月","八月","九月","十月","十一月","十二月"};String[] weeks = {"","星期日","星期一","星期二","星期三","星期四","星期五","星期六"};int index = c.get(Calendar.MONTH);int index1 = c.get(Calendar.DAY_OF_WEEK);sop(c.get(Calendar.YEAR)+"年");//sop((c.get(Calendar.MONTH)+1)+"月");sop(mons[index]);sop(c.get(Calendar.DAY_OF_MONTH)+"日");//sop("星期"+c.get(Calendar.DAY_OF_WEEK));sop(weeks[index1]);}public static void sop(Object obj){System.out.println(obj);}}

运行结果：

四、JDK1.5

JDK1.5版本出现的新特性。
JDK1.5版本后，Collection继承了Iterable接口。Iterable接口将iterator()方法抽取出来。
优点：提高了集合框架扩展性；提供了新功能：foreach：高级for循环。
1、foreach：高级for循环。凡是支持迭代器的集合都支持foreach。
1.1格式：
for(数据类型 变量名 : 被遍历的集合（Collection）或数组){}
1.2特点：
优点：foreach简化了书写，可对集合进行遍历。
缺点：只能提出集合元素，不能修改。
PS:
迭代器：除了遍历，还可以进行remove集合中元素的动作；
如果是用ListIterator,还可以在遍历过程中对集合进行增删改查的动作。
传统for和高级for区别：
高级for有一个局限性：必须有被遍历的目标。
建议：在遍历数组时，用传统for，因为其可以定义角标。

[java] view plaincopyprint?

1. //JDk1.5之后特性   
2. import java.util.*;  
3. class ForEachDemo  
4. {  
5.     public static void main(String[] args)  
6.     {  
7.         ArrayList<String> al = new ArrayList<String>();  
8.   
9.         al.add("abc1");  
10.         al.add("abc2");  
11.         al.add("abc3");       
12.       
13.         //高级for循环   
14.         for(String s : al)  
15.         {  
16.             s = "kk";         
17.         }  
18.         //只能打印集合内容，不能修改   
19.         System.out.println("for循环后集合:"+al);  
20.   
21.         int[] arr = {3,5,6};  
22.         for(int i : arr)  
23.         {  
24.             //高级for循环大大简化了书写   
25.             System.out.println("i:"+i);  
26.         }  
27.   
28.         HashMap<Integer,String> hm = new HashMap<Integer,String>();  
29.   
30.         hm.put(1,"a");  
31.         hm.put(2,"b");  
32.         hm.put(3,"c");  
33.           
34.         //用高级for循环取出键值对：方式一   
35.         Set<Integer> keySet = hm.keySet();  
36.         for(Integer i : keySet)  
37.         {  
38.             System.out.println(i+"::"+hm.get(i));  
39.         }  
40.   
41.         //方式二   
42.         //Set<Map.Entry<Integer,String>> entrySet = hm.entrySet();  
43.         //for(Map.Entry<Integer,String> me : entrySet)  
44.         for(Map.Entry<Integer,String> me : hm.entrySet())  
45.         {  
46.             System.out.println(me.getKey()+":----:"+me.getValue());  
47.         }  
48.     }  
49. }  

//JDk1.5之后特性import java.util.*;class ForEachDemo{public static void main(String[] args){ArrayList<String> al = new ArrayList<String>();al.add("abc1");al.add("abc2");al.add("abc3");//高级for循环for(String s : al){s = "kk";}//只能打印集合内容，不能修改System.out.println("for循环后集合:"+al);int[] arr = {3,5,6};for(int i : arr){//高级for循环大大简化了书写System.out.println("i:"+i);}HashMap<Integer,String> hm = new HashMap<Integer,String>();hm.put(1,"a");hm.put(2,"b");hm.put(3,"c");//用高级for循环取出键值对：方式一Set<Integer> keySet = hm.keySet();for(Integer i : keySet){System.out.println(i+"::"+hm.get(i));}//方式二//Set<Map.Entry<Integer,String>> entrySet = hm.entrySet();//for(Map.Entry<Integer,String> me : entrySet)for(Map.Entry<Integer,String> me : hm.entrySet()){System.out.println(me.getKey()+":----:"+me.getValue());}}}

运行结果：

2、可变数组:简写了数组参数。 不用每次都手动的建立数组对象，只要将要操作的元素作为参数传递即可。
隐式将这些参数封装成类数组。
格式：数据类型... 数组名 
注意：使用时，可变参数一定要定义在参数列表最后面。

[java] view plaincopyprint?

1. //JDK1.5版本出现的新特性：可变参数   
2. class VariableArrayDemo  
3. {  
4.     public static void main(String[] args)  
5.     {  
6.         show("hah",2,1,2,115,3);  
7.     }  
8.     //使用时，可变参数一定要定义在参数列表最后面。   
9.     public static void show(String str,int... ar)     
10.     {  
11.         System.out.println(ar.length);  
12.     }  
13. }  

//JDK1.5版本出现的新特性：可变参数class VariableArrayDemo{public static void main(String[] args){show("hah",2,1,2,115,3);}//使用时，可变参数一定要定义在参数列表最后面。public static void show(String str,int... ar){System.out.println(ar.length);}}

运行结果：

3、静态导入(StaticImport):导入的是类的所有静态成员。
格式：
import static java.util.Arrays.*;
当类名重名时，需要指定具体的包名。

当方法重名时，指定具备所属的对象或类。

[java] view plaincopyprint?

1. //StaticImport 静态导入   
2. import java.util.*;  
3.   
4. //导入的是Arrays这个类中的所有静态成员。   
5. import static java.util.Arrays.*;  
6.   
7. //导入了System类中所有静态成员。   
8. import static java.lang.System.*;  
9.   
10. class StaticImport  
11. {  
12.     public static void main(String[] args)  
13.     {  
14.         //由于静态导入，可省略类   
15.         out.println("hah ");  
16.   
17.         int[] arr = {3,1,4};  
18.   
19.         sort(arr);//Arrays.sort(arr);  
20.         int index = binarySearch(arr,4);//int index = Arrays.binarySearch(arr,1);  
21.   
22.         //这里的Arrays.不能省，因为Object有同名方法。   
23.         out.println(Arrays.toString(arr));  
24.         System.out.println("Index="+index);  
25.     }  
26. }  

//StaticImport 静态导入import java.util.*;//导入的是Arrays这个类中的所有静态成员。import static java.util.Arrays.*;//导入了System类中所有静态成员。import static java.lang.System.*;class StaticImport{public static void main(String[] args){//由于静态导入，可省略类out.println("hah ");int[] arr = {3,1,4};sort(arr);//Arrays.sort(arr);int index = binarySearch(arr,4);//int index = Arrays.binarySearch(arr,1);//这里的Arrays.不能省，因为Object有同名方法。out.println(Arrays.toString(arr));System.out.println("Index="+index);}}

运行结果：