Java中Set、TreeSet接口

Set

    Set(接口)
    特點: 無序(無下標) 不重複

HashSet

    先創建一個Person類
    Person類中有 名字 年齡
    寫上構造函數
    set/get方法
    重寫 toString方法

set添加字符串

    public static void fun1() {
        //使用HashSet 主要用來 去重複
        //創建一個HashSet
        Hash<String> 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<Person> 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<Integer> 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<String> 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<Character> 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<String> aList = new ArrayList<>();
        aList.add("a");
        aList.add("a");
        aList.add("b");
        aList.add("b");
        aList.add("c");
        aList.add("c");
        LinkedHashSet<String> 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<Integer> 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<Worker> 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<Worker> 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<String> 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<String> 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<Character> 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<Integer> 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<Integer>{

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

}

    //  鍵盤錄入5個學生信息(姓名,語文成績,數學成績,英語成績)
    //  錄入的學生信息格式(姓名,語文成績,數學成績,英語成績)
    //  按照總分從高到低輸出到控制檯。輸出學生所有信息

    //創建一個Student類
    public class Student implements Comparable<Student>{
        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<Student> 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