--------- android培训、java培训、期待与您交流! ----------
4 泛型在集合中的使用
4.1泛型介绍
1,在Java SE 1.5之前,没有泛型的情况的下,通过对类型Object的引用来实现参数的“任意化”,“任意化”带来的缺点是要做显式的强制类型转换,而这种转换是要求开发者对实际参数类型可以预知的情况下进行的。对于强制类型转换错误的情况,编译器可能不提示错误,在运行的时候才出现异常,这是一个安全隐患。JDK1.5版本以后出现新特性,用来解决安全问题,是一个类型安全机制。
2,泛型的好处:
- 将运行时期出现问题ClassCastException,转移到了编译时期。 方便于程序员解决问题。让运行时问题减少,安全。,
- 避免了强制转换麻烦。
3,泛型格式:通过<>来定义要操作的引用数据类型
4,什么时候使用泛型?
- 通常在集合框架中很常见,只要见到<>就要定义泛型。
- 其实<> 就是用来接收类型的。
- 当使用集合时,将集合中要存储的数据类型作为参数传递到<>中即可。
4.2 泛型的使用
1, ArrayList<String> al = new ArrayList<String>();//该集合中只能存入String类型的数据。
遍历存入ArrayList集合中元素并输出对应元素的长度。
1 import java.util.*; 2 3 4 class GenericDemo 5 { 6 public static void main(String[] args) 7 { 8 9 ArrayList<String> al=new ArrayList<String>();//规定了只能存入String类型数据 10 11 al.add("abcd234"); 12 al.add("abcd234567"); 13 al.add("abcd2346789"); 14 15 Iterator<String> it = al.iterator(); 16 while(it.hasNext()) 17 { 18 String s = it.next(); 19 20 System.out.println(s+":"+s.length()); 21 } 22 } 23 }
2,TreeSet<String> ts = new TreeSet<String>(new LenComparator());
比较元素的长度并按长度降序排列。当长度相同的元素,按自然顺序的倒序排列。
1 import java.util.*; 2 class GenericDemo2 3 { 4 public static void main(String[] args) 5 { 6 //按比较器比较元素的长度并输出, 7 TreeSet<String> ts = new TreeSet<String>(new LenComparator()); 8 9 //添加元素,元素只能是String类型 10 ts.add("abcd"); 11 ts.add("cc"); 12 ts.add("cba"); 13 ts.add("aaa"); 14 ts.add("z"); 15 ts.add("hahaha"); 16 17 //迭代器遍历元素,迭代器数据类型必须和集合的数据类型一致 18 Iterator<String> it = ts.iterator(); 19 20 while(it.hasNext()) 21 { 22 String s = it.next(); 23 System.out.println(s); 24 } 25 } 26 } 27 //同样比较器也使用了泛型,且数据类型与集合的数据类型保持一致。 28 class LenComparator implements Comparator<String> 29 { 30 public int compare(String o1,String o2) 31 { 32 int num = new Integer(o2.length()).compareTo(new Integer(o1.length())); 33 34 if(num==0) 35 return o2.compareTo(o1); 36 return num; 37 } 38 }
3,泛型类的使用
什么时候定义泛型类?
当类中要操作的引用数据类型不确定的时候,
早期定义Object来完成扩展。
现在定义泛型来完成扩展。
/* class Tool { private Worker w; public void setWorker(Worker w) { this.w = w; } public Worker getWorker() { return w; } } */ class Worker { } class Student { } //泛型前做法。 class Tool { private Object obj; public void setObject(Object obj) { this.obj = obj; } public Object getObject() { return obj; } } //泛型类。 /* 什么时候定义泛型类? 当类中要操作的引用数据类型不确定的时候, 早期定义Object来完成扩展。 现在定义泛型来完成扩展。 */ class Utils<QQ> { private QQ q; public void setObject(QQ q) { this.q = q; } public QQ getObject() { return q; } } class GenericDemo3 { public static void main(String[] args) { Utils<Worker> u = new Utils<Worker>(); u.setObject(new Worker()); //u.setObject(new student());//把错误在编译时显示出来 Worker w = u.getObject();//不用再强制转换 /* Tool t = new Tool(); t.setObject(new Student()); Worker w = (Worker)t.getObject(); */ } }
4,泛型方法的使用
- 泛型类定义的泛型,在整个类中有效。如果被方法使用,
- 那么泛型类的对象明确要操作的具体类型后,所有要操作的类型就已经固定了。
- 为了让不同方法可以操作不同类型,而且类型还不确定。
- 那么可以将泛型定义在方法上。
- 特殊之处:
静态方法不可以访问类上定义的泛型。
如果静态方法操作的应用数据类型不确定,可以将泛型定义在方法上。
1 class Demo<T> 2 { 3 //不同方法可以操作不同类型,同一个方法也可以操作不同类型 4 public void show(T t) 5 { 6 System.out.println("show:"+t); 7 } 8 public <Q> void print(Q q) 9 { 10 System.out.println("print:"+q); 11 } 12 public static <W> void method(W t) 13 { 14 System.out.println("method:"+t); 15 } 16 } 17 class GenericDemo4 18 { 19 public static void main(String[] args) 20 { 21 Demo <String> d = new Demo<String>(); 22 d.show("haha"); 23 //d.show(4); 24 d.print(5); 25 d.print("hehe"); 26 27 Demo.method("xixixixiixi"); 28 29 /* 30 Demo d = new Demo(); 31 d.show("haha"); 32 d.show(new Integer(4)); 33 d.print("heihei"); 34 */ 35 /* 36 Demo<Integer> d = new Demo<Integer>(); 37 38 d.show(new Integer(4)); 39 d.print("hah"); 40 41 Demo<String> d1 = new Demo<String>(); 42 d1.print("haha"); 43 d1.show(5); 44 */ 45 } 46 }
5,泛型也可以定义在接口上
用法举例:
1 interface Inter<T> 2 { 3 void show(T t); 4 } 5 6 /* 7 class InterImpl implements Inter<String> 8 { 9 public void show(String t) 10 { 11 System.out.println("show :"+t); 12 } 13 } 14 15 */ 16 17 class InterImpl<T> implements Inter<T> 18 { 19 public void show(T t) 20 { 21 System.out.println("show :"+t); 22 } 23 } 24 class GenericDemo5 25 { 26 public static void main(String[] args) 27 { 28 29 InterImpl<Integer> i = new InterImpl<Integer>(); 30 i.show(4); 31 //InterImpl i = new InterImpl(); 32 //i.show("haha"); 33 } 34 }
6,泛型的限定
? 通配符。也可以理解为占位符。
泛型的限定;
? extends E: 可以接收E类型或者E的子类型。上限。
? super E: 可以接收E类型或者E的父类型。下限
1 import java.util.*; 2 3 class GenericDemo6 4 { 5 public static void main(String[] args) 6 { 7 /* 8 ArrayList<String> al = new ArrayList<String>(); 9 10 al.add("abc1"); 11 al.add("abc2"); 12 al.add("abc3"); 13 14 ArrayList<Integer> al1 = new ArrayList<Integer>(); 15 al1.add(4); 16 al1.add(7); 17 al1.add(1); 18 19 printColl(al); 20 printColl(al1); 21 */ 22 23 ArrayList<Person> al = new ArrayList<Person>(); 24 al.add(new Person("abc1")); 25 al.add(new Person("abc2")); 26 al.add(new Person("abc3")); 27 printColl(al); 28 29 ArrayList<Student1> al1 = new ArrayList<Student1>(); 30 al1.add(new Student1("abc--1")); 31 al1.add(new Student1("abc--2")); 32 al1.add(new Student1("abc--3")); 33 printColl(al1); //ArrayList<? extends Person> al = new ArrayList<Student>();error 34 35 TreeSet<Student1> ts = new TreeSet<Student1>(new Comp()); 36 ts.add(new Student1("tsabc1")); 37 ts.add(new Student1("tsabc2")); 38 ts.add(new Student1("tsabc3")); 39 40 printColl(ts); 41 } 42 /** 43 * 可以接收Person类型或者其子类型 44 * @param al 45 */ 46 public static void printColl(Collection<? extends Person> al) 47 { 48 Iterator<? extends Person> it = al.iterator(); 49 50 51 while(it.hasNext()) 52 { 53 System.out.println(it.next().getName()); 54 } 55 } 56 /* 57 public static void printColl(ArrayList<?> al)//ArrayList al = new ArrayList<Integer>();error 58 { 59 Iterator<?> it = al.iterator(); 60 61 62 while(it.hasNext()) 63 { 64 System.out.println(it.next().toString()); 65 } 66 } 67 */ 68 } 69 70 class Person 71 { 72 private String name; 73 Person(String name) 74 { 75 this.name = name; 76 } 77 public String getName() 78 { 79 return name; 80 } 81 } 82 83 class Student1 extends Person 84 { 85 Student1(String name) 86 { 87 super(name); 88 } 89 90 } 91 92 93 /* 94 95 class Student implements Comparable<Person>//<? super E> 96 { 97 public int compareTo(Person s) 98 { 99 this.getName() 100 } 101 } 102 */ 103 class Comp implements Comparator<Person> 104 { 105 public int compare(Person s1,Person s2) 106 { 107 108 //Person s1 = new Student("abc1"); 109 return s1.getName().compareTo(s2.getName()); 110 } 111 }
1 import java.util.*; 2 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 public String toString() 15 { 16 return "person :"+name; 17 } 18 } 19 20 class Student extends Person 21 { 22 Student(String name) 23 { 24 super(name); 25 } 26 27 } 28 29 class Worker extends Person 30 { 31 Worker(String name) 32 { 33 super(name); 34 } 35 } 36 class GenericDemo7 37 { 38 public static void main(String[] args) 39 { 40 41 TreeSet<Student> ts = new TreeSet<Student>(new Comp()); 42 43 ts.add(new Student("abc03")); 44 ts.add(new Student("abc02")); 45 ts.add(new Student("abc06")); 46 ts.add(new Student("abc01")); 47 48 Iterator<Student> it = ts.iterator(); 49 50 while(it.hasNext()) 51 { 52 System.out.println(it.next().getName()); 53 } 54 /**/ 55 56 57 58 TreeSet<Worker> ts1 = new TreeSet<Worker>(new Comp()); 59 60 ts1.add(new Worker("wabc--03")); 61 ts1.add(new Worker("wabc--02")); 62 ts1.add(new Worker("wabc--06")); 63 ts1.add(new Worker("wabc--01")); 64 65 66 Iterator<Worker> it1 = ts1.iterator(); 67 68 while(it1.hasNext()) 69 { 70 System.out.println(it1.next().getName()); 71 } 72 } 73 } 74 75 /* 76 class StuComp implements Comparator<Student> 77 { 78 public int compare(Student s1,Student s2) 79 { 80 return s1.getName().compareTo(s2.getName()); 81 } 82 } 83 84 class WorkerComp implements Comparator<Worker> 85 { 86 public int compare(Worker s1,Worker s2) 87 { 88 return s1.getName().compareTo(s2.getName()); 89 } 90 } 91 */ 92 //将上面两个比较器可以合并成一个,类型限定为父类型Person,这样可以接收其子类型的对象 93 class Comp implements Comparator<Person> 94 { 95 public int compare(Person p1,Person p2) 96 { 97 return p2.getName().compareTo(p1.getName()); 98 } 99 }
--------- android培训、java培训、期待与您交流! --------详细请查看:http://edu.csdn.net/heima/