com.google.guava 常用工具类

目录

collect Lists 工具类

collect Multiset 无序可重复集合

collect Table 表格工具类

primitives Ints 整形工具类

Multimap 一个 key 对多个值

连接器 Joiner、分割器 Splitter

字符匹配器：CharMatcher

---

com.google.guava 依赖：

        <!-- https://mvnrepository.com/artifact/com.google.guava/guava -->
        <dependency>
            <groupId>com.google.guava</groupId>
            <artifactId>guava</artifactId>
            <version>28.1-jre</version>
        </dependency>

collect Lists 工具类

com.google.common.collect.Maps 、com.google.common.collect.Sets 也是同理

import com.google.common.collect.Lists;
import org.junit.Test;
import java.util.ArrayList;
import java.util.List;
import java.util.concurrent.CopyOnWriteArrayList;
public class ListsStudy {
    /**
     * static <E> List<E> asList(@Nullable E first, E[] rest)
     * static <E> List<E> asList(@Nullable E first, @Nullable E second, E[] rest)
     * 返回包含指定的第一个、第二个元素和指定数组的 list, rest 数组可以为空，但是不能为 null，返回 list 不可修改，否则抛出异常。
     */
    @Test
    public void test1() {
        List<String> list1 = Lists.asList("admin", new String[]{"zhangsan", "admin"});
        List<String> list2 = Lists.asList("admin", "root", new String[]{});
        System.out.println(list1 + "," + list2);//[admin, zhangsan, admin],[admin, root]
    }
    /**
     * static <E> ArrayList<E> newArrayList(E... elements):创建包含给定元素的可变 ArrayList 实例
     * static <E> ArrayList<E> newArrayList()：返回空 ArrayList
     * static <E> ArrayList<E> newArrayListWithCapacity(int initialArraySize)：返回空 ArrayList，并设置初始容量
     */
    @Test
    public void test2() {
        List<String> list1 = Lists.newArrayList("admin", "zhangsan", "admin");
        System.out.println(list1);//[admin, zhangsan, admin]
    }
    /**
     * static <B> List<List<B>> cartesianProduct(List<? extends B>... lists)
     * 获取多个 list 的笛卡儿积，返回的 list 不可修改，否则异常 UnsupportedOperationException
     */
    @Test
    public void test3() {
        List<Object> list1 = Lists.newArrayList("admin", "root");
        List<Object> list2 = Lists.newArrayList(100, 200);
        List<List<Object>> cartesianProduct = Lists.cartesianProduct(list1, list2);
        System.out.println(cartesianProduct);//[[admin, 100], [admin, 200], [root, 100], [root, 200]]
        cartesianProduct.get(0).add(900);
    }
    /**
     * static <E> CopyOnWriteArrayList<E> newCopyOnWriteArrayList()
     * static <E> CopyOnWriteArrayList<E> newCopyOnWriteArrayList(Iterable<? extends E> elements)
     * 获取 CopyOnWriteArrayList
     * static <E> LinkedList<E> newLinkedList()
     * static <E> LinkedList<E> newLinkedList(Iterable<? extends E> elements)
     */
    @Test
    public void test4() {
        ArrayList<String> arrayList = Lists.newArrayList("admin", "root");
        CopyOnWriteArrayList<String> copyOnWriteArrayList = Lists.newCopyOnWriteArrayList(arrayList);
        copyOnWriteArrayList.add("socket");
        System.out.println(copyOnWriteArrayList);//[admin, root, socket]
    }

    /**元素顺序反转*/
    @Test
    public void test5(){
        List<String> list1 = Lists.newArrayList("admin", "socket", "root");
        List<String> reverse = Lists.reverse(list1);
        System.out.println(reverse);//[root, socket, admin]
    }
    /**获取分割子列表*/
    @org.junit.Test
    public void test6() {
        List<Integer> intList = Lists.newArrayList(10, 20, 30, 40, 50, 60, 70, 80);
        List<String> strList = Lists.newArrayList("a1", "b2", "c3", "d4", "e5", "f6", "g7", "h8");
        List<List<Integer>> subSets = Lists.partition(intList, 5);
        List<List<String>> listList = Lists.partition(strList, 3);
        System.out.println(subSets);//[[10, 20, 30, 40, 50], [60, 70, 80]]
        System.out.println(listList);//[[a1, b2, c3], [d4, e5, f6], [g7, h8]]
    }
}

collect Multiset 无序可重复集合

    /**
     * com.google.common.collect.Multiset：无序但是可以重复的集合（set）。
     * 是对传统 java.util.Collection 的扩展。
     * guava 所有的集合都有create方法
     */
    @Test
    public void test2() {
        Multiset<Object> multiset = HashMultiset.create();
        multiset.add("a");
        multiset.add(200);
        multiset.add("a");
        Iterator<Object> iterator = multiset.iterator();
        while (iterator.hasNext()) {
            System.out.print(iterator.next() + "\t");//a    a   200
        }
    }

