Java笔记4 JavaAPI<2>TreeSet、Comparator、泛型

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

15天-01-集合框架(TreeSet)

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

       |--HashSet：

       |--TreeSet：可以对set集合中的数据排序。

                       底层数据是二叉树。

                       保证元素的唯一性的依据：compareTo方法return 0。

TreeSet排序的第一种方式：

让元素自身具备比较性。元素需要实现comparable接口，覆盖compareTo方法。这种方式也成为元素的自然顺序，或者叫做默认顺序。

 

TreeSet排序的第二种方式：

       当自然元素本身不具备比较性时，或者具备的比较性不是所需要的。这是就需要集合本身具备比较性，在集合初始化时，就有了比较性。

 

²  记住，再给一个类继承Comparable后时，重写compareTo方法时，当对象的主要条件相同时，一定要判断一下次要条件。

示例：

class Studentimplements Comparable<Student>{

    private Stringname;

    private int age;

   

    public Student(String name,int age){

        this.name = name;

        this.age = age;

    }

    /*set和get方法省略*/

 

//  @Override

//  public int compareTo(Object o) {//未加入泛型前的方法操作

//      if(o instanceofStudent){

//          throw new RuntimeException("不是学生对象!");

//      }

//      Student s = (Student)o;

//      if(this.age>s.age){

//          return 1;

//      }else if(this.age==s.age){

//          return this.name.compareTo(s.name);

//      }

//      return -1;

//  }

   

    public int compareTo(Student o) {//当参数为null会报空指针异常

        if(o instanceof Student){//加入泛型这句话可以不要

            throw new RuntimeException("不是学生对象!");

        }

        Student s = (Student)o;//可以不要

        if(this.age>s.age){

            return 1;

        }else if(this.age==s.age){

            return this.name.compareTo(s.name);

        }

        return -1;

    }  

}

 

 

15天-04-集合框架(实现Comparator方式排序)

l  当元素本身不具备比较性，或者具备的比较性不是所需要的，这时需要让容器具备比较性。

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

示例1，继承Comparator不含泛型的比较：

class TreeSetDemo2 {

    public static void main(String[] args){

        TreeSet ts = new TreeSet(newMyCompare1());

        //TreeSet<Student> ts1 = new TreeSet<Student>(newMyCompare2());

        ts.add(new Student("lisi",01));

        ts.add(new Student("wangwu",02));

    }

}

 

class MyCompare1implementsComparator{//自定义比较器1

    @Override

    public int compare(Object o1, Object o2) {

        Student stu1 =(Student)o1;

        Student stu2 =(Student)o2;

        int num =stu1.getName().compareTo(stu2.getName());

        if(num==0){

            if(stu1.getAge()>stu2.getAge()){

                return 1;

            }else if(stu1.getAge()==stu2.getAge()){

                return 0;

            }else{

                return -1;

            }

        }

        return num;

    }

   

}

 

示例2，继承Comparator含泛型的比较：

class MyCompare2implementsComparator<Student>{//自定义比较器2

    @Override

    public int compare(Studentstu1, Student stu2) {

        int num =stu1.getName().compareTo(stu2.getName());

        if(num==0){

//Integer继承了Comparable接口，可以将int类型数据转换为Integer对象//进行比较。

            return new Integer(stu1.getAge()).compareTo(newInteger(stu2.getAge()));

        }

        return num;

    }  

}

 

总结：类对象具有可比性，可以以两种方式实现：

1)       让用于比较的对象所属类继承Comparable接口。

示例：

public class TreeDemo{

       publicstatic void main(String[] args){

       TreeSet ts = new TreeSet();

       …

}

}

class Student implements Comparable{//实现int compare

       …

}

2)       定义比较器，让自定义比较器继承Comparator。

示例：

public class TreeDemo{

       publicstatic void main(String[] args){

       TreeSet ts = new TreeSet(newMyComparator());

       …

}

}

class MyComparator implements Comparator{//实现 int compareTo(Object o1,Objecto2)方法。

       …

}

 

 

15天-06-集合框架(泛型概述)

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

l  泛型的好处：

1)       将运行时期出现的问题ClassCastException,转移到了编译时期，方便于程序员解决问题，让运行事情减少，安全。

2)       避免了强制转换的麻烦。

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

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

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

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

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

l  什么时候定义泛型呢?

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

1)     早期定义Object类完成扩展。

class Utils{

       privateObject q;

       publicvoid setObject(Object q){

       this.q = q;

}

public ObjectgetObject(){

       return q;

}

}

public class Demo{

       publicstatic void main(String[] args){

       Utils u = new Utils();

       u.setObject(new Student());

       Student s = (Student)u.getObject();

}

}

 

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

