问题总结:
1) HashSet和TreeSet自定义对象覆写的方法.
HashSet自定义对象覆写HashCode和equals方法,两个对象的哈希值一样(hashCode,equals都为true)判断为相同元素.
TreeSet自定义对象需要实现Comparable接口,覆写compareTo方法,建立自己的比较功能.
2) HashSet判断元素的唯一性.
两个对象的hash值一样判为同一元素.(hashCode,equals结果都为true)
3) 为什么要用迭代器获取元素,直接输出不是也可以吗?
System.out.print只是将结果打印出来.
Iterator可以将元素取出,并在取出的同时可以对元素进行判断,删除,修改.
4) 为什么compareTo(Object obj)参数只能写Object?
因为不确定接收什么类型,而所有类都属于Object的子类,所以直接写Object.
5) 常见的见转型判断有哪些?
        1, 定义函数时对传递进来的参数和函数中参数传递的结果进行健壮性判断.2, 对于类强制转换时需要健壮性判断.
        3, 当程序需要提高运行效率时进行健壮性判断.
        4,判断传入的数值是否为空.
6) 建立完整Person类的代码执行顺序.(简称代码走的顺序)
        1, 构造函数
        2,   toString
        3, hashCode
        4, equals
        5, compareTo
        6, get
        7, set
       
泛型(JDK 1.5版本推出)
代码格式:
ArrayList<String> as = new ArrayList<String>();       //写在类的后面
好处:
1) 程序的安全性提高了,出现问题的情况由运行时期提升到编译时期.
2) 避免了类型强制转换.
泛型在TreeSet中的使用:
1) TreeSet集合类的后面添加泛型
                //在类的后面写泛型,自定义比较器一定要在TreeSet参数列表内new 对象.
                TreeSet<PersonDemo> ts = new TreeSet<PersonDemo>(new Method());
                ts.add(new PersonDemo("zhangsan",21));
                ts.add(new PersonDemo("lisi",22));
2) 自定义的比较器的实现接口后面添加泛型,compare方法接收自定义类类型的数据,省去了强制转换数据
        //实现的Comparetor类后面添加泛型
        class Method implements Comparator<PersonDemo>{
        //直接接收PersonDemo类型的值,省去了强制装换
        public int compare(PersonDemo p1,PersonDemo p2){
                /*PersonDemo p1 = (PersonDemo)o1;
                PersonDemo p2 = (PersonDemo)o2;*/
                int num = p1.getName().compareTo(p2.getName());
                return num == 0?p1.getAge()-p2.getAge():num;
        }
}
3) 构造器类后面添加泛型
Iterator<PersonDemo> i = ts.iterator();
                while (i.hasNext()){
                        System.out.println(i.next());   //覆写了toString方法后可以直接打印出元素
                }
               
泛型类(了解)
应用场景:
当我们对一个类的对象进行创建和获取的时不确定后期的对象,使用泛型类增强程序安全性.
class Tool<qq>{
        private qq q = null;
        public void set(qq q ){
                this.q = q;
        }
        public qq get(){
                return q;
        }
}

泛型方法(了解)
应用场景: 操作以个方法时,不确定方法中的参数类型,可以使用泛型方法.
public  <ww>void method (ww w){
        System.out.println("method"...+w};
}
//静态方法泛型必须定义在static后面的位置
public static<TT> void func(TT t){
        System.out.println("func..."+t);
}

泛型的通配符(?)
格式:Collection<?> coll
好处:在泛型不确定时,使用通配符可以代表任何泛型.
弊端:通配符出现在泛型中,对象的特种方法无法调用.
        //泛型输入?代表任何泛型
private static void printCollection(Collection<?> coll){
            Iterator<?> it = coll.iterator();
            while(it.hasNext()){
                    System.out.println(it.next());
            }

泛型限定(了解)
上限限定<? extends E> //E是限定的,?是不确定的,任何E类型的子类都可以传递进来
public static void main(String[] args) {
     ArrayList<ProgrGammer> ap = new ArrayList<ProgrGammer>();
     ap.add(new ProgrGammer("zhangsan1","job1",18));
     ap.add(new ProgrGammer("zhangsan2","job2",81));
     iterators(ap);
     
     ArrayList<Manager> am = new ArrayList<Manager>();
     am.add(new Manager("lisi1","manager1",25));
     am.add(new Manager("lisi2","manager2",52));
     iterators(am);
}

private static void iterators(Collection<? extends Employee> coll){
        //<? extends E>  Employee类型的子类都可以传递进来
        Iterator<? extends Employee> it = coll.iterator();
        while(it.hasNext()){
                Employee p = it.next();
                p.job();
        }
}
下限限定<? Super E> //E是限定,?是不确定的,任何E类型的父类都可以传递来

第16天的内容啊，我和你一样 啊。