`Set`继承于Collection接口，是一个不允许出现重复元素，并且无序的集合，主要有HashSet和TreeSet两大实现类。

在判断重复元素的时候，Set集合会调用`hashCode()`和`equal()`方法来实现。

`HashSet`是哈希表结构，主要利用HashMap的key来存储元素，计算插入元素的hashCode来获取元素在集合中的位置；

`TreeSet`是红黑树结构，每一个元素都是树中的一个节点，插入的元素都会进行排序；

###1. Set常用方法
与List接口一样，Set接口也提供了集合操作的基本方法。

但与List不同的是，Set还提供了`equals(Object o)`和`hashCode()`，供其子类重写，以实现对集合中插入重复元素的处理；

下面是Set集合的一些常用方法：
```java
A:添加功能
boolean add(E e);
boolean addAll(Collection<? extends E> c);

B:删除功能
boolean remove(Object o);
boolean removeAll(Collection<?> c);
void clear();

C:长度功能
int size();

D:判断功能
boolean isEmpty();
boolean contains(Object o);
boolean containsAll(Collection<?> c);
boolean retainAll(Collection<?> c);

E:获取Set集合的迭代器：
Iterator<E> iterator();

F:把集合转换成数组
Object[] toArray();
<T> T[] toArray(T[] a);

//判断元素是否重复，为子类提高重写方法
boolean equals(Object o);
int hashCode();
```

###2. HashSet
HashSet实现Set接口，底层由HashMap(后面讲解)来实现，为哈希表结构，新增元素相当于HashMap的key，value默认为一个固定的Object。

在我看来，HashSet相当于一个阉割版的HashMap;

当有元素插入的时候，会计算元素的hashCode值，将元素插入到哈希表对应的位置中来；

它继承于AbstractSet，实现了`Set`, `Cloneable`, `Serializable`接口。
```
(1)HashSet继承AbstractSet类，获得了Set接口大部分的实现，减少了实现此接口所需的工作，实际上是又继承了AbstractCollection类；
(2)HashSet实现了Set接口，获取Set接口的方法，可以自定义具体实现，也可以继承AbstractSet类中的实现；
(3)HashSet实现Cloneable，得到了clone()方法，可以实现克隆功能；
(4)HashSet实现Serializable，表示可以被序列化，通过序列化去传输，典型的应用就是hessian协议。
```
具有如下特点：
```
不允许出现重复因素；
允许插入Null值；
元素无序（添加顺序和遍历顺序不一致）；
线程不安全，若2个线程同时操作HashSet，必须通过代码实现同步；
```

###3. HashSet基本操作
HashSet底层由HashMap实现，插入的元素被当做是HashMap的key，根据hashCode值来确定集合中的位置，由于Set集合中并没有角标的概念，所以并没有像List一样提供`get`方法。

当获取HashSet中某个元素时，只能通过遍历集合的方式进行`equals()`比较来实现；

例子如下:
```java

// 引入包
import java.util.Set;
import java.util.HashSet;
import java.util.Iterator;

public class HelloWorld {
    // 入口
    public static void main(String[] agrs){
        //创建HashSet集合：
        Set hashSet = new HashSet();
        System.out.println("HashSet初始容量大小："+hashSet.size());

//元素添加：
        hashSet.add("my");
        hashSet.add("name");
        hashSet.add("is");
        hashSet.add("jiaboyan");
        hashSet.add(",");
        hashSet.add("hello");
        hashSet.add("world");
        hashSet.add("!");
        System.out.println("HashSet容量大小："+hashSet.size());

//迭代器遍历：
        Iterator iterator = hashSet.iterator();
        while (iterator.hasNext()){
            // 由于我们在定义Set的时候没有声明存储类型，这里可以用Object表示全部类型
            Object str = iterator.next();
            System.out.println(str);
        }

//增强for循环
        for(Object str:hashSet){
            if("jiaboyan".equals(str)){
                System.out.println("你就是我想要的元素:"+str);
            }
            System.out.println(str);
        }

//元素删除：
        hashSet.remove("jiaboyan");
        System.out.println("HashSet元素大小：" + hashSet.size());
        hashSet.clear();
        System.out.println("HashSet元素大小：" + hashSet.size());

//集合判断：
        boolean isEmpty = hashSet.isEmpty();
        System.out.println("HashSet是否为空：" + isEmpty);
        boolean isContains = hashSet.contains("hello");
        System.out.println("HashSet是否为空：" + isContains);
    }
}
```

