guava-collections

JDK和Guava对应关系

Lists :

partition(List, int):按指定大小分割list, int为分割的大小

 

@Test
    public void testPartition() {
        ArrayList<Source> li = Lists.newArrayList();
        Source source1 = new Source();
        source1.setName("a");
        li.add(source1);

        Source source2 = new Source();
        source2.setName("c");
        li.add(source2);

        Source source3 = new Source();
        source3.setName("b");
        li.add(source3);

        List<List<Source>> partition = Lists.partition(li, 1);

        for (List<Source> list : partition) {

            System.out.println(list);//[Source{list=[], name='a'}]//[Source{list=[], name='c'}] //[Source{list=[], name='b'}]
}
    }

 

reverse(List):将list集合元素反转,不可变List用ImmutableList.reverse()。

注意: 并不是改变原list , 而是返回一个新的list ,需要定义变量接收

@Test
    public void testInts() {
        int[] arr = {1,2,3,45};

        List<Integer> integers = Ints.asList(arr);// [1, 2, 3, 45]

        List<Integer> reverse = Lists.reverse(integers);
        System.out.println(integers);//[1, 2, 3, 45]
        System.out.println(reverse);//[45, 3, 2, 1]

    }

 

Sets:

@Test
    public void testSets() {
        Set<String> set1 = Sets.newHashSet();
        set1.add("b");
        set1.add("c");

        Set<String> set2 = Sets.newHashSet();
        set2.add("a");
        set2.add("b");

        Sets.SetView<String> difference = Sets.difference(set1, set2);// 取左差集
        System.out.println(difference);//[c]

        Sets.SetView<String> symmetricDifference = Sets.symmetricDifference(set1, set2);// 取两方差集
        System.out.println(symmetricDifference);//[c, a]

        Sets.SetView<String> intersection = Sets.intersection(set1, set2);// 取交集
        System.out.println(intersection);//[b]

        Sets.SetView<String> union = Sets.union(set1, set2);// 取并集
        System.out.println(union);//[b, c, a]

        // 过滤,结果集中只包含返回true的
        Set<String> filter = Sets.filter(set1, new Predicate<String>() {
            @Override
            public boolean apply(String s) {
                return s.equals("b");
            }
        });
        System.out.println(filter);//[b]
    }
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支持。