Guava库学习：学习Collections（三）Sets

最新推荐文章于 2022-02-02 22:29:27 发布

weixin_34375054

最新推荐文章于 2022-02-02 22:29:27 发布

阅读量209

点赞数

文章标签： python java

原文链接：https://my.oschina.net/realfighter/blog/349902

版权

2019独角兽企业重金招聘Python工程师标准>>>

链接地址：http://www.xx566.com/detail/139.html

上一篇，学习Collections（二）Lists中，我们学习了使用Lists处理List实例，内部提供了许多有用的静态工厂方法，在Java开发中，我们经常提到三大集合：List、Set、 Map，List有序可重复，Set无序不可重复，Map通过键值对存储，这一篇，我们就来学习Collections中的Sets类，与Lists相似，其内部也提供了许多静态工厂方法来处理Set实例。

翻开源代码，我们看到，Sets内部使用了静态工厂方法代替构造器，提供了许多用于Set子类构造和操作的静态方法，我们简单的依次进行说明，如下：

immutableEnumSet( E anElement, E... otherElements)：返回一个包含给定枚举元素的不可变的Set实例。

immutableEnumSet( Iterable<E> elements)：返回一个包含给定枚举元素的不可变的Set实例。

newEnumSet(Iterable<E> iterable,Class<E> elementType)：返回一个包含给定元素的EnumSet实例，与EnumSet#copyOf(Collection)方法不同，当给定集合为空的时候，不会产生异常，它可以转换任何实现了Iterable接口的类，不仅仅是Collection。它会先根据传入的元素类型创建一个空的 EnumSet，再把给定的元素添加到EnumSet返回。

newHashSet()：返回一个可变的空的HashSet实例。

newHashSet(E... elements)：返回一个可变买的HashSet包含给定的元素。

newHashSetWithExpectedSize(int expectedSize)：构造一个期望长度为expectedSize的HashSet实例。

newHashSet(Iterable<? extends E> elements)：返回一个可变的HashSet包含给定的元素，给定元素实现Iterable接口。

newHashSet(Iterator<? extends E> elements)：返回一个可变的HashSet包含给定的元素，给定元素实现Iterator接口。

newConcurrentHashSet()：创建一个线程安全的Set，由ConcurrentHashMap的实例支持，因此进行了相同的并发性担保，与HashSet不同的是，这个Set不允许null元素，该Set是可序列化的。

newConcurrentHashSet( Iterable<? extends E> elements)：创建一个线程安全的Set，包含给定的元素，由ConcurrentHashMap的实例支持，因此进行了相同的并发性担保，与 HashSet不同的是，这个Set不允许null元素，该Set是可序列化的。

newLinkedHashSet()：创建一个可变的、空的LinkedHashSet实例。

newLinkedHashSetWithExpectedSize( int expectedSize)：构造一个期望长度为expectedSize的LinkedHashSet实例。

newLinkedHashSet( Iterable<? extends E> elements)：构造一个包含给定元素的LinkedHashSet实例。

newTreeSet()：返回一个可变的空的TreeSet实例。

newTreeSet( Iterable<? extends E> elements)：返回一个可变的包含给定元素的TreeSet实例。

newTreeSet(Comparator<? super E> comparator)：创建一个具有给定的比较器可变TreeSet的实例。

newIdentityHashSet()：创建一个空的Set，使用特性来确定是否相等。

newCopyOnWriteArraySet()：创建一个空的CopyOnWriteArraySet实例。

newCopyOnWriteArraySet( Iterable<? extends E> elements)：创建一个包含给定元素的CopyOnWriteArraySet实例。

complementOf(Collection<E> collection)：创建一个EnumSet包括不属于指定集合中的所有枚举值。

complementOf( Collection<E> collection, Class<E> type)：创建一个EnumSet包括不属于指定集合中的所有枚举值。

newSetFromMap(Map<E, Boolean> map)：返回一个由给定map支持的Set。

union( final Set<? extends E> set1, final Set<? extends E> set2)：返回两个set集合的并集的不可修改SetView。（若A和B是集合，则A和B并集是有所有A的元素和所有B的元素，而没有其他元素的集合）

intersection( final Set<E> set1, final Set<?> set2)：返回两个set集合的交集的不可修改SetView。（两个集合A 和集合B 的交集是指含有所有既属于 A 又属于 B 的元素，而没有其他元素的集合）

difference( final Set<E> set1, final Set<?> set2)：返回两个set集合的差的不可修改SetView。（A，B是两个集合，则所有属于A且不属于B的元素构成的集合，叫做A与B的差集）

symmetricDifference( Set<? extends E> set1, Set<? extends E> set2)：返回两个set集合的对称差的不可修改SetView。（对称差，即两个集合的对称差是只属于其中一个集合，而不属于另一个集合的元素组成的集合）

