黑马程序员_第15天

（一）   集合框架TreeSet

Set:无序，不可以重复元素。

         |--HashSet：数据结构是哈希表。线程是非同步的。

                                     保证元素唯一性的原理：判断元素的hashCode值是否相同。

                                     如果相同，还会继续判断元素的equals方法，是否为true。

         |--TreeSet：可以对Set集合中的元素进行排序。

                                     底层数据结构是二叉树。

                                     保证元素唯一性的依据：

                                     compareTo方法return 0.

 

                                     TreeSet排序的第一种方式：让元素自身具备比较性。

                                     元素需要实现Comparable接口，覆盖compareTo方法。

                                     这种方式也成为元素的自然顺序，或者叫做默认顺序。

 

                                     TreeSet的第二种排序方式。

                                     当元素自身不具备比较性时，或者具备的比较性不是所需要的。

                                     这时就需要让集合自身具备比较性。

                                     在集合初始化时，就有了比较方式。

 

当元素自身不具备比较性，或者具备的比较性不是所需要的。

这时需要让容器自身具备比较性。

定义了比较器，将比较器对象作为参数传递给TreeSet集合的构造函数。

 

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

定义一个类，实现Comparator接口，覆盖compare方法，将Comparator实例作为参数传给TreeSet容器。

 

（二）   泛型

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

好处

1，将运行时期出现问题ClassCastException，转移到了编译时期。

         方便于程序员解决问题。让运行时问题减少，安全。

2，避免了强制转换麻烦。

 

泛型格式：通过<>来定义要操作的引用数据类型。

在使用java提供的对象时，什么时候写泛型呢？

通常在集合框架中很常见，只要见到<>就要定义泛型。

其实<> 就是用来接收类型的。

当使用集合时，将集合中要存储的数据类型作为参数传递到<>中即可。

 

什么时候定义泛型类？

当类中要操作的引用数据类型不确定的时候，

早期定义Object来完成扩展。

现在定义泛型来完成扩展。

class Worker
{
}
class Student
{
}

//泛型前做法。
class Tool
{
    private Object obj;
    public void setObject(Object obj)
    {
        this.obj = obj;
    }
    public Object getObject()
    {
        return obj;
    }
}
//泛型类。
class Utils<QQ>
{
    private QQ q;
    public void setObject(QQ q)
    {
        this.q = q;
    }
    public QQ getObject()
    {
        return q;
    }
}

class  GenericDemo3
{
    public static void main(String[] args) 
    {
        Utils<Worker> u = new Utils<Worker>();
        u.setObject(new Student());
        Worker w = u.getObject();;
        /*
        Tool t = new Tool();
        t.setObject(new Student());
        Worker w = (Worker)t.getObject();
        */
    }
}

泛型类定义的泛型，在整个类中有效。如果被方法使用，

那么泛型类的对象明确要操作的具体类型后，所有要操作的类型就已经固定了。

为了让不同方法可以操作不同类型，而且类型还不确定。

那么可以将泛型定义在方法上。

 

特殊之处：

静态方法不可以访问类上定义的泛型。

如果静态方法操作的应用数据类型不确定，可以将泛型定义在方法上。

class Demo<T>
{
    public  void show(T t)
    {
        System.out.println("show:"+t);
    }
    public <Q> void print(Q q)
    {
        System.out.println("print:"+q);
    }
    public  static <W> void method(W t)
    {
        System.out.println("method:"+t);
    }
}

 泛型定义在接口上。

interface Inter<T>

{

         void show(T t);

}

 

/*

class InterImpl implements Inter<String>

{

         public void show(String t)

         {

                  System.out.println("show :"+t);

         }

}

*/

 

class InterImpl<T> implements Inter<T>

{

         public void show(T t)

         {

                   System.out.println("show :"+t);

         }

}

调用

class GenericDemo5

{

         public static void main(String[] args)

         {

                   //InterImpl i = new InterImpl();

                   //i.show("haha");

                   InterImpl<Integer> i = new InterImpl<Integer>();

                   i.show(4);

         }

}

泛型限定：

? extends E:可以接收E类型或者E的子类型。上限。

? super E:可以接收E类型或者E类型的父类型。下限。

public static void printColl(Collection<? extends Person> al)//限定为Person和Person的子类
{
    Iterator<? extends Person> it = al.iterator();
    while(it.hasNext())
    {
        System.out.println(it.next().getName());

    }
}