Guava字符串处理Joiner源码分析

最新推荐文章于 2023-12-25 15:44:55 发布
最新推荐文章于 2023-12-25 15:44:55 发布
阅读量1.7k 收藏 2
点赞数
分类专栏： Guava
本文链接：https://blog.csdn.net/u012881904/article/details/69653599
版权

Joiner的使用以及实现原理

作用

  1. 和并字符串的作用，还可以去掉null的值哦
  2. Joining together a sequence of strings with a separator can be unnecessarily tricky – but it shouldn’t be. If your sequence contains nulls, it can be even harder.(连接字符串，但是去掉Null有点麻烦哦)

例子

简单的使用

   /**
     * @method： skipNulls
     * @means: 去调为Null的连接
     */
    Joiner joiner = Joiner.on("; ").skipNulls();
    String joinStr = joiner.join("Harry", null, "Ron", "Hermione");
    //return info:Harry; Ron; Hermione
    System.out.println(joinStr);

    String listStr =Joiner.on(",").join(Arrays.asList(1, 5, 7));
    //return info:"1,5,7"
    System.out.println(listStr);

构造函数

public static Joiner on(String separator) {
    return new Joiner(separator);
}

on:以什么为分隔符

Joiner joiner = Joiner.on("; ")

join加入各种数据类型

  • 连接字符的方式很多，可以是数组，可以是实现了Iterable接口或者Iterator接口
    数组->List 
public final String join(Object[] parts) {
    return join(Arrays.asList(parts));
  }

数组——>list(Iterable 实现了的)

public final String join(@Nullable Object first, @Nullable Object second, Object... rest) {
    //iterable转换为List数组，但是没有进行空间的复制
    return join(iterable(first, second, rest));
  }