collect Table 表格工具类

import com.google.common.collect.HashBasedTable;
import com.google.common.collect.Table;
import org.junit.Test;
import java.util.Map;
import java.util.Set;
public class TableStu {
    /**
     * guava 提供了 Map<R, Map<C, V>> 结构的 com.google.common.collect.Table ,用于存储数据库 table 结构的数据
     * Table涉及到3个概念：rowKey,columnKey,value 。 R 标识数据库航的主键，C 是列名，V 是 列的值。
     * 此实现不同步，如果多个线程访问此表，必须在外部进行同步
     */
    @Test
    public void test1() {
        HashBasedTable<Object, Object, Object> hashBasedTable = HashBasedTable.create();
        hashBasedTable.put("1001", "name", "展护卫");
        hashBasedTable.put("1001", "age", "33");
        hashBasedTable.put("1001", "price", 88898.78);

        hashBasedTable.put("1002", "name", "马汉");
        hashBasedTable.put("1002", "age", "43");
        hashBasedTable.put("1002", "price", 56898.78);

        Set<Object> rowKeySet = hashBasedTable.rowKeySet();
        Set<Object> columnKeySet = hashBasedTable.columnKeySet();
        //rowKeySet=[1001, 1002],columnKeySet=[name, age, price]
        System.out.println("rowKeySet=" + rowKeySet + ",columnKeySet=" + columnKeySet);

        Map<Object, Object> row = hashBasedTable.row("1001");
        Map<Object, Object> name = hashBasedTable.column("name");
        //row={name=展护卫, age=33, price=88898.78},name={1001=展护卫, 1002=马汉}
        System.out.println("row=" + row + ",name=" + name);

        Object name1 = hashBasedTable.get("1001", "name");
        System.out.println("name1=" + name1);//name1=展护卫

        System.out.println("-----------------------------");
        Set<Table.Cell<Object, Object, Object>> cellSet = hashBasedTable.cellSet();
        for (Table.Cell<Object, Object, Object> cell : cellSet) {
            System.out.println("rowKey=" + cell.getRowKey() + " - " + cell.getColumnKey() + " - " + cell.getValue());
        }
    }
}

primitives Ints 整形工具类

1、guava 提供了 Bytes、Shorts、Ints、Longs、Floats、Doubles、Chars、Booleans 8种基本数据类型的扩展支持，以及 Strings 字符串扩展支持。

import com.google.common.collect.*;
import com.google.common.primitives.Ints;
import org.junit.Test;  
import java.util.ArrayList;
import java.util.Collection;
import java.util.Iterator;
import java.util.List;
public class IntsStu {
    //guava 提供了 Bytes/Shorts/Ints/Longs/Floats/Doubles/Chars/Booleans 这些基本数据类型的扩展支持
    @Test
    public void test1() {
        //将 int 数组转为 Integer 型 list
        List<Integer> integerList = Ints.asList(1, 2, 4, 5, 6);
        System.out.println(integerList);//[1, 2, 4, 5, 6]

        int[] ints = new int[]{3, 2, 4, 55, 34, 33, 55, 67};
        int max = Ints.max(ints);//取数组最大值
        int min = Ints.min(ints);//取数组最小值
        System.out.println(max + "," + min);//67,2

        Ints.sortDescending(ints);//将数组倒序排列
        System.out.println(Ints.asList(ints));//[67, 55, 55, 34, 33, 4, 3, 2]

        Ints.reverse(ints);//将数组元素首尾颠倒
        System.out.println(Ints.asList(ints));//[2, 3, 4, 33, 34, 55, 55, 67]

        int[] ints2 = new int[]{3, 2, 4, 55, 34, 33, 55, 67};
        String join = "(" + Ints.join(",", ints2) + ")";//使用连接符连接数组元素
        System.out.println(join);//(3,2,4,55,34,33,55,67)

        ArrayList<Integer> arrayList = Lists.newArrayList(100, 200, 400);
        int[] array = Ints.toArray(arrayList);//list 转数组
        System.out.println(Ints.contains(array, 200));//是否包含目标值。true

        int[] concat = Ints.concat(array, array);//连接多个数组
        System.out.println(Ints.asList(concat));//[100, 200, 400, 100, 200, 400]
    }

Multimap 一个 key 对多个值

