Guava入門

其實我用guava差不多大半年時間了，發現guava真的特別好用，又會使代碼變得很簡潔，最近又系統的學習了一下，大致講一下😊

什么是guava呢？

guava就是類庫，是java api的增強與擴展，里面有大量的方法供我們使用，使用之前需要引入包

<dependencies>
        <!--guava依賴-->
        <dependency>
            <groupId>com.google.guava</groupId>
            <artifactId>guava</artifactId>
            <version>27.0.1</version>
        </dependency>
</dependencies>

guava有哪些方法呢？我們先從以下幾方面開始學習：

1. 字符串處理：分割，連接，填充
2. 新增的集合類型
3. 原生類型

1.字符串的處理：分割，連接，填充

   a. joiner 連接器

joiner on就是將list用，連接轉成字符串

@Test
    public void joinerListTest() {
        List<String> lists = Lists.newArrayList("a","b","g","8","9");
        String result = Joiner.on(",").join(lists);
        System.out.println(result);
    }

結果：a,b,g,8,9

joiner skipNulls()連接跳過null元素(第一個test為了跟第二個進行比對一下)

@Test
    public void joinerListTest1() {
        List<String> lists = Lists.newArrayList("a","b","g",null,"8","9");
        String result = Joiner.on(",").join(lists);
        System.out.println(result);
    }

結果：a,b,g,null,8,9

