黑马程序员 Java自学总结十三 集合框架和其他对象

------ ASP.Net+Android+IO开发.Net培训期待与您交流！ ------

总结内容来源于黑马毕老师的java基础教学视频

集合框架 

为什么出现集合类？

对象是对数据的封装，而集合是对对象的封装。编程中除了对单个象的操作外，

常常还需要对多个对象进行统一操作，这时就需用一个容器将这些对象存储起来，这样的容器就是集合。

集合与数组的区别

他们都是容器，都可以存储对象，他们的区别是：数组的长度是固定的，而集合的长度的可变的；

数组既能存储基本数据类型也能存储引用数据类型，而集合只能存储引用数据类型，

如果给集合添加基本数据类型的元素，这些基本数据类型会自动装箱成对应的引用数据类型；数组存储的元素都是同一类型，而集合可以存储不同类型的元素。

集合的特点： 集合只用于存储对象，它的长度可变，能够存储不同类型的对象。

 

集合框架为什么有这么多的容器？

因为每一个容器对数据的存储方式都有不同，这个存储方式称之为：数据结构。

接口Collection

共性方法

Collection是一个接口，它定义了一些共性的方法，包括添加、移除、清空元素，是否为空、是否包括某一元素，获取元素个数等操作。

注意：

1.它里边有一个iterator方法，专门用于取出此Collection的Iterator对象。

2.集合的add方法的参数类型是Object，以便于接受任意类型的对象。

3.集合中存放的都是对象的引用（地址）。

Iterator（迭代器）

集合中的的元素取出动作，不足以用一个函数来描述（取出前要先判断有没有），同时不同的存储结构，其取出的方式也不同，

所以定义了一个接口Iterator专门用来实现其取出操作。因为要访问集合内部的元素，所以迭代器的实现放在了具体集合的内部。

[java] view plaincopy

1. import java.util.*;  
2. class CollectionDemo  
3. {  
4.      public static void main(String[] args)  
5.      {  
6.           //method_2();      
7.           method_get();  
8.      }  
9.      //迭代器的使用  
10.      public static void method_get()  
11.      {  
12.           ArrayList al1 = new ArrayList();  
13.            
14.           al1.add("java01");//添加元素.  
15.           al1.add("java02");  
16.           al1.add("java03");  
17.           al1.add("java04");  
18.   
19.         //获取迭代器,用于取出集合中的元素  
20.           Iterator it = al1.iterator();  
21.   
22.           it.next();//返回集合中下一个元素  
23.   
24.           //hasNext()方法是判断集合中是否还有元素,返回值为boolean型  
25.           while (it.hasNext())  
26.           {  
27.                     sop("next:"+it.next());  
28.           }  
29.   
30.      }  
31.      public static void method_2()  
32.      {  
33.           ArrayList al1 = new ArrayList();  
34.            
35.           al1.add("java01");//添加元素.  
36.           al1.add("java02");  
37.           al1.add("java03");  
38.           al1.add("java04");  
39.   
40.           ArrayList al2 = new ArrayList();  
41.            
42.           al2.add("java05");//添加元素.  
43.           al2.add("java06");  
44.           al2.add("java03");  
45.           al2.add("java04");  
46.   
47.           //al1.retainAll(al2);//取交集,al1只保留与al2中相同的元素.  
48.           al1.removeAll(al2);//去交集,al1只保留与al2中不同的元素.  
49.   
50.           sop(al1);  
51.           sop(al2);  
52.      }  
53.      public static void method_base()  
54.      {  
55.           //创建一个集合容器.使用Collection接口的子类.ArrayList  
56.           ArrayList al = new ArrayList();  
57.            
58.           al.add("java01");//添加元素.  
59.           al.add("java02");  
60.           al.add("java03");  
61.           al.add("java04");  
62.            
63.           sop("size:"+al.size());//获取个数,集合长度.  
64.          
65.           sop(al);//打印原集合  
66.   
67.           //al.remove("java01");//删除元素  
68.           //al.clear();//清空集合  
69.          
70.           //判断元素是否在集合内  
71.           sop("java03是否在集合内:"+al.contains("java03"));  
72.           sop("集合是否为空:"+al.isEmpty());  
73.            
74.           sop("size:"+al.size());//获取改变后的长度  
75.            
76.           sop(al);//打印改变后的集合  
77.      }  
78.   
79.   
80.      public static void sop(Object obj)  
81.      {  
82.           System.out.println(obj);  
83.      }  
84. }  

Collection的体系结构

Collection

    |--List:元素是有序的,元素可以重复.因为该集合体系有索引.

         |--ArrayList:底层的数据结构使用的是数组结构.特点:查询快,增删慢.线程不同步.

         |--LinkeList:底层使用的是链表数据结构.特点:增删快,查询慢

         |--Vector:底层是数组结构.线程同步.被ArryList替代.

    |--Set:元素是无序的,元素不可以重复.

List:

    特有方法.凡是可以操作角标的方法都是该体系特有的方法.

增

   add(index,element);

   addAll(index,Collection);

删

   remove(index);

改

   set(index,element);

查

   get(index);

   sublist(from,to);

   listInterator();

List集合特有的迭代器.ListIterator是Interator的子接口.

在迭代时,不可以通过集合对象的方法操作集合中的元素.

因为会发生ConcurrentModificationException异常

所以,在迭代器时,只能用迭代器的方法操作元素,可是Iterator的方法是有限的

只能对元素进行判断,取出,删除等操作.

如果想要其他操作的如添加,修改等,就需要使用其子接口,ListIterator.

该接口只能通过List集合的ListIterator方法获取.

ArrayList底层是数组结构，线程不同步。

[java] view plaincopy

1. import java.util.*;  
2.   
3. class ListDemo  
4. {  
5.      public static void sop(Object obj)  
6.      {  
7.           System.out.println(obj);  
8.      }  
9.   
10.   
11.     public static void listbase_method()  
12.      {  
13.           ArrayList al = new ArrayList();  
14.            
15.           al.add("java01");  
16.           al.add("java02");  
17.           al.add("java03");  
18.           sop("原集合:"+al);  
19.   
20.           al.add(1,"java10");//指定位置添加元素  
21.           //al.addAll(2,al);//指定位置添加集合  
22.           al.remove(3);//删除指定位置的元素  
23.         al.set(2,"java03");//修改指定位置的元素  
24.           sop("get(1):"+al.get(1));//获取指定位置的元素  
25.           sop("修改后:"+al);  
26.           //get()获取所有元素  
27.           for (int x=0; x<al.size(); x++)  
28.           {  
29.                sop("al("+x+")"+al.get(x));  
30.           }  
31.   
32.      }  
33.      public static void main(String[] args)  
34.      {  
35.           ArrayList al = new ArrayList();  
36.   
37.           //使用ListIterator迭代器进行添加删除  
38.           ListIterator li = al.listIterator();  
39.           li.add("java01");  
40.           li.add("java02");  
41.           li.add("java03");  
42.           li.add("java04");  
43.   
44.           li.remove("java04");  
45.   
46.           //使用ListIteraor迭代器获取所有元素  
47.           while (li.hasPrevious())//hasPrevious判断前面是否有元素与hasNext相反  
48.           {  
49.                sop("next:"+li.previous());//previous从后往前迭代  
50.           }  
51.      }  
52. }  

ArrayList练习1

[java] view plaincopy