    /**
     * JDK 提供给的Map是一个键，一个值，一对一的，而实际开发中，经常遇到一个 KEY 多个 VALUE 的情况（比如一个分类下的书本），通常使用 Map<k,List<v>>
     * Multimap 提供一个 key 对多个值，它的值其实就是 java.util.Collection 类型，用于存储多个值
     * Multimap 的实现类有：ArrayListMultimap/HashMultimap/LinkedHashMultimap/TreeMultimap/ImmutableMultimap/......
     */
    @Test
    public void test3() {
        Multimap<String, String> multimap = ArrayListMultimap.create();//guava 所有的集合都有 create方法
        multimap.put("name", "鲁迅");
        multimap.put("name", "周树人");
        multimap.put("name", "鲁迅");//相当于往集合中添加值，所以不会覆盖
        multimap.put("age", "45");
        Collection<String> name = multimap.get("name");//取值，返回的集合
        Collection<String> age = multimap.get("age");
        System.out.println(name + "," + age);//[鲁迅, 周树人, 鲁迅],[45]
        multimap.remove("name", "鲁迅");//删除 key 对应集合中的元素，删除匹配的第一个元素。
        System.out.println(multimap);//{name=[周树人, 鲁迅], age=[45]}
    }
    @Test
    public void test4() {
        BiMap<String, String> biMap = HashBiMap.create();
        biMap.put("张三", "[email protected]");
        biMap.put("李四", "[email protected]");
        //biMap.put("王五", "[email protected]");//key 重复时，会覆盖旧值。value 重复时，之间报错
        System.out.println(biMap);//{张三[email protected], 李四[email protected]}
        System.out.println(biMap.get("李四"));//[email protected]
        System.out.println(biMap.inverse().get("[email protected]"));//李四
        System.out.println(biMap);//{张三[email protected], 李四[email protected]}
    }
}

连接器 Joiner、分割器 Splitter

import com.google.common.base.CharMatcher;
import com.google.common.base.Joiner;
import com.google.common.base.Splitter;
import com.google.common.collect.Lists;
import org.junit.Test;
import java.util.ArrayList;
import java.util.Iterator;
@SuppressWarnings("all")
public class JoinerStu {
    /**
     * Joiner 是连接器，用于连接 java.lang.Iterable、java.util.Iterator、java.lang.Object[] 的元素
     * static Joiner on(String separator)：指定分隔符
     * String join(Iterable<?> parts)、String join(Iterator<?> parts)、String join(Object[] parts)：使用分隔符连接集合或者数组中的元素，返回字符串
     * Joiner skipNulls()：自动跳过 null 元素，否则 join 方法会抛空指针异常
     * Joiner useForNull(final String nullText) :对于 null 元素使用 nullText 值代替
     */
    @Test
    public void test1() {
        ArrayList<Integer> arrayList1 = Lists.newArrayList(100, 200, 300, null, 400);
        Joiner joiner1 = Joiner.on(",").skipNulls();
        String join1 = "(" + joiner1.join(arrayList1) + ")";

        Object[] objects = new Object[]{"admin", "root", "apple", null, "huaWei"};
        Joiner joiner2 = Joiner.on("','").useForNull("x");
        String join2 = "('" + joiner2.join(objects) + "')";
        System.out.println(join1 + "\t" + join2);//(100,200,300,400)    ('admin','root','apple','x','huaWei')
    }
    /**
     * Splitter 是分割器，用于分割字符序列 java.lang.CharSequence
     * static Splitter onPattern(String separatorPattern)：返回一个拆分器，该拆分器考虑与给定模式匹配的任何子序列（正则表达式）
     * static Splitter on(Pattern separatorPattern)：使用 Java 正则表达式分割
     * static Splitter fixedLength(final int length)：定长分割，每 length 个字符作为一组
     * Iterable<String> split(final CharSequence sequence)：拆分字符串，返回 Iterable
     * Splitter trimResults()：对拆分后的单个结果去除前后空格
     * Splitter omitEmptyStrings() ：省略空字符串，即对于空元素不再返回。
     */
    @Test
    public void test2() {
        String text = "('admin','root','apple',null ,, ,'hua Wei')";
        Splitter splitter = Splitter.on(",").trimResults().omitEmptyStrings();
        Iterable<String> stringIterable = splitter.split(text);
        Iterator<String> stringIterator = stringIterable.iterator();
        while (stringIterator.hasNext()) {
            System.out.print(stringIterator.next() + "|");//('admin'|'root'|'apple'|null|'hua Wei')|
        }
        System.out.println();
        String message = "Splitter是分割器，通常我们会把它们定义为static final";
        Splitter fixedLength = Splitter.fixedLength(8).trimResults().omitEmptyStrings();
        Iterable<String> iterable = fixedLength.split(message);
        Iterator<String> iterator = iterable.iterator();
        while (iterator.hasNext()) {
            System.out.print(iterator.next() + "|");//Splitter|是分割器，通常我|们会把它们定义为|static f|inal|
        }
    }

字符匹配器：CharMatcher

