集合框架-TreeSet

TreeSet是Set集合的常见子类.

TreeSet:底层结构是 二叉树

　　　　元素是有排序的,但是不可以有重复元素.

相关代码演练:

/*
TreeSet ;元素是有序的,但是不可以元素重复.
                    
*/

import java.util.*;

class TreeSetDemo
{
    public static void main(String [] args)
    {
        TreeSet ts = new TreeSet();
        
        ts.add("java01");
        ts.add("java03");
        ts.add("java02");
        ts.add("java04");
        ts.add("java04");
        
        Iterator it = ts.iterator();
        
        while(it.hasNext())
        {
            sop(it.next());
        }
        
        ts.remove("java02");
        sop(ts);
        
    }
    public static void sop(Object obj)
    {
        System.out.println(obj);
    }
    
    
}

class Student
{
    private String name;
    private int age;
    
    Student(String name,int age)
    {
        this.name = name;
        this.age = age;
    }
    
    public String getName()
    {
        return name;
    }
    public int getAge()
    {
        return age;
    }
}

TreeSet的两种排序方式:

第一种排序方式:(让元素自身具备比较性)让该类实现Comparable接口.并且覆写compareTo方法.这种排序是自然排序.

　　　　　　　保证元素唯一性的依据是: compareTo方法return 0;

代码演示:

/*
        TreeSet存储自定义对象
        
        (会抛出类型转换异常ClassCastException) Student类无法转成Comparable.
        因此Student类需要实现Comparable接口.并且覆写compareTo方法.排序的方式为自然顺序.
        
        排序时,当主要条件相同时,还要判断一下次要条件.
        
        
        需求: 按学生的年龄排序.
*/

import java.util.*;

class TreeSetTest
{
    public static void main(String [] args)
    {
        TreeSet ts = new TreeSet();
        
        ts.add(new Student("lisi08",19));
        ts.add(new Student("lisi02",22));
        ts.add(new Student("lisi007",20));
        ts.add(new Student("lisi09",19));
        
        
        Iterator it = ts.iterator();
        
        while(it.hasNext())
        {
            Student stu = (Student)it.next();
            sop(stu.getName()+"------"+stu.getAge());
        }
        
    }
    public static void sop(Object obj)
    {
        System.out.println(obj);
    }
    
}

class Student implements Comparable //该接口强制让学生具备了比较性. (实现了该接口需要覆盖其compareTo方法)
{
    private String name;
    private int age;
    
    Student(String name,int age)
    {
        this.name = name;
        this.age = age;
    }
    public int compareTo(Object obj)
    {
        
        //return 1; //怎么存的怎么取出
        //return -1;  //倒取存入的对象
        //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;
    }
}

第二种排序方式:(元素不具备比较性,或者比较性是所不需要的)此时,让集合自身具备比较性.在集合一初始化时,就有比较方式.


实现方式: 定义一个类,实现comparator接口,并覆写其中的compare方法.

/*
让容器自身具备比较性,
定义一个比较器.将比较器对象传递给TreeSet集合的构造函数;

思路步骤:
定义一个容器让这个容器实现comparator,并且覆写其中的compare方法.
*/


import java.util.*;

class TreeSetTest2
{
    public static void main(String [] args)
    {
        //TreeSet ts = new TreeSet(); //传入的不是比较器对象时,调用的是CompareTo方法.
        
        TreeSet ts = new TreeSet(new MyComparator());  //将比较器传递给TreeSet的构造函数.
        
        ts.add(new Student("lisi08",19));
        ts.add(new Student("lisi02",22));
        ts.add(new Student("lisi02",23));
        ts.add(new Student("lisi007",20));
        ts.add(new Student("lisi09",19));
        
        Iterator it = ts.iterator();
        
        while(it.hasNext())
        {
            Student stu = (Student)it.next();
            sop(stu.getName()+"-----"+stu.getAge());
        }
        
        
    }
    
    public static void sop(Object obj)
    {
        System.out.println(obj);
    }
    
    
}

class Student implements Comparable //让学生类具备了比较性
{
    private String name;
    private int age;
    Student(String name,int age)
    {
        this.name = name;
        this.age = age;
    }
    public String getName()
    {
        return name;
    }
    public int getAge()
    {
        return age;
    }
    
    public int compareTo(Object obj)  //覆写了Comparable中的compareTo方法.
    {
        if(!(obj instanceof Student))
            throw new RuntimeException("bushixueshengduixiang");
        
        Student s = (Student)obj;
        if(this.age>s.age)
            return 1;
        if(this.age==s.age)
        {
            return this.name.compareTo(s.name);
        }
        return -1;
    }
}

class MyComparator implements Comparator  //定义一个容器并实现了Comparator接口
{
    public int compare(Object o1,Object o2)  //覆写其中的compare方法.
    {
        
        if(!(o1 instanceof Student ||o2 instanceof Student))
            throw new RuntimeException("对象错误.");
        
        Student s1 = (Student)o1;
        Student s2 = (Student)o2;
        
        //return s1.getName().compareTo(s2.getName()); //无法存储到姓名相同年龄不同的对象.
        
        int num = s1.getName().compareTo(s2.getName());  //判断返回值 (1 0 -1)
        if(num==0)   //判断的名字相同时,在判断其年龄是否相同.
        {
            return s1.getAge()-s2.getAge();
            /*
            if(s1.getAge()>s2.getAge())
                return 1;
            if(s1.getAge()==s2.getAge())
                return 0;
            return -1;
            */
        }
        
        return num;
        
    }
}

练习:

按照字符串的长度进行排序.

/*
练习:按照字符串长度排序

*/

import java.util.*;

class TreeSetExam
{
    public static void main(String [] args)
    {
        TreeSet ts = new TreeSet(new StrLengthCompare());
        
    
        ts.add("abcd");
        ts.add("cc");
        ts.add("cba");
        ts.add("a");
        ts.add("hahaha");
        ts.add("aa");
        
        Iterator it = ts.iterator();
        
        while(it.hasNext())
        {
            sop(it.next());
        }
        
    }
    
    public static void sop(Object obj)
    {
        System.out.println(obj);
    }
    
}

class StrLengthCompare implements Comparator
{
    public int compare(Object o1,Object o2)
    {
        if(!(o1 instanceof String || o2 instanceof String))
            throw new RuntimeException("ERROR");
        
        String s1 = (String)o1;
        String s2 = (String)o2;
        
        //int num = s1.length()-s2.length();
        int num = new Integer(s1.length()).compareTo(new Integer(s2.length()));
        
        if(num==0) //判断长度一样的字符串的自然排序.
        {
            return s1.compareTo(s2);
        }
        return num;
    }
}

注意:一定要记得先对主要条件进行判断,在对次要条件进行判断.避免出现漏存的情况.