Java基础——Set、HashSet、LinkedHashSet 、TreeSet

1.HashSet

Set：无序(存储和取出的顺序)和唯一。

HashSet 底层数据结构是哈希表. HashSet 不是线程安全的 集合元素可以是 null
​哈希表:是一个元素为链表的数组,综合了数组和链表的优点

当向 HashSet 集合中存入一个元素时，HashSet 会调用该对象的 hashCode() 方法来得到该对象的 hashCode 值，
然后根据 hashCode 值决定该对象在 HashSet 中的存储位置。
HashSet 集合判断两个元素相等的标准：
两个对象通过 hashCode() 方法比较相等，并且两个对象的 equals() 方法返回值也相等。

HashSet对象中不能存储相同的数据（是按照哈希值来存的所以取数据也是按照哈希值取得），存储数据时是无序的

结论:HashSet 保证元素唯一性是靠元素重写hashCode()和equals()方法来保证的，如果不重写则无法保证。

重写原因：
1、HashSet是根据hashCode值来判断对象是否是同一个。
2、hashCode不等，2个对象一定不等
3、我们希望2个对象属性值都相同的时候，当成同一个对象，所有需要重写hashCode和equals方法(本质：根据对象属性的值来重写，保证属性值一样时，重写后的hashCode一定相同，equals方法一定为true)

注：我们都知道，比较两个引用是否指向同一个对象（实际就是比较内存地址），‘equals’比较两个对象的内容。当然这里的equals()方法是被重写过才能去比较内容相等的吧(当然基本数据类型直接用，string为引用数据类型，调用String类本身重写的equals方法)。

HashSet存储元素保证唯一性的图解

HashSet存储自定义对象保证元素唯一性

package com.xawl.demo3;

import java.util.HashSet;
import java.util.function.Consumer;

/**
 * @Author:liger
 * @Description:爱学Java
 */
public class Test {
    public static void main(String[] args) {
        HashSet<Student> students = new HashSet<>();
        students.add(new Student("张三",23));
        students.add(new Student("李四",24));
        students.add(new Student("王五",25));
        students.add(new Student("张三",23));
        students.forEach(new Consumer<Student>() {
            @Override
            public void accept(Student student) {
                System.out.println(student);
            }
        });
    }
}

存储对象需要重写equals()方法和hashCode()方法

2.LinkedHashSet

数据结构 有两个 链表和哈希表
​链表保证有序 哈希表保证元素唯一
​LinkedHashSet:	元素有序(存取顺序一致) , 并且唯一

元素有序演示

package com.xawl.demo3;
import java.util.LinkedHashSet;
import java.util.function.Consumer;
/**
 * @Author:liger
 * @Description:爱学Java
 */
public class Test2 {
    public static void main(String[] args) {
        LinkedHashSet<Integer> linkedHashSet = new LinkedHashSet<>();
        linkedHashSet.add(20);
        linkedHashSet.add(30);
        linkedHashSet.add(40);
        linkedHashSet.add(50);
        linkedHashSet.add(60);
        linkedHashSet.forEach(new Consumer<Integer>() {
            @Override
            public void accept(Integer integer) {
                System.out.println(integer);
            }
        });
    }
}

3.TreeSet

TreeSet集合的特点: 元素唯一,并且可以对元素进行排序
排序:
		自然排序
		使用比较器排序
	到底使用的是哪一种的排序取决于,构造方法.

注意：使用TreeSet集合进行元素的自然排序，那么对元素有要求，要求这个元素
      必须实现Comparable接口 否则无法进行自然排序

 保证元素的唯一性是靠compareTo方法的返回值来确定如果返回0 表示两个元素相等
		则不重复存储

TreeSet集合排序总结

二叉树存储数据保证唯一性的图

二叉树的数据结构 先存入一个树根 分两个叉
存储元素时 跟树根比较 小的放在左边 大的放在右边
如果相等就不存储
取的时候按照 左中右的顺序来取

TreeSet存储自定义对象并遍历
注意自然排序 此对象 必须实现Comparable接口 否则报错

TreeSet存储自定义对象

package com.xawl.demo4;

import java.util.TreeSet;
import java.util.function.Consumer;

/**
 * @Author:liger
 * @Description:爱学Java
 */
public class Test {
    public static void main(String[] args) {
        TreeSet<Student> students = new TreeSet<>();
        students.add(new Student("吕布",40));
        students.add(new Student("貂蝉",30));
        students.add(new Student("刘备",50));
        students.add(new Student("孙尚香",20));
       students.forEach(new Consumer<Student>() {
           @Override
           public void accept(Student student) {
               System.out.println(student.getName()+"==="+student.getAge());
           }
       });
    }
}

自定义学生类（实现Comparable接口并重写compareTo方法）

package com.xawl.demo4;


/**
 * @Author:liger
 * @Description:爱学Java
 */
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 o) {
    //先比较年龄
        int num=this.age-o.age;
        //长度一样的话比较姓名长度
        int nums=num==0?this.name.length()-o.name.length():num;
        return nums;
    }
}

比较器排序

package com.xawl.demo4;
import java.util.Comparator;
import java.util.TreeSet;
import java.util.function.Consumer;

/**
 * @Author:liger
 * @Description:爱学Java
 */
public class Test2 {
    public static void main(String[] args) {
    //有参构造，重写 compare方法
        TreeSet<Student> students = new TreeSet<>(new Comparator<Student>() {
            @Override
            public int compare(Student o1, Student o2) {
                int num=o1.getAge()-o2.getAge();
                int nums=num==0?o1.getName().length()-o2.getName().length():num;
                return nums;
            }
        });
        students.add(new Student("吕布",40));
        students.add(new Student("貂蝉",30));
        students.add(new Student("刘备",50));
        students.add(new Student("孙尚香",20));
        students.forEach(new Consumer<Student>() {
            @Override
            public void accept(Student student) {
                System.out.println(student.getName()+"==="+student.getAge());
            }
        });
    }
}

练习

编写一个程序，获取10个1至20的随机数，要求随机数不能重复。并把最终的随机数输出到控制台。

package com.xawl.demo5;

import java.util.Random;
import java.util.TreeSet;
import java.util.function.Consumer;

/**
 * @Author:liger
 * @Description:爱学Java
 */
public class Test {
    public static void main(String[] args) {
        /*编写一个程序，获取10个1至20的随机数，要求随机数不能重复。
        并把最终的随机数输出到控制台。*/
        Random ran = new Random();
        TreeSet<Integer> integers = new TreeSet<>();
        while (integers.size()<10){
            int i = ran.nextInt(20)+1;
            if(!integers.contains(i)){
                integers.add(i);
            }
        }
        integers.forEach(new Consumer<Integer>() {
            @Override
            public void accept(Integer integer) {
                System.out.println(integer);
            }
        });
    }
}