1. /* 
2. 去除ArrayList集合中的重复元素 
3.  
4. 思路:新建一个容器,把原容器中的元素取出,存进新容器, 
5.         存的同时,判断新容器中是否存在此元素 
6. */  
7. import java.util.*;  
8. class ArrayListTest  
9. {  
10.      public static ArrayList getSingleElement(ArrayList al)  
11.      {  
12.           ArrayList newal = new ArrayList();  
13.           ListIterator li = al.listIterator();  
14.           while (li.hasNext())  
15.           {  
16.                Object obj = li.next();  
17.                if (!(newal.contains(obj)))  
18.                {  
19.                     newal.add(obj);  
20.                }  
21.           }  
22.           return newal;  
23.      }  
24.      public static void main(String[] args)  
25.      {  
26.           ArrayList al = new ArrayList();  
27.           al.add("java01");  
28.           al.add("java01");  
29.           al.add("java02");  
30.           al.add("java03");  
31.           al.add("java04");  
32.           al.add("java03");  
33.           al.add("java02");  
34.   
35.           System.out.println(al);  
36.   
37.           getSingleElement(al);  
38.   
39.      }  
40. }  

ArrayList练习2

[java] view plaincopy

1. /* 
2. 将自定义对象作为元素存到ArrayList集合中,并去除重复元素. 
3.  
4. 比如:存入人对象.同姓名 同年龄,视为一个人,为重复元素. 
5.  
6. 思路: 
7. 1.对人描述,将数据封装进人对象. 
8. 2.定义容器,将人存入. 
9. 3.取出. 
10.  
11. List集合判断元素是否相同,依据是元素的equals方法,contains方法调用了equals方法, 
12. remove也调用了equals方法. 
13. */  
14. import java.util.*;  
15. class Person  
16. {  
17.      private String name;  
18.      private int age;  
19.      Person(String name,int age)  
20.      {  
21.           this.name = name;  
22.           this.age = age;  
23.      }  
24.      //复写了equals方法,被contains方法调用  
25.      public boolean equals(Object obj)  
26.      {  
27.           if (!(obj instanceof Person))  
28.           {  
29.                return false;  
30.           }  
31.           Person p = (Person)obj;  
32.           System.out.println(this.name+"---"+p.name);  
33.           return this.name.equals(p.name)&&this.age==p.age;  
34.      }  
35.      public String getName()  
36.      {  
37.           return name;  
38.      }  
39.      public int getAge()  
40.      {  
41.           return age;  
42.      }  
43. }  
44. class  ArrayListTest2  
45. {  
46.      public static void sop(Object obj)  
47.      {  
48.           System.out.println(obj);  
49.      }  
50.      public static void main(String[] args)  
51.      {  
52.           ArrayList al = new ArrayList();  
53.           al.add(new Person("2B",15));  
54.           al.add(new Person("2A",30));  
55.           al.add(new Person("2B",15));  
56.           al.add(new Person("3C",50));  
57.           al.add(new Person("4D",60));  
58.           al.add(new Person("3C",50));  
59.            
60.           ArrayList al1 = getSingleElement(al);  
61.   
62.   
63.           Iterator it = al1.iterator();  
64.           while (it.hasNext())  
65.           {  
66.                //由于迭代器next()方法获取的元素是Object类型的,  
67.                //所以需要向下转型为Person  
68.                Person p = (Person)it.next();  
69.                sop(p.getName()+"-------"+p.getAge());  
70.           }  
71.   
72.   
73.      }  
74.   
75.      public static ArrayList getSingleElement(ArrayList al)  
76.      {  
77.           ArrayList newal = new ArrayList();  
78.           ListIterator li = al.listIterator();  
79.           while (li.hasNext())  
80.           {  
81.                Object obj = li.next();  
82.                if (!(newal.contains(obj)))//contain方法调用了底层的equals方法  
83.                {  
84.                     newal.add(obj);  
85.                }  
86.           }  
87.           return newal;  
88.      }  
89. }  

LinkedList:特有方法:

addFirst();           

addLast();            

                      

getFirst();                       |

getLast();                       |

获取元素,但不删除元素|

                                         |--如果集合中没有元素,会出现NoSuchElementException

removeFirst();               |

removeLast();               |

删除元素,并获取元素 |

在JDK1.6出现了替代方法.

offerFirst()

offerLast()

peekFirst()                     |

peekLast()                     |

获取元素,但不删除元素|

                                        |--如果集合中没有元素,会返回null

pollFirst()                      |

pollLast()                       |

删除元素,并获取元素 |

[java] view plaincopy

1. /* 
2. 使用LinkedList模拟一个堆栈或者队列数据结构. 
3. 堆栈数据结构:先进后出 
4. 队列数据结构:先进先出 
5. */  
6. import java.util.*;  
7. //堆栈结构  
8.   
9. //队列结构  
10. class DuiLie  
11. {  
12.      private LinkedList link;  
13.      DuiLie()  
14.      {  
15.           link = new LinkedList();  
16.      }  
17.      public void mySet(Object obj)  
18.      {  
19.           link.addFirst(obj);  
20.      }  
21.      public void myGet()  
22.      {  
23.           System.out.println(link.removeLast());  
24.      }  
25.      boolean isEmpty()  
26.      {  
27.           return link.isEmpty();  
28.      }  
29. }  
30. class  LinkedListTest  
31. {  
32.      public static void sop(Object obj)  
33.      {  
34.           System.out.println(obj);  
35.      }  
36.      public static void main(String[] args)  
37.      {  
38.           DuiLie dt = new DuiLie();  
39.           dt.mySet("java04");  
40.           dt.mySet("java03");  
41.           dt.mySet("java02");  
42.           dt.mySet("java01");  
43.   
44.           while (!(dt.isEmpty()))  
45.           {  
46.                dt.myGet();  
47.           }           
48.      }  
49. }  

Vector中特有的枚举

枚举Enumeration就是Vector特有的取出方式.

发现枚举和迭代器很像.

其实枚举和迭代时一样的.

因为枚举的名称以及方法的名称都过长.

所以被迭代器取代了.

ArrayList取代了Vector，Iterator取代了Enumeration

[java] view plaincopy

1. class VectorDemo  
2. {  
3.      public static void main(String[] args)  
4.      {  
5.           Vector v = new Vector();  
6.   
7.           v.add("java01");  
8.           v.add("java02");  
9.           v.add("java03");  
10.           v.add("java04");  
11.   
12.           //Enumeration就是枚举,是一个接口,类似迭代器  
13.           Enumeration en = v.elements();  
14.   
15.           while (en.hasMoreElements())//类似hasNext  
16.           {  
17.                System.out.println(en.nextElement());//类似next  
18.           }  
19.      }  
20. }  

Set:元素是无序的(存入和取出的顺序不一定一致),元素不可以重复.

   HashSet:底层数据结构是哈希表.

   HashSet是如何保证元素的唯一性的呢?

   是通过元素的两个方法,hashCode和equals来完成.

   如果元素的hashCode值相同,才会判断equals是否为true.

   果元素的hashCode值不同,就不会调用equals.

注意:对于判断元素是否存在,以及删除等操作,依赖的方法是元素的hashCode和equals方法先判断hashCode,其次equals.

编程中,复写hashCode方法时,要尽量确保哈希值的唯一性,减少equals方法调用的次数,提高效率.

[java] view plaincopy

