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 + "|");//|一統天下|
    }
}