Java中的Set

Set <接口>

---

HashSet

特点 : 无序 无下标 不重复

    /**
     * set添加字符串
     */
    public static void fun1() {
        // 使用HashSet 主要用来 去重
        // 创建一个HashSet
        HashSet<String> set = new HashSet<>();
        // 添加 d d 看看效果
        boolean b1 = set.add("d");
        boolean b2 = set.add("d");
        set.add("a");
        set.add("a");
        set.add("b");
        set.add("b");
        set.add("c");
        set.add("c");
        // 有序 怎么存 怎么打印出来
        System.out.println(b1);
        System.out.println(b2);
        System.out.println(set);
    }

    public static void fun2() {
        // 创建一个hashSet 添加六个人 两两一样
        // hashSet 如何自定对象类型 如何去重?
        // 通过重写对象类的equals方法 和 hashCode方法 来去重
        HashSet<Person> set = new HashSet<>();
        set.add(new Person("张三", 12));
        set.add(new Person("张三", 12));
        set.add(new Person("李四", 13));
        set.add(new Person("李四", 13));
        set.add(new Person("王五", 14));
        set.add(new Person("王五", 14));
        // 遍历set集合 查看去重效果
        for (Person person : set) {
            System.out.println(person);
        }
    }

    public static void fun3() {
        // linkedHashSet
        // 特点: 有序 怎么存怎么取
        // 字符串为什么直接放进set中能去重 ? 
        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);
    }

    public static void fun4() {
        //  编写一个程序，获取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); // 自动装箱
        }
        System.out.println(set);
    }

    public static void fun5() {
        //  输入一个字符串,去掉其中重复字符 wlznbwlznb --> wlznb
        System.out.println("请输入一个字符串");
        Scanner scanner = new Scanner(System.in);
        String string = scanner.nextLine();
        LinkedHashSet<Character> set = new LinkedHashSet<>();
        // 字符串转字符数组
        char[] charArray = string.toCharArray();
        // 添加到set集合中 完成去重
        for (int i = 0; i < charArray.length; i++) {
            set.add(charArray[i]); // 自动装箱
        }
        System.out.println(set);
    }

        //  利用set集合 去除ArrayList集合中的重复元素 a a b b c c d d 
        //  (操作原ArrayList)
        ArrayList<String> arrayList = new ArrayList<>();
        arrayList.add("a");
        arrayList.add("a");
        arrayList.add("b");
        arrayList.add("b");
        arrayList.add("c");
        arrayList.add("c");
        arrayList.add("d");
        arrayList.add("d");
        LinkedHashSet<String> set = new LinkedHashSet<>();
        // 将list中所有元素 扔到set中去重
        set.addAll(arrayList);
        // 请控原arraylist 
        arrayList.clear();
        // 再把set中的所有元素 扔arraylist 中
        arrayList.addAll(set);
        System.out.println(arrayList);

---

TreeSet (内部实现 二叉树)

无序 不重复 无下标

主要作用: 用来排序

    public static void fun1() {
        // 创建一个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);
        }
    }

    public static void fun2() {
        // 创建TreeSet集合 保存4个工人
        // 系统给你留了接口Comparable 如果你想通过TreeSet来排序
        // 你就实现这个接口 编写排序的规则 系统就会按规则来给你排序
        TreeSet<Worker> set = new TreeSet<>();
        set.add(new Worker("张三", 23));
        set.add(new Worker("李四", 13));
        set.add(new Worker("王五", 43));
        set.add(new Worker("赵六", 33));
        for (Worker worker : set) {
            System.out.println(worker);
        }
        System.out.println((int)'张');
    }

---

// 保留重复的字符串的比较器
class KeepStringComImpl 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;
        // 存于不存就 取决于这个方法的返回值
        return num == 0 ? 1 : num;

    }
}

    public static void fun3() {
        /*
         * 使用比较器来排序步骤
         * 1. 创建一个类 实现 Comparator接口
         * 2. 实现接口中的方法 并编写 比较的规则
         * 3. 把该类的对象传入 TreeSet 集合中
         */
        // 保留重复的字符串
        TreeSet<String> set = new TreeSet<>(new KeepStringComImpl());
        set.add("asd");
        set.add("asde");
        set.add("asdef");
        set.add("a");
        set.add("as");
        // 按字符串长度排序
        System.out.println(set);
    }

---

