java Set接口

HashSet

1.使用HashSet主要用来去重
//创建一个HashSet
HashSet<String> set = new HashSet<>();
//添加d d 
        boolean b1 = set.add("d");
        boolean b2 = set.add("d");
        set.add("a");
        set.add("b");
        set.add("b");
        set.add("c");
        //有序 怎么存 怎么打印出来
        System.out.println(b1);
        System.out.println(b2);
        System.out.println(set);
2.引用数据类型去重
//创建一个HashSet 添加6个人 两两一样
        //通过重写对象类的 equals方法和 hashCode方法 来去重
        HashSet<Person> set = new HashSet<>();
        set.add(new Person("鹏", 16));
        set.add(new Person("鹏", 16));
        set.add(new Person("水", 17));
        set.add(new Person("水", 17));
        set.add(new Person("茜", 18));
        set.add(new Person("茜", 18));
        for (Person person : set) {
            System.out.println(person);
        }
        //在对象类中重写 equals方法和 hashCode方法
        @Override
    public int hashCode() {
        //31是个质数
        final int prime = 31;
        int result = 1;
        result = prime * result + age;
        result = prime * result + ((name == null) ? 0 : name.hashCode());
        return result;
    }
    //判断两个对象是否相同
    @Override
    public boolean equals(Object obj) {
        if (this == obj)//如果两个对象地址一样
            return true;//返回true
        if (obj == null)//如果传进来的对象是空
            return false;//就返回false
        if (getClass() != obj.getClass())//如果两个对象不是一个类创建出来的
            return false;                   //就返回false
        Person other = (Person) obj;//向下转型(准备调用特有的方法)
        if (age != other.age)
            return false;
        if (name == null) {
            if (other.name != null)
                return false;
        } else if (!name.equals(other.name))//使用字符串类的比较 判断字符串是否相同
            return false;
        return true;
    }

LinkedHashSet

1.     //linkedHashSet 是HashSet的一个子类
        //特点:有序 怎么存就能怎么取出来
        //字符串类是系统类 里面直接就写好了equals方法和HashCode方法
        LinkedHashSet<String> set = new LinkedHashSet<>();
        set.add("l");
        set.add("w");
        set.add("w");
        set.add("a");
        set.add("n");
        set.add("g");
        System.out.println(set);

2.//  编写一个程序，获取10个1至20的随机数，要求随机数不能重复
            LinkedHashSet<Integer> set = new LinkedHashSet<>();
            //集合长度小于10 就添加
            while (set.size() < 10) {
                //随机数
                int num = (int)(Math.random() * (20 - 1 + 1) + 1);
                //添加到集合中
                set.add(num);
            }

3.//  利用set集合 去除ArrayList集合中的重复元素
        //  (操作原ArrayList)
        ArrayList<String> list = new ArrayList<>();
        list.add("a");
        list.add("a");
        list.add("b");
        list.add("b");
        list.add("c");
        list.add("c");
        //创建set
        LinkedHashSet<String> set = new LinkedHashSet<>();
        //将list中所有元素 放到set中去重
        set.addAll(list);
        //清空list
        list.clear();
        //再把set中的所有元素 放到list中
        list.addAll(set);
        //打印
        System.out.println(list);

TreeSet

1. TreeSet(内部实现二叉树)
   无序 不重复 无下标
   主要作用: 用来排序
   //创建TreeSet
        TreeSet<Integer> set = new TreeSet<>();
        set.add(1);
        set.add(13);
        set.add(1);
        set.add(2);
        set.add(3);
        //遍历
        for (Integer integer : set) {
            System.out.println(integer);
        }
2.     //创建TreeSet集合 保存3个工人
        //系统给你留了个接口 如果你想通过TreeSet来排序
        //你就显现这个接口 编写排序规则 系统就会按排序规则来给你排序
        TreeSet<Worker> set = new TreeSet<>();
        set.add(new Worker("张三", 20));
        set.add(new Worker("李四", 18));
        set.add(new Worker("王五", 40));
        set.add(new Worker("赵六", 33));
        for (Worker worker : set) {
            System.out.println(worker);
        }
//在工人类中实现Comparable接口中的compareTo方法
//主要比字符串长度 然后比较年龄 最后比较字符串
    @Override
    public int compareTo(Worker o) {
        //比较字符串长度
        int length = this.getName().length() - o.getName().length();
        //长度一样比年龄
        int num = length == 0 ? this.getAge() - o.getAge() : length;
        //年龄一样 比较字符串
        return num == 0 ? this.getName().compareTo(o.getName()) : num;
    }
3./*
          使用比较器来排序的步骤
          1.创建一个类 实现Comparator接口
          2.实现接口中的方法 并编写 比较的规则
          3.把该类的对象 传入 TreeSet集合中
        */
        //字符串类是系统类 已经写过Comparable接口中的compareTo方法
        //所以要用比较器来排序
        TreeSet<String> set = new TreeSet<>(new StringLengthCompareImpl());
        set.add("asd");
        set.add("asde");
        set.add("asdef");
        set.add("a");
        set.add("asd");
        set.add("as");
        //按字符串长度排序
        System.out.println(set);

//创建一个类 实现Comparator接口
// 保留重复字符串的比较器
class KeepStringImpl implements Comparator<String>{
    @Override
    public int compare(String o1, String o2) {
        int length = o1.length() - o2.length();
        int num = length == 0 ? o1.compareTo(o2) : length;
        //存与不存 取决于这个方法的返回值
        //返回1也行 -1也行
        return num == 0 ? 1 : num;
    }