1. /* 
2. 往HashSet集合中存入自定对象 
3. 姓名和年龄相同为一个人,重复元素 
4. */  
5. import java.util.*;  
6. class  HashSetDemo  
7. {  
8.      public static void sop(Object obj)  
9.      {  
10.           System.out.println(obj);  
11.      }  
12.      public static void main(String[] args)  
13.      {  
14.           HashSet hs = new HashSet();  
15.   
16.           hs.add(new Person("a1",11));  
17.           hs.add(new Person("a2",12));  
18.           hs.add(new Person("a2",12));  
19.           hs.add(new Person("a3",13));  
20.   
21.           Iterator it = hs.iterator();  
22.            
23.           while (it.hasNext())  
24.           {  
25.                Person p = (Person)it.next();  
26.                sop(p.getName()+"::"+p.getAge());                
27.           }  
28.      }  
29. }  
30. class Person  
31. {  
32.      private String name;  
33.      private int age;  
34.      Person(String name,int age)  
35.      {  
36.           this.name = name;  
37.           this.age = age;  
38.      }  
39.      //复写hashCode方法  
40.      public int hashCode()  
41.      {  
42.           System.out.println(this.name+"--hashCoede");  
43.           return this.name.hashCode()+age*37;//尽量确保哈希值唯一性.提高代码效率  
44.   
45.      }  
46.      //复写了equals方法,被contains方法调用  
47.      public boolean equals(Object obj)  
48.      {  
49.           if (!(obj instanceof Person))  
50.           {  
51.                return false;  
52.           }  
53.           Person p = (Person)obj;  
54.           System.out.println(this.name+"--equals--"+p.name);  
55.           return this.name.equals(p.name)&&this.age==p.age;  
56.      }  
57.      public String getName()  
58.      {  
59.           return name;  
60.      }  
61.      public int getAge()  
62.      {  
63.           return age;  
64.      }  
65. }  

TreeSet:可以对Set集合中的元素进行排序,底层数据结构是二叉树.

保证元素唯一性的依据:comparaTo方法.

TreeSet排序的第一种方式:让元素自身具备比较性,元素需要实现Comparable接口,覆盖compareTo方法.

这种方式也称为元素的自然顺序,或叫默认顺序.

[java] view plaincopy

1. */  
2. import java.util.*;  
3. class  TreeSetDemo  
4. {  
5.      public static void sop(Object obj)  
6.      {  
7.           System.out.println(obj);  
8.      }  
9.      public static void main(String[] args)  
10.      {  
11.           TreeSet ts = new TreeSet();  
12.   
13.           ts.add(new Student("lisi001",30));  
14.           ts.add(new Student("lisi004",17));  
15.           ts.add(new Student("lisi005",17));  
16.           ts.add(new Student("lisi008",31));  
17.   
18.           Iterator it = ts.iterator();  
19.   
20.           while (it.hasNext())  
21.           {  
22.                Student s = (Student)it.next();//向下转型  
23.                sop(s.getName()+"::"+s.getAge());  
24.           }  
25.      }  
26. }  
27.   
28. class Student implements Comparable//该接口强制让学生类具有可比性      
29. {  
30.      private String name;  
31.      private int age;  
32.      Student(String name,int age)  
33.      {  
34.           this.name = name;  
35.           this.age = age;  
36.      }  
37.      //复写Comparable接口的compareTo方法供底层调用  
38.      public int compareTo(Object obj)  
39.      {  
40.           if (!(obj instanceof Student))  
41.                throw new RuntimeException("不是Student对象");  
42.           Student s = (Student)obj;//向下转型  
43.           if (this.age > s.age)  
44.                return 1;  
45.           if (this.age == s.age)  
46.                return this.name.compareTo(s.name);//调用了字符串的compareTo方法  
47.           return -1;           
48.      }  
49.      public String getName()  
50.      {  
51.           return name;           
52.      }  
53.      public int getAge()  
54.      {  
55.           return age;  
56.      }  
57. }  

 

TreeSet排序的第二种方式:当元素自身不具备比较性时,或者具备的比较性不是所需要的.

这时就需要让集合自身具备比较性.让集合在初始化时,就有了比较方式.

定义比较器实现Comparator接口,将比较器对象作为参数传递给TreeSet集合的构造函数.

当两种排序都在时,以比较器Comparator为主.

[java] view plaincopy

1. import java.util.*;  
2. class  TreeSetDemo2  
3. {  
4.      public static void sop(Object obj)  
5.      {  
6.           System.out.println(obj);  
7.      }  
8.      public static void main(String[] args)  
9.      {  
10.           TreeSet ts = new TreeSet(new MyComparator());  
11.   
12.           ts.add(new Student("lisi001",30));  
13.           ts.add(new Student("lisi004",17));  
14.           ts.add(new Student("lisi004",18));  
15.           ts.add(new Student("lisi005",17));  
16.           ts.add(new Student("lisi008",31));  
17.   
18.           Iterator it = ts.iterator();  
19.   
20.           while (it.hasNext())  
21.           {  
22.                Student s = (Student)it.next();//向下转型  
23.                sop(s.getName()+"::"+s.getAge());  
24.           }  
25.      }  
26. }  
27.   
28. class Student implements Comparable//该接口强制让学生类具有可比性      
29. {  
30.      private String name;  
31.      private int age;  
32.      Student(String name,int age)  
33.      {  
34.           this.name = name;  
35.           this.age = age;  
36.      }  
37.      //复写Comparable接口的compareTo方法供底层调用  
38.      public int compareTo(Object obj)  
39.      {  
40.           return 1;           
41.      }  
42.      public String getName()  
43.      {  
44.           return name;           
45.      }  
46.      public int getAge()  
47.      {  
48.           return age;  
49.      }  
50. }  
51. class MyComparator implements Comparator//实现比较器接口  
52. {  
53.      public int compare(Object o1,Object o2)  
54.      {  
55.           Student s1 = (Student)o1;  
56.           Student s2 = (Student)o2;  
57.           int num = s1.getName().compareTo(s2.getName());  
58.           if (num == 0)  
59.              return new Integer(s1.getAge()).compareTo(new Integer(s2.getAge()));  
60.         return num;  
61.      }  
62. }  

TreeSet练习

[java] view plaincopy

1. /* 
2. 需求:根据字符串长度进行排序. 
3. 分析: 
4. 1.建立一个比较器 
5. 2.比较器中复写compare方法,分别返回1,0,-1. 
6. */  
7.   
8. import java.util.*;  
9. class LengthComparator implements Comparator  
10. {  
11.      public int compare(Object o1,Object o2)  
12.      {  
13.           if(!(o1 instanceof String))  
14.                throw new RuntimeException("传入的数据不是字符串");  
15.           String s1 = (String)o1;  
16.           String s2 = (String)o2;  
17.         int num = new Integer(s1.length()).compareTo(s2.length());  
18.           if(num == 0)  
19.                return s1.compareTo(s2);  
20.           return num;  
21.      }  
22. }  
23. class  TreeSetTest  
24. {  
25.      public static void main(String[] args)  
26.      {  
27.           TreeSet ts = new TreeSet(new LengthComparator());  
28.   
29.           ts.add("dwadwa");  
30.           ts.add("hfghfdg");  
31.           ts.add("hghh");  
32.           ts.add("fda");  
33.           ts.add("ddd");  
34.            
35.           Iterator it = ts.iterator();  
36.   
37.           while (it.hasNext())  
38.           {  
39.                System.out.println(it.next());  
40.           }  
41.      }  
42. }  

泛型:JDK1.5版本出现新特性.用于解决安全问题,是一个安全机制.

好处:

1.将运行时期出现的问题ClassCastException转移到了编译时期.

    方便与程序员解决问题,让运行时问题减少,安全.

2.避免了强制强转的麻烦.

泛型格式:通过<>来定义要操作的引用数据类型.

在使用java提供的对象时,什么时候写泛型?

通常在集合框架中很常见,

只要见到<>就要定义泛型.

其实<>就是用来接收类型的.