class Utils<QQ>{

       privateQQ q;

       publicvoid setObject(QQ q){

       this.q = q;

}

public QQgetObject(){

       return q;

}

}

public class Demo{

       publicstatic void main(String[] args){

       Utils <Student>u = newUtils<Student>();

       u.setObject(new Student());

       Student s = u.getObject();

}

}

 

 

15天-09-集合框架(泛型方法)

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

示例：

class Utils<QQ>{

       publicvoid set(QQ q){

       …

}

}

l  为了让不同方法可以操作不同类型，而且类型还不确定。那么可以将泛型定义在方法上。

class Demo{

       public<T> void show(T t){//可以接受任意数据类型

       …

}

public <Q>void print(Q q){

       …

}

}

 

 

15天-10-集合框架(静态方法泛型)

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

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

示例：

class Demo<T>{

       publicvoid show(T t){//编译通过

       //…

}

public <Q>void print(Q q){//编译通过

       //…

}

public staticvoid method1(T t){//编译失败

       //…

}

public static<W> void method2(W w){//编译通过

       //…

}

}

 

 

15天-11-集合框架(泛型接口)

l  泛型定义在接口上

示例：

interface Inter<T>{

       voidshow(T t);

}

class interImpl<T> implementsInter<T>{

       publicvoid show(T t){

       System.out.println(“show:”+t);

}

}

public class GenericDemo5{

       publicstatic void main(String[] args){

       InterImpl i = new InterImpl();

       i.show(“hahah”);

       i.show(123);

}

}

 

 

15天-12-集合框架(泛型限定)

l  ？通配符，也可以理解为占位符。

泛型限定：

1)       ? extends E：可以接受E类型或者E类型的子类型，上限。

2)       ？super E：可以接收E类型或者E的父类型，下限。

示例：

class Person{

       privateString name;

       publicPerson(String name){

       this.name = name;

}

public StringgetName(){

       return name;

}

}

class Student extends Person implementsComparable<Person> {//<?superE>

       publicStudent(String name){

       super(name);

}

public intcompareTo(Person s){

       return this,getName();

}

}

class Comp implementsComparator<Student>{

       publicint compareTo(Stiudent st1,Student st2){

       returnst1.getName().CompareTo(st2.getName());

}

}

TreeSet<Student> ts = newTreeSet<Student>(new Comp);

ts.add(new Srudent(“a01”));

ts.add(new Student(“a02”));

 

 

15天-13-集合框架(泛型限定2)

示例：

import java.util.Comparator;

import java.util.Iterator;

import java.util.TreeSet;

 

class Person{

    private Stringname;

    public Person(String name){

        this.name = name;

    }

    public String getName(){

        returnname;

    }

    public String toString(){

        return"Person:"+name;

    }

}

class Worker extends Person{

    public Worker(String name){

        super(name);

}

    public String toString(){

        return"Worker:"+this.getName();

    }

}

 

class Student1extends Person{//注意，每个类都可以隐式地继承Object类，可以重写toString方法。

    public Student1(String name){

        super(name);

    }

    public String toString(){

        return"Student:"+this.getName();

    }

}

 

class Comp1 implements Comparator<Student1>{

 

    public int compare(Student1 o1, Student1 o2) {

       

        return o1.getName().compareToIgnoreCase(o2.getName());//只要重写了父类的toString方法，子类此时会调用子类的toString方法。

    }  

}

class Comp2 implements Comparator<Person>{

 

    @Override

    public int compare(Person o1, Person o2) {

        return o2.getName().compareToIgnoreCase(o1.getName());

    }

   

}

 

public class TreeSetComp01Demo {

 

    public static void main(String[] args) {

//      TreeSet<Student1> ts= new TreeSet<Student1>(new Comp1());

//      ts.add(newStudent1("abc003"));

//      ts.add(newStudent1("abc005"));

//      ts.add(newStudent1("abc001"));

//      ts.add(new Student1("abc002"));

//     

//      Iterator<Student1>it = ts.iterator();

//      while(it.hasNext()){

//          System.out.println(it.next());

//      }

       

       TreeSet<Worker> ts = newTreeSet<Worker>(new Comp2());//泛型 ? extends//Person的运用（Comp2限定了Person类，但是且可以运用到子类Worker中）

        ts.add(new Worker("abc003"));

        ts.add(new Worker("abc005"));

        ts.add(new Worker("abc001"));

        ts.add(new Worker("abc002"));  

       

        Iterator<Worker>it = ts.iterator();

        while(it.hasNext()){

            System.out.println(it.next());

        }

    }

}

 

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