放弃StringBuilder！用Java8的StringJoiner

 在阅读项目代码时，突然看到了StringJoiner这个类的使用，感觉很有意思。

创新互联坚持“要么做到，要么别承诺”的工作理念，服务领域包括：成都做网站、网站设计、外贸营销网站建设、企业官网、英文网站、手机端网站、网站推广等服务，满足客户于互联网时代的东港网站设计、移动媒体设计的需求，帮助企业找到有效的互联网解决方案。努力成为您成熟可靠的网络建设合作伙伴！

对实际开发中也有用，原理上是运用了StringBuilder的一个拼接字符串的封装处理。

为什么会新增这样一个string辅助类？

原有的stringbuilder太死板，不支持分割，如果想让最终的字符串以逗号隔开，需要这样写 

 
 
 
    
  
  
  
  1. StringBuilder sb = new StringBuilder();  
    2. 
  
  
  
  2. IntStream.range(1,10).forEach(i->{  
    3. 
  
  
  
  3.     sb.append(i+"");  
    4. 
  
  
  
  4.     if( i < 10){  
    5. 
  
  
  
  5.         sb.append(",")  
    6. 
  
  
  
  6.     }  
    7. 
  
  
  
  7. }); 
    8.

是不是太死板了，不好用，StringJoiner怎样写呢？ 

 
 
 
    
  
  
  
  1. StringJoiner sj = new StringJoiner(",");  
    2. 
  
  
  
  2. IntStream.range(1,10).forEach(i->sj.add(i+"")); 
    3.

有哪些平时用的还比较少的功能：

  •  setEmptyValue, 默认情况下的emptyValue是前缀加后缀， 用户可自定义emptyValue
  •  merge(StringJoiner other),合并另外一个joiner
  •  length, 当前长度，为空看emptyValue的长度

让我实现StringJoiner，我会怎么办呢？

  •  维护一个List,最后toString的时候join一下就好了。优势：实现非常方便 缺点：list太浪费空间(扩容时都是按照系数扩容的)
  •  在StringBuilder基础上改造（jdk实现方式就是以组合的形式增强的StringBuilder

jdk实现的源码分析

  •  成员变量 
 
 
 
    
  
  
  
  1. private final String prefix;  
    2. 
  
  
  
  2.     private final String delimiter;  
    3. 
  
  
  
  3.     private final String suffix;  
    4. 
  
  
  
  4.     /*  
    5. 
  
  
  
  5.      * StringBuilder value -- at any time, the characters constructed from the  
    6. 
  
  
  
  6.      * prefix, the added element separated by the delimiter, but without the  
    7. 
  
  
  
  7.      * suffix, so that we can more easily add elements without having to jigger  
    8. 
  
  
  
  8.      * the suffix each time.  
    9. 
  
  
  
  9.      */  
    10. 
  
  
  
  10.     private StringBuilder value;  
    11. 
  
  
  
  11.     /*  
    12. 
  
  
  
  12.      * By default, the string consisting of prefix+suffix, returned by  
    13. 
  
  
  
  13.      * toString(), or properties of value, when no elements have yet been added,  
    14. 
  
  
  
  14.      * i.e. when it is empty.  This may be overridden by the user to be some  
    15. 
  
  
  
  15.      * other value including the empty String.  
    16. 
  
  
  
  16.      */  
    17. 
  
  
  
  17.     private String emptyValue; 
    18.

其实从成员变量的注释里就能看出他们的作用和需要注意的点了

  •  构造函数 
 
 
 
    
  
  
  
  1. public StringJoiner(CharSequence delimiter,  
    2. 
  
  
  
  2.                         CharSequence prefix,  
    3. 
  
  
  
  3.                         CharSequence suffix) {  
    4. 
  
  
  
  4.         Objects.requireNonNull(prefix, "The prefix must not be null");  
    5. 
  
  
  
  5.         Objects.requireNonNull(delimiter, "The delimiter must not be null");  
    6. 
  
  
  
  6.         Objects.requireNonNull(suffix, "The suffix must not be null");  
    7. 
  
  
  
  7.         // make defensive copies of arguments  
    8. 
  
  
  
  8.         this.prefix = prefix.toString();  
    9. 
  
  
  
  9.         this.delimiter = delimiter.toString();  
    10. 
  
  
  
  10.         this.suffix = suffix.toString();  
    11. 
  
  
  
  11.         // ！！！构造时就直接将emptyValue拼接好了。  
    12. 
  
  
  
  12.         thisthis.emptyValue = this.prefix + this.suffix;  
    13. 
  
  
  
  13.     } 
    14.