当使用集合时,将集合中要存储的数据类型作为参数传递到<>中即可.

[java] view plaincopy

1. import java.util.*;  
2. class GenericDemo  
3. {  
4.      public static void main(String[] args)  
5.      {  
6.           //定义泛型的类型  
7.           ArrayList<String> al = new ArrayList<String>();  
8.   
9.           al.add("abc");  
10.           al.add("abcdfd");  
11.           al.add("abc023");  
12.   
13.           //al.add(4);//al.add(new Integer(4));//1.5版本自动升级成后面的写法,自动装箱功能  
14.           //定义泛型的类型  
15.           Iterator<String> it = al.iterator();  
16.   
17.           while (it.hasNext())  
18.           {  
19.                String s = it.next();  
20.                System.out.println(s+"..s.length.."+s.length());  
21.           }  
22.      }  
23. }  

泛型练习

[java] view plaincopy

1. /* 
2. 定义一个对象:现在至少需要hashCode(),equals(),compareTo()方法的覆盖. 
3.  
4. hashCode(),equals()可以直接覆盖. 
5. compareTo()需要实现Comparable接口覆盖. 
6. */  
7. import java.util.*;  
8. class GenericDemo2  
9. {  
10.      public static void main(String[] args)  
11.      {  
12.           //明确泛型类型  
13.           TreeSet<String> ts = new TreeSet<String>(new LenComparator());  
14.   
15.           ts.add("abc003");  
16.           ts.add("abc0ggh");  
17.           ts.add("abc0223");  
18.           ts.add("abc54");  
19.           ts.add("abcfwa");  
20.           //明确泛型类型  
21.           Iterator<String> it = ts.iterator();  
22.   
23.           while (it.hasNext())  
24.           {  
25.                String s = it.next();  
26.                System.out.println(s);  
27.           }  
28.   
29.      }  
30. }  
31. //定义一个比较器  
32. class LenComparator implements Comparator<String>  
33. {  
34.      public int compare(String s1,String s2)  
35.      {  
36.           //s1和s2调换位置既可实现反向排序  
37.           int num = new Integer(s1.length()).compareTo(new Integer(s2.length()));  
38.           if (num == 0)  
39.                return s1.compareTo(s2);  
40.           return num;  
41.      }  
42. }  

泛型类：

什么时候定义泛型类?

当类中操作的引用数据类型不确定的时候，早先定义Object来完成扩展，现在定义泛型．

泛型方法&&静态方法泛型:

泛型类定义的泛型,在整个类中有效.如果被方法使用，那么泛型类的对象明确要操作的具体类型后,所要操作的类型就已经固定了.

为了让不同方法可以操作不同类型,而且类型还不确定.

那么可以将泛型定义在方法上.

特殊之处:

静态方法不可以访问类上定义的泛型.

如果静态方法操作的应用数据类型不确定,可以将泛型定义在方法上.

[java] view plaincopy

1. class Demo  
2. {  
3.      public <T> void show(T t)  
4.      {  
5.           System.out.println(t);  
6.      }  
7.      public <Q> void print(Q q)  
8.      {  
9.           System.out.println(q);  
10.      }  
11.      public static <W> void method(W w)  
12.      {  
13.           System.out.println(w);  
14.      }  
15. }  

泛型定义在接口上

[java] view plaincopy

1. interface Inter<T>  
2. {  
3.      public abstract void show(T t);  
4. }  
5. class InterImpl<T> implements Inter<T>  
6. {  
7.      public void show(T t)  
8.      {  
9.           System.out.println("show :"+t);  
10.      }  
11. }  

泛型的限定

?通配符.也可以理解为占位符.

泛型的限定:

? extends E:可以接受E类型或者E的子类型.

? super E:可以接收E类型或者E的父类型.

[java] view plaincopy

1. import java.util.*;  
2. class  GenericDemo6  
3. {  
4.      public static void main(String[] args)  
5.      {  
6.           ArrayList<Person> al = new ArrayList<Person>();  
7.   
8.           al.add(new Person("abc1"));  
9.           al.add(new Person("abc2"));  
10.           al.add(new Person("abc3"));  
11.   
12.           ArrayList<Student> al2 = new ArrayList<Student>();  
13.   
14.           al2.add(new Student("abc1"));  
15.           al2.add(new Student("abc2"));  
16.           al2.add(new Student("abc3"));  
17.   
18.           printAl(al2);  
19.      }  
20.      public static void printAl(ArrayList<? extends Person> al)  
21.      {  
22.           Iterator<? extends Person> it = al.iterator();  
23.            
24.           while(it.hasNext())  
25.           {  
26.                System.out.println(it.next().getName());  
27.           }  
28.      }  
29. }  
30.   
31. class Person  
32. {  
33.      private String name;  
34.      Person(){}  
35.      Person(String name)  
36.      {  
37.           this.name = name;           
38.      }  
39.      public String getName()  
40.      {  
41.           System.out.println("Person");  
42.           return name;  
43.      }  
44. }  
45. class Student extends Person  
46. {  
47.      private String name;  
48.      Student(String name)  
49.      {  
50.           this.name = name;  
51.      }  
52.      public String getName()  
53.      {  
54.           System.out.println("Student");  
55.           return name;  
56.      }  
57. }  

Map子类特点和共性

Map集合:该集合存储键值对.一对一对往里存.但要确保键的唯一性.

1.添加

   put(K key,V value)

   putAll(Map<? extendes K,?extends V> m)

2.删除

   clear()

   remove(Object key)

3.修改

   containsValue(Object value)

   containsKey(Object key)

   isEmpty()

4.获取

   get(Object key)

   size()

   values()

   entrySet()

   keySet()

Map

     |--Hashtable:底层是哈希表数据结构,不可以存入null键null值,该集合是线程同步.

     |--HashMap:底层是哈希表数据结构,允许使用null键null值,该集合是不同步的.

     |--TreeMap:底层是二叉树数据结构,线程不同步.可以给Map集合中的键进行排序.

Map和Set很像.

Set底层就是使用了Map集合.

[java] view plaincopy

1. import java.util.*;  
2. class MapDemo  
3. {  
4.      public static void main(String[] args)  
5.      {  
6.           Map<String,String> map = new HashMap<String,String>();  
7.   
8.           //添加元素,put方法会返回此键的原值,并且新值会覆盖原值  
9.           map.put("01","zhangsan1");  
10.           map.put("02","zhangsan2");  
11.           map.put("03","zhangsan3");  
12.   
13.           //判断是否包含  
14.           System.out.println("containsKey:"+map.containsKey("002"));  
15.           //System.out.println("remove:"+map.remove("02"));//删除  
16.   
17.          map.put(null,"haha");  
18.          System.out.println("get:"+map.get(null));  
19.           //可以通过get方法的返回值判断一个键是否存在,返回值是否是null  
20.   
21.          //获取集合中所有的值,并返回一个集合  
22.           Collection<String> coll = map.values();  
23.           System.out.println(coll);  
24.   
25.          //获取map集合中所有的键和值  
26.           System.out.println(map);  
27.      }  
28. }  

Map的keySet和entrySet方法

Map集合的取出原理:将Map集合转成Set集合.在通过迭代器取出.

Map集合的两种取出方式:

1.keySet:将Map中所有的键存入到Set集合,因为Set具备迭代器,可以用迭代器取出所有的键,在根据get方法,获取每一个键对应的值.         

2.entrySet:将Map集合中的映像关系存入到set集合中,而这个关系的数据类型就是:Map.Entry

[java] view plaincopy

