黑马程序员技术交流社区

标题: 毕老师学习笔记之泛型2 [打印本页]
作者: 骑着毛驴去赶    时间: 2014-3-16 22:10
标题: 毕老师学习笔记之泛型2
本帖最后由 骑着毛驴去赶 于 2014-3-16 22:14 编辑

四：泛型接口
五:泛型限定
1.泛型中的<?>占位符
为什么要使用这个占位符那：例如当我们定义了两个不同类型的集合时，我们想要遍历这两个集合，我们就需要定义两个方法，两Iterator迭代器
试想，既然这两个方法的功能都是一样的我们可不可以定义一个方法一个迭代器来实现那？答案是肯定的，看实例：
  1. main；
  2. ArrayList<String> arr = new ArrayList<String>();
  3. arr.add("adb");
  4. ArrayList<Integer>arr1 = new ArrayList<Integer>();
  5. arr1.add(123);
  6. //定义遍历集合的方法
  7. public static void show(ArrayList<?> arr)
  8. {
  9. //定义迭代器
  10. Iterator<?> it =arr.iterator();
  11. while(it.hasNext())
  12. {
  13. sysout(it.next());
  14. }
  15. }
复制代码


解释:由实例我们可以看出我们在定义方法时在方法是参数里我们定义了一个带<?>占位符的ArrayList集合，同时迭代器也使用了该占位符
也就是说，当我们传入的参数不确定时，我们就使用这种方式来处理
当然我们也可以通过自定义泛型来实现，不过我们需要在方法中声明该泛型
例如:public static<T> void show(ArrayList<T> arr)
注意：当我们使用泛型时弊端就是我们不能使用传入类型的特有方法，因为我们传入的参入不明确
2.泛型限定
应用场景：当存在父子继承时，例如Person类和Student类，当我们创建了一个Person类的ArrayList集合并写出该集合的迭代器
进行遍历的方法，此时一切功能都不会出问题，可是当我们传入的是子类Student 的集合时就会反生错误，此时我们就需要通过泛型的限
定来实现
实例<1>：


  1. class Person
  2. {
  3. //省略getset方法
  4. }
  5. class Student extends Person
  6. {
  7. //省略getset方法
  8. }
  9. main:
  10. ArrayList<Person> arr = new ArrayList<Person>();
  11. arr.add(new Person());
  12. ArrayList<Student> arr1 = new ArrayList<Student>();
  13. arr1.add(new Student());
  14. //定义迭代器进行遍历
  15. public static void GenericShow(ArrayList<? extends Person> arr)
  16. {
  17. Iterator <? extends Person> it = arr.iterator();
  18. while(it.hasNext())
  19. {
  20. sysout(it.next().getName());
  21. }
  22. }
复制代码

解释:
①：方法public static void GenericShow(ArrayList<? extends Person> arr)中参数<>的含义是：该参数接受的
类型是Person类或者是继承子Person类的子类类型的集合(上限限定)
②：实例<? super E>可以接受E类型后E类型的父类类型(下限限定)
错误的形参：public static void GenericShow(ArrayList<Person> arr)当我们使用这种方式进行参数的接受时，只能接受Person
类的参数其子类是无法进行传递
3.利用泛型实现比较器
应用场景：当存在父子继承时，我们想要用一个比较器来实现父类和个个子类对象的比较，此时就用到了泛型和泛型的限定来实现
实例<3-1>:

  1. import java.util.Comparator;
  2. import java.util.Iterator;
  3. import java.util.TreeSet;

  5. class Person
  6. {
  7. private String name;
  8. //省略构造器和getset方法
  9. Person(String name)
  10. {
  11. this.name=name;
  12. }
  13. public String getName()
  14. {
  15. return name;
  16. }

  18. }
  19. class Student extends Person
  20. {
  21. //省略构造器和getset方法
  22. Student(String name)
  23. {
  24. super(name);
  25. }

  27. }
  28. class Worker extends Person
  29. {
  30. //省略构造器和getset方法
  31. Worker(String name)
  32. {
  33. super(name);
  34. }

  36. }
  37. class GerenicDemo
  38. {
  39. public static void main(String[] args)
  40. {
  41. TreeSet<Person> ts1 = new TreeSet<Person>(new Comp());
  42. ts1.add(new Person("acb01"));
  43. ts1.add(new Person("acb02"));
  44. ts1.add(new Person("acb03"));
  45. TreeSet<Student> ts2 = new TreeSet<Student>(new Comp());
  46. ts2.add(new Student("sacb01"));
  47. ts2.add(new Student("sacb02"));
  48. ts2.add(new Student("sacb03"));
  49. TreeSet<Worker> ts3=new TreeSet<Worker>(new Comp());
  50. ts3.add(new Worker("wacb01"));
  51. ts3.add(new Worker("wacb03"));
  52. ts3.add(new Worker("wacb02"));

  54. GenericMethodf(ts1);
  55. GenericMethodf(ts2);
  56. GenericMethodf(ts3);
  57. }
  58. //定义遍历方法
  59. public static void GenericMethodf(TreeSet<? extends Person> arr)
  60. {
  61. Iterator<? extends Person> it = arr.iterator();
  62. while(it.hasNext())
  63. {
  64. System.out.println(it.next().getName());
  65. }
  66. }
  67. }
  68. //定义比较器
  69. class Comp implements Comparator<Person>
  70. {
  71. public int compare(Person p1,Person p2)
  72. {
  73. return p1.getName().compareTo(p2.getName());
  74. }
  75. }
