元素不能重复

  • TreeSet：基于红黑树实现，支持有序性操作，例如根据一个范围查找元素的操作。
    但是查找效率不如 HashSet，HashSet 查找的时间复杂度为 O(1)，TreeSet 则为 O(logN)。
  • HashSet：基于哈希表实现，支持快速查找，但不支持有序性操作。
    并且失去了元素的插入顺序信息，也就是说使用 Iterator 遍历 HashSet 得到的结果是不确定的。
  • LinkedHashSet：具有 HashSet 的查找效率，且内部使用双向链表维护元素的插入顺序。

    实现类

    HashSet

    HashSet扩展AbstractSet并且实现Set接口。
    无序排列
    基于哈希表实现，支持快速查找，但不支持有序性操作。
    失去了元素的插入顺序信息，也就是说使用 Iterator 遍历 HashSet 得到的结果是不确定的。
    1. HashSet(); // 建立默认的散列集合
    2. HashSet(Collection c); // 用c中元素初始化散列集合
    3. HashSet(int capacity); // 建立指定初始化容量的散列集合
    4. HashSet(int capacity,float fillRatio); // 初始化容量和填充比(加载容量)的散列集合
    5. /** 
    6. * 填充比必须介于0.0~1.0之间，它决定在散列集合向上调整大小之前，有多少能被充满。
    7. * 具体说，就是当元素个数大于容量*填充比时，散列集合扩大
    8. * 没有填充比的构造方法，默认0.75
    9. */

判断重复元素，需要靠hashCode和equals

  1. class Box {
  2.     private String name;
  3.     private Integer size;
  5.     public Box(String name,Integer size){
  6.         this.name=name;
  7.         this.size=size;
  8.     }
  10.     @Override
  11.     public boolean equals(Object o) {
  12.         if (this == o) {
  13.             return true;
  14.         }
  15.         if (o == null || getClass() != o.getClass()) {
  16.             return false;
  17.         }
  18.         Box box = (Box) o;
  19.         return Objects.equals(name, box.name) &&
  20.                 Objects.equals(size, box.size);
  21.     }
  23.     @Override
  24.     public int hashCode() {
  25.         return Objects.hash(name, size);
  26.     }
  28.     @Override
  29.     public String toString(){
  30.         return "name:"+this.name+"-size:"+this.size+"\n";
  31.     }
  33. }
  34. public class Main {
  36.     public static void main(String[] args) throws Exception{
  37.         Set<Box> all = new HashSet<>();
  38.         all.add(new Box("Java",3));
  39.         all.add(new Box("Java",3));
  40.         all.add(new Box("JSP",3));
  41.         all.add(new Box("Android",5));
  42.         System.out.println(all);
  43.     }
  44. }

TreeSet

TreeSet为使用树来进行存储的Set接口提供了一个工具，对象按升序自动存储。
在存储了大量的需要进行快速检索排序信息的情况下，TreeSet是一个很好的选择。
基于红黑树实现，支持有序性操作，例如根据一个范围查找元素的操作。 但是查找效率不如 HashSet，HashSet 查找的时间复杂度为 O(1)，TreeSet 则为 O(logN)。

  1. TreeSet(); // 建立空的树集合，该树集合将根据其元素的自然顺序按升序排序。
  2. TreeSet(Collection c); // 构造了包含c的元素的树集合
  3. TreeSet(Comparator comp); // 构造了空的树集合，它按照由comp指定的比较方法进行排序
  4. TreeSet(SortedSet ss); // 构造包含ss的元素的树集合

TreeSet排序

  1. class Box implements Comparable<Box> {
  2.     private String name;
  3.     private Integer size;
  5.     public Box(String name,Integer size){
  6.         this.name=name;
  7.         this.size=size;
  8.     }
  10.     @Override
  11.     public String toString(){
  12.         return "name:"+this.name+"-size:"+this.size;
  13.     }
  15.     @Override
  16.     public int compareTo(Box o) {
  17.         if (this.size > o.size){
  18.             return 1;
  19.         }else if(this.size < o.size){
  20.             return -1;
  21.         }else {
  22.             return this.name.compareTo(o.name);
  23. //            return 0;
  24.         }
  25.     }
  26. }
  27. public class Main {
  29.     public static void main(String[] args) throws Exception{
  30.         Set<Box> all = new TreeSet<>();
  31.         all.add(new Box("A",3));
  32.         all.add(new Box("B",2));
  33.         all.add(new Box("C",1));
  34.         System.out.println(all);
  35.     }
  36. }

LinkedHashSet

具有 HashSet 的查找效率，且内部使用双向链表维护元素的插入顺序。