1. import java.util.*;  
2. class MapDemo2  
3. {  
4.      public static void main(String[] args)  
5.      {  
6.           Map<String,String> map = new HashMap<String,String>();  
7.            
8.           map.put("001","panfeng01");  
9.           map.put("002","panfeng02");  
10.           map.put("003","panfeng03");  
11.           map.put("004","panfeng04");  
12.   
13.           //将Map集合中的映像关系取出,存入到Set集合中.entrySet()  
14.           Set<Map.Entry<String,String>> entry = map.entrySet();  
15.   
16.           Iterator<Map.Entry<String,String>> it = entry.iterator();  
17.   
18.           while (it.hasNext())  
19.           {  
20.                Map.Entry<String,String> me = it.next();  
21.                String k = me.getKey();  
22.                String v = me.getValue();  
23.                System.out.println("key--"+k+"   value--"+v);  
24.           }  
25.   
26.         /* 
27.                //先获取Map集合的所有键的Set集合,keySet(); 
28.                Set<String> ks = map.keySet(); 
29.                //有了Set集合就可以获取其迭代器 
30.                Iterator<String> it = ks.iterator(); 
31.                while (it.hasNext()) 
32.                { 
33.                     String key = it.next(); 
34.                     String value = map.get(key); 
35.                     System.out.println("key--"+key+"::value--"+value); 
36.                } 
37.           */  
38.      }  
39. }  
40.   
41. /* 
42. Map.Entry 其实Entry也是一个接口,它是Map接口中的一个内部接口 
43. 写法: 
44. interface Map 
45. { 
46.      public static interface Entry 
47.      { 
48.           public abstract Object getKey(); 
49.           public abstract Object getvalue(); 
50.      } 
51. } 
52. */  

Map练习1

[java] view plaincopy

1. /* 
2. 每一个学生都有对应的归属地. 
3. 学生Student,地址String. 
4. 学生属性:姓名.年龄. 
5. 注意:姓名和年龄相同视为同一个学生. 
6. 保证学生唯一性. 
7.  
8. 1.描述学生. 
9. 2.定义Map容器,将学生作为键,地址作为值.存入. 
10. 3.获取Map集合中的元素. 
11. */  
12. import java.util.*;  
13. class Student implements Comparable<Student>//实现比较排序接口  
14. {  
15.      private String name;  
16.      private int age;  
17.      Student(String name,int age)  
18.      {  
19.           this.name = name;  
20.           this.age = age;  
21.      }  
22.      //复写Object的hashCode方法,具备自己的哈希值  
23.      public int hashCode()  
24.      {  
25.           return name.hashCode()+age*34;  
26.      }  
27.      //复写Object的equals方法,具备自己的比较方式  
28.      public boolean equals(Object o)  
29.      {  
30.           if (!(o instanceof Student))  
31.                throw new ClassCastException("类型不匹配");           
32.           Student s = (Student)o;  
33.           return this.name.equals(s.name)&&this.age==s.age;  
34.      }  
35.      //复写了所实现接口的compareTo方法,具备自己独特的排序方式.  
36.      public int compareTo(Student s)  
37.      {  
38.           int num = new Integer(this.age).compareTo(new Integer(s.age));  
39.           if(num == 0)  
40.                return this.name.compareTo(s.name);  
41.           return num;  
42.      }  
43.      public String getName()  
44.      {  
45.           return name;  
46.      }  
47.      public int getAge()  
48.      {  
49.           return age;  
50.      }  
51. }  
52.   
53. class MapTest  
54. {  
55.      public static void main(String[] args)  
56.      {  
57.           HashMap<Student,String> map = new HashMap<Student,String>();  
58.   
59.           map.put(new Student("lisi01",21),"beijing");  
60.           map.put(new Student("lisi02",9),"tianjin");  
61.           map.put(new Student("lisi03",20),"shanghai");  
62.           map.put(new Student("lisi04",20),"guangzhou");  
63.   
64.           //第一种取出方式 keySet  
65.           Set<Student> set = map.keySet();      
66.           Iterator<Student> it = set.iterator();  
67.           while (it.hasNext())  
68.           {  
69.                Student stu = it.next();  
70.                String value = map.get(stu);  
71.                System.out.println(stu.getName()+"-"+stu.getAge()+"-"+value);  
72.           }  
73.   
74.           //第二种取出方式 entrySet  
75.           Set<Map.Entry<Student,String>> set2 = map.entrySet();  
76.           Iterator<Map.Entry<Student,String>> it2 = set2.iterator();  
77.           while (it2.hasNext())  
78.           {  
79.                Map.Entry<Student,String> me = it2.next();  
80.                Student stu = me.getKey();  
81.                String value = me.getValue();  
82.                System.out.println(stu.getName()+"::"+stu.getAge()+"::"+value);  
83.   
84.           }  
85.      }  
86. }  

Map练习2

[java] view plaincopy

1. /* 
2. 需求:对学生对象的年龄进行升序排序. 
3.  
4. 因为数据是以键值对形式存在的. 
5. 所以要使用可以排序的Map集合,TreeMap. 
6. */  
7. import java.util.*;  
8. class  TreeMapTest  
9. {  
10.      public static void main(String[] args)  
11.      {  
12.           TreeMap<Student,String> tm = new TreeMap<Student,String>(new StuComparator());  
13.   
14.           tm.put(new Student("lisi01",21),"beijing");  
15.           tm.put(new Student("lisi02",9),"tianjin");  
16.           tm.put(new Student("lisi03",20),"shanghai");  
17.           tm.put(new Student("lisi04",20),"guangzhou");  
18.   
19.           Set<Student> set = tm.keySet();  
20.           Iterator<Student> it = set.iterator();  
21.           while (it.hasNext())  
22.           {  
23.                Student s = it.next();  
24.                String value = tm.get(s);  
25.                System.out.println(s.getName()+"-"+s.getAge()+"-"+value);  
26.   
27.           }  
28.      }  
29. }  
30. //定义一个比较器实现Comparator接口,并复写compare方法  
31. class StuComparator implements Comparator<Student>  
32. {  
33.      public int compare(Student s1,Student s2)  
34.      {  
35.           int num = s1.getName().compareTo(s2.getName());  
36.           if(num == 0)  
37.                return new Integer(s1.getAge()).compareTo(new Integer(s2.getAge()));  
38.           return num;  
39.      }  
40. }  

Map练习3

[java] view plaincopy

