你还不会使用Guava处理字符串? 那你还不进来学习?

ゝ一世哀愁。 2022-10-16 06:21 181阅读 0赞

### 文章目录 ###

*   *  你还不会使用Guava处理字符串? 那你还不进来学习?
     *   *  连接器\[Joiner\]
         *  拆分器\[Splitter\]
     *  参考
     *  源代码

## 你还不会使用Guava处理字符串? 那你还不进来学习? ##

### 连接器\[Joiner\] ###

> 用分隔符把字符串序列连接起来也可能会遇上不必要的麻烦。如果字符串序列中含有null，那连接操作会更难。但是连接器Joiner让我们连接字符串变得更加简单

比如我们现在一个字符串的集合，然后我们需要用‘\#’来把这个集合中的数据连接起来，用Joiner怎么做呢？

public class JoinerTest { 
    
        private final List<String> stringList = Arrays.asList("Google", "Guava", "Java", "Scala", "Kafka");
    
        @Test
        public void testJoinOnJoin() { 
            String result = Joiner.on("#").join(stringList);
            Assertions.assertEquals("Google#Guava#Java#Scala#Kafka", result);
        }
    }

通过`Joiner.on("#").join(stringList);`就可以把一个集合通过某个连接符来连接成字符串

那如果现在我们的集合中包含`null`，该如何处理，正常我们写程序可能会没考虑到这种空指针的问题。

public class JoinerTest { 
    
        private final List<String> stringListWithNullValue = Arrays.asList("Google", "Guava", "Java", "Scala", null);
        
        @Test
        public void testJoinOnJoinWithNullValue() { 
            assertThrows(NullPointerException.class, () -> { 
                String result = Joiner.on("#").join(stringListWithNullValue);
            });
        }
    }

比如如果用`Joiner.on("#").join(stringListWithNullValue)`,对于集合中有`null`的情况是会报空指针异常的，那种情况我们要怎么处理？

我们可以通过`skipNulls()`来过滤掉集合中的`null`元素。

public class JoinerTest { 
    
        private final List<String> stringListWithNullValue = Arrays.asList("Google", "Guava", "Java", "Scala", null);
    
        @Test
        public void testJoinOnJoinWithNullValueButSkip() { 
            String result = Joiner.on("#").skipNulls().join(stringListWithNullValue);
            Assertions.assertEquals("Google#Guava#Java#Scala", result);
        }
    
    }

而且通过这种Fluent风格的Joiner让连接字符串更简单。

那再比如说，我们有个要求是当集合元素有`null`元素的时候，我们需要用默认值去代替，该怎么做呢？

package org.example.joiner;
    
    import com.google.common.base.Joiner;
    import org.junit.jupiter.api.Assertions;
    import org.junit.jupiter.api.Test;
    
    import java.util.Arrays;
    import java.util.List;
    
    import static org.junit.jupiter.api.Assertions.assertThrows;
    
    public class JoinerTest { 
    
        private final List<String> stringListWithNullValue = Arrays.asList("Google", "Guava", "Java", "Scala", null);
    
        @Test
        public void testJoin_On_Join_WithNullValue_UseDefaultValue() { 
            String result = Joiner.on("#").useForNull("DEFAULT").join(stringListWithNullValue);
            Assertions.assertEquals("Google#Guava#Java#Scala#DEFAULT", result);
        }
    }

我们可以使用`useForNull("默认代替的字符串")`来完成连接。

public class Joiner { 
      
        public static Joiner on(String separator) { 
            return new Joiner(separator);
        }
    
        public static Joiner on(char separator) { 
            return new Joiner(String.valueOf(separator));
        }
      }

**Joiner的`on`方法总会返回一个新的joiner实例。这使得joiner实例都是线程安全的**

使用的方式还有很多，还可以把集合连接后返回一个`StringBuilder`对象

@Test
        public void testJoin_On_Append_To_StringBuilder() { 
            final StringBuilder builder = new StringBuilder();
            StringBuilder resultBuilder = Joiner.on("#").useForNull("DEFAULT").appendTo(builder, stringListWithNullValue);
            assertSame(resultBuilder,builder);//传入的对象和返回出来的对象是同一个对象
            assertEquals("Google#Guava#Java#Scala#DEFAULT",resultBuilder.toString());
            assertEquals("Google#Guava#Java#Scala#DEFAULT",builder.toString());
        }

当然还可以把集合连接后写入一个文件流中

@Test
        public void testJoin_On_Append_To_Writer() { 
            final String targetFileName = "guava-joiner.txt";
            try (FileWriter writer = new FileWriter(new File(targetFileName))) { 
                Joiner.on("#").useForNull("DEFAULT").appendTo(writer, stringListWithNullValue);
                assertTrue(Files.isFile().test(new File(targetFileName)));
            } catch (IOException e) { 
                fail("append to the writer occur fetal error.");
            }
        }

