Java容器——Set接口

1.定義

set中不允許放入重復的元素（元素相同時只取一個）。它使用equals()方法進行比較，如果返回true，兩個對象的HashCode值也應該相等。

2.方法

TreeSet中常用的方法：

boolean add(E e)：添加一個元素，如果set中不存在該元素

boolean addAll(Collection<? extends E> c)：向set添加集合

E ceiling(E e)：返回大於等於給定元素的最小元素，沒有返回null

void clear()：移除所有元素

Object clone()：淺拷貝集合

boolean contains(Object o)：判斷set是否包含某元素

E first()：返回set的第一個元素

E last()：返回set的最后一個元素

E floor(E e)：返回給定元素的上一元素

E higher(E e)：返回比給定元素大的最小元素

E lower(E e)：返回比給定元素小的最大元素

SortedSet<E> headSet(E toElement)：返回不包含給定元素前面的所有元素

SortedSet<E> tailSet(E fromElement)：返回大於等於給定元素后面的所有元素

SortedSet<E> subSet(E fromElement, E toElement)：返回開始/結束元素之間的所有元素集合，[from, to）

NavigableSet<E> headSet(E toElement, boolean inclusive)：返回比給定元素小的元素集合，true表示小於等於

NavigableSet<E> tailSet(E fromElement, boolean inclusive)：返回比給定元素大的元素集合，true表示大於等於

boolean isEmpty()：判斷set是否為空

Iterator<E> iterator()：返回一個升序的set迭代器

E pollFirst()：移除第一個元素，返回null如果set為空

E pollLast()：移除最后一個元素，返回null如果set為空

boolean remove(Object o)：移除指定元素

int size()：返回集合元素數目

3.常用實現類

3.1 HashSet

1）可以放入空值；

2）傳入元素時，調用HashCode方法獲取hash值，然后決定存儲位置；

3.2 LinkedHashSet

1）HashSet的子類，使用HashCode確定在集合中的位置，使用鏈表的方式確定位置（有序,按照輸入的順序輸出）

3.3 TreeSet

1）默認情況下，直接使用TreeSet無參構造器創建Set的對象，在其中放入元素時，必須實現Comparable接口(用於排序)，

     按照compareTo方法排序；

2）若創建TreeSet對象時，傳入了一個實現Comparator接口的類，則TreeSet使用Comparator接口的compare方法排序，

     此時集合中的元素無需實現Comparable接口；如果放入了實現Comparable接口的元素，以Comparator為標准 。

4. 示例         

4.1 SetFunc.java

import java.util.*;

public class SetFunc {

    public static void main(String[] args){

        // HashSet
        Set<Customer> c1 = new HashSet<>();
        c1.add(new Customer(1,"AAA"));
        c1.add(new Customer(1,"AAA"));
        c1.add(new Customer(2,"AAA"));
        c1.add(null);
        System.out.println(c1.size());   // 3
        for(Customer c:c1){
            System.out.println(c);
        }


        // LinkedHashSet
        Set<Customer> c2 = new LinkedHashSet<>();
        c2.add(new Customer(1,"AAA"));
        c2.add(new Customer(3,"CCC"));
        c2.add(new Customer(2,"BBB"));
        for(Customer c:c2){
            System.out.println(c);
        }


        /*
        * TreeSet
        * 使用TreeSet()構造器
        * 需要為Customer類實現Comparable接口，即實現compareTo方法
        * */
        TreeSet<Customer> c3 = new TreeSet<>();
        c3.add(new Customer(1,"AAA"));
        c3.add(new Customer(3,"CCC"));
        c3.add(new Customer(4,"DDD"));
        c3.add(new Customer(5,"EEE"));
        Customer b = new Customer(2,"BBB");
        for(Customer c:c3){
            System.out.println(c);
        }


        // first
        Customer a = c3.first();
        System.out.println("first: "+a);        // Customer：[Id=1, Name=AAA]
        // last
        Customer e = c3.last();
        System.out.println("last: "+e);        // Customer：[Id=5, Name=EEE]

        // ceiling
        Customer ceil1 = c3.ceiling(b);
        System.out.println("ceiling: : "+ceil1);    // Customer：[Id=3, Name=CCC]

        // lower
        a = c3.lower(b);
        System.out.println("lower b: "+a);        // Customer：[Id=1, Name=AAA]
        Customer pre = c3.lower(a);
        System.out.println("lower a: "+pre);      // null
        // higher
        Customer c = c3.higher(b);
        System.out.println("higher b: "+c);       // Customer：[Id=3, Name=CCC]

        // floor
        a = c3.floor(b);
        System.out.println("floor b: "+a);      // Customer：[Id=1, Name=AAA]

        // subSet, [from, to)
        Set<Customer> c41 = c3.subSet(a, c);
        System.out.println("c41: "+c41);

        // headSet, [ , to)
        Set<Customer> c42 = c3.headSet(e);
        System.out.println("c42: "+c42);
        // headSet, [, to]
        c42 = c3.headSet(e, true);
        System.out.println("c42: "+c42);

        // tailSet, [From, ]
        Set<Customer> c43 = c3.tailSet(c);
        System.out.println("c43: "+c43);
        // tailSet, (from, ]
        c43 = c3.tailSet(c, false);
        System.out.println("c43: "+c43);


        /*
        * TreeSet
        * 使用TreeSet(Comparator<? super E> comparator)構造器
        * 需要實現Comparator接口，即實現compare方法
        * */
        Comparator comparator = new CustomerComparator();
        TreeSet<Customer> c5 = new TreeSet<>(comparator);
        c5.add(new Customer(1,"AAA"));
        c5.add(new Customer(3,"CCC"));
        c5.add(new Customer(2,"BBB"));
        c5.add(new Customer(4,"DDD"));
        for(Customer cus:c5){
            System.out.println(cus);
        }
    }
}

4.2 Customer.java

import java.util.Objects;

public class Customer implements Comparable<Customer>{

    private int customerId;
    private String customerName;

    public Customer(Integer customerId, String customerName) {
        this.customerId = customerId;
        this.customerName = customerName;
    }

    public int getCustomerId() {
        return customerId;
    }
    public String getCustomerName() {
        return customerName;
    }

    @Override
    public String toString() {
        return "Customer：[Id=" + customerId + ", Name=" + customerName + "]";
    }

     /*
     * 重寫compareTo方法
     * 按Id或者name排序
     * 可以對整體添加負號決定升降序
     * */
    @Override
    public int compareTo(Customer o) {
//        return this.customerId - o.customerId;
        return this.customerName.compareTo(o.customerName);
    }

    /*
    * 重寫equals和hashcode方法
    * 這里id和name相同則為同一對象
    * */
    @Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (!(o instanceof Customer)) return false;
        Customer customer = (Customer) o;
        return customerId == customer.customerId &&
                Objects.equals(customerName, customer.customerName);
    }

    @Override
    public int hashCode() {
        return Objects.hash(customerId, customerName);
    }

}

4.3 CustomerComparator.java

import java.util.Comparator;

public class CustomerComparator implements Comparator<Customer> {

    @Override
    public int compare(Customer c1, Customer c2) {
        // 按Id排序
        return c1.getCustomerId() - c2.getCustomerId();
     }
}

！！！