复制代码

注意：我们调用的时候只能使用父类的方法例如：return p2.getName().compareTo().p2.getName();

六：Collection工具类
        1.Collection.sort(list)
                当我们在对list进行排序时，我们就用到了Collections工具类，Set集合的排序有了TreeSet的排序方法，但是
                list集合还没有专门的排序方法，所以Collections工具类就诞生了，
                Collection.sort(list)方法是对list的元素进行自然排序，如果想要进行自定义排序，则就需要定义一个比较器
                并实现Comparator接口中的comparator方法
                实例：

  1. import java.util.ArrayList;
  2. import java.util.Collection;
  3. import java.util.Collections;
  4. import java.util.Comparator;
  5. import java.util.List;

  7. /**
  8. * 利用比较器对list中的元素按字符串的长度
  9. * 进行排序
  10. * @author lenovo
  11. *
  12. */
  13. public class CllectionsSortDemo
  14. {
  15. public static void main(String[] args)
  16. {
  17. CollectionsStorMethod();
  18. }
  19. public static void CollectionsStorMethod()
  20. {
  21. List<String> list = new ArrayList<String>();
  22. list.add("aaaa");
  23. list.add("cedsg");
  24. list.add("bsbd");
  25. list.add("sbd");
  26. list.add("fbd");
  27. list.add("aa");
  28. sop("排序前："+list);
  29. Collections.sort(list,new CollectionsSort());
  30. sop("排序后："+list);
  31. }
  32. public static void sop(Object obj)
  33. {
  34. System.out.println(obj);
  35. }
  36. }
  37. class CollectionsSort implements Comparator<String>
  38. {
  39. public int compare(String obj1, String obj2) {
  40. if(obj1.length()<obj2.length())
  41. return -1;
  42. if(obj1.length()>obj2.length())
  43. return 1;
  44. return obj1.compareTo(obj2);
  45. }

  47. }
  48. 注意:只要是想实现对象间的比较就必须实现comparator或compareTo方法，不是用Comparator
  49. 接口就是Comparable接口
复制代码
2.Collections.max();//求集合中的最大值

  1. Collections.max(list);//当参数中不指定比较器的话，是按自然顺序获取最大值的
  2. 实例：
  3. import java.util.ArrayList;
  4. import java.util.Collections;
  5. import java.util.Comparator;
  6. import java.util.List;

  8. /**
  9. *
  10. * @author lenovo
  11. *
  12. */
  13. public class CollectionsMsxDemo
  14. {
  15. public static void main(String[] args)
  16. {
  17. CollectionsMaxMethod();
  18. }
  19. public static void CollectionsMaxMethod()
  20. {
  21. List<String> list = new ArrayList<String>();
  22. list.add("aaaa");
  23. list.add("cedsg");
  24. list.add("bsbd");
  25. list.add("sbd");
  26. list.add("fbd");
  27. list.add("aa");
  28. sop("排序前："+list);
  29. Collections.max(list);
  30. sop("排序后："+list);
  31. String max =Collections.max(list,new CollectionsSort());
  32. sop("最大值是："+max);
  33. }
  34. public static void sop(Object obj)
  35. {
  36. System.out.println(obj);
  37. }
  38. }
  39. class CollectionsSort implements Comparator<String>
  40. {

  42. @Override
  43. public int compare(String obj1, String obj2) {
  44. // TODO Auto-generated method stub
  45. if(obj1.length()<obj2.length())
  46. return -1;
  47. if(obj1.length()>obj2.length())
  48. return 1;
  49. return obj1.compareTo(obj2);
  50. }

  52. }
复制代码

3.Collections.binarySearch();//查找指定元素在集合中的位置(使用二分查找法)
        注意要想使用Collections.binarySearch()方法进行list元素的查找，就必须要保证次list元素
        是按照一定的顺序进行排序的，否则查找结果会发生不正确现象
        实例：

  1. import java.util.ArrayList;
  2. import java.util.Collections;
  3. import java.util.List;

  5. /**
  6. *使用Collenctions.binarySearch()进行list元素的查找
  7. * @author lenovo
  8. *
  9. */
  10. public class CollectionsBinarySearchDemo
  11. {
  12. public static void main(String[] args)
  13. {
  14. binarySearchMethod();
  15. }
  16. public static void binarySearchMethod()
  17. {
  18. List<String> list = new ArrayList<String>();
  19. list.add("aaaa");
  20. list.add("cedsg");
  21. list.add("bsbd");
  22. list.add("sbd");
  23. list.add("fbd");
  24. list.add("aa");
  25. sop("排序前："+list);
  26. Collections.max(list);
  27. sop("排序后："+list);
  28. int index =Collections.binarySearch(list,"aaaa");
  29. sop("index："+index);
  30. }

  32. public static void sop(Object obj)
  33. {
  34. System.out.println(obj);
  35. }

  37. }
  38. 解释：Collections.binarySearch(list,"")方法查找集合中的元素，放回的是该元素在集合中的位置从0开始
  39. 如果找到返回该元素的位置，没有找到返回负数(-(插入点) - 1)
  40. 解释：插入点：当前查找元素如果在集合中存在的话，其位置，即第一个大于此键的元素索引
复制代码






欢迎光临 黑马程序员技术交流社区 (http://bbs.itheima.com/) 黑马程序员IT技术论坛 X3.2