Set集合及其子集合

Set集合的特点
1.元素存取无序
2.没有索引
3.不能存储重复的元素

Set集合继承Colletion 可使用Colletion的常用方法
Collection集合的常用方法
boolean add(E e) 向集合中添加元素
boolean remove(E e) 将元素从集合中删除
void clear() 清空集合所有的元素
boolean isEmpty() 判断集合是否为空
int size() 获取集合的长度
boolean contains(E e) 判断集合中是否包含指定的元素

/*
通过多态的形式创建一个Set集合对象
向集合中添加四个元素：hello world java world
使用增强for循环遍历集合

 */

import java.util.HashSet;
import java.util.Iterator;
import java.util.Set;
public class lianxi01 {
    public static void main(String[] args) {
        Set<String>set= new HashSet<>();
      set.add("hello ")  ;
      set.add("world")  ;
      set.add("java ")  ;
      set.add("hello ")  ;
        //        boolean contains(E e)             判断集合中是否包含指定的元素
        System.out.println(set.contains("world"));//true
      //遍历器
        Iterator<String> it = set.iterator();
        while (it.hasNext()){
            String s = it.next();
            System.out.println(s);
//            world
//            hello 
//            java
        }
    }
}

HashSet集合的特点
1.底层是哈希表结构
2.元素存取无序(存储的顺序和取出的顺序有可能是不一致的)
3.没有索引
4.不能存储重复元素
HashSet集合保证元素唯一性的原理
1.根据对象的哈希值计算存储位置
如果当前位置没有元素则直接存入
如果当前位置有元素存在，则进入第二步
2.当前元素的元素和已经存在的元素比较哈希值
如果哈希值不同，则将当前元素进行存储
如果哈希值相同，则进入第三步
3.通过equals()方法比较两个元素的内容
如果内容不相同，则将当前元素进行存储
如果内容相同，则不存储当前元素

HashSet集合的特点
* 无序(
* 不允许存储重复的元素
* 没有索引
数据结构:
JDK8之前: 哈希表(数组 + 链表)
JDK8之后: 哈希表(数组 + 链表 + 红黑树)

HashSet集合存储学生对象并遍历的重要步骤
1.定义一个学生类
包含姓名和年龄两个属性
并重写hashCode()和equals()方法
2.创建HashSet集合对象，泛型为学生对象类型
3.创建几个学生对象，并存储到集合中
4.通过增强for循环遍历集合

学生类

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

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

    public Student() {
    }

    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 boolean equals(Object o) {
        if (this == o) return true;
        if (o == null || getClass() != o.getClass()) return false;

        Student student = (Student) o;

        if (age != student.age) return false;
        return name != null ? name.equals(student.name) : student.name == null;
    }

    @Override
    public int hashCode() {
        int result = name != null ? name.hashCode() : 0;
        result = 31 * result + age;
        return result;
    }

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

测试类

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

public class HashSetDemo {
    public static void main(String[] args) {
        HashSet<Student> hash = new HashSet<>();
        hash.add(new Student("周杰",55));
        hash.add(new Student("周杰伦",24));
        hash.add(new Student("周杰伦",24));
        hash.add(new Student("陶喆",44));
        hash.add(new Student("宋喆",33));
        hash.add(new Student("宋喆",33));
        Iterator<Student> it = hash.iterator();
        for (Student st : hash) {
            System.out.println(st);
        }
//        while (it.hasNext()){
//            Student s  = it.next();
//            System.out.println(s);
//        }
        /*
        Student{name='陶喆', age=44}
        Student{name='宋喆', age=33}
        Student{name='周杰', age=55}
        Student{name='周杰伦', age=24}

         */
    }
}

LinkedHashSet
LinkedHashSet集合的概述和特点
LinkedHashSet集合是HashSet集合的子类
有序(存储的顺序和取出的顺序是一致的)
不允许存储重复的元素
没有索引

数据结构:
数组+链表 + 链表 ==> 数组 + 双向链表

TreeSte
TreeSet集合的特点
1.元素有序。元素可以按照一定规则进行排序。具体要取决于构造方法
TreeSet()：根据元素的自然顺序进行排序
TreeSet(Comparator c)：根据指定的比较器进行排序
2.TreeSet集合没有索引。只能通过迭代器、增强for循环进行遍历
3.TreeSet集合不能存储重复元素

import java.util.TreeSet;

public class lainxi01 {
    public static void main(String[] args) {
        TreeSet<Integer> tree= new TreeSet<>();
        tree.add(8);
        tree.add(88);
        tree.add(12);
        tree.add(122);
        tree.add(122);
//        TreeSet()：根据元素的自然顺序进行排序
        System.out.println(tree);//[8, 12, 88, 122]
    }
}

自然排序Comparable接口的使用
使用自然排序Comparable的重要步骤
1.定义学生类
包含姓名和年龄两个属性
实现Comparable接口，重写compareTo()方法
主要条件：年龄升序
次要条件：姓名字母顺序
2.创建TreeSet集合对象，泛型为学生对象类型
3.创建几个学生对象，并存入集合中
4.使用增强for循环遍历集合

学生类

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

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

    public Student() {
    }

    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 int compareTo(Student s) {
//        return 1;
       int   num = this.age-s.age;//this = s2   s = s1
       int num1 =num==0?this.name.compareTo(s.name):num;
       return num1;
    }
}

