Java中的set集合

1 Set

1.1 特点

• 不允许出现重复的元素
• 无序的集合
• 提供了equals(Object o)和hashCode()，供其子类重写，以实现对集合中插入重复元素的处理

1.2 实现类

• HashSet类
• TreeSet类

1.3 方法

• add( ) 向集合中添加元素
• clear( ) 去掉集合中所有的元素
• contains( ) 判断集合中是否包含某一个元素
• isEmpty( ) 判断集合是否为空
• iterator( ) 主要用于递归集合，返回一个Iterator()对象
• remove( ) 从集合中去掉特定的对象
• size( ) 返回集合的大小

1.4 HashSet

• 哈希表结构
• 不允许重复的元素
• 无序的集合
• 允许插入null
• 新增元素相当于HashMap的key，value默认为一个固定的Object
• hashCode值决定该对象在HashSet中的存储位置
• 添加可变对象时，需注意与已有对象重复。

package learn;

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


public class test {

    public static void main(String[] args) {
        Set<String> set=new HashSet<String>();

        String s1=new String("hello");
        String s2=s1;
        String s3=new String("world");
        String s4 = null;

        //添加元素
        set.add(s1);
        set.add(s2);
        set.add(s3);
        set.add(s4);

        //输出set的大小
        System.out.println("set的大小为："+set.size());

        //输出set
        System.out.println("set的内容为："+set);

        //迭代器遍历
        Iterator<String> iterator = set.iterator();
        while (iterator.hasNext()){
            String str = iterator.next();
            System.out.println("迭代器遍历："+str);
        }

        //for循环,判断相等
        for(String str:set){
            if("hello".equals(str)){
                System.out.println("你就是我想要的元素:"+str);
            }
        }

        //是否包含
        boolean t1 = set.contains("world");
        System.out.println("是否包含："+t1);

        //删除某个对象
        set.remove(null);
        System.out.println("删除后剩下的元素："+set);

        //清空set
        set.clear();
        System.out.println("清空后剩下的元素："+set);

        //判断是否为空
        boolean t2 =set.isEmpty();
        System.out.println("判断是否为空："+t2);
    }
}

输出结果：

set的大小为：3
set的内容为：[null, world, hello]
迭代器遍历：null
迭代器遍历：world
迭代器遍历：hello
你就是我想要的元素:hello
是否包含：true
删除后剩下的元素：[world, hello]
清空后剩下的元素：[]
判断是否为空：true

1.5 TreeSet

• 树结构（红黑树）
• 具有排序功能：自然排序或自定义排序
• 不允许重复的元素
• 允许插入null
  与HashSet集合相比，TreeSet还提供了几个额外方法：
• Comparator comparator():如果TreeSet采用了定制顺序，则该方法返回定制排序所使用的Comparator，如果TreeSet采用自然排序，则返回null；
• Object first():返回集合中的第一个元素；
• Object last():返回集合中的最后一个元素；
• Object lower(Object e)：返回指定元素之前的元素。
• Object higher(Object e)：返回指定元素之后的元素。
• SortedSet subSet（Object fromElement，Object toElement）：返回此Set的子集合，含头不含尾；
• SortedSet headSet(Object toElement)：返回此Set的子集，由小于toElement的元素组成；
• SortedSet tailSet(Object fromElement)：返回此Set的子集，由大于fromElement的元素组成;

package learn;

import java.util.Comparator;
import java.util.Iterator;
import java.util.TreeSet;

public class treeset {
    public static void main(String[] args) {
        TreeSet<Integer> treeSet = new TreeSet<Integer>();

        //添加元素
        treeSet.add(3);
        treeSet.add(8);
        treeSet.add(89);
        treeSet.add(34);
        treeSet.add(4);
        treeSet.add(3);

        //输出treeSet
        System.out.println("内容为："+treeSet.toString());

        //输出treeSet的大小
        System.out.println("treeSet的大小为："+treeSet.size());

        //for循环遍历
        for (int t:treeSet){
            System.out.println("for循环遍历元素为："+t);
        }

        //迭代器遍历：升序
        Iterator<Integer> iterator1 = treeSet.iterator();
        while (iterator1.hasNext()){
            int t1 = iterator1.next();
            System.out.println("迭代器遍历（升序）："+t1);
        }

        //迭代器遍历：降序
        Iterator<Integer> iterator2 =treeSet.descendingIterator();
        while (iterator2.hasNext()){
            int t2 =iterator2.next();
            System.out.println("迭代器遍历（降序）："+t2);
        }

        //返回第一个元素
        System.out.println("第一个元素为："+treeSet.first());

        //返回最后一个元素
        System.out.println("最后一个元素为："+treeSet.last());

        //返回指定元素之前的元素
        System.out.println("返回指定元素之前的元素:"+treeSet.lower(4));

        //返回指定元素之后的元素
        System.out.println("返回指定元素之后的元素:"+treeSet.higher(4));

        //返回此Set的子集合，含头不含尾
        System.out.println("返回此Set的子集合，含头不含尾:"+treeSet.subSet(4,89));

        //返回此Set的子集，由小于toElement的元素组成
        System.out.println("返回此Set的子集，由小于4的元素组成:"+treeSet.headSet(4));

        //返回此Set的子集，由大于fromElement的元素组成
        System.out.println("返回此Set的子集，由大于4的元素组成:"+treeSet.tailSet(4));

        //更改排序方式，重写Comparat()
        TreeSet<Integer> nums = new TreeSet<>(new Comparator<Integer>() {
            @Override
            public int compare(Integer o1, Integer o2) {
                return -(o1-o2);
            }
        });
        //向集合中添加元素
        nums.add(4);
        nums.add(2);
        nums.add(1);
        nums.add(3);
        nums.add(0);
        //输出集合，可以看到元素已经处于排序状态
        System.out.println("更改排序方式："+nums);
    }
}

输出结果：

treeSet的大小为：5
for循环遍历元素为：3
for循环遍历元素为：4
for循环遍历元素为：8
for循环遍历元素为：34
for循环遍历元素为：89
迭代器遍历（升序）：3
迭代器遍历（升序）：4
迭代器遍历（升序）：8
迭代器遍历（升序）：34
迭代器遍历（升序）：89
迭代器遍历（降序）：89
迭代器遍历（降序）：34
迭代器遍历（降序）：8
迭代器遍历（降序）：4
迭代器遍历（降序）：3
第一个元素为：3
最后一个元素为：89
返回指定元素之前的元素:3
返回指定元素之后的元素:8
返回此Set的子集合，含头不含尾:[4, 8, 34]
返回此Set的子集，由小于4的元素组成:[3]
返回此Set的子集，由大于4的元素组成:[4, 8, 34, 89]
更改排序方式：[4, 3, 2, 1, 0]