### 4. HashSet元素添加分析
Set集合不允许添加重复元素，那么到底是个怎么情况呢？

来看一个简单的例子：
```java
// 引入包
import java.util.Set;
import java.util.HashSet;

// 测试类
class App {
    private String name;

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

public class HelloWorld {
    // 入口
    public static void main(String[] agrs){
        //第一个 Set集合：
        Set set1 = new HashSet();
        String str1 = "jiaboyan";
        String str2 = "jiaboyan";
        set1.add(str1);
        set1.add(str2);
        System.out.println("长度："+set1.size()+",内容为："+set1);

//第二个 Set集合：
        Set set2 = new HashSet();
        App app1 = new App();
        app1.setName("jiaboyan");

App app2 = new App();
        app2.setName("jiaboyan");

set2.add(app1);
        set2.add(app2);
        System.out.println("长度："+set2.size()+",内容为："+set2);

//第三个 Set集合：
        Set set3 = new HashSet();
        App app3 = new App();
        app3.setName("jiaboyan");
        set3.add(app3);
        set3.add(app3);
        System.out.println("长度："+set3.size()+",内容为："+set3);
    }
}
```
上面的案例得出的结果是：
```
长度：1,内容为：[jiaboyan]
长度：2,内容为：[com.example.demo.App@28d93b30, com.example.demo.App@1b6d3586]
长度：1,内容为：[com.example.demo.App@4554617c]
```
可以看到，第一个Set集合中最终只有一个元素；第二个Set集合保留了2个元素；第三个集合也只有1个元素；

究竟是什么原因呢？

原来HashSet的`add(E e)`方法，在底层`HashSet`是调用了`HashMap`的`put(K key, V value)`方法。

该方法在`HashMap`中添加元素时，先判断`key`的`hashCode`值是否相同，如果相同，则调用`equals()`、`==`进行判断，若相同则覆盖原有元素；如果不同，则直接向Map中添加元素；

简单的理解，就是内存地址一致则覆盖，不一致则添加，所以才存在第二种情况保留了2个元素。

### 5. TreeSet
从名字上可以看出，此集合的实现和树结构有关。

与HashSet集合类似，TreeSet也是基于Map来实现，具体实现TreeMap(后面讲解)，其底层结构为红黑树（特殊的二叉查找树）；

与HashSet不同的是，TreeSet具有排序功能，分为自然排序(123456)和自定义排序两类，默认是自然排序；

在程序中，我们可以按照任意顺序将元素插入到集合中，等到遍历时TreeSet会按照一定顺序输出--倒序或者升序；

它继承AbstractSet，实现`NavigableSet,` `Cloneable`, `Serializable`接口。
```
（1）与HashSet同理，TreeSet继承AbstractSet类，获得了Set集合基础实现操作；
（2）TreeSet实现NavigableSet接口，而NavigableSet又扩展了SortedSet接口。这两个接口主要定义了搜索元素的能力，例如给定某个元素，查找该集合中比给定元素大于、小于、等于的元素集合，或者比给定元素大于、小于、等于的元素个数；简单地说，实现NavigableSet接口使得TreeSet具备了元素搜索功能；
（3）TreeSet实现Cloneable接口，意味着它也可以被克隆；
（4）TreeSet实现了Serializable接口，可以被序列化，可以使用hessian协议来传输；
```
具有如下特点：
```
对插入的元素进行排序，是一个有序的集合（主要与HashSet的区别）;
底层使用红黑树结构，而不是哈希表结构；
允许插入Null值；
不允许插入重复元素；
线程不安全；
```

### 6. TreeSet的一些常用方法
```java
A:遍历：升序
treeSet.iterator();

B:遍历：降序
treeSet.descendingIterator();

C:获取TreeSet头节点
treeSet.first();

D:获取指定元素之前的所有元素集合：(不包含指定元素)
treeSet.headSet(V);

E:获取给定元素之间的集合：（包含头，不包含尾）
treeSet.subSet("1","world");

F:删除并返回第一个元素：如果set集合不存在元素，则返回null
treeSet.pollFirst();

G:删除并返回最后一个元素：如果set集合不存在元素，则返回null
treeSet.pollLast();

H:清空集合
treeSet.clear();
```

