Splitter

版权声明：本文为博主原创文章，未经博主允许不得转载。 https://blog.csdn.net/u012410733/article/details/51584389

                                        <link rel="stylesheet" href="https://csdnimg.cn/release/phoenix/template/css/ck_htmledit_views-e2445db1a8.css">
                    <div class="htmledit_views">

Guava全文介绍地址:Google Guava

这次主要介绍是的是com.google.common.base.Splitter。我想做为一个程序员我们每天和String打交道的时候是会占很多时间的吧。字符串以一些分隔符标记分隔开也是我们工作中经常要遇到的问题。但是用Guava–Splitter，它会提取重叠子字符串的输入字符串,通常是通过识别表象的分隔符序列。这个分隔符可以指定单个字符,固定字符串,正则表达式或CharMatcher实例。或者,而不是使用一个分离器,分配器可以提取相邻给定固定长度的子字符串。

它的所有方法如下:

   
   
static Splitter fixedLength(int length)
返回一个splitter对象把目标字符串按字符长度分隔

Splitter limit(int limit)
返回一个splitter对象,但它停止分隔当它到达limit的时候。
Returns a splitter that behaves equivalently to this splitter but stops splitting after it reaches the limit.

Splitter omitEmptyStrings()
返回一个splitter对象,但是返回结果会删除空字符

static Splitter on(char separator)
返回一个splitter对象,通过给定的单个字符进行分隔

static Splitter on(CharMatcher separatorMatcher)
返回一个splitter对象,通过给定的CharMatcher进行分隔

static Splitter on(Pattern separatorPattern)
返回一个splitter对象,通过给定的Pattern进行分隔

static Splitter on(String separator)
返回一个splitter对象,通过给定的字符串进行分隔

static Splitter onPattern(String separatorPattern)
返回一个splitter对象,认为任何子序列匹配一个给定的模式(正则表达式)是一个分隔符。

Iterable <String> split(CharSequence sequence)
将序列分为字符串组件和使他们可以通过迭代器

List <String> splitToList(CharSequence sequence)
将序列分为字符串组件作为一个不可变的list

Splitter trimResults()
返回一个splitter对象，但是为移除返回list对象中每个对象前后的空白，相当于trimResults(CharMatcher.WHITESPACE)

Splitter trimResults(CharMatcher trimmer)
返回一个splitter对象，但是为移除返回list对象中每个对象前后与给定的CharMatcher对应的字符

Splitter.MapSplitter withKeyValueSeparator(char separator)
返回一个MapSplitterce,通过指定单个的cahr分解成entries，然后再通过entry中的特定字符分隔成key-value形式Map。是Join.withKeyValueSeparator()的逆运算

Splitter.MapSplitter withKeyValueSeparator(Splitter keyValueSplitter)
返回一个MapSplitterce,通过指定Splitter分解成entries，然后再通过entry中的特定字符分隔成key-value形式的Map。是Join.withKeyValueSeparator()的逆运算

Splitter.MapSplitter withKeyValueSeparator(String separator)
返回一个MapSplitterce,通过指定String分解成entries，然后再通过entry中的特定字符分隔成key-value形式的Map。是Join.withKeyValueSeparator()的逆运算
   
   

然后大家就可以对照下面的例子来理解这个类的用法了。

   
   
