Set Interface

Set<> Collection<> {
    size();

    isEmpty();

    contains(Object o);

    Iterator<> iterator();

    Object[] toArray();

    <> [] toArray([] a);


    add(e);


    remove(Object o);


    containsAll(Collection<?> c);

    addAll(Collection<? > c);

    retainAll(Collection<?> c);

    removeAll(Collection<?> c);

    clear();


    equals(Object o);

    hashCode();
}

1.HashSet：

　　HashSet使用的是至關複雜的方式來存儲元素的，使用HashSet可以最快的獲取集合中的元素，效率很是高（以空間換時間）。會根據hashcode和equals來龐端是不是同一個對象，若是hashcode同樣，而且equals返回true，則是同一個對象，不能重複存放。

package com.set;

import java.util.HashSet;
import java.util.Set;

class Student{
    int id;
    public Student(int id) {
        this.id = id;
    }
    @Override
    public String toString() {
        return this.id+"";
    }
    @Override
    public int hashCode() {
        return this.id;
    }
    @Override
    public boolean equals(Object obj) {
        if (obj instanceof Student){
            Student  stu = (Student) obj;
            if (stu.id == this.id)
                return true;
        }
        return false;
    }
}
public class HashSetTest {
    public static void main(String[] args) {
        Set<Student> set = new HashSet<Student>();
        Student s1 = new Student(1);
        Student s2 = new Student(1);
        Student s3 = new Student(2);
        set.add(s1);
        set.add(s2);
        set.add(s3);
        for (Student s : set) {
            System.out.println(s);
        }
    }
}

正如上例所示，重寫了hashCode()和equals()方法來區分贊成對象後，就不能存放同以對象了。若是註釋這兩個方法，則全部Student對象視爲不一樣對象，均可以存放。

 

　　2.TreeSet

　　TreeSet也不能存放重複對象，可是TreeSet會自動排序，若是存放的對象不能排序則會報錯，因此存放的對象必須指定排序規則。排序規則包括天然排序和客戶排序。

　　①天然排序：TreeSet要添加哪一個對象就在哪一個對象類上面實現java.lang.Comparable接口，而且重寫comparaTo()方法，返回0則表示是同一個對象，不然爲不一樣對象。

　　②客戶排序：創建一個第三方類並實現java.util.Comparator接口。並重寫方法。定義集合形式爲TreeSet ts = new TreeSet(new 第三方類());

package com.set;

import java.util.Set;
import java.util.TreeSet;

class Student1 implements Comparable<Student1>{
    int id;
    public Student1(int id) {
        this.id = id;
    }
    @Override
    public String toString() {
        return this.id+"";
    }
    @Override
    public int hashCode() {
        return this.id;
    }
    @Override
    public boolean equals(Object obj) {
        if (obj instanceof Student1){
            Student1  stu = (Student1) obj;
            if (stu.id == this.id)
                return true;
        }
        return false;
    }
    public int compareTo(Student1 o) {
        return (this.id-o.id);
    }
}

public class TreeSetTest {
    public static void main(String[] args) {
        Set<Student1> set = new TreeSet<Student1>();
        Student1 s1 = new Student1(5);
        Student1 s2 = new Student1(1);
        Student1 s3 = new Student1(2);
        Student1 s4 = new Student1(4);
        Student1 s5 = new Student1(3);
        set.add(s1);
        set.add(s2);
        set.add(s3);
        set.add(s4);
        set.add(s5);
        for (Student1 s : set) {
            System.out.println(s);
        }
    }

}

package com.set;

import java.util.Set;
import java.util.TreeSet;

class MySort implements java.util.Comparator<Student2>{

    public int compare(Student2 o1, Student2 o2) {
        return o2.id-o1.id;
    }
}
class Student2{
    int id;
    public Student2(int id) {
        this.id = id;
    }
    @Override
    public String toString() {
        return this.id+"";
    }
    @Override
    public int hashCode() {
        return this.id;
    }
    @Override
    public boolean equals(Object obj) {
        if (obj instanceof Student2){
            Student2  stu = (Student2) obj;
            if (stu.id == this.id)
                return true;
        }
        return false;
    }
}
public class TreeSetTest2 {
    public static void main(String[] args) {
        Set<Student2> set = new TreeSet<Student2>(new MySort());
        Student2 s1 = new Student2(5);
        Student2 s2 = new Student2(1);
        Student2 s3 = new Student2(2);
        Student2 s4 = new Student2(4);
        Student2 s5 = new Student2(3);
        set.add(s1);
        set.add(s2);
        set.add(s3);
        set.add(s4);
        set.add(s5);
        for (Student2 s : set) {
            System.out.println(s);
        }
    }

}

package com.set;

import java.util.ArrayList;
import java.util.Collections;
import java.util.List;

class MySort1 implements java.util.Comparator<Student3>{
    public int compare(Student3 o1, Student3 o2) {
        return o2.id-o1.id;
    }
}
class Student3 implements Comparable<Student3>{
    int id;
    public Student3(int id) {
        this.id = id;
    }
    @Override
    public String toString() {
        return this.id+"";
    }
    public int compareTo(Student3 o) {
        return (this.id-o.id);
    }
}

public class ListSort {
    public static void main(String[] args) {
        List<Student3> list = new ArrayList<Student3>();
        Student3 s1 = new Student3(5);
        Student3 s2 = new Student3(1);
        Student3 s3 = new Student3(2);
        Student3 s4 = new Student3(4);
        Student3 s5 = new Student3(3);
        list.add(s1);
        list.add(s2);
        list.add(s3);
        list.add(s4);
        list.add(s5);
        System.out.println(list);
        //天然排序：
        Collections.sort(list);
        System.out.println(list);
        //客戶排序
        Collections.sort(list, new MySort1());
        System.out.println(list);
    }
}

　　3.LinkedHashSet

　　LinkedHashSet按照插入順序保存對象，同時還保存了HashSet的查詢速度。

對 set 的遍歷

1.迭代遍歷：

Set<String> set = new HashSet<String>();
Iterator<String> it = set.iterator();
while (it.hasNext()) {
  String str = it.next();
  System.out.println(str);
}

2.for循環遍歷：

for (String str : set) {
      System.out.println(str);
}

Set<Object> set = new HashSet<Object>();
for (Object obj: set) {
      if(obj instanceof Integer){
                int aa= (Integer)obj;
             }else if(obj instanceof String){
               String aa = (String)obj
             }
}