//这个是继承JDK的抽象List新创建一个list匿名类，没有进行数据复制操作！
private static Iterable<Object> iterable(
      final Object first, final Object second, final Object[] rest) {
    checkNotNull(rest);
    return new AbstractList<Object>() {
      @Override
      public int size() {
        return rest.length + 2;
      }
      @Override
      public Object get(int index) {
        switch (index) {
          case 0:
            return first;
          case 1:
            return second;
          default:
            return rest[index - 2];
        }
      }
    };

List->Iterable接口(可以forEach…)

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

Iterable调用->Iterator接口(Iterator是Iterable接口的一个成员变量)

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

然后调用appendTo成员变量进行处理。
之前的处理的都是为了各种类型的数据而进行的构造相互之间调用，和设置分隔符on方法
private final String separator，这个是唯一的一个成员变量的信息。appendTo方法处理将所有的字符串按照给定的格式进行处理。append也是一样的有各种类型的append方法将各种类型的数据进行转换，因为这个要被子类进行覆盖处理哦，这样就可以不要Null的或者处理map等等。

appendTo

  • 字段类型的可变参数
public final StringBuilder appendTo(
      StringBuilder builder, @Nullable Object first, @Nullable Object second, Object... rest) {
    return appendTo(builder, iterable(first, second, rest));
  }
  • 可以forEach的集合,实现了Iterable接口信息
public final StringBuilder appendTo(StringBuilder builder, Iterable<?> parts) {
    return appendTo(builder, parts.iterator());
  }
  • 迭代器接口.Stringbuffer是Appendable的实现类 
public final StringBuilder appendTo(StringBuilder builder, Iterator<?> parts) {
    try {
      appendTo((Appendable) builder, parts);
    } catch (IOException impossible) {
      throw new AssertionError(impossible);
    }
    return builder;
  }
  • 最终处理的信息哦，这里被覆盖了就可以随便的操作要不要null,看到这里有处理分隔符，有遍历Iterator的集合的信息哦。这里就是最远上的处理
public <A extends Appendable> A appendTo(A appendable, Iterator<?> parts) throws IOException {
    checkNotNull(appendable);
    if (parts.hasNext()) {
      appendable.append(toString(parts.next()));
      while (parts.hasNext()) {
        appendable.append(separator);
        appendable.append(toString(parts.next()));
      }
    }
    return appendable;
  }
//不能为null
CharSequence toString(Object part) {
    checkNotNull(part); // checkNotNull for GWT (do not optimize).
    return (part instanceof CharSequence) ? (CharSequence) part : part.toString();
  }

各种继承的Joniner，处理原始的全部处理的Joiner之外还有三种Jonier

匿名类好像Guava非常喜欢使用这个东西，特别是在方法之中使用这个玩意

 private Joiner(Joiner prototype) {
    this.separator = prototype.separator;
  }

public Joiner skipNulls();实现匿名类返回覆盖父类的方法，过滤掉为Null的

public Joiner skipNulls() {
    return new Joiner(this) {
      @Override
      //覆盖最后的一个实现，其他都一样的！
      public <A extends Appendable> A appendTo(A appendable, Iterator< ?> parts) throws IOException {
        checkNotNull(appendable, "appendable");
        checkNotNull(parts, "parts");
        //两次遍历的意义就是，找到第一个null之后再去添加分隔符
        while (parts.hasNext()) {
          Object part = parts.next();
          if (part != null) {
            appendable.append(Joiner.this.toString(part));
            break;
          }
        }
        while (parts.hasNext()) {
          Object part = parts.next();
          if (part != null) {
            appendable.append(separator);
            appendable.append(Joiner.this.toString(part));
          }
        }
        return appendable;
      }
      //返回一种类型的Joiner不能再使用第二种类型的了
      @Override
      public Joiner useForNull(String nullText) {
        throw new UnsupportedOperationException("already specified skipNulls");
      }

      @Override
      public MapJoiner withKeyValueSeparator(String kvs) {
        throw new UnsupportedOperationException("can't use .skipNulls() with maps");
      }
    };
  }

public Joiner useForNull(final String nullText) 将为null的值替换为当前值

这个其实就是覆盖toString哈哈，使用一种之后能在使用其他的了

public Joiner useForNull(final String nullText) {
    checkNotNull(nullText);
    return new Joiner(this) {
      @Override
      CharSequence toString(@Nullable Object part) {
        return (part == null) ? nullText : Joiner.this.toString(part);
      }
      @Override
      public Joiner useForNull(String nullText) {
        throw new UnsupportedOperationException("already specified useForNull");
      }

      @Override
      public Joiner skipNulls() {
        throw new UnsupportedOperationException("already specified useForNull");
      }
    };
  }

最后一种是处理map中的数据MapJoiner

例子:这个我们估计经常会使用这种的样子的字符串
name=doctor,sex=man这种数据估计可以经常看到吧！

    Map<String, String> map = Maps.newLinkedHashMap();
    map.put("name", "doctor");
    map.put("sex", "man");
    /**
     * @method： withKeyValueSeparator
     * @means:  将key使用什么分割
     * date: 2017/4/7
     * author: wangji
     */
    String join = Joiner.on(",").withKeyValueSeparator("=").join(map);
    //return info: name=doctor,sex=man
    System.out.println(join);

MapJoiner没有进行继承，而是使用了组合模式,因为加入数据的方式变化了，不会可能是List之类的数据只能是Entry数组，或者Map接口，所以join变化了，但是append几乎还是以前的数据信息，进行简单的变化，处理数据的时候使用代理使用原来的那个joiner的方法，比如这里还可以将Null的值替换呢，就是使用了joiner.useForNull(nullText)

public static final class MapJoiner {
    private final Joiner joiner;
    private final String keyValueSeparator;

    private MapJoiner(Joiner joiner, String keyValueSeparator) {
      this.joiner = joiner; // only "this" is ever passed, so don't checkNotNull
      this.keyValueSeparator = checkNotNull(keyValueSeparator);
    }

    public <A extends Appendable> A appendTo(A appendable, Map<?, ?> map) throws IOException {
      return appendTo(appendable, map.entrySet());
    }

    public StringBuilder appendTo(StringBuilder builder, Map<?, ?> map) {
      return appendTo(builder, map.entrySet());
    }

    public String join(Map<?, ?> map) {
      return join(map.entrySet());
    }

    public <A extends Appendable> A appendTo(A appendable, Iterable<? extends Entry<?, ?>> entries)
        throws IOException {
      return appendTo(appendable, entries.iterator());
    }

    public <A extends Appendable> A appendTo(A appendable, Iterator<? extends Entry<?, ?>> parts)
        throws IOException {
      checkNotNull(appendable);
      if (parts.hasNext()) {
        Entry<?, ?> entry = parts.next();
        //这里处理了两个分割符，一个来自外围的代理，一个是map的key的分割。
        appendable.append(joiner.toString(entry.getKey()));
        appendable.append(keyValueSeparator);
        appendable.append(joiner.toString(entry.getValue()));
        while (parts.hasNext()) {
          appendable.append(joiner.separator);
          Entry<?, ?> e = parts.next();
          appendable.append(joiner.toString(e.getKey()));
          appendable.append(keyValueSeparator);
          appendable.append(joiner.toString(e.getValue()));
        }
      }
      return appendable;
    }
    public StringBuilder appendTo(StringBuilder builder, Iterator<? extends Entry<?, ?>> entries) {
      try {
        appendTo((Appendable) builder, entries);
      } catch (IOException impossible) {
        throw new AssertionError(impossible);
      }
      return builder;
    }

    public String join(Iterable<? extends Entry<?, ?>> entries) {
      return join(entries.iterator());
    }

    public String join(Iterator<? extends Entry<?, ?>> entries) {
      return appendTo(new StringBuilder(), entries).toString();
    }
    //将NULL的值进行替换掉处理！
    public MapJoiner useForNull(String nullText) {
      return new MapJoiner(joiner.useForNull(nullText), keyValueSeparator);
    }
  }
汪小哥
关注
专栏目录
Java工具库Guava字符串处理:分割、连接、填充的使用示例
BADAO_LIUMANG_QIZHI的博客
11-22 1771
在上面入门Guava的使用之后，学习其对字符串处理的相关方法的示例。
Guava字符串的处理
诺浅的专栏
04-27 535
对集合的处理 List<String> list =new ArrayList<String>(); list.add("xx"); list.add("zz"); list.add("dd"); System.out.println(Joiner.on(",").join(list)); //xx,zz,dd 可以操作迭代器 Iterator<String&gt...
Guava源码解析四：Joiner源码解析
dancheng1的博客
12-05 867
将字符串数组按指定分隔符连接起来，或字符串串按指定索引开始使用指定分隔符连接起来 变量 //分割符 private final String separator;   构造方法 两个构造函数都是静态构造器，所以不能直接使用这两个构造器去创建Joiner，所以想要创建Joiner只能使用静态方法。 可接收字符串和字符，字符串可以为空，字符不可为空字符 private Joiner(...
guava源码阅读之Joiner
w535921917的博客
12-09 181
建议：简单看下appendTo即可  Joiner 主要用来将字符串或者字符串数组、列表之类的东西，拼接成一个以指定符号分隔各个元素的字符串，比如把 [a, b, c] 拼接成 “a b c”。 举个栗子： String str1[] = {"a", "b", "c", "d"}; String str2[] = {"a", "b", "c", "d&
Guava-Joiner类
xuaomo的博客
01-25 788
引入 String字符串代码中出现的频率是相当高的，涉及字符串的知识点也是很多很多，比如String、StringBuilder、StringBuffer三者的区别，性能的比较，是否线程安全等等。  用分隔符把字符串序列连接起来也可能会遇上不必要的麻烦。如果字符串序列中含有null，那连接操作会更难。Fluent风格的Joiner让连接字符串更简单。 方法
输出数组中的字符串
weixin_44981329的博客
04-13 1536
之前输出数组中的字符串，要不直接System.out.println(list.toString()); 要不就是for循环数组，先后截取掉中括号和尾部的逗号。既繁琐代码也不美观。 现推荐几种输出方式。 System.out.println(Joiner.on(",").join(list))； 可以直直接输出字符串。但是有个问题。如果数组中有Null ，那么会报空指针。 针对这种情况， ...
Guava-字符串工具
hefrankeleyn的博客
07-27 418
Guava字符串工具：Joiner、Splitter、CharMatcher、Charsets、Strings
基于Guava的字符串操作
ZZY1078689276的专栏
03-03 5563
Guava 字符串拼接 字符串分割 字符串查找 字符串变换 Guava   在编程中，我们可能会经常操作字符串，为了简便起见，Guava中为我们封装了若干的简单操作方法，下面我就是以实用为目的，简单的介绍一下字符串的拼接、分割、查找与变换。 字符串拼接   字符串的拼接采用的是Guava中的Joiner类中的方法，用法如下： @Test publi...
Guava - 字符串格式转化
⚡
03-27 566
Guava - 字符串格式转化 依赖 测试用例 一：依赖 <dependency> <groupId>com.google.guava</groupId> <artifactId>guava</artifactId> <version>30.1-jre</version> </dependency> 二：测试用例 import com.google.common.base.Case
Guava的Joiner的日常使用
最新发布
飞鸟快快的专栏
12-25 980
日常使用，Joiner注意参数为null的时候 记得skipNull或者useForNUll
SQL导入错误的（0）NULL缺省NULL解决方案
瑰的博客
09-30 7153
    错误 #1064 - You have an error in your SQL syntax; check the manual that corresponds to your MySQL server version for the right syntax to use near '(0) NULL DEFAULT NULL, `update_date` datetim...
guava编程
can_chen的博客
11-28 647
文章目录JoinerSplitterListsMapsIntsMultiSetMultiMap不可变集合 Joiner Joiner的作用是：把集合（或数组或可变参数）通过指定的分隔符连接成字符串 1.传统的方法实现（代码量多，还需要考虑第一个元素的特殊情况） public static void main(String[] args) { List<Integer> list = new ArrayList<>(); list.add(1); list.ad
Joiner拼接String
black_的博客
06-05 895
传统拼接模式：需要去掉最后的一个符号。 @Test public void test6() { List<String> list = new ArrayList<String>(); list.add("kobe"); list.add("james"); list.add("paul"); StringBuilder builder = ne...
关于字符串拼接效率比较
蜗牛敲代码的博客
06-08 2100
1.效率最差：使用+符号拼接 2.效率较好：concat 3.效率好：join拼接和StringBuffer性能差不多，略高。 4.最好的：StringBuilder是最好的 StringBuilder sb=new StringBuilder(); for (int i =0;i<100;i++){ sb=sb.appe...
Guava 工具类之joiner的使用
weixin_30642029的博客
08-04 245
　　joiner主要用于对字符串的连接，也可用于对map中key value的连接 public class JoinerTest { private static final List<String> list1 = Arrays.asList ("google","guava","java","sc...
guava翻译系列之Joiner
weixin_33888907的博客
02-27 142
基本的guava工具 在前面的章节，我们已经讨论了什么是GUAVA和怎样去安装GUAVA，在这一章我们将开始使用guava，我们将展示guava提供的基本功能，并且了解一下这些基本功能是怎样帮助我们简化日常工作遇到的的问题在这一章节中，我们将覆盖一下几个方面的内容: 使用Joiner Class 将字符串以指定的分隔符连接起来。 我们也会涉及到使用Ma...
Guava库之字符串操作
achang07的博客
02-08 2978
Guava是google推出的一个类库，包含了很多个模块，今天先学习一下其中字符串处理相关的工具类。 通过Maven将Guava的jar包获取到本地，同时获取到其源码和doc文档，将doc文档解压打开后对该类库有一个大概的了解。 字符串相关的处理基本都在com.google.common.base包下，而其中与字符串处理相关的类包含如下几个： Strings Strings类提供了一些...
Guava中Splitter和Joiner的用法
Learning
06-14 4352
字符串的分隔和连接是一个常用的操作.Guava提供了Spliiter和Joiner来帮助我们简化开发。 Splitter的用法基本用法测试代码public static void main(String[] args) { String str = "a,b, c,,d"; Iterable<String> result = Splitter.on(',')/
Guava系列：Joiner的使用方法（数组或集合拼接字符串）&实现原理源码
NIO4444
01-31 2113
场景 指定数组或list等集合元素拼接成String，并可以指定null对象默认值、指定拼接字符。 demo package com.nio4444.demo; import com.google.common.base.Joiner; import java.util.ArrayList; import java.util.List; public class guava { public static void main(String[] args) { ...
Guava基础工具：Joiner与MapJoiner实战应用
通过这篇文章，读者可以了解到Guava提供的高效且易于使用的工具，尤其是在处理字符串操作和Map数据结构时，它们简化了代码编写，提高了开发效率。学习和掌握这些工具，有助于在实际项目中更有效地利用Guava的强大...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值