为什么要一开始就构造好呢？如果我想直接自定义emptyValue直接用构造函数初始化不是更方便吗？是因为绝大多数场景下都不会自定义emptyValue的场景吗？不对啊，感觉这个场景非常必要啊。

  •  添加元素 
 
 
 
    
  
  
  
  1. public StringJoiner add(CharSequence newElement) {  
    2. 
  
  
  
  2.         prepareBuilder().append(newElement);  
    3. 
  
  
  
  3.         return this;  
    4. 
  
  
  
  4. }  
    5. 
  
  
  
  5. private StringBuilder prepareBuilder() {  
    6. 
  
  
  
  6.         // 从构造函数和类变量的声明可以看出，没有添加元素前stringbuilder是没有初始化的  
    7. 
  
  
  
  7.         if (value != null) {  
    8. 
  
  
  
  8.             // 已经有元素存在的情况下，添加元素前先将分隔符添加进去  
    9. 
  
  
  
  9.             value.append(delimiter);  
    10. 
  
  
  
  10.         } else {  
    11. 
  
  
  
  11.             // 没有元素存在的情况下先把前缀加进去  
    12. 
  
  
  
  12.             value = new StringBuilder().append(prefix);  
    13. 
  
  
  
  13.         }  
    14. 
  
  
  
  14.         return value;  
    15. 
  
  
  
  15. } 
    16.

可以看出再添加元素的过程中就已经把前缀和分割字符什么的都处理好了，全部都在stringbuilde中了，唯一没有处理的就是后缀。 为什么？这样做tostring什么的时候真的超级方便的有木有。

  • 关键的toString 
 
 
 
    
  
  
  
  1. public String toString() {  
    2. 
  
  
  
  2.     if (value == null) {  
    3. 
  
  
  
  3.         // 这里如果没有自定义空值就是前缀+后缀咯。 
    4. 
  
  
  
  4.         return emptyValue;  
    5. 
  
  
  
  5.     } else {  
    6. 
  
  
  
  6.         // 为什么不直接value.toString()+suffix?????  
    7. 
  
  
  
  7.         if (suffix.equals("")) {  
    8. 
  
  
  
  8.             return value.toString();  
    9. 
  
  
  
  9.         } else {  
    10. 
  
  
  
  10.             int initialLength = value.length();  
    11. 
  
  
  
  11.             String result = value.append(suffix).toString();  
    12. 
  
  
  
  12.             // reset value to pre-append initialLength  
    13. 
  
  
  
  13.             value.setLength(initialLength);  
    14. 
  
  
  
  14.             return result;  
    15. 
  
  
  
  15.         }  
    16. 
  
  
  
  16.     }  
    17. 
  
  
  
  17. } 
    18.

为什么不直接value.toString()+suffix？答案在merge方法

  •  merge 
 
 
 
    
  
  
  
  1. public StringJoiner merge(StringJoiner other) {  
    2. 
  
  
  
  2.         Objects.requireNonNull(other);  
    3. 
  
  
  
  3.         if (other.value != null) {  
    4. 
  
  
  
  4.             final int length = other.value.length();  
    5. 
  
  
  
  5.             // 下面这段注释是说避免merge(this)时受影响，为什么？  
    6. 
  
  
  
  6.             // lock the length so that we can seize the data to be appended  
    7. 
  
  
  
  7.             // before initiate copying to avoid interference, especially when  
    8. 
  
  
  
  8.             // merge 'this'  
    9. 
  
  
  
  9.             StringBuilder builder = prepareBuilder();  
    10. 
  
  
  
  10.             builder.append(other.value, other.prefix.length(), length);  
    11. 
  
  
  
  11.         }  
    12. 
  
  
  
  12.         return this;  
    13. 
  
  
  
  13.     }  
    14. 
  
  
  
  14. private StringBuilder prepareBuilder() {  
    15. 
  
  
  
  15.         if (value != null) {  
    16. 
  
  
  
  16.             value.append(delimiter);  
    17. 
  
  
  
  17.         } else {  
    18. 
  
  
  
  18.             value = new StringBuilder().append(prefix);  
    19. 
  
  
  
  19.         }  
    20. 
  
  
  
  20.         return value;  
    21. 
  
  
  
  21.     } 
    22.

