黑马程序员——集合（中）——TreeSet、泛型

——- android培训、java培训、期待与您交流！ ———-

1.1，TreeSet
TreeSet:可以对Set集合中的元素进行排序。
底层数据结构是二叉树。
保证元素唯一性的依据：
compareTo方法return 0.

1.2，TreeSet排序的两种方式
1，第一种方式：自然顺序
让元素自身具备比较性，元素需要实现Comparable接口，覆盖compareTo方法。
这种方式也被称为元素的自然顺序，或者叫做默认顺序。

2，第二种方式：比较器
当元素自身不具备比较性时，或者具备的比较性不是所需要的。
这时就需要让集合自身具备比较性，在集合初始化时，就有了比较方式。
定义一个比较器，将比较器对象作为参数传递给TreeSet集合的构造函数。

注： 比较器构造方式：定义一个类，实现Comparator接口，覆盖compare方法。
     当两种排序都存在时，以比较器为主。

示例：

import java.util.*;

/*
当元素自身不具备比较性，或者具备的比较性不是所需要的。
这时需要让容器自身具备比较性。
定义了比较器，将比较器对象作为参数传递给TreeSet集合的构造函数。

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

定义一个类，实现Comparator接口，覆盖compare方法。


*/
class Student implements Comparable//该接口强制让学生具备比较性。
{
    private String name;
    private int age;

    Student(String name,int age)
    {
        this.name = name;
        this.age = age;
    }

    public int compareTo(Object obj)
    {

        //return 0;

        if(!(obj instanceof Student))
            throw new RuntimeException("不是学生对象");
        Student s = (Student)obj;

        //System.out.println(this.name+"....compareto....."+s.name);
        if(this.age>s.age)
            return 1;
        if(this.age==s.age)
        {
            return this.name.compareTo(s.name);
        }
        return -1;
        /**/
    }

    public String getName()
    {
        return name;

    }
    public int getAge()
    {
        return age;
    }
}
class TreeSetDemo2 
{
    public static void main(String[] args) 
    {
        TreeSet ts = new TreeSet();

        ts.add(new Student("lisi02",22));
        ts.add(new Student("lisi02",21));
        ts.add(new Student("lisi007",20));
        ts.add(new Student("lisi09",19));
        ts.add(new Student("lisi06",18));
        ts.add(new Student("lisi06",18));
        ts.add(new Student("lisi007",29));
        //ts.add(new Student("lisi007",20));
        //ts.add(new Student("lisi01",40));

        Iterator it = ts.iterator();
        while(it.hasNext())
        {
            Student stu = (Student)it.next();
            System.out.println(stu.getName()+"..."+stu.getAge());
        }
    }
}

class MyCompare 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()));
            /*
            if(s1.getAge()>s2.getAge())
                return 1;
            if(s1.getAge()==s2.getAge())
                return 0;
            return -1;
            */
        }


        return num;

    }
}

2.1，泛型
泛型：JDK1.5版本以后出现新特性。用于解决安全问题，是一个类型安全机制。
泛型格式：通过<>来定义要操作的引用数据类型。

2.2，泛型的好处
1.将运行时期出现问题ClassCastException，转移到了编译时期。，
方便于程序员解决问题。让运行时问题减少，安全。，

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

2.3，在使用java提供的对象时，什么时候写泛型呢？
通常在集合框架中很常见，只要见到<>就要定义泛型。
其实<> 就是用来接收类型的。
当使用集合时，将集合中要存储的数据类型作为参数传递到<>中即可。

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

2.5，泛型方法
泛型类定义的泛型，在整个类中有效。如果被方法使用，
那么泛型类的对象明确要操作的具体类型后，所有要操作的类型就已经固定了。
为了让不同方法可以操作不同类型，而且类型还不确定。
那么可以将泛型定义在方法上。

特殊之处：
静态方法不可以访问类上定义的泛型。
如果静态方法操作的应用数据类型不确定，可以将泛型定义在方法上。

示例：

//泛型类
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);
    }
}

2.6，什么时候定义接口？
当接口中要操作的引用数据类型不确定的时候，就定义泛型来完成扩展。

示例： 

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

2.7，通配符(?)
? 通配符，也可以理解为点位符。

2.8，泛型的限定
？ extends E: 可以接收E类型或者E的子类型。上限。
？ super E: 可以接收E类型或者E的父类型。下限

示例：

import java.util.*;
/*
? 通配符。也可以理解为占位符。
泛型的限定；
？ extends E: 可以接收E类型或者E的子类型。上限。
？ super E: 可以接收E类型或者E的父类型。下限

*/


class  GenericDemo6
{
    public static void main(String[] args) 
    {
        /*
        ArrayList<String> al = new ArrayList<String>();

        al.add("abc1");
        al.add("abc2");
        al.add("abc3");

        ArrayList<Integer> al1 = new ArrayList<Integer>();
        al1.add(4);
        al1.add(7);
        al1.add(1);

        printColl(al);
        printColl(al1);
        */

        ArrayList<Person> al = new ArrayList<Person>();
        al.add(new Person("abc1"));
        al.add(new Person("abc2"));
        al.add(new Person("abc3"));
        //printColl(al);

        ArrayList<Student> al1 = new ArrayList<Student>();
        al1.add(new Student("abc--1"));
        al1.add(new Student("abc--2"));
        al1.add(new Student("abc--3"));
        printColl(al1);  //ArrayList<? extends Person> al = new ArrayList<Student>();error

    }
    public static void printColl(Collection<? extends Person> al)
    {
        Iterator<? extends Person> it = al.iterator();


        while(it.hasNext())
        {
            System.out.println(it.next().getName());
        }
    }
    /*
    public static void printColl(ArrayList<?> al)//ArrayList al = new ArrayList<Integer>();error
    {
        Iterator<?> it = al.iterator();


        while(it.hasNext())
        {
            System.out.println(it.next().toString());
        }
    }
    */
}

class Person
{
    private String name;
    Person(String name)
    {
        this.name = name;
    }
    public String getName()
    {
        return name;
    }
}

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

}


/*

class Student implements Comparable<Person>//<? super E>
{
    public int compareTo(Person s)
    {
        this.getName()
    }
}
*/
class Comp implements Comparator<Person>
{
    public int compare(Person s1,Person s2)
    {

        //Person s1 = new Student("abc1");
        return s1.getName().compareTo(s2.getName());
    }
}

TreeSet<Student> ts = new TreeSet<Student>(new Comp());
ts.add(new Student("abc1"));
ts.add(new Student("abc2"));
ts.add(new Student("abc3"));

——- android培训、java培训、期待与您交流！ ———-