黑马程序员技术交流社区

标题: TreeSet、泛型限定和比较器限定方式的综合运用方式 [打印本页]
作者: itheima_llt    时间: 2015-4-17 12:28
标题: TreeSet、泛型限定和比较器限定方式的综合运用方式
  1. ##七、TreeSet、泛型限定和比较器限定方式的综合运用方式一
  2. 下面来个综合的复杂代码

  4. ```
  5. //让每一个集合自身具备比较性
  6. import java.util.*;
  7. class GenericDemo6
  8. {
  9.         public static void main(String[] args)
  10.         {
  11.                 //定义Person集，可以存放Person和Person的子类对象
  12.                 TreeSet<Person> al1 = new TreeSet<Person>();
  13.                 al1.add(new Student("Student--abc--1"));
  14.                 al1.add(new Student("Student--abc--3"));
  15.                 al1.add(new Student("Student--abc--2"));
  16.                 al1.add(new Worker("Worker--abc--2"));
  17.                 al1.add(new Worker("Worker--abc--3"));
  18.                 al1.add(new Worker("Worker--abc--1"));
  19.                 al1.add(new Person("Person--abc1"));
  20.                 al1.add(new Person("Person--abc3"));
  21.                 al1.add(new Person("Person--abc2"));
  22.                 printColl(al1);

  24.         }

  26.         public static void printColl(TreeSet<? extends Person> al)
  27.         {
  28.                 Iterator<? extends Person> it = al.iterator();

  30.                 while(it.hasNext())
  31.                 {
  32.                         System.out.println(it.next());
  33.                 }
  34.         }

  36. }

  38. class Person implements Comparable<Person>
  39. {
  40.         private String name;
  41.         Person(String name)
  42.         {
  43.                 this.name = name;
  44.         }
  45.         public String getName()
  46.         {
  47.                 return name;
  48.         }

  50.         public String toString()
  51.         {
  52.                 return name;
  53.         }

  55.         public int compareTo(Person s)
  56.         {
  57.                 return this.getName().compareTo(s.getName());
  58.         }
  59. }

  61. //<? super Person>所以<>只可以填<Person>,
  62. //注意<? super Person>的Person是跟着TreeSet<Person>中的Person走的！

  64. class Student extends Person implements Comparable<Person>
  65. {
  66.         Student(String name)
  67.         {
  68.                 super(name);
  69.         }

  71.         public int compareTo(Person s)
  72.         {
  73.                 //Person s = new Student();这个是可以接受进来的，所以能比较
  74.                 return this.getName().compareTo(s.getName());
  75.         }
  76. }

  78. class Worker extends Person implements Comparable<Person>
  79. {
  80.         Worker(String name)
  81.         {
  82.                 super(name);
  83.         }

  85.         public int compareTo(Person s)
  86.         {
  87.                 //Person s = new Worker();这个是可以接受进来的，所以能比较
  88.                 return this.getName().compareTo(s.getName());
  89.         }
  90. }
  91. ```

  93. ##八、TreeSet、泛型限定和比较器限定方式的综合运用方式二
  94. ```
  95. //让集合具备比较性
  96. import java.util.*;
  97. class GenericDemo6
  98. {
  99.         public static void main(String[] args)
  100.         {
  101.                 //定义Person集，可以存放Person和Person的子类对象
  102.                 TreeSet<Person> al1 = new TreeSet<Person>(new Comp());
  103.                 al1.add(new Student("Student--abc--1"));
  104.                 al1.add(new Student("Student--abc--3"));
  105.                 al1.add(new Student("Student--abc--2"));
  106.                 al1.add(new Worker("Worker--abc--2"));
  107.                 al1.add(new Worker("Worker--abc--3"));
  108.                 al1.add(new Worker("Worker--abc--1"));
  109.                 al1.add(new Person("Person--abc1"));
  110.                 al1.add(new Person("Person--abc3"));
  111.                 al1.add(new Person("Person--abc2"));
  112.                 printColl(al1);

  114.         }

  116.         public static void printColl(TreeSet<? extends Person> al)
  117.         {
  118.                 Iterator<? extends Person> it = al.iterator();

  120.                 while(it.hasNext())
  121.                 {
  122.                         System.out.println(it.next());
  123.                 }
  124.         }

  126. }

  128. class Person
  129. {
  130.         private String name;
  131.         Person(String name)
  132.         {
  133.                 this.name = name;
  134.         }
  135.         public String getName()
  136.         {
  137.                 return name;
  138.         }

  140.         public String toString()
  141.         {
  142.                 return name;
  143.         }
  144. }

  146. class Student extends Person
  147. {
  148.         Student(String name)
  149.         {
  150.                 super(name);
  151.         }
  152. }

  154. class Worker extends Person
  155. {
  156.         Worker(String name)
  157.         {
  158.                 super(name);
  159.         }
  160. }

  162. //<? super Person>所以<>只可以填<Person>,在本例中是不可以Person父类填写Object类的
  163. //注意<? super Person>的Person是跟着TreeSet<Person>中的Person走的！
  164. class Comp implements Comparator<Person>
  165. {
  166.         public int compare(Person s1,Person s2)
  167.         {
  168.                 return s1.getName().compareTo(s2.getName());
  169.         }
  170. }
  171. ```
复制代码






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