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());   //
         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();
      }
 }

！！！