Java中Set、TreeSet接口

Set

    Set(接口)
    特点: 无序(无下标) 不重复

HashSet

    先创建一个Person类
    Person类中有 名字 年龄
    写上构造函数
    set/get方法
    重写 toString方法

set添加字符串

    public static void fun1() {
        //使用HashSet 主要用来 去重复
        //创建一个HashSet
        Hash set = new HashSet<>();
        //添加 d d
        boolean b1 = set.add("d");
        boolean b2 = set.add("d");
        set.add("a");
        set.add("b");
        set.add("c");
        //无序(不是怎么存的 就怎么取)
        System.out.println(b1);
        System.out.println(b2);
        System.out.println(set);
    }

    //创建一个HashSet 添加6个人 两两一样
    //通过重写对象类的 equals方法 和 HashCode方法来去重

    HashSet p = new HashSet<>();
    p.add(new Person("aa", 16));
    p.add(new Person("aa", 16));
    p.add(new Person("bb", 16));
    p.add(new Person("bb", 16));
    p.add(new Person("cc", 16));
    p.add(new Person("cc", 16));
    //使用foreach快速遍历
    for (Person person : p){
        System.out.println(person);
    }

    //在Person类中 使用系统方法 自动生成 重写
    //hashCode和equals方法
    //之后使用系统自动生成的hashCode和equals方法
    @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;// 使用字符串类的 equals方法 比较 判断字符串是否相同
        return true;
    }

    //编写一个程序 获取10个 1至20分随机数,要求随机数不能重复
    HashSet set = new HashSet<>();
    //集合长度 < 10 的时候 就添加
    while(set.size()){
        int num = (int)(Math.random()*20 - 1);
        set.add(num);
    }
    System.out.println(set);

linkedHashSet

    linkedHashSet 是 Hashset的一个子类
    特点: 有序(怎么存的 就能怎么取出来)

    linkedHashSet set = new linkedHashSet<>();
    set.add("z");
    set.add("j");
    set.add("a");
    set.add("a");
    set.add("v");
    set.add("a");
    System.out.println(set);

    //输入一个字符串 去掉其中重复字符
    Scanner scanner = new Scanner(System.in);
    String string = scanner.nextLine();
    LinkedHashSet set = new LinkedHashSet<>();
    char[] charArray = string.toCharArray();
    for (int i = 0; i < charArray.length; i++) {
            set.add(charArray[i]);
        }
    System.out.println(set);

    //利用set集合 去除ArrayList集合中的重复元素
    //(操作原ArrayList)
    ArrayList aList = new ArrayList<>();
        aList.add("a");
        aList.add("a");
        aList.add("b");
        aList.add("b");
        aList.add("c");
        aList.add("c");
        LinkedHashSet set = new LinkedHashSet<>();
        //将 aList中的元素全都扔到 set中 去重
        set.addAll(aList);
        //清空原aList
        aList.clear();
        //把set中去完重的元素扔回aList中
        aList.addAll(set);
        //打印
        System.out.println(aList);

