Guava 集合工具类 Lists

一、接口声明

以下是 com.google.common.collect.Lists 接口的声明：

@GwtCompatible(emulated=true)
public final class Lists
    extends Object

二、接口方法

官方文档：https://google.github.io/guava/releases/27.0.1-jre/api/docs/com/google/common/collect/Lists.html

三、使用

Lists 类主要提供了对List类的子类构造以及操作的静态方法。在Lists类中支持构造 ArrayList、LinkedList 以及 newCopyOnWriteArrayList 对象的方法。其中提供了以下构造ArrayList的函数：下面四个构造一个 ArrayList 对象，但是不显式的给出申请空间的大小：

newArrayList()
newArrayList(E... elements)
newArrayList(Iterable<? extends E> elements)
newArrayList(Iterator<? extends E> elements)

以下两个函数在构造 ArrayList 对象的时候给出了需要分配空间的大小:

newArrayListWithCapacity(int initialArraySize)
newArrayListWithExpectedSize(int estimatedSize)

如果你事先知道元素的个数，可以用 newArrayListWithCapacity 函数；如果你不能确定元素的个数，可以用 newArrayListWithExpectedSize 函数，在 newArrayListWithExpectedSize 函数里面调用了 computeArrayListCapacity(int arraySize) 函数，其实现如下：

@VisibleForTesting 
static int computeArrayListCapacity(int arraySize) {
    checkArgument(arraySize >= 0);
　　　
　　// TODO(kevinb): Figure out the right behavior, and document it
    return Ints.saturatedCast(5L + arraySize + (arraySize / 10));
}

返回的容量大小为 5L + arraySize + (arraySize / 10)，当 arraySize 比较大的时候，给定大小和真正分配的容量之比为 10/11。

Lists 类还支持构造 LinkedList、newCopyOnWriteArrayList 对象，其函数接口为：

newLinkedList()
newLinkedList(Iterable<? extends E> elements)　　　
newCopyOnWriteArrayList()
newCopyOnWriteArrayList(Iterable<? extends E> elements)

我们还可以将两个（或三个）类型相同的数据存放在一个list中，这样可以传入到只有一个参数的函数或者需要减少参数的函数中，这些函数如下：

asList(@Nullable E first, E[] rest)
asList(@Nullable E first, @Nullable E second, E[] rest)

Lists 类中 transform 函数可以根据传进来的 function 对 fromList 进行相应的处理，并将处理得到的结果存入到新的list对象中，这样有利于我们进行分析，函数接口如下：

public static <F, T> List<T> transform(List<F> fromList, Function<? super F, ? extends T> function)

使用例子：

Function<String, Integer> strlen = new Function<String, Integer>() {
    public Integer apply(String from) {
        Preconditions.checkNotNull(from);
        return from.length();
    }
};

List<String> from = Lists.newArrayList("abc", "defg", "hijkl");
List<Integer> to = Lists.transform(from, strlen);
for (int i = 0; i < from.size(); i++) {
    System.out.printf("%s has length %d\n", from.get(i), to.get(i));
}

Function<String, Boolean> isPalindrome = new Function<String, Boolean>() {
    public Boolean apply(String from) {
        Preconditions.checkNotNull(from);
        return new StringBuilder(from).reverse().toString().equals(from);
    }
};
from = Lists.newArrayList("rotor", "radar", "hannah", "level", "botox");
List<Boolean> to1 = Lists.transform(from, isPalindrome);
for (int i = 0; i < from.size(); i++) {
    System.out.printf("%s is%sa palindrome\n", from.get(i), to1.get(i) ? " " : " NOT ");
}
// changes in the "from" list are reflected in the "to" list
System.out.printf("\nnow replace hannah with megan...\n\n");
from.set(2, "megan");
for (int i = 0; i < from.size(); i++) {
    System.out.printf("%s is%sa palindrome\n", from.get(i), to1.get(i) ? " " : " NOT ");
}

Lists 还可以将传进来的 String 或者 CharSequence 分割为单个的字符，并存入到一个新的List对象中返回，如下：

ImmutableList<Character> wyp = Lists.charactersOf("wyp");
System.out.println(wyp);

四、测试类

package com.example.guava.collect;

import com.google.common.base.Function;
import com.google.common.collect.ImmutableList;
import com.google.common.collect.Lists;
import org.checkerframework.checker.nullness.qual.Nullable;
import org.junit.Test;

import java.util.List;

public class ListsTest {

    public void test1(){
        List<String> list1 = Lists.newArrayList();
        for (int i = 0; i < 10; i++) {
            list1.add(i + "");
        }
        System.out.println("list1: " + list1);
        //输出：list1: [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]

        //2、传入多参数
        List<String> list2 = Lists.newArrayList("1", "2", "3");
        System.out.println("list2: " + list2);
        //输出：list2: [1, 2, 3]

        //3、传入数组
        List<String> list3 = Lists.newArrayList(new String[]{"22", "22"});
        System.out.println("list3: " + list3);
        //输出：list3: [22, 22]

        //4、传入集合
        List<String> list4 = Lists.newArrayList(list1);
        System.out.println("list4: " + list4);
        //输出：list4: [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]

        //5、使用条件：你确定你的容器会装多少个，不确定就用一般形式的
        //说明：这个容器超过10个还是会自动扩容的。不用担心容量不够用。默认是分配一个容量为10的数组，不够将扩容
        //整个来说的优点有：节约内存，节约时间，节约性能。代码质量提高。
        List<String> list = Lists.newArrayListWithExpectedSize(10);

        //这个方法就是直接返回一个10的数组。
        List<String> list_ = Lists.newArrayListWithCapacity(10);
    }

    @Test
    public void testLists() {
        String str = "i love u";
        String[] strs = {"i like u", "i miss u"};

        List<String> list = Lists.asList(str, strs);
        System.out.println(list);   // [i love u, i like u, i miss u]

        strs[1] = "i hate u";
        System.out.println(list);   // [i love u, i like u, i hate u]

        /**
         * transform：根据传进来的function对fromList进行相应的处理
         * 并将处理得到的结果存入到新的list对象中返回
         */
        List<Object> transformList = Lists.transform(list, new Function<String, Object>() {
            @Override
            public Object apply(@Nullable String input) {
                return input.toUpperCase();
            }
        });
        System.out.println(transformList);      //[I LOVE U, I LIKE U, I HATE U]

        /**
         * partition：根据size传入的List进行切割，切割成符合要求的小的List
         * 并将这些小的List存入一个新的List对象中返回
         */
        List<List<String>> lists = Lists.partition(list, 2);
        System.out.println(lists);      // [[i love u, i like u], [i hate u]]

        /**
         * charactersOf：将传进来的String或者CharSequence分割为单个的字符
         * 并存入到一个ImmutableList对象中返回
         * ImmutableList：一个高性能、不可变的、随机访问列表的实现
         */
        ImmutableList<Character> characters = Lists.charactersOf("tingfeng");
        System.out.println(characters);     // [t, i, n, g, f, e, n, g]

        /**
         * reverse：返回一个传入List内元素倒序后的List
         */
        List<String> reverse = Lists.reverse(list);
        System.out.println(reverse);    // [i hate u, i like u, i love u]
    }

}

五、相关文章

• Google Guava 快速入门 —— 目录

未经允许请勿转载：程序喵 » Google Guava 快速入门 —— 【集合工具】Lists 类