黑马程序员----java基础--JDK新特性和集合其他类

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

一、JDK1.5新特性

JDK升级的三大原因：

(1)、提高代码的复用性

(2)、提高代码的安全性

(3)、简化书写

1、泛型机制

JDK1.5版本以后出现新特性。用于解决安全问题，是一个类型安全机制。

(1)、泛型概念

泛型是根据数组的思想设计出来的，因为数组一旦建立成功就已经明确了数据类型，所以可根据数组思想给集合指定类型。

如：数组：int[] arr=new int[4];

而集合的泛型：ArrayList al=new ArrayList();

ArrayList-->int; <>-->[]；al-->arr

为什么使用泛型？

在使用泛型前，存入集合中的元素可以是任何类型的，当从集合中取出时，所有的元素都是Object类型，需要进行向下的强制类型转换，转换到特定的类型。

好处：

1：将运行时期的问题ClassCastException问题转换成了编译失败，体现在编译时期，程序员就可以解决问题。

2：避免了强制转换的麻烦。 

只要带有<>的类或者接口，都属于带有类型参数的类或者接口，在使用这些类或者接口时，必须给<>中传递一个具体的引用数据类型。

泛型技术：其实应用在编译时期，是给编译器使用的技术，到了运行时期，泛型就不存在了。

为什么? 因为泛型的擦除：也就是说，编辑器检查了泛型的类型正确后，在生成的类文件中是没有泛型的。

在运行时，如何知道获取的元素类型而不用强转呢？

泛型的补偿：因为存储的时候，类型已经确定了是同一个类型的元素，所以在运行时，只要获取到该元素的类型，在内部进行一次转换即可，所以使用者不用再做转换动作了。 

什么时候用泛型类呢？

当类中的操作的引用数据类型不确定的时候，以前用的Object来进行扩展的，现在可以用泛型来表示。这样可以避免强转的麻烦，而且将运行问题转移到的编译时期。

泛型类型参数只能被类或接口类型赋值，不能被基本数据类型赋值，基本数据类型需要使用对应的包装类。

泛型前：

 1 import java.util.*;
 2 //没有使用泛型前。有很大的安全隐患，在编译时期不会检查出来错误，但是运行的时候就出现了错误
 3 class GenericDemo 
 4 {
 5     public static void main(String[] args) 
 6     {
 7         ArrayList al=new ArrayList();
 8         al.add("java01");
 9         al.add("java02");
10         al.add("java03");
11         al.add(545);
12         for (Iterator it=al.iterator();it.hasNext() ; )
13         {
14             String str=(String)it.next();//这里需要强转。.ClassCastException
15             System.out.println(str);
16         }
17     }
18 }

 泛型后：

 1 import java.util.*;
 2 //泛型出现后，增加了程序的安全性，直接把问题在编译时期暴露出来
 3 class GenericDemo 
 4 {
 5     public static void main(String[] args) 
 6     {
 7         //增加泛型，明确集合中存放的对象是String，直接把错误暴露在编译时期
 8         ArrayList al=new ArrayList();
 9         al.add("java01");
10         al.add("java02");
11         al.add("java03");
12 //      al.add(545);//error；
13         for (Iterator it=al.iterator();it.hasNext() ; )
14         {
15             String str=it.next();//这里不用强制转换
16             System.out.println(str);
17         }
18     }
19 }

 示例：

 1 import java.util.*;
 2 class GenericDemo 
 3 {
 4     public static void main(String[] args) 
 5     {
 6 
 7         ArrayList al=new ArrayList();
 8         al.add("abc");
 9         al.add("abqqe");
10         al.add("k");
11         al.add("fd");        
12         Collections.sort(al,Collections.reverseOrder(new LenComparator()));//逆转LenComparator比较器的比较顺序
13         for (Iterator it=al.iterator();it.hasNext() ; )
14         {
15             String str=it.next();
16             System.out.println(str);
17         }
18     }
19 }
20 //按照字符串的长度进行排序
21 class LenComparator implements Comparator
22 {
23     public int compare(String s1,String s2){
24         int num= s1.length()-s2.length();
25         return num==0?s1.compareTo(s2):num;
26     }
27 }

 (2)、泛型类：将泛型定义在类上

