集合的泛型

一：泛型的普通使用

1.集合泛型的好处

　　是一种安全机制，将运行时可能出现的问题转移到编译时期

　　避免了强转

2.程序示例

 1 import java.util.ArrayList;
 2 import java.util.Iterator;
 3 
 4 public class Test49 {
 5 
 6     public static void main(String[] args) {
 7         ArrayList<String> a=new ArrayList<>();
 8         a.add("java1");
 9         a.add("java2ww");
10         a.add("java3");
11         Iterator<String> it=a.iterator();
12         while(it.hasNext()){
13             String s=it.next();
14             System.out.println(s.length());
15         }
16     }
17 
18 }

3.简单使用

　　Comparator比较器同样有泛型，这时，compare就会自带和比较器相同的类型

 1 import java.util.Comparator;
 2 import java.util.TreeSet;
 3 
 4 public class Test50 {
 5 
 6     public static void main(String[] args) {
 7         TreeSet<String> t=new TreeSet<>(new wor());
 8         t.add("aaaaa");
 9         t.add("bbb");
10         t.add("abcd");
11         t.add("bbd");
12         System.out.println(t);
13     }
14 
15 }
16 
17 class wor implements Comparator<String>{
18 
19     @Override
20     public int compare(String o1, String o2) {
21         int num=new Integer(o1.length()).compareTo(new Integer(o2.length()));
22         if(num==0){
23             return o1.compareTo(o2);
24         }
25         return num;
26     }
27     
28 }

4.泛型类

　　当引用类型不确定的时候，可以使用泛型类。当类上确定了一个类型之后，再操作就是这个类型的操作，除非重新定义一个对象，就是换成新的类型

 1 public class Test51 {
 2 
 3     public static void main(String[] args) {        
 4         out<String> out1=new out<String>();
 5         out1.show("aa");
 6         out1.print("jui");
 7     }
 8 }
 9 class out<T>{
10     public void show(T t){
11         System.out.println("show :"+t);
12     }
13     public void print(T t){
14         System.out.println("print :"+t);
15     }
16 }

5.泛型方法

　　不像泛型类，当类已经确定之后，方法的类型必须跟着类的类型运行。

　　相同的方法可以被任意的类型使用。

 1 public class Test52 {
 2 
 3     public static void main(String[] args) {
 4         out1 out=new out1();
 5         out.show("hhh");
 6         out.show(7);
 7         out.print("uuuu");
 8     }
 9 
10 }
11 class out1{
12     public <T> void show(T t){
13         System.out.println("show :"+t);
14     }
15     public <Q> void print(Q q){
16         System.out.println("print :"+q);
17     }
18 }

6.泛型类和泛型方法的结合

 1 public class Test53 {
 2 
 3     public static void main(String[] args) {
 4         out2<String> out=new out2<>();
 5         out.show("hhh");               //这个只能跟着泛型类的方法走
 6         out.print(5);
 7     }
 8 
 9 }
10 class out2<T>{
11     public void show(T t){             //这个是属于泛型类的方法
12         System.out.println("show :"+t);
13     }
14     public <Q> void print(Q q){        //这个属于泛型方法
15         System.out.println("print :"+q);
16     }
17 }

7.静态方法的泛型问题

　　静态方法不可以访问泛型类上定义的类型，因为是静态，但是可以定义在方法上，就是静态方法泛型。

 1 public class Test54 {
 2 
 3     public static void main(String[] args) {
 4         out3<String> out=new out3<>();
 5         out.show("aa");
 6         out.print(88);
 7         out.method("cccccc");
 8     }
 9 
10 }
11 class out3<T>{
12     public void show(T t){             //这个是属于泛型类的方法
13         System.out.println("show :"+t);
14     }
15     public <Q> void print(Q q){        //这个属于泛型方法
16         System.out.println("print :"+q);
17     }
18     public static <W> void method(W w){//静态方法的泛型
19         System.out.println("method :"+w);
20     } 
21 }

