Set以及其实现类

set:无序：是指添加元素的顺序和遍历的顺序不一致，无下标，不可重复，因为没有下标，所以不可以使用for i进行遍历

package Set;

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

public class TestSet {
    public static void main(String[] args) {
        //创建一个集合
        Set<String> set=new HashSet<>();
        //1添加元素
        set.add("华为");
        set.add("小米");
        set.add("苹果");
        set.add("苹果");
        set.add("摩托罗");
        System.out.println("元素个数"+set.size());
        System.out.println(set.toString());
        //2删除元素
        set.remove("小米");
        System.out.println(set.toString());
        //3遍历元素
        System.out.println("增强for遍历");
//        3.1增强for遍历
        for (String s:set) {
            System.out.println(s);

        }
//        3.2迭代器
        System.out.println("迭代器遍历");
        Iterator<String> iterator=set.iterator();
        while (iterator.hasNext()){
            String s=iterator.next();
            System.out.println(s);
        }
        //4判空
        System.out.println(set.isEmpty());
    }
}

Hashset：

HashSet:基于HashCode计算元素存放的位置。当存入的元素的哈希码相同时，会调用equals进行确认，如果为true,表示已经有了一个相同的元素了，set会拒绝添加该元素。

创建一个Person类

package Set;

public class Person {
    private String name;
    private int  age;

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

    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;
    }

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

    @Override
    public int hashCode() {
        int n1=this.name.hashCode();
        int n2=this.age;
        return n1+n2;
    }

    @Override
    public boolean equals(Object obj) {
        if (this==obj){
            return true;
        }
        if (obj==null){
            return false;
        }
        if (obj instanceof Person){
            Person p=(Person)obj;
            if (this.age==p.getAge()&&this.name==p.getName()){
                return true;
            }
        }
        return false;

    }
}
创建一个
```java
package Set;

import java.util.HashSet;

public class TestHashSet {
    public static void main(String[] args) {
        HashSet<Person> hashSet=new HashSet<>();

        Person p1=new Person("刘德华",22);
        Person p2=new Person("郭富城",25);
        Person p3=new Person("黎明",23);
        Person p4=new Person("刘思思",25);

        //添加元素
        hashSet.add(p1);
        hashSet.add(p2);
        hashSet.add(p3);
        hashSet.add(p4);
        
//        当没有重写Person类的hashcode方法和equal方法时可以添加进去
        hashSet.add(new Person("刘德华",22));

        System.out.println("元素的个数是" +hashSet.size());
        System.out.println(hashSet.toString());
    }
}

以上是一个测试类

hashSet存储结构：哈希表（数组+链表，1.8之后加入了红黑树）

存储过程：

1. 根据hashcode计算保存的位置，如果此位置为空，则直接保存，如果不为空执行第二步
2. 执行equal方法，如果equal方法为true，则认为时重复，否则形成链表

TreeSet：

使用TreeSet保存数据，
存储结构：红黑树（一种类似于有序的二叉树，通过红色和黑色进行防止树的不平衡）
要求：元素必须实现Comparable接口，compareTo()方法为0时，认为时同重复元素

1. 基于排列顺序实现元素不重复
2. 实现类SortedSet接口，对集合元素自动排序
3. 元素对象的类型必须实现Comparable接口，指定排序规则
4. 通过CompareTo方法确定元素是否为重复元素。**

Person实现Comparable接口，重写compareTo方法

package Set;

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

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

    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;
    }

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

    @Override
    public int hashCode() {
        int n1=this.name.hashCode();
        int n2=this.age;
        return n1+n2;
    }

    @Override
    public boolean equals(Object obj) {
        if (this==obj){
            return true;
        }
        if (obj==null){
            return false;
        }
        if (obj instanceof Person){
            Person p=(Person)obj;
            if (this.age==p.getAge()&&this.name==p.getName()){
                return true;
            }
        }
        return false;

    }
//重写compareTo方法，实现Person 的排序
    @Override
    public int compareTo(Person o) {
        int n1=(this.name).compareTo(o.getName());
        int n2=this.age-o.getAge();
        return n1==0?n2:n1;
    }
}

编写测试类

package Set;

import java.util.TreeSet;

public class TestTreeSet {
    public static void main(String[] args) {
        TreeSet<Person> treeSet=new TreeSet<>();

        Person p1=new Person("dsdf",22);
        Person p2=new Person("gjsgjs",25);
        Person p3=new Person("sdjfosjf",23);
        Person p4=new Person("kspg",25);
        Person p5=new Person("kspg",28);

        //添加元素
        treeSet.add(p1);
        treeSet.add(p2);
        treeSet.add(p3);
        treeSet.add(p4);
        treeSet.add(p5);
        System.out.println(treeSet.size());
        System.out.println(treeSet.toString());
    }
}

结果发现先按name的字母排序，再按年龄的大小排序。

Comparator接口：一个定义比较规则的接口

package Set;

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

public class TestComparator {
    public static void main(String[] args) {
//        创建一个集合，并指定比较规则
        TreeSet<String> treeSet=new TreeSet<>(new Comparator<String>() {//Comparator这是一个比较构造器，用来定制比较的规则
            @Override
            public int compare(String o1, String o2) {

                int n1=o1.length()-o2.length();//先按长度排，再按首字母排
                int n2=o1.compareTo(o2);
                return n1==0?n2:n1;
            }
        });
    treeSet.add("hhiahiaf");
    treeSet.add("fgds");
    treeSet.add("sdfss");
    treeSet.add("hhiahgsdgsgiaf");
    treeSet.add("fgjhf");
    treeSet.add("g");

        System.out.println(treeSet);
    }
}

这个字符串按照长度排完序之后，再按照首字母排序的结果