1. /* 
2. 练习: 
3. "sdfgzxcvasdfxcvdf"获取该字符串中的字母出现的次数. 
4.  
5. 希望打印结果:a(1)c(2).... 
6.  
7. 通过结果发现,每一个字母都有对应关系的次数. 
8. 说明字母和次数之间是映射关系. 
9.  
10. 注意了,当发现有映射关系时,可以选择Map集合. 
11. 因为Map集合中存放的就是映射关系. 
12.  
13. 什么时候使用Map集合呢? 
14. 当数据之间存在映射关系时,就要先想到Map集合. 
15.  
16. 思路: 
17. 1.将字符串转成字符数组.因为要对每一个字母进行操作. 
18. 2.定义一个Map集合,因为打印结果的字母有顺序,所以使用TreeMao集合. 
19. 3.遍历字符数组,将每一个字母作为键去查Map集合. 
20.   如果返回null,将该字母和1存入到Map集合中. 
21.   如果返回不是null,说明该字母在Map集合中已经存在, 
22.   那么就获取该次数进行自增,然后将该字母和自增后的次数存入到Map集合中. 
23.   覆盖调用原键所对应的值 
24. 4.将Map集合中的数据变成指定的字符窜形式返回. 
25. */  
26. import java.util.*;  
27. class MapTest3  
28. {  
29.      public static void main(String[] args)  
30.      {  
31.           System.out.println(charCount("abdacdbee"));  
32.      }  
33.      public static String charCount(String str)  
34.      {  
35.           char[] chs = str.toCharArray();  
36.           TreeMap<Character,Integer> tm = new TreeMap<Character,Integer>();  
37.           int count = 0;  
38.           for (int x = 0;x < chs.length;x++ )  
39.           {  
40.                //判断是否为字母,只取字母  
41.                if(chs[x]>='a'&&chs[x]<='z' || chs[x]>='A'&&chs[x]<='Z')  
42.                {  
43.                     Integer value = tm.get(chs[x]);  
44.                     if(!(value==null))  
45.                          count = value;  
46.                     count++;  
47.                     tm.put(chs[x],count);  
48.                     count = 0;  
49.                }  
50.                continue;  
51.                     /* 
52.                     if(value==null) 
53.                     { 
54.                          tm.put(chs[x],1); 
55.                     } 
56.                     else 
57.                     { 
58.                          tm.put(chs[x],value+1); 
59.                     } 
60.                     */                     
61.           }  
62.           //定义一个容器,用来存储迭代出的元素.  
63.           StringBuilder sb = new StringBuilder();  
64.           Set<Map.Entry<Character,Integer>> set  = tm.entrySet();  
65.           Iterator<Map.Entry<Character,Integer>> it = set.iterator();  
66.           while (it.hasNext())  
67.           {  
68.                Map.Entry<Character,Integer> me = it.next();  
69.                Character ch = me.getKey();  
70.                Integer value = me.getValue();  
71.                sb.append(ch+"("+value+")");  
72.           }  
73.           return sb.toString();  
74.      }  
75. }  

Map练习4--扩展

[java] view plaincopy

1. /* 
2. Map扩展知识. 
3.  
4. Map集合被使用是因为具备映射关系. 
5.  
6. 需求: 
7. 1. 
8. "yureban";"01","zhangsan" 
9. "yureban";"02","lisi" 
10.  
11. "jiuyeban";"01","wangwu" 
12. "jiuyeban";"02","zhaoliu" 
13.  
14. 2. 
15. "yureban"; Student("01","zhangsan") 
16. "yureban";Student("02","lisi") 
17.  
18. "jiuyeban";Student("01","wangwu") 
19. "jiuyeban";Student("02","zhaoliu") 
20.  
21. */  
22. import java.util.*;  
23. class Student  
24. {  
25.      private String id;  
26.      private String name;  
27.      Student(String id,String name)  
28.      {  
29.           this.id = id;  
30.           this.name = name;  
31.      }  
32.      public String toString()  
33.      {  
34.           return id+"::"+name;  
35.      }  
36. }  
37. class  MapTest4  
38. {  
39.      public static void main(String[] args)  
40.      {  
41.           //demo1();  
42.           demo2();  
43.      }  
44.      public static void demo2()  
45.      {  
46.           TreeMap<String,List<Student>> sch = new TreeMap<String,List<Student>>();  
47.   
48.           List<Student> yure = new ArrayList<Student>();  
49.           sch.put("yureban",yure);  
50.           yure.add(new Student("01","zhangsan"));  
51.           yure.add(new Student("02","lisi"));  
52.           List<Student> jiuye = new ArrayList<Student>();  
53.           sch.put("jiuyeban",jiuye);  
54.           jiuye.add(new Student("01","wangwu"));  
55.           jiuye.add(new Student("01","zhaoliu"));      
56.            
57.          Set<String> set = sch.keySet();  
58.           Iterator<String> it = set.iterator();  
59.           while (it.hasNext())  
60.           {  
61.                String s = it.next();  
62.                List l = sch.get(s);  
63.                System.out.println(s);  
64.                 
65.                for(int x = 0;x<l.size();x++)  
66.                {  
67.                     System.out.println(l.get(x));  
68.                }  
69.           }  
70.      }  
71.      public static void demo1()  
72.      {  
73.           //定义一个映射集合,作为学校,集合中的key是教室名称,value是教室  
74.           TreeMap<String,TreeMap<String,String>> tm = new TreeMap<String,TreeMap<String,String>>();  
75.   
76.           //定义一个yureban映射集合,作为教室,key是学号,value是学生名字  
77.           TreeMap<String,String> tm1 = new TreeMap<String,String>();  
78.           tm.put("yureban",tm1);  
79.           tm1.put("01","zhangsan");  
80.           tm1.put("02","lisi");  
81.           //定义一个jiuyeban映射集合,作为教室,key是学号,value是学生名字  
82.           TreeMap<String,String> tm2 = new TreeMap<String,String>();  
83.           tm.put("jiuyeban",tm2);  
84.           tm2.put("01","wangwu");  
85.           tm2.put("02","zhaoliu");  
86.            
87.          Set<String> set = tm.keySet();  
88.           Iterator<String> it = set.iterator();  
89.           while (it.hasNext())  
90.           {  
91.                String s = it.next();  
92.                System.out.println(s);  
93.                method(tm.get(s));  
94.           }  
95.      }  
96.      public static void method(TreeMap<String,String> tm)  
97.      {  
98.          Set<String> set = tm.keySet();  
99.           Iterator<String> it = set.iterator();  
100.           while (it.hasNext())  
101.           {           
102.                String s = it.next();  
103.                String s1 = tm.get(s);  
104.                System.out.println(s+"::"+s1);  
105.           }  
106.      }  
107. }  

集合框架工具类

Collections:

          根据元素的自然顺序 对指定列表按升序进行排序。

         sort(List<T> list)

          根据指定比较器产生的顺序对指定列表进行排序。

          sort(List<T> list, Comparator<? super T> c)

         

          根据元素的自然顺序，返回给定 collection 的最大元素。

          max(Collection<? extends T> coll)

          根据指定比较器产生的顺序，返回给定 collection 的最大元素。

          max(Collection<? extends T> coll, Comparator<? super T> comp)

[java] view plaincopy

1. import java.util.*;  
2. class CollectionsDemo  
3. {  
4.      public static void sop(Object obj)  
5.      {  
6.           System.out.println(obj);  
7.      }  
8.   
9.      public static void main(String[] args)  
10.      {  
11.           //sortDemo();  
12.           maxDemo();  
13.      }  
14.   
15.      public static void maxDemo()  
16.      {  
17.           List<String> list = new ArrayList<String>();  
18.   
19.           list.add("cdvf");  
20.           list.add("bdvfer");  
21.           list.add("advfdwa");  
22.           list.add("adf");  
23.           list.add("ef");  
24.           Collections.sort(list);  
25.           String max = Collections.max(list,new StrLenComparator());  
26.           sop("max="+max);  
27.      }  
28.   
29.      public static void sortDemo()  
30.      {  
31.           List<String> list = new ArrayList<String>();  
32.   
33.           list.add("cdvf");  
34.           list.add("bdvfer");  
35.           list.add("advfdwa");  
36.           list.add("adf");  
37.           list.add("ef");  
38.           sop(list);  
39.   
40.           Collections.sort(list);  
41.           sop(list);  
42.   
43.           Collections.sort(list,new StrLenComparator());  
44.           sop(list);  
45.      }  
46. }  
47. class StrLenComparator implements Comparator<String>  
48. {  
49.      public int compare(String s1,String s2)  
50.      {  
51.           if(s1.length()>s2.length())  
52.                return 1;  
53.           if(s1.length()<s2.length())  
54.                return -1;  
55.           return s1.compareTo(s2);  
56.      }  
57. }  

