1 Set接口

1.1 HashSet

哈希表是一种数据结构，哈希表能够提供快速存取操作。哈希表是基于数组的，所以也存在缺点，数组一旦创建将不能扩展。

HashSet 中的数据是无序的不可重复的。HashSet 按照哈希算法存取数据的，具有非常好性能，它的工作原理是这样的，当向 HashSet 中插入数据的时候，他会调用对象的 hashCode 得到该对象的哈希码，然后根据哈希码计算出该对象插入到集合中的位置.

1.1.1 HashSet集合操作

import java.util.HashSet;
import java.util.Iterator;
import java.util.Set;

/**
 * HashSet集合：无序，不可重复
 */
public class HashSetTest01 {
    public static void main(String[] args) {
        //创建HashSet集合
        Set<String> set = new HashSet<>();
        //添加元素
        set.add("jack");
        set.add("Tom");
        set.add("Lee");
        set.add("rose");
        set.add("Lee");
        set.add("Lee");

        //删除元素
        //set.remove("Lee");
        //遍历集合，没有下标不能使用下标遍历
        //foreach遍历
        for (String s : set) {
            System.out.println(s);
        }
        //迭代器遍历
        Iterator<String> it = set.iterator();
        while (it.hasNext()) {
            System.out.println(it.next());
        }
    }
}

import java.util.HashMap;
import java.util.HashSet;
import java.util.Iterator;
import java.util.Objects;

/**
 * HashSet集合：无序，不可重复
 */
public class HashSetTest02 {
    public static void main(String[] args) {
        //创建HashSet集合对象
        HashSet<Object> set = new HashSet<>();
        //添加元素
        set.add(new Student());
        set.add(new Student(1111, "张三"));
        set.add(new Student(2222, "jack"));
        set.add(new Student(1234, "rose"));
        set.add(new Student(2222, "jack"));
        //遍历集合
        //foreach遍历
        for (Object obj : set) {
            System.out.println(obj);
        }
        //迭代器遍历
        Iterator<Object> it = set.iterator();
        while (it.hasNext()) {
            System.out.println(it.next());
        }


    }
}

class Student {
    int id;
    String name;

    public Student() {

    }

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

    @Override
    //重写toString方法
    public String toString() {
        return "Student{" + "id=" + id + ", name='" + name + '\'' + '}';
    }
    
}

1.2 TreeSet

TreeSet集合底层实际上是一个TreeMap，TreeMap集合底层是一个二叉树。

放到TreeSet集合中的元素，等同于放到了TreeMap集合的key部分了。

TreeSet集合的元素：无序不可重复，但是可按照元素的大小顺序自动排序。称为：可排序集合。

import java.util.TreeSet;

public class TreeSetTest01 {
    public static void main(String[] args) {
        TreeSet<String> ts = new TreeSet<>();
        ts.add("A张");
        ts.add("Lee");
        ts.add("jack");
        ts.add("Boy");
        for (String s : ts) {
            System.out.println(s);
        }

        TreeSet<Integer> num = new TreeSet<>();
        num.add(12);
        num.add(34);
        num.add(0);
        num.add(3);
        num.add(97);
        for (Integer i : num) {
            System.out.println(i);
        }
    }
}

自定义的类型来说，TreeSet不能排序。

import java.util.TreeSet;

/**
 * 底层是一个二叉树
 * 放到TreeSet集合中的元素，等同于放到TreeMap集合key部分
 * TreeSet集合中的元素，无序不可重复，但是可以按照元素大小顺序排序
 * 称为可排序集合
 */
public class TreeSetTest02 {
    public static void main(String[] args) {
        TreeSet<Student> stu = new TreeSet<>();
        stu.add(new Student(12));
        stu.add(new Student(11));
        stu.add(new Student(18));
        stu.add(new Student(10));
        for (Student s : stu) {
            System.out.println(s);
        }
    }
}

class Student {
    int age;

    public Student(int age) {
        this.age = age;
    }

    @Override
    public String toString() {
        return "Student[" + "age=" + age + ']';
    }
}

出现ClassCastException(类转换异常)，出现这个异常的原因是Student类没有实现Comparable接口。

1.2.1 TreeSet集合操作

import java.util.Comparator;
import java.util.Iterator;
import java.util.TreeSet;

/**
 * TreeSet集合特点：无序，不可重复
 * 但是可以按照大小排序
 */
public class TreeSetTest01 {
    public static void main(String[] args) {
        //创建TreeSet集合对象
        TreeSet<Integer> tr = new TreeSet();

        //加入比较器后变成可以存储重复值
//        TreeSet<Integer> tr = new TreeSet<>(new Comparator<Integer>() {
//            @Override
//            public int compare(Integer o1, Integer o2) {
//                return o1-o2;
//            }
//        });
        //添加元素
        tr.add(100);
        tr.add(200);
        tr.add(23);
        tr.add(100);
        tr.add(50);
        System.out.println(tr.size());//5
        //遍历集合
        //foreach遍历
        for (Integer i : tr) {
            System.out.println(i);
        }
        System.out.println("-----------");
        //迭代器遍历
        Iterator<Integer> it = tr.iterator();
        while (it.hasNext()) {
            System.out.println(it.next());
        }

    }
}

import java.util.TreeSet;

/**
 * 底层是一个二叉树
 * 放到TreeSet集合中的元素，等同于放到TreeMap集合key部分
 * TreeSet集合中的元素，无序不可重复，但是可以按照元素大小顺序排序
 * 称为可排序集合
 */
public class TreeSetTest02 {
    public static void main(String[] args) {
        TreeSet<Person> tr = new TreeSet<>();
        tr.add(new Person(12,"zhangsan"));
        tr.add(new Person(11,"lisi"));
        tr.add(new Person(22,"jack"));
        for (Object obj : tr){
            System.out.println(obj);
        }
    }
}
//通过实现Comparable接口进行排序
class Person implements Comparable<Person> {
    int id;
    String name;

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

    @Override
    public int compareTo(Person o) {
        return this.id - o.id;
    }

    @Override
    public String toString() {
        return "Person{" + "id=" + id + ", name='" + name + '\'' + '}';
    }
}