在定义带类型参数的类时，在紧跟类命之后的<>内,指定一个或多个类型参数的名字，同时也可以对类型参数的取 值范围进行限定，多个类型参数之间用,号分隔。

泛型出现前设计类方法：用Object来代替任意对象，但是这种设计方式编译时期不会报错（因为Object任何类型都能接收）运行时期容易出现ClassCastException异常，而且还得强转。

泛型出现前：

 1 class Student{}
 2 class Worker{}
 3 class Tool{
 4     private Object obj;
 5     public void setObject(Object obj){
 6         this.obj=obj;
 7     }
 8     public Object getObject(){
 9         return obj;
10     }
11 }
12 class Dmeo{
13     public static void main(Sting[] args){
14         Tool t=new Tool();
15         t.setObject(new Student());//Object obj=new Student();这里可以传入任意类型的对象，Objec都可以接收
16         Student s=(Student)t.getObject();//强转，容易出现ClassCastException异常
17     }
18 }

 泛型出现后的设计思想：当类中要操作的引用数据类型不确定的时候，这是把泛型定义在类上。泛型类定义的泛型，在整个类中有效。如果被方法使用，那么泛型类的对象明确要操作的具体类型后，所有要操作的类型就已经固定了。

 1 import java.util.*;
 2 class Student
 3 {
 4 }
 5 class Worker
 6 {
 7 }
 8 class Utils
 9 {
10     private T t;    
11     public void setObject(T t){
12         this.t=t;
13     }
14     public T getObject(){
15         return t;
16     }
17 }
18 class GenericDemo2 
19 {
20     public static void main(String[] args)     {
21         
22         Utils u=new Utils();
23         u.setObject(new Student());//如果传入的不是Student对象，编译时期就会直接报错。
24         Student s=u.getObject();//避免强转
25     }
26 }

 (3)、泛型方法；泛型定义在方法上

为了让不同方法可以操作不同类型，而且类型还不确定。那么可以将泛型定义在方法上。当方法和类上都有泛型的时候，方法内的操作以方法上的泛型为依据，与类上的泛型无关。

注意：方法上的泛型定义在返回值类型的前面即可，如：返回值。

 1 import java.util.*;
 2 class Demo
 3 {
 4     public void show(T t){
 5         System.out.println(t);
 6     }
 7     public void print(T t){
 8         System.out.println(t);
 9     }
10 }
11 class GenericDemo3 
12 {
13     public static void main(String[] args) 
14     {
15         Demo d=new Demo();
16         d.show("你好");
17         d.print("你也好");
18 //        d.print(234);//error;不兼容的类型: int无法转换为String
19         //怎么既能让print()打印Integer又能打印String呢？
20         Demo d1=new Demo();
21         d1.print(45);
22         //上面的方法有点繁琐，而且内存中的对象太多，可以采用把泛型定//义在方法上解决。
23     }
24 }

 代码修正后：

 1 import java.util.*;
 2 class Demo
 3 {
 4     public void show(T t){
 5         System.out.println(t);
 6     }
 7     public void print(E e){
 8         System.out.println(e);
 9     }
10     public void run(Q q){
11         System.out.println(q);
12     }
13 }
14 class GenericDemo3
15 {
16     public static void main(String[] args){
17         Demo d=new Demo();        
18         d.print(78);
19         d.print("你好");
20         d.show("你也好");
21         d.show(34);//不兼容的类型: int无法转换为String.该方法上没有定义泛型，所以还是跟着类上的泛型走的。
22         d.run(65);
23     }
24 }

 特殊之处：

静态方法不可以访问类上定义的泛型。(静态优先于对象存在)

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

public static void function(Q t) {

       System.out.println("function:"+t);

}

(4)、泛型接口：泛型定义在接口上

