大資料必學Java基礎（五十七）：Set接口講解

文章目錄

​​Set接口講解​​

​​一、HashSet實作類的使用​​

​​1、放入Integer類型資料​​

​​2、放入String類型資料​​

​​3、放入自定義的引用資料類型的資料​​

​​4、HashSet原理圖：（簡要原理圖）​​

​​5、疑問​​

​​二、LinkedHashSet使用​​

​​三、比較器的使用​​

​​1、以int類型為案例​​

​​2、比較String類型資料​​

​​3、比較double類型資料​​

​​4、比較自定義的資料類型​​

​​5、外部比較器和内部比較器誰好呀？​​

​​四、TreeSet實作類的使用​​

​​1、存入Integer類型資料（底層利用的是内部比較器）​​

​​2、原理底層：二叉樹（資料結構中的一個邏輯結構）​​

​​3、 放入String類型資料：（底層實作類内部比較器）​​

​​4、想放入自定義的Student類型的資料​​

​​5、TreeSet底層的二叉樹的周遊是按照升序的結果出現的，這個升序是靠中序周遊得到的​​

​​五、Collection部分整體結構圖​​

Set接口講解

一、HashSet實作類的使用

1、放入Integer類型資料

package com.lanson.test07;

import java.util.HashSet;

/**
 * @author : lansonli
 */
public class TestInteger {
    //這是main方法，程式的入口
    public static void main(String[] args) {
        //建立一個HashSet集合：
        HashSet<Integer> hs = new HashSet<>();
        System.out.println(hs.add(19));//true
        hs.add(5);
        hs.add(20);
        System.out.println(hs.add(19));//false 這個19沒有放入到集合中
        hs.add(41);
        hs.add(0);
        System.out.println(hs.size());//唯一，無序
        System.out.println(hs);

    }
}      

2、放入String類型資料

package com.lanson.test07;

import java.util.HashSet;

/**
 * @author : lanson
 */
public class TestString {
    //這是main方法，程式的入口
    public static void main(String[] args) {
        //建立一個HashSet集合：
        HashSet<String> hs = new HashSet<>();
        hs.add("hello");
        hs.add("apple");
        hs.add("banana");
        hs.add("html");
        hs.add("apple");
        hs.add("css");
        System.out.println(hs.size());
        System.out.println(hs);
    }
}      

3、放入自定義的引用資料類型的資料

package com.lanson.test07;

import java.util.HashSet;

/**
 * @author : lansonli
 */
public class TestStudent {
    //這是main方法，程式的入口
    public static void main(String[] args) {
        //建立一個HashSet集合：
        HashSet<Student> hs = new HashSet<>();
        hs.add(new Student(19,"lili"));
        hs.add(new Student(20,"lulu"));
        hs.add(new Student(18,"feifei"));
        hs.add(new Student(19,"lili"));
        hs.add(new Student(10,"nana"));
        System.out.println(hs.size());
        System.out.println(hs);
    }
}      

上面自定義的類型不滿足 唯一，無序的特點。為什麼呢？

4、HashSet原理圖：（簡要原理圖）

5、疑問

5.1、數組的長度是多少？

5.2、數組的類型是什麼？

5.3、hashCode，equals方法真的調用了嗎？

5.4、底層表達式是什麼？

5.5、同一個位置的資料向前放還是向後放？

5.6、放入數組中的資料，是直接放的嗎？是否封裝為對象了？

二、LinkedHashSet使用

其實就是在HashSet的基礎上，多了一個總的連結清單，這個總連結清單将放入的元素串在一起，友善有序的周遊：

可以看到LinkedHashMap.Entry 繼承自HashMap.Node 除了Node 本身有的幾個屬性外，額外增加了before after 用于指向前一個Entry 後一個Entry。也就是說，元素之間維持着一條總的連結清單資料結構

代碼：

package com.lanson.test07;

import java.util.HashSet;
import java.util.LinkedHashMap;
import java.util.LinkedHashSet;

/**
 * @author : lansonli
 */
public class TestInteger {
    //這是main方法，程式的入口
    public static void main(String[] args) {
        //建立一個HashSet集合：
        LinkedHashSet<Integer> hs = new LinkedHashSet<>();
        System.out.println(hs.add(19));//true
        hs.add(5);
        hs.add(20);
        System.out.println(hs.add(19));//false 這個19沒有放入到集合中
        hs.add(41);
        hs.add(0);
        System.out.println(hs.size());//唯一，無序
        System.out.println(hs);
    }
}      