8.泛型接口

 1 interface inter<T>{
 2     void show(T t);
 3 }
 4 class impInter1 implements inter<String>{   //当继承接口时，类型已经知道
 5     @Override
 6     public  void show(String t) {
 7         System.out.println("t :"+t);
 8     }    
 9 }
10 class impInter2<T> implements inter<T>{   //当继承接口时，类型仍然不知道，在类后面同样跟着T
11     @Override
12     public  void show(T t) {
13         System.out.println("t :"+t);
14     }    
15 }
16 public class Test55 {
17     public static void main(String[] args) {
18         impInter1 imp0=new impInter1();            //类型已经被接口给定义好了
19         imp0.show("yubh");
20         impInter2<String> imp1=new impInter2<>();
21         imp1.show("yubh");
22         impInter2<Integer> imp2=new impInter2<>();
23         imp2.show(888);
24     }
25 
26 }

二：泛型的高级使用，泛型的限定

1.通配符？

 1 import java.util.ArrayList;
 2 import java.util.Iterator;
 3 
 4 public class Test56 {
 5 
 6     public static void main(String[] args) {
 7         ArrayList<String> al = new ArrayList<String>();
 8         al.add("abc1");
 9         al.add("abc2");
10         al.add("abc3");
11         ArrayList<Integer> al1 = new ArrayList<Integer>();
12         al1.add(4);
13         al1.add(7);
14         al1.add(1);
15         printColl(al);
16         printColl(al1);
17     }
18     public static void printColl(ArrayList<?> al)    //通配符
19     {
20         Iterator<?> it = al.iterator();
21         while(it.hasNext())
22         {
23             System.out.println(it.next());
24         }
25     }
26 }

2.? extends E,上限定

 1 import java.util.ArrayList;
 2 import java.util.Iterator;
 3 
 4 class Persony
 5 {
 6     private String name;
 7     Persony(String name)
 8     {
 9         this.name = name;
10     }
11     public String getName()
12     {
13         return name;
14     }
15 }
16 class Studenty extends Persony
17 {
18     Studenty(String name)
19     {
20         super(name);
21     }
22 
23 }
24 public class Test57 {
25     public static void main(String[] args) {        
26         ArrayList<Persony> al = new ArrayList<Persony>();
27         al.add(new Persony("abc1"));
28         al.add(new Persony("abc2"));
29         al.add(new Persony("abc3"));
30         printColl(al);
31         ArrayList<Studenty> al1 = new ArrayList<Studenty>();
32         al1.add(new Studenty("abc--1"));
33         al1.add(new Studenty("abc--2"));
34         al1.add(new Studenty("abc--3"));
35         printColl(al1);
36     }
37     public static void printColl(ArrayList<? extends Persony> al)   //? extends Persony 是上线
38     {
39         Iterator<? extends Persony> it = al.iterator();
40         while(it.hasNext())
41         {
42             System.out.println(it.next().getName());
43         }
44     }
45 }

3.下限

 1 import java.util.Collection;
 2 import java.util.Comparator;
 3 import java.util.Iterator;
 4 import java.util.TreeSet;
 5 
 6 public class Test58 {
 7     public static void main(String[] args) {
 8         TreeSet<Studentt> ts = new TreeSet<Studentt>(new Comp());
 9         ts.add(new Studentt("abc1"));
10         ts.add(new Studentt("abc5"));
11         ts.add(new Studentt("abc3"));
12         printColl(ts);
13     }
14     public static void printColl(TreeSet<Studentt> ts)
15     {
16         Iterator<Studentt> it = ts.iterator();
17         while(it.hasNext())
18         {
19             System.out.println(it.next().getName());
20         }
21     }
22 }
23 class Persont
24 {
25     private String name;
26     Persont(String name)
27     {
28         this.name = name;
29     }
30     public String getName()
31     {
32         return name;
33     }
34 }
35 
36 class Studentt extends Persont
37 {
38     Studentt(String name)
39     {
40         super(name);
41     }
42 
43 }
44 class Comp implements Comparator<Persont>            //studentt是下限，Comparable<? super E>是用法
45 {
46     public int compare(Persont s1,Persont s2)
47     {
48         return s1.getName().compareTo(s2.getName());
49     }
50 }