### 7.TreeSet基本操作
```java
// 引入包
import java.util.TreeSet;
import java.util.SortedSet;
import java.util.Iterator;

public class HelloWorld {
    // 入口
    public static void main(String[] agrs){
        TreeSet treeSet = new TreeSet();
        System.out.println("TreeSet初始化容量大小："+treeSet.size());

//元素添加：
        treeSet.add("my");
        treeSet.add("name");
        treeSet.add("jiaboyan");
        treeSet.add("hello");
        treeSet.add("world");
        treeSet.add("1");
        treeSet.add("2");
        treeSet.add("3");
        System.out.println("TreeSet容量大小：" + treeSet.size());
        System.out.println("TreeSet元素顺序为：" + treeSet.toString());

//增加for循环遍历：
        for(Object str:treeSet){
            System.out.println("遍历元素："+str);
        }

//迭代器遍历：升序
        Iterator iteratorAesc = treeSet.iterator();
        while(iteratorAesc.hasNext()){
            Object str = iteratorAesc.next();
            System.out.println("遍历元素升序："+str);
        }

//迭代器遍历：降序
        Iterator iteratorDesc = treeSet.descendingIterator();
        while(iteratorDesc.hasNext()){
            Object str = iteratorDesc.next();
            System.out.println("遍历元素降序："+str);
        }

//元素获取:实现NavigableSet接口
        Object firstEle = treeSet.first();//获取TreeSet头节点：
        System.out.println("TreeSet头节点为：" + firstEle);

// 获取指定元素之前的所有元素集合：(不包含指定元素)
        SortedSet headSet = treeSet.headSet("jiaboyan");
        System.out.println("jiaboyan节点之前的元素为："+headSet.toString());

//获取给定元素之间的集合：（包含头，不包含尾）
        SortedSet subSet = treeSet.subSet("1","world");
        System.out.println("1--jiaboan之间节点元素为："+subSet.toString());

//集合判断：
        boolean isEmpty = treeSet.isEmpty();
        System.out.println("TreeSet是否为空："+isEmpty);
        boolean isContain = treeSet.contains("who");
        System.out.println("TreeSet是否包含who元素："+isContain);

//元素删除：
        boolean jiaboyanRemove = treeSet.remove("jiaboyan");
        System.out.println("jiaboyan元素是否被删除"+jiaboyanRemove);

//集合中不存在的元素，删除返回false
        boolean whoRemove = treeSet.remove("who");
        System.out.println("who元素是否被删除"+whoRemove);

//删除并返回第一个元素：如果set集合不存在元素，则返回null
        Object pollFirst = treeSet.pollFirst();
        System.out.println("删除的第一个元素："+pollFirst);

//删除并返回最后一个元素：如果set集合不存在元素，则返回null
        Object pollLast = treeSet.pollLast();
        System.out.println("删除的最后一个元素："+pollLast);

treeSet.clear();//清空集合:
    }
}
```

### 8.TreeSet元素排序
在前面的章节，我们讲到了TreeSet是一个有序集合，可以对集合元素排序，其中分为自然排序和自定义排序：
```java
// 引入包
import java.util.TreeSet;

public class HelloWorld {
    // 入口
    public static void main(String[] agrs){
        TreeSet<String> treeSetString = new TreeSet<String>();
        treeSetString.add("a");
        treeSetString.add("z");
        treeSetString.add("d");
        treeSetString.add("b");
        System.out.println("字母顺序：" + treeSetString.toString());

TreeSet<Integer> treeSetInteger = new TreeSet<Integer>();
        treeSetInteger.add(1);
        treeSetInteger.add(24);
        treeSetInteger.add(23);
        treeSetInteger.add(6);
        System.out.println("数字顺序：" + treeSetInteger.toString());
    }
}
```

已有0条评论

添加新评论☺

如果认为本文对您有所帮助请赞助本站

支付宝扫一扫赞助

已有0条评论

添加新评论☺