TreeSet

    TreeSet(内部实现: 二叉树)
    无序(无下标) 不重复
    主要作用: 用来排序
    (无序的意思是 不按照怎么存进去的顺序取出来)

    创建一个Worker类 继承 Person类 写出构造方法

    //创建一个TreeSet
    TreeSet set = new TreeSet<>();
    set.add(1);
    set.add(13);
    set.add(1);
    set.add(2);
    set.add(3);
    set.add(4);
    //遍历
    for(Integer integer : set){
        System.out.println(integer);
    }

    //创建TreeSet集合 保存4个工人 
    // 系统给你留了一个接口Comparable 如果你想 通过TreeSet来排序
    // 你就实现这个接口 编写 排序的规则 系统就会按规则 来给你排序
    TreeSet wSet = new TreeSet<>();
    wSet.add(new Worker("ygs", 21));
    wSet.add(new Worker("ygh", 21));
    wSet.add(new Worker("ygssb", 21));
    wSet.add(new Worker("xsd", 22));
    wSet.add(new Worker("hzn", 19));
    wSet.add(new Worker("wl", 24));
    for (Worker worker : wSet) {
            System.out.println(worker);
        }
    }

    来到Wroker类中:
    public class Worker extends Person implements Comparable<Worker>{

        public Worker() {
        }

        public Worker(String name, int age) {
            super(name, age);
        }

        //实现Compareable接口中 compareTo方法
        @Override
        public int compareTo(Worker o) {
            return 0;
        }
        //返回0时 set中 只有一个元素
        //1(正数) 按存进去的顺序 正序打印
        //-1(负数)按存进去的顺序 倒序打印

        //TreeSet 按二叉树保存的
        //要保存的数比我小 放在我的左边(返回负数)
        //要保存的数比我大 放在我的右边(返回正数)
        //要保存的数 和我一样大 不存储
        //打印按从小到大输出

        //使用TreeSet排序的步骤
        //1.让TreeSet集合中保存的对象 实现Comparable接口
        //2.实现compareTo方法
        //3.在compareTo方法中 实现 你要排序的规则
    }

   第一个传进集合里的相当于根 也就是 return 0 时
   打印出来的那个值 就是 根
   当 this.getAge() - o.getAge() > 0 时
   传进来的值 在 根的右边
   this.getAge() - o.getAge() < 0 时,在根的左边
   this.getAge() - o.getAge() ==  0 时 不存储

    // 按年龄比较
    //创建TreeSet集合 保存4个工人 
    // 系统给你留了一个接口Comparable 如果你想 通过TreeSet来排序
    // 你就实现这个接口 编写 排序的规则 系统就会按规则 来给你排序
    TreeSet wSet = new TreeSet<>();
    wSet.add(new Worker("ygs", 21));
    wSet.add(new Worker("ygh", 21));
    wSet.add(new Worker("ygssb", 21));
    wSet.add(new Worker("xsd", 22));
    wSet.add(new Worker("hzn", 19));
    wSet.add(new Worker("wl", 24));
    for (Worker worker : wSet) {
            System.out.println(worker);
        }
    }

    来到Wroker类中:
    public class Worker extends Person implements Comparable<Worker>{

        public Worker() {
        }

        public Worker(String name, int age) {
            super(name, age);
        }

        //实现接口中的方法
        @Override
        public int compareTo(Workder o){
            //按年龄比较
            return this.getAge() - o.getAge();
        }
     }   

    //按姓名排序
    @Override
    public int compareTo(Workder o){
        return this.getNage().compareTo(o.getName());
    }

    //比较的主要条件 按年龄
    //次要条件 按姓名
    @Override
    public int compareTo(Worker o){
        if(this.getAge() == o.getAge()){
            reutrn this.getNage().compareTo(o.getName())
        }
        return this.getAge() - i.getAge();
    }

    //主要比字符串长度
    //然后比年龄
    //最后比较字符串
    @Override
    public int compareTo(Worker o){
        int length = this.getName().length();
        int length2 = o.getName().length();
        if(this.getAge() > o.getAge()){
            return this.getAge() - o.getAge();
        }else if(this.getAge() == o.getAge()){
            return this.getName.compareTo(o.getName());
        }
        return length - length - 2;
    }