题外话题，现在我们考虑一下，如果不用Guava的Joiner我们平时该怎么处理这种字符串的连接呢？其实利用java8也是可以很快实现的，只是没有Guava这么简单便捷。

public class JoinerTest { 
    
        private final List<String> stringListWithNullValue = Arrays.asList("Google", "Guava", "Java", "Scala", null);
    
    
        @Test
        public void testJoiningByStreamWithDefaultValue() { 
            String result = stringListWithNullValue.stream().map(this::defaultValue).collect(joining("#"));
            assertEquals("Google#Guava#Java#Scala#DEFAULT", result);
        }
    
        private String defaultValue(final String item) { 
            return item == null || item.isEmpty() ? "DEFAULT" : item;
        }
    }

还有对于map这种key，value形式，Guava的Joiner可以用`withKeyValueSeparator`方法进行连接。

@Test
        public void testJoinOnWithMap() { 
            final Map<String, String> stringMap = of("Hello", "Guava", "Java", "Scala");
            assertEquals("Hello=Guava#Java=Scala", Joiner.on('#').withKeyValueSeparator("=").join(stringMap));
        }

### 拆分器\[Splitter\] ###

> JDK内建的字符串拆分工具有一些古怪的特性。比如，String.split悄悄丢弃了尾部的分隔符。 问题：`”,a, ,b,”.split(“,”)`返回什么呢？

package org.example.splitter;
    
    import org.junit.jupiter.api.Test;
    
    import java.util.Arrays;
    
    import static org.junit.jupiter.api.Assertions.assertEquals;
    
    public class SplitterTest { 
        @Test
        public void test_string_split() { 
            String str = ",a, ,b,";
            String[] split = str.split(",");
            assertEquals(4, split.length);
            assertEquals("[, a, , b]", Arrays.toString(split));
        }
    
    }

所以这不是我们期望的结果，我们期望的结果只是需要拿到a和b两个字符，那如果通过Guava的Splitter，我们就可以很容易的做到。

@Test
        public void testSplitOnSplit() { 
            List<String> result = Splitter.on(",").omitEmptyStrings().trimResults().splitToList(",a, ,b,");
            assertEquals(2,result.size());
            assertEquals("a",result.get(0));
            assertEquals("b",result.get(1));
        }

看到了吧，这就是Splitter的厉害之处。再继续看多几个例子

@Test
        public void testSplit_On_Split_OmitEmpty() { 
            List<String> result = Splitter.on("|").splitToList("hello|world|||");
            assertNotNull(result);
            assertEquals(5, result.size());
            //过滤掉split之后的空字符串
            result = Splitter.on("|").omitEmptyStrings().splitToList("hello|world|||");
            assertNotNull(result);
            assertEquals(2, result.size());
        }
    
        @Test
        public void testSplit_On_Split_OmitEmpty_TrimResult() { 
            List<String> result = Splitter.on("|").omitEmptyStrings().splitToList("hello | world|||");
            assertNotNull(result);
            assertEquals(2, result.size());
            assertEquals("hello ", result.get(0));
            assertEquals(" world", result.get(1));
    
            //过滤掉split之后的空字符串并把结果进行trim操作
            result = Splitter.on("|").trimResults().omitEmptyStrings().splitToList("hello | world|||");
            assertEquals("hello", result.get(0));
            assertEquals("world", result.get(1));
        }
    
    	@Test
        public void testSplitFixLength() { 
            //还可以按照长度进行分割
            List<String> result = Splitter.fixedLength(4).splitToList("aaaabbbbccccdddd");
            assertNotNull(result);
            assertEquals(4, result.size());
            assertEquals("aaaa", result.get(0));
            assertEquals("bbbb", result.get(1));
            assertEquals("cccc", result.get(2));
            assertEquals("dddd", result.get(3));
        }
    
    	@Test
        public void testSplitOnSplitLimit() { 
            //限制分割后的结果集个数
            List<String> result = Splitter.on("#").limit(3).splitToList("hello#world#java#google#scala");
            assertNotNull(result);
            assertEquals(3, result.size());
            assertEquals("hello", result.get(0));
            assertEquals("world", result.get(1));
            assertEquals("java#google#scala", result.get(2));
        }
    
    	@Test
        public void testSplitOnSplitLimit() { 
            //限制分割后的结果集个数
            List<String> result = Splitter.on("#").limit(3).splitToList("hello#world#java#google#scala");
            assertNotNull(result);
            assertEquals(3, result.size());
            assertEquals("hello", result.get(0));
            assertEquals("world", result.get(1));
            assertEquals("java#google#scala", result.get(2));
        }
    
    
    
        @Test
        public void testSplitOnPatternString() { 
            //还可以按照正则表达式分割
            List<String> result = Splitter.onPattern("\\|").trimResults().omitEmptyStrings().splitToList("hello | world|||");
            assertNotNull(result);
            assertEquals(2,result.size());
            assertEquals("hello",result.get(0));
            assertEquals("world",result.get(1));
        }
    
        @Test
        public void testSplitOnPattern() { 
            List<String> result = Splitter.on(Pattern.compile("\\|")).trimResults().omitEmptyStrings().splitToList("hello | world|||");
            assertNotNull(result);
            assertEquals(2,result.size());
            assertEquals("hello",result.get(0));
            assertEquals("world",result.get(1));
        }
    
    
        @Test
        public void testSplitOnSplitToMap() { 
            Map<String, String> result = Splitter.on(Pattern.compile("\\|")).trimResults()
                    .omitEmptyStrings().withKeyValueSeparator("=").split("hello=HELLO| world=WORLD|||");
            assertNotNull(result);
            assertEquals(2,result.size());
            assertEquals("HELLO",result.get("hello"));
            assertEquals("WORLD",result.get("world"));
    
        }

