Set集合的使用

set集合

package org.example.set;
​
import java.util.HashSet;
import java.util.Set;
​
/*
* Set 集合特点
*   不包含重复元素的集合
*   没有带索引的方法，所以不能使用普通for循环遍历*/
public class SetDemo {
    public static void main(String[] args) {
        // 创建集合对象
        Set<String> set=new HashSet<>();
        //添加元素
        set.add("zhangsan");
        set.add("lisi");
        set.add("wangwu");
        //不包含重复元素，插入重复元素无效
        set.add("lisi");
        //遍历set
        for (String item : set) {
            System.out.println(item);//输出lisi,zhangsan,wangwu
        }
    }
}

哈希值

哈希值是JDK根据对象的地址或者字符串或者数字算出来的int类型的数值

Object类中有一个方法可以获取对象的哈希值

public int hashCode();//返回对象的哈希码值

package org.example.set;
​
public class HashDemo {
    public static void main(String[] args) {
        //创建Student对象
        Student s1 = new Student("张三", 20);
        //同一个对象多次调用hashCode()方法返回的哈希值是相同的
        System.out.println(s1.hashCode());//356573597
        System.out.println(s1.hashCode());//356573597
        Student s2 = new Student("李四", 20);
        //默认情况下，不同对象的hashCode是不同的
        System.out.println(s2.hashCode());//1735600054
    }
}

HashSet集合

1. HashSet集合特点

   1. 底层数据结构是哈希表

   2. 对集合的迭代顺序不作任何保证，也就是说不保证存储和取出的元素顺序是一致的

   3. 没有带索引的方法，所以不能使用普通for循环遍历

   4. 由于是Set集合，所以是不包含重复元素的集合

LinkedHashSet集合

LinkedHashSet集合特点

1. 哈希表和链表实现的Set接口，具有可预测的迭代顺序

2. 由链表保证元素有序，也就是说元素的存储和取出顺序是一致的

3. 由哈希表保证元素唯一，也就是说没有重复的元素

package org.example.set;
​
import java.util.LinkedHashSet;
​
public class LinkedHashSetDemo {
    public static void main(String[] args) {
        //创建集合对象
        LinkedHashSet<String> linkedHashSet = new LinkedHashSet<>();
        //添加对象
        linkedHashSet.add("zhangsan");
        linkedHashSet.add("lisi");
        linkedHashSet.add("wangwu");
        //添加重复数据
        linkedHashSet.add("lisi");
        //遍历集合
        for (String item : linkedHashSet) {
            System.out.print(item+" ");//zhangsan lisi wangwu 
        }
​
    }
}

TreeSet集合

TreeSet集合特点

1. 元素有序，这里的顺序不是值存储和取出的顺序，而是按照一定的规则进行排序，具体排序方式取决于构造方法

   1. TreeSet(): 根据其元素的自然排序进行排序

   2. TreeSet(Comparator comparator): 根据指定的比较器进行排序

2. 没有带索引的方法，所以不能使用普通的for循环遍历

3. 由于是Set集合，所以不包含重复元素的集合

package org.example.set;
​
import java.util.TreeSet;
​
public class TreeSetDemo {
    public static void main(String[] args) {
        //创建集合对象
        TreeSet<Integer> treeSet = new TreeSet<>();
        //添加元素
        treeSet.add(20);
        treeSet.add(18);
        treeSet.add(28);
        treeSet.add(10);
        //添加重复元素
        treeSet.add(20);
        //遍历集合-按照自然排序排序
        for (Integer integer : treeSet) {
            System.out.print(integer+" ");//10 18 20 28
        }
​
    }
}

自然排序Comparable的使用

1. 存储学生对象并遍历，创建TreeSet集合无参构造方法

2. 要求: 按照年龄从小到大排序，年龄相同时，按照姓名的字母顺序排序

Student类

package org.example.set;
​
public class Student implements Comparable<Student> {
    private String name;
    private int age;
​
    public Student() {
    }
​
    public Student(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 "Student{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }
​
    @Override
    public int compareTo(Student s) {
        //按照年龄从小到大排序
        int num=this.age-s.age;
        num=num==0?this.name.compareTo(s.name):num;
        return num;
    }
}

ComparableDemo类

package org.example.set;
​
import java.util.TreeSet;
​
public class ComparableDemo {
    public static void main(String[] args) {
        //创建集合对象
        TreeSet<Student> treeSet = new TreeSet<>();
        //创建学生对象
        Student s1 = new Student("zhangsan", 29);
        Student s2 = new Student("lisi", 28);
        Student s3 = new Student("wangwu", 30);
        Student s4 = new Student("zhaoliu", 33);
        Student s5 = new Student("sunqi", 33);
        //把学生添加到集合中
        treeSet.add(s1);
        treeSet.add(s2);
        treeSet.add(s3);
        treeSet.add(s4);
        treeSet.add(s5);
        //遍历集合
        for (Student student : treeSet) {
            System.out.println(student);
        }
    }
}

比较器排序Comparator的使用

1. 存储学生对象并遍历，创建TreeSet集合使用带参数构造方法

2. 要求: 按照年龄从小到大排序，年龄相同时，按照姓名的字母顺序排序

package org.example.set;
​
import java.util.Comparator;
import java.util.TreeSet;
​
public class ComparatorDemo {
    public static void main(String[] args) {
        //创建集合对象
        TreeSet<Student> treeSet = new TreeSet<>(new Comparator<Student>() {
            @Override
            public int compare(Student s1, Student s2) {
                int num = s1.getAge() - s2.getAge();
                num = num == 0 ? s1.getName().compareTo(s2.getName()) : num;
                return num;
            }
        });
        //创建学生对象
        Student s1 = new Student("zhangsan", 29);
        Student s2 = new Student("lisi", 28);
        Student s3 = new Student("wangwu", 30);
        Student s4 = new Student("zhaoliu", 33);
        Student s5 = new Student("sunqi", 33);
        //把学生添加到集合中
        treeSet.add(s1);
        treeSet.add(s2);
        treeSet.add(s3);
        treeSet.add(s4);
        treeSet.add(s5);
        //遍历集合
        for (Student student : treeSet) {
            System.out.println(student);
        }
    }
}