三、比較器的使用

1、以int類型為案例

比較的思路：将比較的資料做差，然後傳回一個int類型的資料，将這個int類型的數值  按照 =0  >0  <0

int a = 10;
int b = 20;
System.out.println(a-b); // =0  >0  <0      

2、比較String類型資料

String類實作了Comparable接口，這個接口中有一個抽象方法compareTo，String類中重寫這個方法即可

String a = "A";
String b = "B";
System.out.println(a.compareTo(b));      

3、比較double類型資料

double a = 9.6;
double b = 9.3;
/* System.out.println((int)(a-b));*/
System.out.println(((Double) a).compareTo((Double) b));      

4、比較自定義的資料類型

4.1、内部比較器

package com.lanson.test08;

/**
 * @author : lansonli
 */
public class Student implements Comparable<Student>{
    private int age;
    private double height;
    private String name;

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    public double getHeight() {
        return height;
    }

    public void setHeight(double height) {
        this.height = height;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

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

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

    @Override
    public int compareTo(Student o) {
        //按照年齡進行比較：
        /*return this.getAge() - o.getAge();*/
        //按照身高比較
        /*return ((Double)(this.getHeight())).compareTo((Double)(o.getHeight()));*/
        //按照名字比較：
        return this.getName().compareTo(o.getName());
    }
}      

package com.lanson.test08;

/**
 * @author : lansonli
 */
public class Test02 {
    //這是main方法，程式的入口
    public static void main(String[] args) {
        //比較兩個學生：
        Student s1 = new Student(14,160.5,"alili");
        Student s2 = new Student(14,170.5,"bnana");
        System.out.println(s1.compareTo(s2));
    }
}      

4.2、外部比較器

package com.lanson.test09;

import java.util.Comparator;

/**
 * @author : lansonli
 */
public class Student{
    private int age;
    private double height;
    private String name;

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    public double getHeight() {
        return height;
    }

    public void setHeight(double height) {
        this.height = height;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

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

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


}



class BiJiao01 implements Comparator<Student> {
    @Override
    public int compare(Student o1, Student o2) {
        //比較年齡：
        return o1.getAge()-o2.getAge();
    }
}

class BiJiao02 implements Comparator<Student> {
    @Override
    public int compare(Student o1, Student o2) {
        //比較姓名：
        return o1.getName().compareTo(o2.getName());
    }
}      

class BiJiao03 implements Comparator<Student> {
    @Override
    public int compare(Student o1, Student o2) {
        //在年齡相同的情況下 比較身高  年齡不同比較年齡
        if((o1.getAge()-o2.getAge())==0){
            return ((Double)(o1.getHeight())).compareTo((Double)(o2.getHeight()));
        }else{//年齡不一樣
            return o1.getAge()-o2.getAge();
        }
    }
}      

package com.lanson.test09;

import com.lanson.test09.Student;

import java.util.Comparator;

/**
 * @author : lansonli
 */
public class Test02 {
    //這是main方法，程式的入口
    public static void main(String[] args) {
        //比較兩個學生：
        Student s1 = new Student(9,160.5,"alili");
        Student s2 = new Student(14,170.5,"bnana");
        //擷取外部比較器：
        Comparator bj1 = new BiJiao03();
        System.out.println(bj1.compare(s1, s2));
    }
}      

5、外部比較器和内部比較器誰好呀？

答案：外部比較器，多态，擴充性好

四、TreeSet實作類的使用

1、存入Integer類型資料（底層利用的是内部比較器）

package com.lanson.test10;

import java.util.TreeSet;

/**
 * @author : lansonli
 */
public class Test01 {
    //這是main方法，程式的入口
    public static void main(String[] args) {
        //建立一個TreeSet:
        TreeSet<Integer> ts = new TreeSet<>();
        ts.add(12);
        ts.add(3);
        ts.add(7);
        ts.add(9);
        ts.add(3);
        ts.add(16);
        System.out.println(ts.size());
        System.out.println(ts);

    }
}      

特點：唯一，無序（沒有按照輸入順序進行輸出）， 有序（按照升序進行周遊）

2、原理底層：二叉樹（資料結構中的一個邏輯結構）

3、 放入String類型資料：（底層實作類内部比較器）

package com.lanson.test10;

import java.util.TreeSet;

/**
 * @author : lansonli
 */
public class Test02 {
    //這是main方法，程式的入口
    public static void main(String[] args) {
        //建立一個TreeSet:
        TreeSet<String> ts = new TreeSet<>();
        ts.add("elili");
        ts.add("blili");
        ts.add("alili");
        ts.add("elili");
        ts.add("clili");
        ts.add("flili");
        ts.add("glili");
        System.out.println(ts.size());
        System.out.println(ts);
    }
}      

4、想放入自定義的Student類型的資料

4.1、利用内部比較器

package com.lanson.test10;

/**
 * @author : lansonli
 */
public class Student implements Comparable<Student> {
    private int age;
    private String name;

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

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

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