filter(Set<E> unfiltered, Predicate<? super E> predicate)：返回传入Set集合unfiltered中满足给定Predicate的元素集合Set。

filter( SortedSet<E> unfiltered, Predicate<? super E> predicate)：返回传入SortedSet集合unfiltered中满足给定Predicate的元素集合SortedSet。

filter( NavigableSet<E> unfiltered, Predicate<? super E> predicate)：返回传入NavigableSet集合unfiltered中满足给定Predicate的元素集合NavigableSet。

cartesianProduct( List<? extends Set<? extends B>> sets)：返回通过从各给定集中选择一个元素所形成每一个可能的集合。

cartesianProduct( Set<? extends B>... sets)：返回通过从各给定集中选择一个元素所形成每一个可能的集合。

powerSet(Set<E> set)：返回一个set，包含给定set的所有可能父级集合。

unmodifiableNavigableSet( NavigableSet<E> set)：返回指定NavigableSet的不可修改视图。

synchronizedNavigableSet( NavigableSet<E> navigableSet)：返回一个同步的（线程安全的）NavigableSet，由指定的NavigableSet支持。

Sets类中提供的方法很多，我们这里对其中的一些重点和特别的方法做一些示例学习，其他的方法不再赘述，示例代码如下：

/**
 * Sets：处理Set实例的实用类
 * User: Realfighter
 * Date: 2014/9/3
 * Time: 20:00
 */
public class SetsTest {
 
    Set<Integer> set1;//测试用
    Set<Integer> set2;//测试用
 
    /**
     * 初始化测试集合
     */
    @Before
    public void setUp() {
        set1 = Sets.newHashSet(1, 2, 3, 4, 5);
        set2 = Sets.newHashSet(1, 3, 5, 7, 9);
    }
 
    /**
     * filter：返回传入Set集合unfiltered中满足给定Predicate的元素集合Set
     */
    @Test
    public void testFilter() {
        Set<String> set = Sets.newHashSet("i like u", "i miss u", "i love u");
        Predicate<String> predicate = new Predicate<String>() {
            @Override
            public boolean apply(String input) {
                //过滤包含字母l的元素
                return input.contains("l");
            }
        };
        //输出：[i like u, i love u]
        System.out.println(Sets.filter(set, predicate));
    }
 
    /**
     * difference：返回两个set集合的差的不可修改SetView
     * A，B是两个集合，则所有属于A且不属于B的元素构成的集合，叫做A与B的差集
     */
    @Test
    public void testDifference() {
        //输出：[2, 4]
        System.out.println(Sets.difference(set1, set2));
    }
 
    /**
     * symmetricDifference：返回两个set集合的对称差的不可修改SetView
     * 对称差，即两个集合的对称差是只属于其中一个集合，而不属于另一个集合的元素组成的集合
     */
    @Test
    public void testSymmetricDifference() {
        //输出：[2, 4, 9, 7]
        System.out.println(Sets.symmetricDifference(set1, set2));
    }
 
    /**
     * intersection：返回两个set集合的交集的不可修改SetView
     * 两个集合A和集合B的交集是指含有所有既属于A又属于B的元素，而没有其他元素的集合
     */
    @Test
    public void testIntersection() {
        //输出：[1, 3, 5]
        System.out.println(Sets.intersection(set1, set2));
    }
 
    /**
     * Union：返回两个set集合的并集的不可修改SetView
     * 若A和B是集合，则A和B并集是有所有A的元素和所有B的元素，而没有其他元素的集合
     */
    @Test
    public void testUnion() {
        //输出：[1, 2, 3, 4, 5, 9, 7]
        System.out.println(Sets.union(set1, set2));
    }
 
    /**
     * cartesianProduct：返回通过从各给定集中选择一个元素所形成每一个可能的集合
     */
    @Test
    public void testCartesianProduct() {
        Set<String> set1 = Sets.newHashSet("i love u", "i hate u");
        Set<String> set2 = Sets.newHashSet("tom", "jerry");
        Set<List<String>> sets = Sets.cartesianProduct(set1, set2);
        //输出：[[i hate u, tom], [i hate u, jerry], [i love u, tom], [i love u, jerry]]
        System.out.println(sets);
    }
 
    /**
     * powerSet：返回一个set，包含给定set的所有可能父级集合
     */
    @Test
    public void testPowerSet() {
        Set<String> set1 = Sets.newHashSet("i love u", "i hate u");
        Set<Set<String>> sets = Sets.powerSet(set1);
        for (Set<String> set : sets) {
            System.out.print(set);
        }
        //输出：[][i hate u][i love u][i hate u, i love u]
    }
 
}

转载于:https://my.oschina.net/realfighter/blog/349902