集合
1.Set:无序，元素值唯一，不允许重复
  |--HashSet
  |--TreeSet：可以对Set集合中的元素进行自然排序。底层数据是二叉树。
保证元素唯一性的依据：compareTo（）方法return  0

TreeSet存储自定义对象，往TreeSet集合中存储自定义对象，根据学生年龄进行排序

排序方法一：让元素具备比较性

让自定义对象实现Comparable接口，强制让对象自身具有比较性，然后重写compareTo（）方法。这种方式也称位元素的自然顺序，或者叫默认顺序。排序时，当主要条件相同时，一定要判断一下次要条。

public int compareTo(Object obj){
                if (!(obj instanceof Student))
                        throw new RuntimeException("传入错误对象");

                Student s=(Student) obj;
                if (this.age<s.age)
                        return -1;
                if (this.age==s.age)
                        return this.name.compareTo(s.name);
                return 1;
        }

TreeSet集合的第二种排序方式
当元素不具备比较性时 ，或者具备的比较性不是所需要的，这时需要让集合自身具备比较性。在集合初始化时，就有了比较方式。
定义一个比较器，将比较器对象作为参数传递给TreeSet集合的构造函数。
定义一个类，实现comparator接口，覆盖compare（Object1，Object2）方法

当两种排序都存在时，以比较器为主

TreeSet ts=new TreeSet(new MyComparator());

class MyComparator implements Comparator
{
        public int compare(Object o1,Object o2)
        {
                Student s1=(Student) o1;
                Student s2=(Student) o2;

                int num = s1.getName().compareTo(s2.getName());
                if (num==0)
                {
                        return new Integer(s1.getAge()).compareTo(new Integer(s2.getAge()));
                }
                return num;
        }
}

练习三：//按照字符长度排序
import java.util.*;

class TreeSetTest3
{
        public static void main(String[] args)
        {
                TreeSet ts=new TreeSet(new StringLenthComparator());

                ts.add("avs");
                ts.add("dsfsdfsdf");
                ts.add("sfas");
                ts.add("asvs");
                ts.add("vs");
               
                Iterator it = ts.iterator();
                while (it.hasNext())
                {
                        System.out.println(it.next());
                }
        }
}

class StringLenthComparator implements Comparator
{
        public int compare(Object o1,Object o2)
        {
                String s1=(String)o1;
                String s2=(String)o2;

                int num=new Integer(s1.length()).compareTo(new Integer(s2.length()));

                if (num ==0)
                        num= s1.compareTo(s2);
                return num;
        }
}


2.泛型：JDK1.5版本以后出现的新特性，用于解决安全问题，是一种安全机制

好处：
1.将运行时期出现的问题ClassCsatException，转移到了编译时期
方便于程序员解决问题，让运行时期问题减少，更安全
2.避免了强转

ArrayList <参数化类型>list=new ArrayList<参数化类型>()；

Iterator <参数化类型>it = list.iterator();

//按照字符长度排序

//泛型的演示
import java.util.*;

class FanXing
{
        public static void main(String[] args)
        {
                TreeSet<String> ts=new TreeSet<String>(new StringLenthComparator());//泛型

                ts.add("avs");
                ts.add("dsfsdf");
                ts.add("vs");
               
                Iterator<String> it = ts.iterator();//泛型
                while (it.hasNext())
                        System.out.println(it.next());
        }
}

class StringLenthComparator implements Comparator<String>//泛型
{
        public int compare(String o1,String o2)
        {
                int num=new Integer(o1.length()).compareTo(new Integer(o2.length()));

                if (num ==0)
                        num= o1.compareTo(o2);

                return num;
        }
}


泛型类：
什么时候定义：
当类中要操作的的引用数据类型不确定的时候。
早期定义Object来完成扩展
现在定义泛型来完成扩展。

Class Utils <QQ>
{
Private QQ q;
public void setObject(QQ q)
{
this.q=q;
}
Public QQ getObject()
{
Return q;
}
}

Utils<Worker> u = new Utils<Worker>();

泛型类定义的泛型，在整个类中有效。如果被方法使用，那么泛型类的明确要操作的具体类型后，所有所有要操作的类型就已经固定利润。

为了让不同的方法可以操作不同类型，而且类型还不确定，那么就可以将泛型定义在方法上
class Demo
{
        public <T>void show(T t)//泛型在方法内定义，只在方法内有效，print（T t）也是可以的
        {}

        public <Q>void print（Q q）
        {}
}

特殊之处：静态方法不可以访问类上定义的泛型。如果静态方法操作的引用数据类型不确定，可以泛型定义在方法上。
  泛型去放在返回值类型之前：
Public  static  <Q>  void  method(Q q){}

泛型接口：
interface Inter<T>{
        void show(T t);
}

class Interimpl implements Inter<String>//方法一，由子类确定好参数类型
{
        public void show(String t){}
}

class Interimpl<T> implements Inter<T>//方法二，由调用者确定好参数类型
{
        public void show(T t){}
}


泛型限定：

通配符<?>，也可以理解为占位符。
<?  extends E>：可以接受E类型或者E的子类型，上限
<?  super  E>：可以接受E或者E的父类型，下限


<?  super  E>的演示
import java.util.*;
class TreeSetTestfan2
{
        public static void main(String[] args)
        {
                TreeSet<Student> ts=new TreeSet<Student>(new MyComparator());
                ts.add(new Student("lisi01"));
                ts.add(new Student("lisi02"));
       
                Iterator<Student> it=ts.iterator();

                while (it.hasNext()){
               
                        System.out.println(it.next().getName());
                }


            TreeSet<Worker> ts1=new TreeSet<Worker>(new MyComparator());
                ts1.add(new Worker("zhangsan01"));
                ts1.add(new Worker("zhangsan02"));
                       

                Iterator<Worker> it1=ts1.iterator();

                while (it1.hasNext()){
                       
                        System.out.println(it1.next().getName());

            }
        }
}

class MyComparator implements Comparator<Person>
{
        public int compare(Person o1,Person o2)
        {
                int num = o1.getName().compareTo(o2.getName());
               
                return num;
        }
}

class Person
{
        private String name;

        Person(String name)
        {
                this.name=name;
        }

        public  String getName()
        {
                return name;
        }
        public String toSting()
        {
                return "person:"+name;
        }
}
class Student extends Person
{
        Student(String name)
        {
                super(name);
        }
}

class Worker extends Person
{
        Worker(String name)
        {
                super(name);
        }
}

额 新人报道，努力中