如果子类明确了父类(接口)的类型，在创建对象的时候不需要再次明确泛型的类型了。

 1 interface Inter{
 2     public abstract void show(T t);
 3 }
 4 class Demo implements Inter{
 5     public void show(String s){
 6         System.out.println(“show==”+s);
 7     }
 8 }
 9 class GenericDemo{
10     public static void main(String[] args){
11         Demo d=new Demo();//这里不带泛型，因为子类实现接口的时候已经指定了泛型的类型，如果加上会出现错误: Demo不带有参数
12         d.show(“hhahah”);
13     }
14 }

 如果子类实现父类(接口)的时候也不确定什么类型的时候，子类也可以加上泛型，这时候创建子类对象的时候必须明确泛型类型。

 1 interface Inter{
 2     public abstract void show(T t);
 3 }
 4 class Demo implements Inter{
 5     public void show(T t){
 6         System.out.println(“show==”+t);
 7     }
 8 }
 9 class GenericDemo{
10     public static void main(String[] args){
11         Demo d=new Demo();
12         d.show(4);
13     }
14 }

 (5)、泛型通配符：

泛型中的通配符：可以解决当具体类型不确定的时候，这个通配符就是 ?  ；当操作类型时，不需要使用类型的具体功能时，只使用Object类中的功能。那么可以用 ? 通配符来表未知类型。

 1 class GenericDemo{
 2     public static void main(String[] args){
 3         ArrayList al =new ArrayList();
 4         al.add(“abc1”);
 5         al.add("abc2");
 6         al.add("abc3");
 7         ArrayList al1=new ArrayList();
 8         al1.add(4);
 9         al1.add(7);
10         al1.add(1);
11         //怎么可以方便的获取到两个集合中的数据呢？
12         printColl(al);
13         printColl(al1);
14     }
15     public static void printColl(ArrayList al){
16     //这里的？也可以换成T，效果都是一样的，但是换成T有个好处就是可以对T进行操作。
17     //如果换成T要在函数上定义一下。
18         for(Iteratorit =al.iterator();it.hasNext();){
19             //T t=it.next();
20         System.out.println(it.next());
21         }
22     }
23 }

 (6)、泛型限定

上限：？extends E：可以接收E类型或者E的子类型对象。

下限：？super E：可以接收E类型或者E的父类型对象。

上限什么时候用：往集合中添加元素时，既可以添加E类型对象，又可以添加E的子类型对象。为什么？因为取的时候，E类型既可以接收E类对象，又可以接收E的子类型对象。

下限什么时候用：当从集合中获取元素进行操作的时候，可以用当前元素的类型接收，也可以用当前元素的父类型接收。

TreeSet(Comparator comparator)

Comparable

TreeSet(Collection c)

代码演示：

 1 import java.util.*;
 2 class Person
 3 {
 4     private String name;
 5     Person(String name)
 6     {
 7         this.name = name;
 8     }
 9     public String getName()
10     {
11         return name;
12     }
13     public String toString()
14     {
15         return name;
16     }
17 }
18 class Student extends Person
19 {
20     Student(String name)
21     {
22         super(name);
23     }
24 }
25 class Worker extends Person
26 {
27     Worker(String name)
28     {
29         super(name);
30     }
31 }
32 class Comp implements Comparator
33 {
34     public int compare(Person p1,Person p2)
35     {
36         return p2.getName().compareTo(p1.getName());
37     }
38 }
39 class GenericDemo
40 {
41     public static void main(String[] args) 
42     {        
43         TreeSet ts = new TreeSet(new Comp());
44         ts.add(new Student("abc03"));
45         ts.add(new Student("abc02"));
46         ts.add(new Student("abc06"));
47         ts.add(new Student("abc01"));            
48         TreeSet ts1 = new TreeSet(new Comp());
49         ts1.add(new Worker("wabc--03"));
50         ts1.add(new Worker("wabc--02"));
51         ts1.add(new Worker("wabc--06"));
52         ts1.add(new Worker("wabc--01"));
53         printSet(ts);
54         printSet(ts1);    
55     }
　　　　//可以迭代Person类以及Person类的子类
56     public static void printSet(TreeSetextends Person> ts){
57         for (Iteratorextends Person> it=ts.iterator();it.hasNext() ; )
58         {
59             System.out.println(it.next().toString());
60         }
61     }    
62 }

 泛型的细节：

）、泛型到底代表什么类型取决于调用者传入的类型，如果没传，默认是Object类型；

2）、使用带泛型的类创建对象时，等式两边指定的泛型必须一致；

       原因：编译器检查对象调用方法时只看变量，然而程序运行期间调用方法时就要考虑对象具体类型了；

3）、等式两边可以在任意一边使用泛型，在另一边不使用(考虑向后兼容)；

ArrayList al = new ArrayList