测试类

import java.util.TreeSet;

/*
使用自然排序Comparable的重要步骤
       1.定义学生类
                包含姓名和年龄两个属性
                实现Comparable接口，重写compareTo()方法
                主要条件：年龄升序
                次要条件：姓名字母顺序
       2.创建TreeSet集合对象，泛型为学生对象类型
       3.创建几个学生对象，并存入集合中
       4.使用增强for循环遍历集合

 */
public class TreeSteDemo {
    public static void main(String[] args) {
        TreeSet<Student> terr = new TreeSet<>();
        terr.add(new Student("王二",23));
        terr.add(new Student("李二",44));
        terr.add(new Student("赵二",44));
        terr.add(new Student("王二",4));
        terr.add(new Student("王二",4));
        for (Student st : terr) {
            System.out.println(st.getName()+","+st.getAge());

        }

    }
}

自然排序Comparable的使用
主要条件：年龄升序
次要条件：姓名字母顺序
1…定义学生类
2.测试类

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

public class TreeSteTest {
    public static void main(String[] args) {
        TreeSet<Student> tree = new TreeSet<>(new Comparator<Student>() {

            @Override
            public int compare(Student s1, Student s2) {
                //this.age - s.age
                //s1-s2
                //从小到大
                int num = s1.getAge()-s2.getAge();
                //字母升序
                int num1 = num==0?s1.getName().compareTo(s2.getName()):num;
                return num1;
            }
        });
        tree.add(new Student("a王皓",55));
        tree.add(new Student("cc李文革",12));
        tree.add(new Student("a邓亚区",11));
        tree.add(new Student("a邓亚区",11));
        tree.add(new Student("v分速度",11));
        for (Student st : tree) {
            System.out.println(st.getName()+","+st.getAge());
        }
      /*  a邓亚区,11
        v分速度,11
        cc李文革,12
        a王皓,55*/

    }
}

比较器排序 Comparator

//比较器排序 Comparator

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

public class demo02 {
    public static void main(String[] args) {
        TreeSet<Student> st = new TreeSet<>(new Comparator<Student>() {
            @Override
            public int compare(Student s1, Student s2) {
                int num = Student.sumber(s2)-Student.sumber(s1);
                int num1 = num==0?s2.getChinese()-s1.getChinese():num;
                int num2 = num1==0?s1.getName().compareTo(s2.getName()):num1;
                return num2;
            }
        });
        st.add(new Student("a邓虎",88,89));
        st.add(new Student("b张虎",88,89));
        st.add(new Student("李虎",98,79));
        st.add(new Student("马虎",94,95));
        st.add(new Student("马虎",94,95));
        st.add(new Student("马虎",92,92));
        for (Student st1 : st) {
            System.out.println(st1);
        }
    }
}

不重复随机数案例的主要步骤
1.创建一个TreeSet集合对象，泛型为Integer类型
2.创建Random对象，用于生成随机数
3.使用while循环判断集合长度是否不等于10
如果长度不为10，则生成随机数保存到集合中
4.使用增强for循环遍历集合

import java.util.Random;
import java.util.TreeSet;
public class RandomDemo {
    public static void main(String[] args) {
        TreeSet<Integer> it = new TreeSet<>();
        Random r = new Random();
        while (it.size()<10) it.add(r.nextInt(10)+1);
        for (Integer integer : it) System.out.println(integer);
//        1
//        2
//        3
//        4
//        5
//        6
//        7
//        8
//        9
//        10
    }
}