TreeSet介绍

一、TreeSet原理：

1.TreeSet存储对象的时候, 可以排序, 但是需要指定排序的算法

2.Integer能排序(有默认顺序), String能排序(有默认顺序), 自定义的类存储的时候出现异常(没有顺序)

3.如果想把自定义类的对象存入TreeSet进行排序, 那么必须实现Comparable接口，或者实现一个比较器

             在类上implements Comparable
             重写compareTo()方法
             在方法内定义比较算法, 根据大小关系, 返回正数负数或零
             在使用TreeSet存储对象的时候, add()方法内部就会自动调用compareTo()方法进行比较, 根据比较结果使用二叉树形式进行存储

4.TreeSet依靠TreeMap来实现

二、TreeSet实现有序的2种方式

1）、元素实现Comparable接口：

实例：

实体类User（实现Comparable接口）：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50

package com.model.elgin.collections;

public class Userimplements Comparable<User>{
   
    private int id;
    private String name;
    private String phone;
    
    public int getId() {
        return id;
    }
    public void setId(int id) {
        this.id = id;
    }
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    public String getPhone() {
        return phone;
    }
    public void setPhone(String phone) {
        this.phone = phone;
    }
    
    public User(int id,String name,String phone) {
        super();
        this.id = id;
        this.name = name;
        this.phone = phone;
    }
    
    @Override
    public String toString() {
        return "User [id=" + id +", name=" + name +", phone=" + phone +"]";
    }
    
    @Override
    public int compareTo(User user) {
        if(this.id>user.getId()){
            return 1;
        } else if(this.id==user.getId()){
            return 0;
        }
        return -1;
    }
}

测试类：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31

package com.model.elgin.collections;

import java.util.Set;
import java.util.TreeSet;

public class TestTreeSet {
    
    public static void main(String[] args) {
        
        /*
         * TreeSet有序、唯一。
         * 实现有序的2种方式：
         * 1.集合中的元素对象实现Comparable接口，TreeSet声明使用无参构造
         * 2.声明一个比较器 Comparator ，TreeSet声明使用有参构造，参数传入比较器的一个实例对象
         * 
         */
        Set<User> set=new TreeSet<User>();
        User user1=new User(10,"jim","13232326565");
        User user2=new User(20,"jack","13232326566");
        User user3=new User(30,"lily","13232326567");
        User user4=new User(40,"lucy","13232326568");
        User user5=new User(40,"lucy","13232326568");
        set.add(user1);
        set.add(user3);
        set.add(user4);
        set.add(user2);
        set.add(user5);
        System.out.println(set);
    }
}

运行之后发现结果有序（根据id由小到大）排列

2）、通过自定义比较器实现（User类不需要实现Comparable接口）：

比较器类： UserComparator

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

package com.model.elgin.collections;

import java.util.Comparator;

public class UserComparatorimplements Comparator<User> {

    @Override
    public int compare(User user1, User user2) {
        if(user1.getId()>user2.getId()){
            return 1;
        }else if(user1.getId()==user2.getId()){
            return 0;
        }
        return -1;
    }   
}

测试类：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32

package com.model.elgin.collections;

import java.util.Comparator;
import java.util.Set;
import java.util.TreeSet;

public class TestTreeSet {
    
    public static void main(String[] args) {
        
        /*
         * TreeSet有序、唯一。
         * 实现有序的2种方式：
         * 1.集合中的元素对象实现Comparable接口，TreeSet声明使用无参构造
         * 2.声明一个比较器 Comparator ，TreeSet声明使用有参构造，参数传入比较器的一个实例对象
         * 
         */
        Comparator<User> comparator=new UserComparator();
        Set<User> set=new TreeSet<User>(comparator);
        User user1=new User(10,"jim","13232326565");
        User user2=new User(20,"jack","13232326566");
        User user3=new User(30,"lily","13232326567");
        User user4=new User(40,"lucy","13232326568");
        User user5=new User(40,"lucy","13232326568");
        set.add(user1);
        set.add(user3);
        set.add(user4);
        set.add(user2);
        set.add(user5);
        System.out.println(set);
    }
}

运行，同样可以得到上述有序的结果。