Set系列集合

Set集合是属于Collection下的一个分支。

Set集合的特点：无序列，添加进去的顺序和取出来的顺不一样；不重复；无索引。

HashSet：无序，不重复，无索引。

LinkedHashSet：有序，不重复，无索引。

TreeSet：排序，不重复，无索引。

set.of( )：返回一个不可修改的集合，也就是不能再添加、删除元素，如果集合存放的元素是对象，那么对象的属性值可以修改。

Set集合常用的方法

Set集合的遍历

因为没有索引，所以不支持普通for循环。

增强for循环：

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

 forEach：

set.forEach(obj -> System.out.println(obj));

迭代器

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

HashSet集合

HashSet类实现类Set接口，是使用Set集合时最常用的一个实现类。

HashSet的特点

• 元素唯一性，HashSet去重必须重写对象的equals方法和hashcode方法
• 无序性
• 允许null元素

注意：hashcode就是用对象的某个属性乘一个质数，得到一串数字，用这个数字来表示对象。然后根据hashcode的值确定元素的位置。

HashSet构造方法

public  HashSet( )：创建一个空的集合

public  HashSet( int capacity )：创建一个初始容量为capacity的集合

public  HashSet( int capacity ,float loadFactor)：创建一个初始容量为capacity，负载因子为loadFactor的集合。（负载因子就是扩容倍数，capacity默认16，默认是0.75倍扩容）。

public HashSet(Collection c) ：创建一个包含c集合中所有元素的集合对象。

HashSet常用方法

TreeSet集合

TreeSet集合实现了Set接口 ，TreeSet中的元素按照自然排序或者指定的比较器进行排序，并且不允许重复元素。

使用TreeSet集合的注意点

• 自然排序 VS 比较器：TreeSet可以按照元素的自然排序进行排序，但此时元素必须要具备自然排序的能力，如果集合中的元素是基本数据类型，那么当元素添加到集合当中时，会进行自动装箱，所有基本数据类型的包装类都实现了Comparable接口，重写了它的CompareTo方法，所以基本数据类型的元素是具有自然排序能力的，默认是升序排序。如果集合中的元素是对象，那么对象的类必须实现Comparable接口，并且重写它的CompareTo方法，在CompareTo方法中，指定用对象的哪一个属性进行排序。如果要使用比较器，那么在创建TreeSet集合对象的时候要传入一个比较器对象，使用匿名类的方式，然后再在它的compare方法中规定排序的规则。自然排序和比较器最大的区别就是，自然排序会改变类结构，比较器不会。如果调用sort( )方法的时候传递的参数为空的话，就按照自然排序的规则排序，如果没有自然排序就会报错。

    实现此接口的对象集合（和数组）可以通过 Arrays.sort() 方法或使用 TreeMap 、 TreeSet 集合      进行自动排序。

//比较器排序 
public static void main(String[] args) {
        Vector vector = new Vector();
        vector.add(new Student("张三",23));
        vector.add(new Student("孙琦",21));
        vector.add(new Student("李四",19));
        vector.add(new Student("赵柳",24));
        vector.sort(new Comparator() {
            @Override
            public int compare(Object o1, Object o2) {
                if(o1 instanceof Student s1){
                    if(o2 instanceof  Student s2){
                        return s1.getAge() - s2.getAge();
                    }
                }
                return 0;
            }
        });
        for (Object o : vector) {
            System.out.println(o);
        }
    }

//自然排序要改变类结构
public class Teacher implements Comparable {
    private String name;
    private int age;

    public Teacher() {
    }

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

    /**
     * 获取
     * @return name
     */
    public String getName() {
        return name;
    }

    /**
     * 设置
     * @param name
     */
    public void setName(String name) {
        this.name = name;
    }

    /**
     * 获取
     * @return age
     */
    public int getAge() {
        return age;
    }

    /**
     * 设置
     * @param age
     */
    public void setAge(int age) {
        this.age = age;
    }

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

    @Override
    public int compareTo(Object o) {
        if(o == null){
            throw new NullPointerException();
        }
        if(o instanceof Teacher teacher){
            return this.age - teacher.age;
        }
        throw new ClassCastException();
    }
}


public class Student implements Comparable{ // 类声明中实现该接口
// 省略其余代码
@Override
public int compareTo(Object o) { // 重写compareTo方法
if (o == null ) {
throw new NullPointerException();
}
if (this.equals(o)) {
return 0;
}
if (o instanceof Student student) {
return age - student.getAge() > 0 ? 1 : -1;
}
throw new ClassCastException();
}
}

public class TeacherTest {
    public static void main(String[] args) {
//        ArrayList arrayList = new ArrayList();
//        arrayList.add(new Teacher("张三",23));
//        arrayList.add(new Teacher("李四",25));
//        arrayList.add(new Teacher("王五",19));
//        System.out.println(arrayList);
//        Teacher teacher = new Teacher();
//        teacher.compareTo(arrayList);
        TreeSet treeSet = new TreeSet();
        treeSet.add(new Teacher("张三",23));
        treeSet.add(new Teacher("李四",19));
        treeSet.add(new Teacher("王五",28));
        System.out.println(treeSet);
    }

• 元素唯一性：TreeSet不允许重复元素，每个元素在集合中只出现一次。
• null元素的处理：TreeSet不允许null元素，如果插入null元素，会报空指针异常。
• TreeSet的迭代器：。按照集合的排序顺序进行遍历，从最小到最大。 

我们想要告诉 TreeSet 集合按照指定的规则排序，有两种办法：

第一种：让元素的类实现 Comparable 接口，重写 compareTo() 方法

第二种：在创建 TreeSet 集合时，通过构造方法传递 Compartor 比较器对象

常用方法

构造方法

public  TreeSet( )

public  TreeSet((Collection c)

public  TreeSet(Comparator comparator)

public  TreeSet((SortedSet s)

常用方法

 

 注意：Treeset集合最大的特点是可以对元素进行排序，但是必须指定元素的排序规则。

方法的说明

E  ceiling( E  e )：返回此集合中大于等于给定元素的最小元素，如果不存在返回null。

E  floor( E  e )：返回此集合中小于等于给定元素的最小元素，如果不存在返回null。

Iterator  descendingIterator( )：按降序返回此集合中元素的迭代器。

Iterator  iterator( )：按升序返回此集合中元素的迭代器。

E  first( )：返回集合中的第一个元素。

E  last( )：返回集合中的最后一个元素。

headSet( E  e )：返回小于e的所有元素的集合。

headSet( E  e ,  boolean  flag)：返回小于等于e的所有元素的集合。

E  higher( E  e)：返回此集合中大于e的所有元素的集合，只是大于，没有等于。

E  lower(E  e)：返回此集合中小于e的所有元素的集合，只是小于，没有等于。

LinkedHashSet动态存储数据

LinkedHashSet继承自HashSet类，同时也实现了Set接口。与HashSet不同的是，HashSet对元素的迭代是顺序是不确定的，而LinkedHashSet的迭代顺序就是按照插入顺序进行的，当需要保留元素的插入顺序时，可以使用LinkedHashSet。

LinkedHashSet的特点

• 元素唯一性：LinkedHashSet不允许有重复元素，每个元素只能出现一次，与HashSet相同。
• 元素插入顺序：迭代顺序就是元素插入顺序。
• null元素的处理：LinkedHashSet允许插入null元素，但只能有一个。