基本用法

public static void main(String[] args) {
    Splitter splitter = Splitter.on(";");
    Iterable<String> iterable = splitter.split("1;2;3;4;5;6");
    System.out.println(iterable);
}

流程分析

1. 通过查看Splitter.split()的源代码发现其内部返回了个可迭代的对象，并没有立刻执行相应的计算，而是在需要的时候才会执行计算

public Iterable<String> split(final CharSequence sequence) {
    checkNotNull(sequence);
    return new Iterable<String>() {
      @Override
      public Iterator<String> iterator() {
        return splittingIterator(sequence);
       }
    };

2. 而splittingIterator实际上是调用strategy.iterator(this, sequence);

private Iterator<String> splittingIterator(CharSequence sequence) {
    return strategy.iterator(this, sequence);
  }

3. Strategy类的介绍
   这个类是进行字符、字符串、正则处理的接口，最终返回一个Iterator<String>，代表一个字符串被分割后的迭代器，实际使用了策略模式，不同的情况使用不同的策略来进行处理

private interface Strategy {
    Iterator<String> iterator(Splitter splitter, CharSequence toSplit);
  }

4. SplittingIterator类
   Strategy接口返回迭代器实际进行字符串切割的类，不同的Strategy返回不同的SplittingIterator的子类
   主要有两个抽象方法留给自类实现，分割执行的基本流程在AbstractIterator<String>中进行定义

private abstract static class SplittingIterator extends AbstractIterator<String> {
    // 这两个方法就是定位分隔符在字符串中的开始和结束位置，start为查找的起始位置，找到离start最近的一个便停止，根据start可以切分为多个
    abstract int separatorStart(int start);
    abstract int separatorEnd(int separatorPosition);
}

5. Splitter.on()分析
   里面返回的Strategy是一个匿名内部类，Strategy的iterator方法返回了一个匿名SplittingIterator类，实现了SplittingIterator的两个抽象方法，从这个代码里面可以很清楚的知道separatorStart和separatorEnd的意义

public static Splitter on(final String separator) {
    checkArgument(separator.length() != 0, "The separator may not be the empty string.");
    if (separator.length() == 1) {
      return Splitter.on(separator.charAt(0));
    }
    return new Splitter(
        new Strategy() {
          @Override
          public SplittingIterator iterator(Splitter splitter, CharSequence toSplit) {
            return new SplittingIterator(splitter, toSplit) {
              @Override
              public int separatorStart(int start) {
                int separatorLength = separator.length();

                positions:
                for (int p = start, last = toSplit.length() - separatorLength; p <= last; p++) {
                  for (int i = 0; i < separatorLength; i++) {
                    if (toSplit.charAt(i + p) != separator.charAt(i)) {
                      // 这里直接使用break也可以，但是会执行多一些的代码
                      continue positions;
                    }
                  }
                  return p;
                }
                return -1;
              }

              @Override
              public int separatorEnd(int separatorPosition) {
                return separatorPosition + separator.length();
              }
            };
          }
        });
  }

6. continue label说明

7. Splitter.onPattern()分析
定义了一个CommonPattern接口，默认的实现是JdkPattern，JdkPattern里面有一个JDK提供的Pattern类型的pattern变量，实际操作都是使用pattern变量进行的，也可以通过SPI的形式夹在自定义的外部实现类。代码如下点击去看下就知道大概的流程了

public static Splitter onPattern(String separatorPattern) {
return on(Platform.compilePattern(separatorPattern));
}

private static Splitter on(final CommonPattern separatorPattern) {
checkArgument(
!separatorPattern.matcher("").matches(),
"The pattern may not match the empty string: %s",
separatorPattern);

return new Splitter(
    new Strategy() {
      @Override
      public SplittingIterator iterator(final Splitter splitter, CharSequence toSplit) {
        final CommonMatcher matcher = separatorPattern.matcher(toSplit);
        return new SplittingIterator(splitter, toSplit) {
          @Override
          public int separatorStart(int start) {
            return matcher.find(start) ? matcher.start() : -1;
          }

          @Override
          public int separatorEnd(int separatorPosition) {
            return matcher.end();
          }
        };
      }
    });

}