比较器Comparator

    //使用比较器来排序
    //1.创建一个类 实现Comparator接口
    //2.实现接口中的方法 并编写比较的规则
    //3.把该类的对象传入 TreeSet集合中
    public static void fun3() {
        //主要比 字符串长度
        //次要比 比较字符串
        TreeSet set = new TreeSet<>(new StringLegnthCompareImpl());
        set.add("asd");
        set.add("asde");
        set.add("asdef");
        set.add("a");
        set.add("as");
        System.out.println(set);
    }
    //创建一个比较器类 专门做字符串的比较
    //实现Comparator接口 并实现方法
    class StringLegnthCompareImpl implements Comparator<String>{

        //比较的规则
        //主要比 字符串长度
        //次要比 比较字符串
        @Override
        public int compare(String o1, String o2) {
            if (o1.length() == o2.length()) {
                return o1.compareTo(o2);
            }
            return o1.length() - o2.length();
        }
    }

    public static void fun4() {
        //主要比 字符串长度
        //次要比 比较字符串
        TreeSet set = new TreeSet<>(new RepeatStringImpl());
        set.add("asd");
        set.add("asde");
        set.add("asdef");
        set.add("a");
        set.add("asd");
        System.out.println(set);
    }

    //保留重复的字符串 的 比较器
    class RepeatStringImpl implements Comparator<String>{
        @Override
        public int compare(String o1,String o2){
            int length = o1.length() - o2.length();
            //这里运用三目运算法来实现
            //写比较器的规则 用三目运算法可以方便很多
            //这里的 num 表示
            //如果 length == 0 就 返回o1.compareTo(o2)
            //如果 length != 0 就 返回 length
            int num = length == 0 ? o1.compareTo(o2) : length;

            //这里表示 如果 num == 0 就返回 1
            //如果 num != 0 就 返回 num
            return num == 0 ? 1 : num;
        }
    }

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

    class CompareStringAndRepeatTheSameString implements Comparator<Character>{

    @Override
    public int compare(Character o1, Character o2) {
        int num = o1.compareTo(o2);
        return num == 0 ? 1 : num;
    }
}

    public static void fun6() {
        /*
         * 程序启动后, 可以从键盘输入接收多个整数, 
         * 直到输入quit时结束输入. 把所有输入的整数倒序排列打印.
         * 保留重复 比较器实现
         */
        Scanner scanner = new Scanner(System.in);       
        TreeSet set = new TreeSet<>(new KeepIntImpl());
        while (true) {
            System.out.println("请输入整数 输入quit时结束输入");
            String string = scanner.nextLine();
            if (string.equals("quit")) {
                break;
            }
            // 输入的时整数的时候
            int num = Integer.parseInt(string);
            // 添加到容器中 排序
            set.add(num);

        }
        System.out.println(set);
    }
    class KeepIntImpl implements Comparator{

    @Override
    public int compare(Integer o1, Integer o2) {
        int num = o1 - o2;
        return -(num == 0 ? 1 : num);
    }

}

    //  键盘录入5个学生信息(姓名,语文成绩,数学成绩,英语成绩)
    //  录入的学生信息格式(姓名,语文成绩,数学成绩,英语成绩)
    //  按照总分从高到低输出到控制台。输出学生所有信息

    //创建一个Student类
    public class Student implements Comparable{
        private String name;
        private int ChineseScore;
        private int MathScore;
        private int EnglishScore;
        private int sum;

        //构造函数
        public Student() {
        }

        public Student(String name, int chineseScore, int mathScore, int englishScore) {
            this.name = name;
            ChineseScore = chineseScore;
            MathScore = mathScore;
            EnglishScore = englishScore;
            this.sum = chineseScore + mathScore + englishScore;
        }

        //set/get方法
        public String getName() {
            return name;
        }
        public void setName(String name) {
            this.name = name;
        }
        public int getChineseScore() {
            return ChineseScore;
        }
        public void setChineseScore(int chineseScore) {
            ChineseScore = chineseScore;
        }
        public int getMathScore() {
            return MathScore;
        }
        public void setMathScore(int mathScore) {
            MathScore = mathScore;
        }
        public int getEnglishScore() {
            return EnglishScore;
        }
        public void setEnglishScore(int englishScore) {
            EnglishScore = englishScore;
        }

        public int getScore() {
            return sum;
        }

        //不希望 外界修改总成绩 只获取就行
    //  public void setSum(int sum) {
    //      this.sum = sum;
    //  }

        //重写toString
        @Override
        public String toString() {
            return "Student [name=" + name + ", ChineseScore=" + ChineseScore + ", MathScore=" + MathScore
                    + ", EnglishScore=" + EnglishScore + ", Score=" + sum + "]";
        }
        //写排序规则
        @Override
        public int compareTo(Student o) {
            int num = this.sum - o.sum;
            return num == 0 ? 1 : num;
        }       
}

    public class Demo {
        public static void main(String[] args) {
        //创建容器
            TreeSet set = new TreeSet<>();
            Scanner scanner = new Scanner(System.in);
            while(set.size() < 5) {
                System.out.println("请输入学生信息 +(姓名,语文成绩,数学成绩,英语成绩)");
                //接收格式 姓名,语文成绩,数学成绩,英语成绩
                String string = scanner.nextLine();
                // 按逗号切割字符串
                String[] strings = string.split(",");
                // 把成绩取出来
                int chineseScore = Integer.parseInt(strings[1]);
                int mathScore = Integer.parseInt(strings[2]);
                int englishScore = Integer.parseInt(strings[3]);
                // 构建对象
                Student student = new Student(strings[0], chineseScore, mathScore, 
                        englishScore);
                // 把对象扔集合中排序
                set.add(student);
            }
            //打印
            System.out.println(set);
    }
                                                                                      Day.19