Collections(binarySearch)

[java] view plaincopy

1. /* 
2. 集合框架工具类 
3. Collections: 
4.          使用二分搜索法搜索指定列表,以获得指定对象 
5.                binarySearch(List<? extends Comparable<? super T>> list, T key) 
6.           使用二分搜索法搜索指定列表,以获得指定对象 
7.                binarySearch(List<? extends T> list, T key, Comparator<? super T> c) 
8. */  
9.   
10. import java.util.*;  
11. class BinarySearchDemo  
12. {  
13.      public static void main(String[] args)  
14.      {  
15.           binarySearch();  
16.      }  
17.      public static void binarySearch()  
18.      {  
19.           List<String> list = new ArrayList<String>();  
20.   
21.           list.add("cdvf");  
22.           list.add("bdvfer");  
23.           list.add("advfdwa");  
24.           list.add("adf");  
25.           list.add("ef");  
26.           Collections.sort(list);  
27.           System.out.println(list);  
28.           int index = Collections.binarySearch(list,"bdf");  
29.           System.out.println("index="+index);  
30.   
31.         Collections.sort(list,new StrLenComparator());  
32.           System.out.println(list);  
33.           int index2 = Collections.binarySearch(list,"bdf",new StrLenComparator());  
34.           System.out.println("index2="+index2);  
35.      }  
36. }  
37.   
38. class StrLenComparator implements Comparator<String>  
39. {  
40.      public int compare(String s1,String s2)  
41.      {  
42.           if(s1.length()>s2.length())  
43.                return 1;  
44.           if(s1.length()<s2.length())  
45.                return -1;  
46.           return s1.compareTo(s2);  
47.      }  
48. }  

Collections(fill、replaceAll、reverse)

[java] view plaincopy

1. /* 
2. 集合框架工具类 
3. Collections: 
4.           将集合中的元素全部替换成obj 
5.                fill(List<? super T> list, T obj) 
6.           将原值替换成新值 
7.                replaceAll(List<T> list, T oldVal, T newVal) 
8.          反转指定列表中元素的顺序。 
9.                reverse(List<?> list) 
10. */  
11. import java.util.*;  
12. class FillDemo  
13. {  
14.      public static void main(String[] args)  
15.      {  
16.           fillDemo();  
17.      }  
18.      /* 
19.      练习:fill方法可以将list集合中所有元素替换成指定元素. 
20.           将list集合中部分元素替换成指定元素. 
21.      */  
22.      public static void fillDemo()  
23.      {  
24.           List<String> list = new ArrayList<String>();  
25.   
26.           list.add("cdvf");  
27.           list.add("bdvfer");  
28.           list.add("advfdwa");  
29.           list.add("adf");  
30.           list.add("ef");  
31.   
32.           sop(list);  
33.           Collections.fill(list,"pp");  
34.           sop(list);  
35.      }  
36.   
37.      public static void sop(Object obj)  
38.      {  
39.           System.out.println(obj);  
40.      }  
41. }  

Collections(reverseOrder)

[java] view plaincopy

1. /* 
2. 集合框架工具类 
3. Collections: 
4.           返回一个比较器,它强行逆转实现了Comparable接口的对象collection的自然顺序 
5.                reverseOrder() 
6.           返回一个比较器，它强行逆转指定比较器的顺序 
7.                reverseOrder(Comparator<T> cmp) 
8. */  
9. import java.util.*;  
10. class ReverseOrderDemo  
11. {  
12.      public static void main(String[] args)  
13.      {  
14.           TreeSet<String> list = new TreeSet<String>(Collections.reverseOrder(new StrLenComparator()));  
15.   
16.           list.add("cdvf");  
17.           list.add("bdvfer");  
18.           list.add("advfdwa");  
19.           list.add("adf");  
20.           list.add("ef");  
21.            
22.           Iterator<String> it = list.iterator();  
23.           while (it.hasNext())  
24.           {  
25.                String s = it.next();  
26.                System.out.println(s);  
27.           }  
28.      }  
29. }  
30.   
31. class StrLenComparator implements Comparator<String>  
32. {  
33.      public int compare(String s1,String s2)  
34.      {  
35.           if(s1.length()>s2.length())  
36.                return 1;  
37.           if(s1.length()<s2.length())  
38.                return -1;  
39.           return s1.compareTo(s2);  
40.      }  
41. }  

Collections(其他常见方法)

返回指定 collection 支持的同步（线程安全的）collection

synchronizedCollection(Collection<T> c)

返回指定列表支持的同步（线程安全的）列表。

synchronizedList(List<T> list)

返回由指定映射支持的同步（线程安全的）映射。

synchronizedMap(Map<K,V> m)

返回指定 set 支持的同步（线程安全的）set。

synchronizedSet(Set<T> s)

              

在指定列表的指定位置处交换元素

swap(List<?> list, int i, int j)

使用默认随机源对指定列表进行位置的调换(随机调换位置)

shuffle(List<?> list)

－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－

数组工具类Arrays(asList(数组变集合))

Arrays:用于操作数组的工具类,里面都是静态方法

     其中大部分方法参见 Collections 工具类.

将数组变成list集合

     asList(array)

把数组变成集合有什么好处?

     可以使用集合的思想和方法操作数组中的元素.

     注意:将数组变成集合,不可以使用集合的增删方法.

          因为数组的长度是固定的.    

     如果增删,会发生UnsupportedOperationException(不支持操作异常).

十分注意:如果数组中的元素都是对象.那么变成集合时,数组中的元素就直接转成集合中的元素

     如果数组中的元素都是基本数据类型,那么会将该数组作为集合中的元素存在.

集合变数组

集合变数组

Collection接口中的toArray方法

          返回包含此 collection 中所有元素的数组

          toArray()

          返回包含此 collection 中所有元素的数组,类型与指定数组的类型相同

          toArray(T[] a)

1.指定类型的数组到底要定义多长呢?

当指定类型的数组长度小于集合的size,那么该方法内部会创建一个新的数组.长度为集合的size.

当指定类型的数组长度大于集合的size,就不会创建新的数组,而是使用传递进来的数组,用null补位.

所以创建一个刚刚好的数组最有,长度为size.

2.为什么要将集合变数组?

为何限定对数组的操作,不需要进行增删.

高级for循环

高级for循环

格式

for(数据类型 变量名 : 被遍历的集合(Collection)或者数组)

{

}

对集合进行遍历.

只能获取元素.不能对集合进行操作.

迭代器除了遍历,还可以进行remove集合中的元素操作.

如果是ListIterator,还可以在遍历中对集合进行增删改查操作.

传统for和高级for有什么区别?

高级for有一个局限性,必须有被遍历的目标.

[java] view plaincopy

1. import java.util.*;  
2. class ForEachDemo  
3. {  
4.      public static void main(String[] args)  
5.      {  
6.           //取出List集合  
7.           ArrayList<String> al = new ArrayList<String>();  
8.   
9.           al.add("abc1");  
10.           al.add("abc2");  
11.           al.add("abc3");  
12.           for (String s : al )  
13.           {  
14.                System.out.println(s);  
15.           }  
16.            
17.           //取出数组  
18.           int[] arr = {2,3,4};  
19.           for (Integer i : arr )  
20.           {  
21.                System.out.println(i);  
22.           }  
23.            
24.           //取出Map集合  
25.           HashMap<Integer,String> hm = new HashMap<Integer,String>();  
26.   
27.           hm.put(1,"a");  
28.           hm.put(2,"b");  
29.           hm.put(3,"c");  
30.           Set<Map.Entry<Integer,String>> me = hm.entrySet();  
31.           for (Map.Entry<Integer,String> set : me )  
32.           {  
33.                System.out.println(set);  
34.           }  
35.      }  
36. }  