merge的思路是用当前的striingBuilder去append other的value（必须去掉前缀），源码注释中的merge 'this'问题是什么呢？prepareBuilder()的时候可能会先append(delimiter)，如果other就是this，那么length其实就多了一个delimiter，此时append还是得以添加前的length为准。

merge的实现方式决定了toString时不能直接value.append(suffix).toString(),因为 builder.append(other.value, other.prefix.length(), length);这行代码，默认加上suffix后这里的merge的length得减去suffix的length（嗯，看来作者是想得多好多），而且merge时得把另外一个sj的内容append到当前这个sj的suffix之前（想想就麻烦多了~）

  •  length 
 
 
 
    
  
  
  
  1. public int length() {  
    2. 
  
  
  
  2.         // Remember that we never actually append the suffix unless we return  
    3. 
  
  
  
  3.         // the full (present) value or some sub-string or length of it, so that  
    4. 
  
  
  
  4.         // we can add on more if we need to.  
    5. 
  
  
  
  5.         return (value != null ? value.length() + suffix.length() :  
    6. 
  
  
  
  6.             emptyValue.length());  
    7. 
  
  
  
  7.     } 
    8.

没什么好说的，记住length不只是add的元素的length，还有前后缀。

总结

  •  基于StringBuilder实现，add时就把prefix和分隔符给加上了，suffix永远都不加，知道toString和length调用时才加入计算。这样带来的merge操作实现的极大便利性！！！！！学到了，真的不错
  •  emptyValue这个一定要构造时就生成吗？用户想有自己的默认值还需要先构造实例再注入吗。这个觉得还是有点奇怪
  •  Objects这个工具方法是返回的校验的值本身，不错。 
 
 
 
    
  
  
  
  1. public StringJoiner setEmptyValue(CharSequence emptyValue) {  
    2. 
  
  
  
  2. // 注意这个Objects.requireNonNull方法是return的第一个参数。  
    3. 
  
  
  
  3.         this.emptyValue = Objects.requireNonNull(emptyValue,  
    4. 
  
  
  
  4.             "The empty value must not be null").toString();  
    5. 
  
  
  
  5.         return this;  
    6. 
  
  
  
  6. }  
    7.

当前标题：放弃StringBuilder！用Java8的StringJoiner
当前URL：http://www.shufengxianlan.com/qtweb/news38/399588.html

网站建设、网络推广公司-创新互联，是专注品牌与效果的网站制作，网络营销seo公司；服务项目有等

广告

声明：本网站发布的内容（图片、视频和文字）以用户投稿、用户转载内容为主，如果涉及侵权请尽快告知，我们将会在第一时间删除。文章观点不代表本网站立场，如需处理请联系客服。电话：028-86922220；邮箱：631063699@qq.com。内容未经允许不得转载，或转载时需注明来源： 创新互联

猜你还喜欢下面的内容

全网营销推广知识

各行业网站

正泰动物制药　　 　济桢教育　　 　雅安做网站　　 　成都二枢机房　　 　资阳网站建设　　 　宣威网站建设　　 　鸿程源茂　　 　移动服务器托管　　 　内江做网站　　 　绵阳服务器托管　　 　品牌网站建设　　 　ssl证书申请　　 　营销型网站建设　　 　护栏打桩机　　 　手机软件开发　　 　域名ssl证书　　 　免备案虚拟主机　　 　成都网站建设　　 　成都画册制作　　 　成都创新互联