怎么样？你学废了吗？

## 参考 ##

[\[Google Guava\] 6-字符串处理：分割，连接，填充][Google Guava_ 6-]

[guava常用工具总结][guava]

[Google guava工具类的介绍和使用][Google guava]

## 源代码 ##

[https://gitee.com/cckevincyh/guava-demo][https_gitee.com_cckevincyh_guava-demo]

[Google Guava_ 6-]: http://ifeve.com/google-guava-strings/
[guava]: https://g.yuque.com/liyufei/ia5qdo/gnz17s
[Google guava]: https://juejin.im/post/6844903667498221581
[https_gitee.com_cckevincyh_guava-demo]: https://gitee.com/cckevincyh/guava-demo

发表评论取消回复

表情：

评论列表（有 0 条评论，181人围观）

还没有评论，来说两句吧...

相关阅读

相关什么？你还不会打包给运维？！那快来看看

目录一、首先是JAVA打包我们只需要用maven打包即可，生成文件为xxxx.jar 二、Vue打包而打包是运行 npm run build 只要把 dist

待我称王封你为后i/ 2024年03月04日 01:48/ 0 赞/ 64 阅读

相关你说啥什么?注解你还不会？

注解文末有彩蛋。一、什么是注解？ Annotaion `注解（Annotaion）`是从JDK5.0开始引入的一种新技术称之为注解机制。 `注解

叁歲伎倆/ 2022年12月04日 07:52/ 0 赞/ 226 阅读

相关什么，你还不会用CompletableFuture？

如果对JAVA8中的Supplier、Function等类不熟悉的话，可以先移步我的另外一篇文章[快速理解Consumer、Supplier、Predicate与Functio

痛定思痛。/ 2022年12月04日 03:25/ 0 赞/ 240 阅读

相关你还不会使用Guava处理字符串? 那你还不进来学习?

文章目录你还不会使用Guava处理字符串? 那你还不进来学习? 连接器\[Joiner\] 拆分器\[Splitt

ゝ一世哀愁。/ 2022年10月16日 06:21/ 0 赞/ 182 阅读

相关不懂这个工具类，你还说你会Java?

哈喽，大家好，我是指北君。日常开发中，我们会使用各种工具类，利用封装好的轮子，能让我们的开发事半功倍。但是在JDK中，有一个特别的工具类——java.lang.Arrays.c

系统管理员/ 2022年09月07日 14:43/ 0 赞/ 212 阅读

相关不懂SqlSession，你还说你会Mybatis?

上一篇文章中，我们介绍了 SqlSessionFactory 的创建过程，忘记了的，可以回顾一下，或者看下下面这张图也行。 ![image-20210722082105477

逃离我推掉我的手/ 2022年08月28日 12:45/ 0 赞/ 190 阅读

相关什么？你还不会写JQuery 插件

如今做web开发，jquery 几乎是必不可少的，就连vs神器在2010版本开始将Jquery 及ui 内置web项目里了。至于使用jquery好处这里就不再赘述了，用过的都知

我会带着你远行/ 2022年08月05日 12:08/ 0 赞/ 174 阅读

相关什么？你还不会写jQuery插件

[什么？你还不会写JQuery 插件][JQuery] 前言　　如今做web开发，jquery 几乎是必不可少的，就连vs神器在2010版本开始将Jquery 及ui

电玩女神/ 2022年06月16日 04:08/ 0 赞/ 204 阅读

相关我去，你竟然还不会用 synchronized

> 二哥，离你上一篇[我去][Link 1]已经过去两周时间了，这个系列还不打算更新吗？着急着看呢。以上是读者 Jason 发来的一条信息，不看不知道，一看真的是吓一跳，上

冷不防/ 2021年09月10日 08:24/ 0 赞/ 340 阅读

相关【Spring注解驱动开发】你还不会使用@Resource和@Inject注解？那你就out了！！

写在前面 > 我在冰河技术微信公众号中发表的《[【Spring注解驱动开发】使用@Autowired@Qualifier@Primary三大注解自动装配组件，你会了吗

Myth丶恋晨/ 2021年09月01日 09:28/ 0 赞/ 246 阅读