public class SplitterTest {


@Test
public void testSplitter() {
String startSring = "Washington D.C=Redskins#New York City=Giants#Philadelphia=Eagles#Dallas=Cowboys";
Map<String,String> testMap = Maps.newLinkedHashMap();
testMap.put( "Washington D.C", "Redskins");
testMap.put( "New York City", "Giants");
testMap.put( "Philadelphia", "Eagles");
testMap.put( "Dallas", "Cowboys");
Splitter.MapSplitter mapSplitter = Splitter.on( "#").withKeyValueSeparator( "=");
Map<String,String> splitMap = mapSplitter.split(startSring);
assertThat(testMap,is(splitMap));
}


@Test
public void testSplitPattern(){
String pattern = "\\d+";
String text = "foo123bar45678baz";
String[] expected = new String[]{ "foo", "bar", "baz"};
Iterable<String> values = Splitter.on(Pattern.compile(pattern)).split(text);
int index = 0;
for (String value : values) {
assertThat(value,is(expected[index++]));
}
}


@Test
public void testSplitStringPattern(){
String pattern = "\\d+";
String text = "foo123bar45678baz";
String[] expected = new String[]{ "foo", "bar", "baz"};
Iterable<String> values = Splitter.onPattern(pattern).split(text);
int index = 0;
for (String value : values) {
assertThat(value,is(expected[index++]));
}
}


@Test
public void testSplit(){
String delimiter = "&";
String text = "foo&bar&baz";
String[] expected = new String[]{ "foo", "bar", "baz"};
Iterable<String> values = Splitter.on(delimiter).split(text);
int index = 0;
for (String value : values) {
assertThat(value,is(expected[index++]));
}
}


@Test
public void testSplitTrimResults(){
String delimiter = "&";
String text = "foo & bar& baz ";
String[] expected = new String[]{ "foo", "bar", "baz"};
Iterable<String> values = Splitter.on(delimiter).trimResults().split(text);
int index = 0;
for (String value : values) {
assertThat(value,is(expected[index++]));
}
}


@Test
public void testSplitTrimResultsII(){
String delimiter = "&";
String text = "1foo&bar2&2baz3";
String[] expected = new String[]{ "foo", "bar", "baz"};
Iterable<String> values = Splitter.on(delimiter).trimResults(CharMatcher.JAVA_DIGIT).split(text);
int index = 0;
for (String value : values) {
assertThat(value,is(expected[index++]));
}
}


@Test
public void testSplitOnCharacter(){
char delimiter = '|';
String text = "foo|bar|baz";
String[] expected = new String[]{ "foo", "bar", "baz"};
Iterable<String> values = Splitter.on(delimiter).split(text);
int index = 0;
for (String value : values) {
assertThat(value,is(expected[index++]));
}
}


@Test
public void testSplitOnCharacterKeepMissing(){
char delimiter = '|';
String text = "foo|bar|||baz";
String[] expected = new String[]{ "foo", "bar", "", "", "baz"};
Iterable<String> values = Splitter.on(delimiter).split(text);
int index = 0;
for (String value : values) {
assertThat(value,is(expected[index++]));
}
}


@Test
public void testSplitOnCharacterOmitMissing(){
char delimiter = '|';
String text = "foo|bar|||baz";
String[] expected = new String[]{ "foo", "bar", "baz"};
Iterable<String> values = Splitter.on(delimiter).omitEmptyStrings().split(text);
int index = 0;
for (String value : values) {
assertThat(value,is(expected[index++]));
}
}
}
   
   

        </div>
            </div>

版权声明：本文为博主原创文章，未经博主允许不得转载。 https://blog.csdn.net/u012410733/article/details/51584389

                                        <link rel="stylesheet" href="https://csdnimg.cn/release/phoenix/template/css/ck_htmledit_views-e2445db1a8.css">
                    <div class="htmledit_views">

Guava全文介绍地址:Google Guava

这次主要介绍是的是com.google.common.base.Splitter。我想做为一个程序员我们每天和String打交道的时候是会占很多时间的吧。字符串以一些分隔符标记分隔开也是我们工作中经常要遇到的问题。但是用Guava–Splitter，它会提取重叠子字符串的输入字符串,通常是通过识别表象的分隔符序列。这个分隔符可以指定单个字符,固定字符串,正则表达式或CharMatcher实例。或者,而不是使用一个分离器,分配器可以提取相邻给定固定长度的子字符串。

它的所有方法如下:

 
 
static Splitter fixedLength(int length)
返回一个splitter对象把目标字符串按字符长度分隔

Splitter limit(int limit)
返回一个splitter对象,但它停止分隔当它到达limit的时候。
Returns a splitter that behaves equivalently to this splitter but stops splitting after it reaches the limit.

Splitter omitEmptyStrings()
返回一个splitter对象,但是返回结果会删除空字符

static Splitter on(char separator)
返回一个splitter对象,通过给定的单个字符进行分隔

static Splitter on(CharMatcher separatorMatcher)
返回一个splitter对象,通过给定的CharMatcher进行分隔

static Splitter on(Pattern separatorPattern)
返回一个splitter对象,通过给定的Pattern进行分隔

static Splitter on(String separator)
返回一个splitter对象,通过给定的字符串进行分隔

static Splitter onPattern(String separatorPattern)
返回一个splitter对象,认为任何子序列匹配一个给定的模式(正则表达式)是一个分隔符。

Iterable <String> split(CharSequence sequence)
将序列分为字符串组件和使他们可以通过迭代器

List <String> splitToList(CharSequence sequence)
将序列分为字符串组件作为一个不可变的list

Splitter trimResults()
返回一个splitter对象，但是为移除返回list对象中每个对象前后的空白，相当于trimResults(CharMatcher.WHITESPACE)