    /**
     * 字符匹配器：CharMatcher ,只要灵活使用，可以发挥很大的作用
     * static CharMatcher is(final char match)：表示等于
     * CharMatcher or(CharMatcher other)：表示或者
     * static CharMatcher inRange(final char startInclusive, final char endInclusive)：表示 in，在某个范围内
     * CharMatcher and(CharMatcher other)：表示并且
     * static CharMatcher isNot(final char match)：表示不等于
     * int countIn(CharSequence sequence)：获取字符序列中匹配的次数
     * String trimFrom(CharSequence sequence)：去掉字符串序列中前后被匹配的字符
     * String trimLeadingFrom(CharSequence sequence)：去掉头部匹配的字符
     * String trimTrailingFrom(CharSequence sequence)：去掉尾部匹配的字符
     * String removeFrom(CharSequence sequence)：删除字符串中所有匹配的字符
     * String replaceFrom(CharSequence sequence, CharSequence replacement)：使用 replacement 替换 sequence 中匹配的字符
     * static CharMatcher any()：表示任意字符
     * static CharMatcher anyOf(final CharSequence sequence): 表示 sequence 字符序列中的任意字符
     * static CharMatcher ascii()：获取 ascii 码的字符匹配器。对照表：http://ascii.911cha.com/
     * static CharMatcher whitespace()：获取空白字符匹配器，包含 \r、\n、\t 等字符
     */
    @Test
    public void test3() {
        //表示匹配字符 ',' 或者字符 '|' 或者字符 '_'
        CharMatcher charMatcher = CharMatcher.is(',').or(CharMatcher.is('|')).or(CharMatcher.is('_'));
        boolean matches1 = charMatcher.matches(',');
        boolean matches2 = charMatcher.matches('|');
        boolean matches3 = charMatcher.matches('_');
        boolean matches4 = charMatcher.matches('#');
        System.out.println(matches1 + "," + matches2 + "," + matches3 + "," + matches4);//true,true,true,false

        //表示匹配 [a,c] 之间的字符，但是不能等于 'b'
        CharMatcher matcher = CharMatcher.inRange('a', 'c').and(CharMatcher.isNot('b'));
        boolean a = matcher.matches('a');
        boolean b = matcher.matches('b');
        boolean c = matcher.matches('c');
        System.out.println(a + "," + b + "," + c);//true,false,true

        //判断字符是否是数字；判断字符是字母
        CharMatcher matcher1 = CharMatcher.inRange('0', '9');
        CharMatcher matcher2 = CharMatcher.inRange('a', 'z').or(CharMatcher.inRange('A', 'Z'));
        System.out.println(matcher1.matches('7') + "," + matcher1.matches('p'));//true,false
        System.out.println(matcher2.matches('f') + "," + matcher2.matches(','));//ftrue,false

        //获取 "abc123sdk897" 字符串中数字出现的次数
        int countIn = matcher1.countIn("abc123sdk897");
        System.out.println(countIn);//6

        //去掉字符串前后的 \r、\n、\t 以及空格字符
        CharMatcher matcher3 = CharMatcher.is('\t').or(CharMatcher.is('\r')).or(CharMatcher.is('\n')).or(CharMatcher.is(' '));
        String text3 = "\r Solr Home \n ";
        String trimFrom = matcher3.trimFrom(text3);
        System.out.println(trimFrom);//Solr Home

        //删除 "abc123SDK897" 字符串中所有的字母
        String removeFrom = matcher2.removeFrom("abc123SDK897");
        System.out.println(removeFrom);//123897

        CharMatcher matcher4 = CharMatcher.is('淫').or(CharMatcher.is('毒'));
        String text4 = "卖淫团伙同时也是一个贩毒组织。";
        String replaceFrom = matcher4.replaceFrom(text4, "xx");
        System.out.println(replaceFrom);//卖xx团伙同时也是一个贩xx组织。

        //剔除目标字符串中的所有数字字符
        CharMatcher matcher5 = CharMatcher.anyOf("0123456789");
        String replace = matcher5.replaceFrom("嬴政一统六国221", "");
        System.out.println(replace);//嬴政一统六国

        //获取目标字符串中 ascii 码的字符个数（汉字不属于 ascii 码之内）
        CharMatcher ascii = CharMatcher.ascii();
        int count = ascii.countIn("12abn_)*77%三国");
        System.out.println(count);//11

        //去掉目标字符串中所有空格
        CharMatcher whitespace = CharMatcher.whitespace();
        String text6 = " 一统 天 下 \r\n\t";
        String replace1 = whitespace.replaceFrom(text6, "");
        System.out.println("|" + replace1 + "|");//|一统天下|
    }
}