public static void main(String[] args)
{
  
  TreeSet<Student> ts = new TreeSet<Student>(new Comp());
  ts.add(new Student("abc03"));
  ts.add(new Student("abc02"));
  ts.add(new Student("abc06"));
  ts.add(new Student("abc01"));
  
  Iterator<Student> it = ts.iterator();
  while(it.hasNext())
  {
   System.out.println(it.next().getName());
  }


  TreeSet<Worker> ts1 = new TreeSet<Worker>(new Comp());
  ts1.add(new Worker("wabc--03"));
  ts1.add(new Worker("wabc--02"));
  ts1.add(new Worker("wabc--06"));
  ts1.add(new Worker("wabc--01"));

  Iterator<Worker> it1 = ts1.iterator();
  while(it1.hasNext())
  {
   System.out.println(it1.next().getName());
  }
}
}

class Comp implements Comparator<Person>//<? super e>
{
public int compare(Person p1,Person p2)
{
  return p2.getName().compareTo(p1.getName());
}
}
//<? super e>怎么用？不理解这个用法
class Person
{
private String name;
Person(String name)
{
  this.name = name;
}
public String getName()
{
  return name;
}
public String toString()
{
  return "person :"+name;
}
}
class Student extends Person
{
Student(String name)
{
  super(name);
}
}
class Worker extends Person
{
Worker(String name)
{
  super(name);
}
}

这个是限定传入对象类型<? super e>，限定下限，不限定上限：一般是集合取出元素时限定：
TreeMap(Comparator<? super K> comparator)  ：这个是TreeMap的构造函数中的比较器：限定下限，因为比较元素时，要将元素进行取出

<? extends e>限定上限，不限定下限：一般是往集合增加元素时候限定：
addAll(Collection<? extends E> c) ：这是Collection类的add方法，因为往集合中增加元素，所以要限定往集合中增加的元素，

感觉楼上有理

又补充掌握一个知识点 逛论坛有好处啊

zhangyangLengen 发表于 2014-11-9 14:20
这个是限定传入对象类型

可以给个实例吗？具体怎么用的呢？

嗯：
public class GenericAdvanceDemo2 {

        /**
         * @param args
         */
        public static void main(String[] args) {

                ArrayList<Person> al = new ArrayList<Person>();
               
                al.add(new Person("abc",30));
                al.add(new Person("abc4",34));
               
                ArrayList<Student> al2 = new ArrayList<Student>();
               
                al2.add(new Student("stu1",11));
                al2.add(new Student("stu2",22));
                ArrayList<String> al3 = new ArrayList<String>();
               
                al3.add("stu3331");
                al3.add("stu33332");
               
                printCollection(al2);
                printCollection(al);
        }
        /**
         * 迭代并打印集合中元素。
         *
         * 可以对类型进行限定：
         * ? extends E:接收E类型或者E的子类型对象。上限！
         *
         * ? super E ：接收E类型或者E的父类型。下限！
         * @param al
         */
        /*public static void printCollection(Collection<? extends Person> al) { //限定上限，不确定下限

                Iterator<? extends Person> it = al.iterator();
               
                while(it.hasNext()){
//                        T str = it.next();
//                        System.out.println(str);
//                        System.out.println(it.next().toString());
                        Person         p = it.next();                                                                System.out.println(p.getName()+":"+p.getAge());
                }
        }*/
       
//限定下限，不确定上限
        public static void printCollection(Collection<? super Student> al){
                Iterator<? super Student> it = al.iterator();
               
                while(it.hasNext()){
                        System.out.println(it.next());
                }
}

public class GenericAdvanceDemo4 {
        public static void main(String[] args) {

//向这个TreeSet集合中就能够进行存放Person的子类了，因为比较器中限定了Person的比较类型的下限
        TreeSet<Person> al1 =
new TreeSet<Person>(new CompByName());
               
                al1.add(new Person("abc4",34));
                al1.add(new Person("abc1",30));
                al1.add(new Person("abc2",38));
               
        TreeSet<Student> al2 =
new TreeSet<Student>(new CompByName());
               
                al2.add(new Student("stu1",11));
                al2.add(new Student("stu7",20));
                al2.add(new Student("stu2",22));
               
               
                TreeSet<String> al4 = new TreeSet<String>();
                al4.add("abcdeef");
//                al1.addAll(al4);//错误，类型不匹配。
               
//                al1.addAll(al2);
//                al1.addAll(al3);
               
//                System.out.println(al1.size());
               
                Iterator<Student> it = al2.iterator();
                while(it.hasNext()){
                        System.out.println(it.next());
                }
               
        }
}


/*
* class TreeSet<Worker>
* {
*                 Tree(Comparator<? super Worker> comp);
* }
*
* 什么时候用下限呢？通常对集合中的元素进行取出操作时，可以是用下限。
*
*/

class CompByName implements Comparator<Person>{

        @Override
        public int compare(Person o1, Person o2) {
               
                int temp = o1.getName().compareTo(o2.getName());
               
                return temp==0? o1.getAge()-o2.getAge():temp;
        }
       
}

class CompByStuName implements Comparator<Student>{
        @Override
        public int compare(Student o1, Student o2) {
               
                int temp = o1.getName().compareTo(o2.getName());
               
                return temp==0? o1.getAge()-o2.getAge():temp;
        }
}

class CompByWorkerName
implements Comparator<Worker>{
        @Override
        public int compare(Worker o1, Worker o2) {
                int temp = o1.getName().compareTo(o2.getName());
               
                return temp==0? o1.getAge()-o2.getAge():temp;
        }
}

这个要好好的理解啊

zhangyangLengen 发表于 2014-11-9 20:25
这个要好好的理解啊

哦，好的，谢谢!:handshake

没事，互相学习

我是初学者，来看看学习下