Set( HashSet / TreeSet)

Collection接口下有两个子接口:

List: 存储的元素是有序的，可以通过下标来操作元素

        实现类: ArrayList / LinkedList / Vector

Set: 存储的元素无序，且不允许重复(使用较少)

        实现类: HashSet / LinkedHashSet / TreeSet

List 继承自 Collection接口，在Collection的基础上新增了很多通过下标操作元素的方法

Set 继承自 Collection接口，并且没有在Collection的基础上新增方法，Set接口里的方法和Collection接口里的方法相同

Collection(Set)里的常用方法:

add(E e) / remove(Object e) / clear() / size() / iterator()

Set的特点:

        1. 存储的元素无序，不能通过下标来操作元素

        2. 存储的元素不允许重复(判断元素是否重复的依据)

public class SetDemo {
    public static void main(String[] args) {
        Set<Integer> numbers = new HashSet<>();

        // 调用 add 方法添加元素
        numbers.add(45);
        numbers.add(67);
        numbers.add(89);
        numbers.add(56);

        numbers.remove("hello");
        numbers.remove(89);

        // 序重要特征： 不能通过下标来操作元素!
        /*Iterator<Integer> iterator = numbers.iterator();
        while (iterator.hasNext()) {
            System.out.println(iterator.next());
        }*/

        // Set是无序的，没有get(int index)方法获取到元素，只能使用迭代器来获取元素
        for (Integer number : numbers) {
            System.out.println(number);
        }

        /*
        Set有一个特点是去重
        Set的使用场景: 只要用户User登录到服务器了，就将用户记录一下，下次再登录不记录
        要给所有的用户发送广播，可以考虑使用 Set来存储数据
        ArrayList  if(!contains()) list.add(user);
         */
    }
}

1. HashSet判断元素是否重复

HashSet分析:

        1. 存储的元素是无序的，不能通过序号操作元素

        2. 存储的元素不允许重复

判断元素是否重复的依据:

        判断元素的哈希值是否相同，如果哈希值不同，直接存入；

        如果哈希值相同，再调用 equals 方法，如果equals方法返回true,就认为重复;

        如果哈希值相同，但是 equals方法返回false，依然会存入

public class HashSetDemo {
    public static void main(String[] args) {
        Set<Integer> set = new HashSet<>();
        set.add(4);
        set.add(10);
        set.add(8);
        set.add(9);
        set.add(10);  // 当存储的数据相同时，只会保留一个
        System.out.println(set);

        Set<String> words = new HashSet<>();
        words.add("hello");
        words.add("good");
        words.add(new String("hello"));

        String s1 = "he";
        String s2 = "llo";
        words.add(s1 + s2);
        System.out.println(words);


        HashSet<Person> people = new HashSet<>();
        Person p1 = new Person("张三", 18, 1.75, "上海");
        Person p2 = new Person("张三", 18, 1.75, "上海");
        Person p3 = new Person("李四", 19, 1.8, "北京");
        people.add(p1);
        people.add(p2);
        people.add(p3);

        // people.toString() 实现原理是  [p1.toString(),p3.toString()]
        System.out.println(people);  // people.toString()

        /*// HashSet 的toString实现原理:
        StringBuilder sb = new StringBuilder("[");
        for (Person person : people) {
            sb.append(person);
        }
        sb.append("]");
        System.out.println(sb);*/
    }
}

2. TreeSet判断元素是否重复：

TreeSet的特点:

1. 存储的元素无序，不能通过下标来操作元素

2. 将元素强制类型转换成为Comparable类型的对象，然后再调用元素的compareTo()方法，根据返回值进行排序。

        要求 存储的元素必须要有 compareTo()方法

3. 存储的元素不允许重复

public class Dog implements Comparable<Dog> {
    private String name;
    private int age;
    private double weight;

    public Dog() {
    }

    public Dog(String name, int age, double weight) {
        this.name = name;
        this.age = age;
        this.weight = weight;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getAge() {
        return age;
    }

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

    public double getWeight() {
        return weight;
    }

    public void setWeight(double weight) {
        this.weight = weight;
    }

    @Override
    public String toString() {
        return "Dog{" +
                "name='" + name + '\'' +
                ", age=" + age +
                ", weight=" + weight +
                '}';
    }

    @Override
    public int compareTo(Dog o) {
        int x = age - o.age;
        if (x == 0) {  // 年龄相同
            if (weight > o.weight) return 1;
            else if (weight < o.weight) return -1;
            if (weight == o.weight) return name.compareTo(o.name);

            /*int y = (int) (weight - o.weight);
            if (y == 0) return name.compareTo(o.name);
            return y;*/
        }
        return x;
    }
}

public class TreeSetDemo {
    public static void main(String[] args) {
        Set<Integer> numbers = new TreeSet<>();

        numbers.add(5);
        numbers.add(9);
        numbers.add(3);
        numbers.add(7);
        numbers.add(10);
        numbers.add(8);
        numbers.add(6);

        System.out.println(numbers);

        Set<String> words = new TreeSet<>();
        words.add("hello");
        words.add("good");
        words.add("yes");
        words.add("abcdefg");
        words.add("abx");
        words.add("abm");

        System.out.println(words);

        /*Set<Person> people = new TreeSet<>();
        people.add(new Person());  // 报错，因为 Person没有实现 Comparable接口*/

        /*TreeMap如果要存入对象，对象必须要实现 Comparable 接口!
         在存入元素时，会调用元素的 compareTo()方法，根据返回值来判断是 往前排还往后排或者替换!
         如果返回值 > 0 往后, < 0 往前， ==0 不存入了*/
        Set<Dog> dogs = new TreeSet<>();
        Dog d1 = new Dog("tony", 3, 12.5);
        Dog d2 = new Dog("jack", 2, 10.9);
        Dog d3 = new Dog("henry", 3, 11.8);
        Dog d4 = new Dog("helen", 2, 10.8);
        dogs.add(d1);
        dogs.add(d2);
        dogs.add(d3);
        dogs.add(d4);
        System.out.println(dogs);
    }
}