@Test
public void joinerListTest2() {
    List<String> lists = Lists.newArrayList("a","b,"g",null,"8","9");
    String result = Joiner.on(",").skipNulls().join(lists);
    System.out.println(result);
}
結果：a,b,g,8,9

  如果連接的時候list里面含有null值，會報空指針，因為join實現如下：

1.
public final String join(Iterable<?> parts) {
        return this.join(parts.iterator());
    }

2.
public final String join(Iterator<?> parts) {
        return this.appendTo(new StringBuilder(), parts).toString();
    }

3.
@CanIgnoreReturnValue
    public final StringBuilder appendTo(StringBuilder builder, Iterator<?> parts) {
        try {
            this.appendTo((Appendable)builder, (Iterator)parts);
            return builder;
        } catch (IOException var4) {
            throw new AssertionError(var4);
        }
    }

4.
@CanIgnoreReturnValue
    public <A extends Appendable> A appendTo(A appendable, Iterator<?> parts) throws IOException {
        Preconditions.checkNotNull(appendable);
        if (parts.hasNext()) {
            appendable.append(this.toString(parts.next()));

            while(parts.hasNext()) {
                appendable.append(this.separator);
                appendable.append(this.toString(parts.next()));
            }
        }
        return appendable;
    }

5.
@CanIgnoreReturnValue
    public static <T> T checkNotNull(T reference) {
        if (reference == null) {
            throw new NullPointerException();
        } else {
            return reference;
        }
    }

 joiner useForNull(final String value)用value替換null元素值

@Test
    public void useNullListTest() {
        List<String> lists = Lists.newArrayList("a", "b", "g", null, "8", "9");
        String result = Joiner.on(",").useForNull("哈哈").join(lists);
        System.out.println(result);
    }

結果：a,b,g,哈哈,8,9

 joiner withKeyValueSeparator(String value)   map連接器，keyValueSeparator為key和value之間的分隔符

@Test
    public void withMapTest() {
        Map<Integer, String> maps = Maps.newHashMap();
        maps.put(1, "哈哈");
        maps.put(2, "壓壓");
        String result = Joiner.on(",").withKeyValueSeparator(":").join(maps);
        System.out.println(result);
        System.out.println(maps);
    }

結果：
1:哈哈,2:壓壓
{1=哈哈, 2=壓壓}

  b. splitter 拆分器

 splitter on 拆分

@Test
    public void splitterListTest() {
        String test = "34344,34,34,哈哈";
        List<String> lists = Splitter.on(",").splitToList(test);
        System.out.println(lists);
    }

結果：[34344, 34, 34, 哈哈]

 splitter trimResults 拆分去除前后空格

@Test
    public void trimResultListTest() {
        String test = "  34344,34,34,哈哈 ";
        List<String> lists = Splitter.on(",").trimResults().splitToList(test);
        System.out.println(lists);
    }

結果：[34344, 34, 34, 哈哈]

splitter omitEmptyStrings 去除拆分出來空的字符串

@Test
    public void omitEmptyStringsTest() {
        String test = "  3434,434,34,,哈哈 ";
        List<String> lists = Splitter.on(",").omitEmptyStrings().splitToList(test);
        System.out.println(lists);
    }

結果：[  3434, 434, 34, 哈哈 ]

splitter fixedLength(int lenght) 把字符串按固定長度分割

@Test
    public void fixedLengthTest() {
        String test = "343443434哈哈";
        List<String> lists = Splitter.fixedLength(3).splitToList(test);
        System.out.println(lists);
    }

結果：[343, 443, 434, 哈哈]

  b. charMatcher 匹配器

charMatcher is(Char char)  給單一字符匹配

@Test
    public void isTest() {
        String str = "12312,agg";
        CharMatcher charMatcher1 = CharMatcher.is('g');
        System.out.println(charMatcher1.retainFrom(str));
    }

結果：gg

charMatcher  retainFrom(String s)  在字符序列中保留匹配字符，移除其他字符

@Test
    public void charMatcherTest() {
        String str = "12312,agg  ";
        //兩個匹配符,先匹配再操作
        CharMatcher charMatcher1 = CharMatcher.is('1');
        CharMatcher charMatcher2 = CharMatcher.is('2');
        //兩個CharMatcher或操作
        CharMatcher charMatcher3 = charMatcher1.or(charMatcher2);
        System.out.println(charMatcher3.retainFrom(str));
    }

結果：1212

charMatcher matchersAllOf(Char char) 測試是否字符序列所有字符都匹配

@Test
    public void matchesAllOfTest() {
        String str = "12312,agg";
        CharMatcher charMatcher1 = CharMatcher.is('g');
        System.out.println(charMatcher1.matchesAllOf(str));
    }

結果：false
@Test
    public void matchesAllOfTest() {
        String str = "ggggg";
        CharMatcher charMatcher1 = CharMatcher.is('g');
        System.out.println(charMatcher1.matchesAllOf(str));
    }

結果：true

2.原生類型

 定義list，map

@Test
    public void test() {
        //JDK 
        List<String> list = new ArrayList<String>();
        list.add("a");
        list.add("b");
        list.add("c");
        list.add("d");
        //guava
        List<String> lists = Lists.newArrayList("a", "b", "g", null, "8", "9");
        List<String> lists1 = Lists.newArrayList();
        Map<Integer, String> maps = Maps.newHashMap();
}

 

3.新增集合（這里我只講一下Mulitmap,平時用這個會使代碼很方便，這里我就多講一下）

   Multimap就是將相同key的value值放在一個list里面，這樣子取相同key下面的所有value值就非常簡單了，不然還得for循環去匹配，把相同key值的value值找出來，在進行處理。map<key,value>鍵值key不能重復，所以當遇到這樣子場景的時候map就非常不適合了，下面我們看下例子：

  @Test
    public void test1(){
        //假設a表跟b表是一對多的關系，通過a表id是b表的外鍵，比如從b表查出了一堆數據，想把a.id相同的數據放在一起,A,B分別代表a,b表的model
        List<B> bList = BMapper.selectByExample(XXXXX);
        Multimap<Integer,B> bMultimap = ArrayListMultimap.create();
        bList.forEach(v->{
            bMultimap.put(v.getAId(),v);   
        });

    }

 Multimap.get(key)即使沒有key值，會返回空的list。

 Multimap.keySet()返回的用set<T>表示的不重復key;Multimap.keys()返回的是用Multiset表示的key,key數量跟value值數量一致；Multimap.containKeys()是表示是否包含這個key;

 Multimap.size()返回所有值的個數，而非不同鍵的個數。要得到不同鍵的個數，要用Multimap.keySet().size()