Splitter trimResults(CharMatcher trimmer)
返回一个splitter对象，但是为移除返回list对象中每个对象前后与给定的CharMatcher对应的字符

Splitter.MapSplitter withKeyValueSeparator(char separator)
返回一个MapSplitterce,通过指定单个的cahr分解成entries，然后再通过entry中的特定字符分隔成key-value形式Map。是Join.withKeyValueSeparator()的逆运算

Splitter.MapSplitter withKeyValueSeparator(Splitter keyValueSplitter)
返回一个MapSplitterce,通过指定Splitter分解成entries，然后再通过entry中的特定字符分隔成key-value形式的Map。是Join.withKeyValueSeparator()的逆运算

Splitter.MapSplitter withKeyValueSeparator(String separator)
返回一个MapSplitterce,通过指定String分解成entries，然后再通过entry中的特定字符分隔成key-value形式的Map。是Join.withKeyValueSeparator()的逆运算
 
 

然后大家就可以对照下面的例子来理解这个类的用法了。

 
 
public class SplitterTest {


@Test
public void testSplitter() {
String startSring = "Washington D.C=Redskins#New York City=Giants#Philadelphia=Eagles#Dallas=Cowboys";
Map<String,String> testMap = Maps.newLinkedHashMap();
testMap.put( "Washington D.C", "Redskins");
testMap.put( "New York City", "Giants");
testMap.put( "Philadelphia", "Eagles");
testMap.put( "Dallas", "Cowboys");
Splitter.MapSplitter mapSplitter = Splitter.on( "#").withKeyValueSeparator( "=");
Map<String,String> splitMap = mapSplitter.split(startSring);
assertThat(testMap,is(splitMap));
}


@Test
public void testSplitPattern(){
String pattern = "\\d+";
String text = "foo123bar45678baz";
String[] expected = new String[]{ "foo", "bar", "baz"};
Iterable<String> values = Splitter.on(Pattern.compile(pattern)).split(text);
int index = 0;
for (String value : values) {
assertThat(value,is(expected[index++]));
}
}


@Test
public void testSplitStringPattern(){
String pattern = "\\d+";
String text = "foo123bar45678baz";
String[] expected = new String[]{ "foo", "bar", "baz"};
Iterable<String> values = Splitter.onPattern(pattern).split(text);
int index = 0;
for (String value : values) {
assertThat(value,is(expected[index++]));
}
}


@Test
public void testSplit(){
String delimiter = "&";
String text = "foo&bar&baz";
String[] expected = new String[]{ "foo", "bar", "baz"};
Iterable<String> values = Splitter.on(delimiter).split(text);
int index = 0;
for (String value : values) {
assertThat(value,is(expected[index++]));
}
}


@Test
public void testSplitTrimResults(){
String delimiter = "&";
String text = "foo & bar& baz ";
String[] expected = new String[]{ "foo", "bar", "baz"};
Iterable<String> values = Splitter.on(delimiter).trimResults().split(text);
int index = 0;
for (String value : values) {
assertThat(value,is(expected[index++]));
}
}


@Test
public void testSplitTrimResultsII(){
String delimiter = "&";
String text = "1foo&bar2&2baz3";
String[] expected = new String[]{ "foo", "bar", "baz"};
Iterable<String> values = Splitter.on(delimiter).trimResults(CharMatcher.JAVA_DIGIT).split(text);
int index = 0;
for (String value : values) {
assertThat(value,is(expected[index++]));
}
}


@Test
public void testSplitOnCharacter(){
char delimiter = '|';
String text = "foo|bar|baz";
String[] expected = new String[]{ "foo", "bar", "baz"};
Iterable<String> values = Splitter.on(delimiter).split(text);
int index = 0;
for (String value : values) {
assertThat(value,is(expected[index++]));
}
}


@Test
public void testSplitOnCharacterKeepMissing(){
char delimiter = '|';
String text = "foo|bar|||baz";
String[] expected = new String[]{ "foo", "bar", "", "", "baz"};
Iterable<String> values = Splitter.on(delimiter).split(text);
int index = 0;
for (String value : values) {
assertThat(value,is(expected[index++]));
}
}


@Test
public void testSplitOnCharacterOmitMissing(){
char delimiter = '|';
String text = "foo|bar|||baz";
String[] expected = new String[]{ "foo", "bar", "baz"};
Iterable<String> values = Splitter.on(delimiter).omitEmptyStrings().split(text);
int index = 0;
for (String value : values) {
assertThat(value,is(expected[index++]));
}
}
}
 
 

        </div>
            </div>