class KeepString implements Comparator<Character>{
    @Override
    public int compare(Character o1, Character o2) {
        int num = o1.compareTo(o2);
        return num == 0 ? 1 : num;
    }
}

    public static void fun4() {
        //  键盘接收一个字符串, 程序对其中所有字符进行排序
        //  要求保留重复的
        System.out.println("请输入一个字符串");
        Scanner scanner = new Scanner(System.in);
        String nextLine = scanner.nextLine();
        TreeSet<Character> set = new TreeSet<>(new KeepString());
        char[] charArray = nextLine.toCharArray();
        for (int i = 0; i < charArray.length; i++) {
            set.add(charArray[i]);
        }
        System.out.println(set);
    }

---

class KeepInt implements Comparator<Integer>{
    @Override
    public int compare(Integer o1, Integer o2) {
        int num = o1 - o2;
        return -(num == 0 ? 1 : num);
    }
}

    public static void fun5() {
        /*
         * 程序启动后, 可以从键盘输入接收多个整数, 
         * 直到输入quit时结束输入. 把所有输入的整数倒序排列打印.
         * 保留重复 比较器实现
         */     
        System.out.println("请输入整数");
        Scanner scanner = new Scanner(System.in);

        TreeSet<Integer> treeSet = new TreeSet<>(new KeepInt());
        while (true) {
            String string = scanner.nextLine();
            if (string.equals("quit")) {
                break;
            }
            // 输入的是整数的时候
            int num = Integer.parseInt(string);
            treeSet.add(num);
        }
        System.out.println(treeSet);
    }

---

        //  键盘录入5个学生信息(姓名,语文成绩,数学成绩,英语成绩)
        //  录入的学生信息格式(姓名,语文成绩,数学成绩,英语成绩)
        //  按照总分从高到低输出到控制台。输出学生所有信息
        Scanner scanner = new Scanner(System.in);
        TreeSet<Student> set = new TreeSet<>();
        while (set.size() < 5) {
            System.out.println("请输入学生信息格式 " + "(姓名,语文成绩,数学成绩,英语成绩)");
            String string = scanner.nextLine();
            // 按逗号切割字符串
            String[] strings = string.split(",");
            // 把成绩取出来
            int chinese = Integer.parseInt(strings[1]);
            int math = Integer.parseInt(strings[2]);
            int english = Integer.parseInt(strings[3]);
            // 构建对象
            Student  student = new Student(strings[0], chinese, math, english);
            set.add(student);

        }
        System.out.println(set);

    // 实现接口中的唯一方法
    /*
     * 返回0时 set中只有一个元素
     * 1 正数  按存进去的顺序 正序打印
     * -1 负数 按存进去的顺序 倒序打印
     * 
     * TreeSet 按二叉树保存的
     * 要保存的数比我小 放在我的左边 (返回负数)
     * 要保存的数比我大 放在我的右边 (返回正数)
     * 要保存的数一样大 就不存储
     * 打印按从小到大输出 (升序) 
     * 
     * 使用TreeSet排序的步骤
     * 1. 让TreeSet集合中保存的对象 实现comparable接口
     * 2. 实现compareTo方法
     * 3. 在compareTo方法中 实现 你要排序的规则
     * 
     */

    /*
    @Override
    public int compareTo(Worker o) {
        // 按年龄比较
        return this.getAge() - o.getAge();
    }
    */
    /*
    // 按姓名排序
    @Override
    public int compareTo(Worker o) {
        return this.getName().compareTo(o.getName());
    }
    */
    // 比较的主要条件 按年龄
    //      次要条件 按姓名
    // 年龄相同时 去比较姓名
    /*
    @Override
    public int compareTo(Worker o) {
        int num = this.getAge() - o.getAge(); // 主要比年龄
        return num == 0 ? this.getName().compareTo(o.getName()) : num ; // 次要比姓名
    }
    */

    /*
     * 主要比字符串长度
     * 然后比年龄
     * 最后比字符串
     */
    @Override
    public int compareTo(Worker o) {
        int s = this.getName().length() - o.getName().length();
        int num = this.getAge() - o.getAge();
//      if (s == 0 ) {
//          if (num == 0) {
//              return this.getName().compareTo(o.getName());
//          }
//          return num;
//      }
//      return s;

        return s == 0 ? num == 0 ? this.getName().compareTo(o.getName()) : num : s ;

    }

系统重写的equals方法

    // 判断两个对象是否相同
    @Override
    public boolean equals(Object obj) {
        if (this == obj) // 如果两个对象地址一样
            return true; // 就返回true
        if (obj == null) // 如果传进来的对象是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;
    }