    @Override
    public int compareTo(Student o) {
        return this.getAge()-o.getAge();
    }
}


package com.lanson.test10;

import java.util.TreeSet;

/**
 * @author : lansonli
 */
public class Test03 {
    //這是main方法，程式的入口
    public static void main(String[] args) {
        //建立一個TreeSet:
        TreeSet<Student> ts = new TreeSet<>();
        ts.add(new Student(10,"elili"));
        ts.add(new Student(8,"blili"));
        ts.add(new Student(4,"alili"));
        ts.add(new Student(9,"elili"));
        ts.add(new Student(10,"flili"));
        ts.add(new Student(1,"dlili"));
        System.out.println(ts.size());
        System.out.println(ts);
    }
}      

4.2、通過外部比較器

package com.lanson.test10;

import java.util.Comparator;

/**
 * @author : lansonli
 */
public class Student  {
    private int age;
    private String name;

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

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

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



}

class BiJiao implements Comparator<Student>{
    @Override
    public int compare(Student o1, Student o2) {
        return o1.getName().compareTo(o2.getName());
    }
}


package com.lanson.test10;

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

/**
 * @author : lansonli
 */
public class Test03 {
    //這是main方法，程式的入口
    public static void main(String[] args) {
        //建立一個TreeSet:
        //利用外部比較器，必須自己制定：
        Comparator<Student> com = new BiJiao();
        TreeSet<Student> ts = new TreeSet<>(com);//一旦指定外部比較器，那麼就會按照外部比較器來比較
        ts.add(new Student(10,"elili"));
        ts.add(new Student(8,"blili"));
        ts.add(new Student(4,"alili"));
        ts.add(new Student(9,"elili"));
        ts.add(new Student(10,"flili"));
        ts.add(new Student(1,"dlili"));
        System.out.println(ts.size());
        System.out.println(ts);
    }
}      

實際開發中利用外部比較器多，因為擴充性好（多态）

package com.lanson.test10;

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

/**
 * @author : lansonli
 */
public class Test03 {
    //這是main方法，程式的入口
    public static void main(String[] args) {
        //建立一個TreeSet:
        //利用外部比較器，必須自己制定：
        /*Comparator<Student> com = new Comparator<Student>() {
            @Override
            public int compare(Student o1, Student o2) {
                return o1.getName().compareTo(o2.getName());
            }
        };*/
        TreeSet<Student> ts = new TreeSet<>(new Comparator<Student>() {
            @Override
            public int compare(Student o1, Student o2) {
                return o1.getName().compareTo(o2.getName());
            }
        });//一旦指定外部比較器，那麼就會按照外部比較器來比較
        ts.add(new Student(10,"elili"));
        ts.add(new Student(8,"blili"));
        ts.add(new Student(4,"alili"));
        ts.add(new Student(9,"elili"));
        ts.add(new Student(10,"flili"));
        ts.add(new Student(1,"dlili"));
        System.out.println(ts.size());
        System.out.println(ts);
    }
}      

5、TreeSet底層的二叉樹的周遊是按照升序的結果出現的，這個升序是靠中序周遊得到的

五、Collection部分整體結構圖

• 📢歡迎點贊 👍 收藏 ⭐留言 📝 如有錯誤敬請指正！
• 📢本文由 Lansonli 原創
• 📢停下休息的時候不要忘了别人還在奔跑，希望大家抓緊時間學習，全力奔赴更美好的生活✨