Set集合

• Set集合，基础自Collection。特征是插入无序，不可指定位置访问。
• Set集合的实现类可说是基于Map集合去写的。通过内部封装Map集合来实现的比如HashSet内部封装了HashMap。
• Set集合的数据库不能重复（== 或 eqauls）的元素
• Set集合的常用实现类有 HashSet TreeSet

 

1.TreeSet： 

TreeSet基于TreeMpa实现，TreeMap本质就是红黑树。所以TreeSet其实于是基于红黑树的。

TreeSet有个特点，插入无序内部有序。

插入数据实现Comparable接口，通过compareTo方法去比较大小，或者在实例化TreeSet的时候自定义排序Comparator方法。内部的int compare(T o1, T o2)比较对象大小。

如果插入数据即不实现Commparable或在插入的时候也不指定排序方式Comparator那么就会报错

   1.1证明TreeSet内部是有序的

上面代码无论你运行多少遍，执行结果都如下：

a b c d

我们自己实现的对象要实现排序 1、 实现Comparable 2、指定排序方式 Comparator

   1.2实现Comparable

让set根据年龄排序 

public class Person implements Comparable<Person>{
    private int id;
    private String sname;
    private int age;

    public Person() {
    }

    public Person(int id, String sname, int age) {
        this.id = id;
        this.sname = sname;
        this.age = age;
    }
    

    public int getId() {
        return id;
    }

    public void setId(int id) {
        this.id = id;
    }

    public String getSname() {
        return sname;
    }

    public void setSname(String sname) {
        this.sname = sname;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    @Override
    public int compareTo(Person o) {
        // TODO Auto-generated method stub
        return this.age - o.age;
    }

    @Override
    public String toString() {
        return "Person [id=" + id + ", sname=" + sname + ", age=" + age + "]";
    }
    
}

public static void main(String[] args) {
        Set<Person> set = new TreeSet<>();
        set.add(new Person(1, "张三", 1));
        set.add(new Person(34, "王五", 3));
        set.add(new Person(232, "李四", 2));
        for (Person person : set) {
            System.out.println(person);
        }
    }

执行结果：

Person [id=1, sname=张三, age=1]
Person [id=2, sname=李四, age=2]
Person [id=34, sname=王五, age=3]

自定义排序 指定Comparator实现类的实例化对象

public static void main(String[] args) {
        Set<Person> set = new TreeSet<>(new IdSort());
        set.add(new Person(3, "张三", 1));
        set.add(new Person(1, "王五", 3));
        set.add(new Person(2, "李四", 2));
        for (Person person : set) {
            System.out.println(person);
        }
    }

执行结果：

Person [id=1, sname=王五, age=3]
Person [id=2, sname=李四, age=2]
Person [id=3, sname=张三, age=1]

注意：注意当两个对象比较相当（就是比较器返回0）时，那么就会发生覆盖

2.HashSet

内部无序，封装了HashMap。就是用HashMap的key位来存储值. 

//set集合内部的封装的HashMap对象 private transient HashMap<E,Object> map;

 元素不可重复 其实就是元素不能（ ==或equals() ）

public static void main(String[] args) {
        Set<String> set = new HashSet<>();
        set.add("1");
        set.add("1");
        System.out.println("size:" + set.size());
    }

执行结果是 size:1.详细用过Map集合的你很明白这一点。如果添加的元素相==或equals HashSet就只会保留其中一个。当我们将自己写的类存入set集合时一定要重写 equals和hashCode

/**
 * 注意：没有重写equals方法和hashCode的Person
 * @author 20190313
 *
 */
public class Person{
    private int id;
    private String sname;
    private int age;
    
    public Person() {}
    
    public Person(int id, String sname, int age) {
        this.id = id;
        this.sname = sname;
        this.age = age; 
    }
    
    
    
    public int getId() {
        return id;
    }


    public void setId(int id) {
        this.id = id;
    }


    public String getSname() {
        return sname;
    }


    public void setSname(String sname) {
        this.sname = sname;
    }


    public int getAge() {
        return age;
    }


    public void setAge(int age) {
        this.age = age;
    }

}

public static void main(String[] args) {
        Set<Person> set = new HashSet<>();
        set.add(new Person(1, "zs", 1));
        set.add(new Person(1, "zs", 1));
        System.out.println("size:" + set.size());
    }

执行结果还是2.将equals和hashCode重写就可用了

@Override
    public boolean equals(Object obj) {
        // TODO Auto-generated method stub
        if (obj != null && obj instanceof Person) {
            Person o = (Person) obj;
            if (this.id == o.id && this.age == o.age) {
                if (sname != null) {
                    return sname.equals(o.sname);
                } else {
                    return o.sname == null;
                }
            }
        }
        return false;
    }
    
    @Override
    public int hashCode() {
        // TODO Auto-generated method stub
        return this.id + this.age;
    }

注意：重写equals和hashCode一定要注意想equals的对象一定hashCode。hashCode相等的对象不一定相equals

重写完后执行结果就是 1 啦

3.比较

HashSet 效率要高于TreeSet，因为HashSet采用散列算法快速对集合进行增删改查 时间复杂度更是几乎接近O(1)，但内部无序。

TreeSet 内部有序，可根据指定规则去排序。但效率要比较HashSet低。时间复杂度位O(log n)

4.set遍历方式

   forEach：

forEach底层其实就是依赖迭代器

   for (Object object : set) {
            System.out.println(object);
        }

迭代器：

Iterator iterator = set.iterator();
        while(iterator.hasNext()) {
            System.out.println(iterator.next());
        }