可变参数

[java] view plaincopy

1. /* 
2. JDK1.5版本出现的新特性. 
3.  
4. 可变参数: 
5.      其实就是数组参数的简写形式 
6.      不用每一次都手动的建立数组对象 
7.      只要将要操作的元素作为参数传递即可 
8.      隐式将这些参数封装成了数组 
9.  
10. 在使用时注意：可变参数一定要定义在参数列表最后面 
11.  
12.  
13. */  
14. class  ParamMethodDemo  
15. {  
16.      public static void main(String[] args)  
17.      {  
18.   
19.           show(3,4);  
20.           show(3,4,5,6,7,8,8,9);  
21.           show(3,4,3,4,6,6);  
22.      }  
23.      public static void show(int ... i)//int可以为任意类型,要和传递进来的类型保持一致  
24.      {  
25.           System.out.println(i.length);  
26.      }  
27. }  

静态导入

[java] view plaincopy

1. /* 
2. StaticImport:静态导入.     
3.  
4. 当类名重名时,需要指定具体的包名. 
5. 当方法重名时,需要指定所属的对象或者类. 
6. */  
7. import java.util.*;  
8. import static java.util.Arrays.*;//导入的是Arrays的所有静态成员(包括方法和变量)  
9. import static java.lang.System.*;  
10. class StaticImport  
11. {  
12.      public static void main(String[] args)  
13.      {  
14.           int[] arr = {5,4,7,6};  
15.   
16.           sort(arr);  
17.           int index = binarySearch(arr,5);  
18.           out.println(Arrays.toString(arr));//Object也有toString方法,所以必须指定Arrays  
19.           out.println("Index="+index);  
20.      }  
21. }  

System--Properties

[java] view plaincopy

1. /* 
2. System:类中的方法和属性都是静态的 
3. out:标准输出,默认是控制台. 
4. int:标准输入,默认是键盘. 
5. */  
6. import java.util.*;  
7. class  SystemDemo  
8. {  
9.      public static void main(String[] args)  
10.      {  
11.           Properties prop = System.getProperties();  
12.           //因为Properties是HashTable的子类,也就是Map集合的一个子类对象.  
13.           //那么可以通过Map的方法取出该集合中的元素.  
14.           //该集合中存储都是的字符串.没有泛型定义.  
15.   
16.           //在系统中自定义一些特有信息  
17.           System.setProperty("mykey","myvalue");  
18.   
19.           //获取指定属性信息  
20.           System.out.println(System.getProperty("os.name"));  
21.           /* 
22.           //获取所有属性信息 
23.           for (Object obj : prop.keySet()) 
24.           { 
25.                String value = (String)prop.get(obj); 
26.                System.out.println(obj+"::"+value); 
27.           } 
28.           */  
29.      }  
30. }  

Runtime

[java] view plaincopy

1. /* 
2. Runtime对象 
3. 该类并没有提供构造函数. 
4. 说明不可以new对象,那么会直接想到该类的方法都是静态的. 
5. 发现该类中还有非静态方法. 
6. 说明该类中肯定会提供了方法获取本类对象,该方法是静态,返回值是本类类型. 
7. 由这个特点可以看出该类使用了单例设计模式完成. 
8.  
9.  
10. 该方式是static Runtime getRuntime() 
11.  
12. */  
13. class RuntimeDemo  
14. {  
15.      public static void main(String[] args) throws Exception  
16.      {  
17.           Runtime r = Runtime.getRuntime();  
18.           Process p = r.exec("D:\\Program Files\\Baidu\\BaiduPlayer\\1.19.0.110\\BaiduPlayer.exe");  
19.   
20.           r.exec("notepad Helloworld.java");  
21.   
22.           c  
23.   
24.           p.destroy();  
25.      }  
26. }  

Date：

[java] view plaincopy

1. import java.util.Date;  
2. import java.text.*;  
3. class DateDemo  
4. {  
5.      public static void main(String[] args)  
6.      {  
7.           Date d = new Date();  
8.           System.out.println(d);  
9.   
10.           //将模式封装到SimpleDateFormat对象中  
11.           SimpleDateFormat sdf = new SimpleDateFormat("yyyy年MM月dd日E hh:mm:ss");  
12.   
13.           //调用format方法让模式格式化指定date对象  
14.           String time = sdf.format(d);  
15.   
16.           System.out.println("时间:"+time);  
17.      }  
18. <strong>}</strong>  

Calendar：类是一个抽象类，它为特定瞬间与一组诸如 YEAR、MONTH、DAY_OF_MONTH、HOUR 等日历字段之间的转换提供了一些方法

[java] view plaincopy

1. /* 
2. 两个练习: 
3. 1.获取任意年的二月有多少天. 
4. 2.获取昨天的现在这个时刻. 
5. */  
6. import java.util.*;  
7. class CalendarDemo2  
8. {  
9.      public static void main(String[] args)  
10.      {  
11.           Calendar c = Calendar.getInstance();  
12.            
13.           //c.set(2014,2,23);  
14.   
15.           c.add(Calendar.MONTH,5);  
16.   
17.           printCalendar(c);  
18.      }  
19.      public static void printCalendar(Calendar c)  
20.      {  
21.           //查表法  
22.           String[] mon = {"一月","二月","三月","四月"  
23.                               ,"五月","六月","七月","八月",  
24.                               "九月","十月","十一月","十二月"};  
25.           int index = c.get(Calendar.MONTH);  
26.   
27.           String[] week = {"","星期日","星期一","星期二","星期三","星期四"  
28.                                         ,"星期五","星期六"};      
29.           int index2 = c.get(Calendar.DAY_OF_WEEK);           
30.   
31.                           
32.   
33.           System.out.println(c.get(Calendar.YEAR)+"年");  
34.           System.out.println(mon[index]);  
35.           System.out.println(c.get(Calendar.DAY_OF_MONTH)+"日");  
36.           System.out.println(week[index2]);  
37.   
38.   
39.           /* 
40.           Date d = new Date(); 
41.  
42.           SimpleDateFormat sdf = new SimpleDateFormat("yyyy"); 
43.  
44.           String s = sdf.format(d); 
45.  
46.           System.out.println(s); 
47.           */  
48.      }  
49.   
50. }  

Math：类包含用于执行基本数学运算的方法，如初等指数、对数、平方根和三角函数

[java] view plaincopy

1. /* 
2. 练习:给定一个小数. 
3. 保留该小数的后两位. 
4. */  
5. import java.util.*;  
6. class MathDemo  
7. {  
8.      public static void main(String[] args)  
9.      {  
10.           Random r = new Random();  
11.           for(int x=0; x<10; x++)  
12.           {  
13.                //double d = (int)(Math.random()*10);//取随机数  
14.                int i = r.nextInt(10);//取0到10之间的随机数,不包含10  
15.                System.out.println(d);  
16.           }  
17.      }  
18.      public static void show()  
19.      {  
20.           double d = Math.ceil(12.34);//返回大于指定数字的最小整数  
21.           double d1 = Math.floor(12.34);//返回小于指定数字的最小整数  
22.           long l = Math.round(12.34);//四舍五入  
23.           double d2 = Math.pow(2,3);  
24.           System.out.println(d);  
25.           System.out.println(d1);  
26.           System.out.println(l);  
27.           System.out.println(d2);  
28.   
29.      }  
30. }  

------ ASP.Net+Android+IO开发.Net培训期待与您交流！ ------