1、字符串的处理
字符串的连接&拆分&匹配及常用操作
Joiner&Splitter
@Test
public void testJoiner() {
String[] strs = new String[]{"pan",null,"teng"};
//由于字符串中含有null 因此会抛出异常,需要调用以下方法
//Joiner joiner = Joiner.on("-").skipNulls(); //跳过 null
Joiner joiner = Joiner.on("-").useForNull("空"); //将null用“空” 替换
//joiner.skipNulls(); 这样调用是不行的，不会改变 joiner，需要将skipNulls 返回值赋给joiner才行
String joinStr = joiner.join(strs[0], strs[1], strs[2]);
System.out.println("joinStr = " + joinStr);
//joiner 还可以连接对象，这种情况下 会调用对象的toString方法，将对象转换为String
}
Joiner
/* CharMatcher 默认常量实现类:
* ANY: 匹配任何字符
* ASCII: 匹配是否是ASCII字符
* BREAKING_WHITESPACE: 匹配所有可换行的空白字符(不包括非换行空白字符,例如"\u00a0")
* DIGIT: 匹配ASCII数字
* INVISIBLE: 匹配所有看不见的字符
* JAVA_DIGIT: 匹配UNICODE数字, 使用 Character.isDigit() 实现
* JAVA_ISO_CONTROL: 匹配ISO控制字符, 使用 Charater.isISOControl() 实现
* JAVA_LETTER: 匹配字母, 使用 Charater.isLetter() 实现
* JAVA_LETTER_OR_DIGET: 匹配数字或字母
* JAVA_LOWER_CASE: 匹配小写
* JAVA_UPPER_CASE: 匹配大写
* NONE: 不匹配所有字符
* SINGLE_WIDTH: 匹配单字宽字符, 如中文字就是双字宽
* WHITESPACE: 匹配所有空白字符
*
* 常用操作方法:
* 修剪[trim]、折叠[collapse]、移除[remove]、保留[retain]
* CharMatcher is(char match): 返回匹配指定字符的Matcher
* CharMatcher isNot(char match): 返回不匹配指定字符的Matcher
* CharMatcher anyOf(CharSequence sequence): 返回匹配sequence中任意字符的Matcher
* CharMatcher noneOf(CharSequence sequence): 返回不匹配sequence中任何一个字符的Matcher
* CharMatcher inRange(char startInclusive, char endIncludesive): 返回匹配范围内任意字符的Matcher
* CharMatcher forPredicate(Predicate<? super Charater> predicate): 返回使用predicate的apply()判断匹配的Matcher
* CharMatcher negate(): 返回以当前Matcher判断规则相反的Matcher
* CharMatcher and(CharMatcher other): 返回与other匹配条件组合做与来判断的Matcher
* CharMatcher or(CharMatcher other): 返回与other匹配条件组合做或来判断的Matcher
* boolean matchesAnyOf(CharSequence sequence): 只要sequence中有任意字符能匹配Matcher,返回true
* boolean matchesAllOf(CharSequence sequence): sequence中所有字符都能匹配Matcher,返回true
* boolean matchesNoneOf(CharSequence sequence): sequence中所有字符都不能匹配Matcher,返回true
* int indexIn(CharSequence sequence): 返回sequence中匹配到的第一个字符的坐标
* int indexIn(CharSequence sequence, int start): 返回从start开始,在sequence中匹配到的第一个字符的坐标
* int lastIndexIn(CharSequence sequence): 返回sequence中最后一次匹配到的字符的坐标
* int countIn(CharSequence sequence): 返回sequence中匹配到的字符计数
* String removeFrom(CharSequence sequence): 删除sequence中匹配到到的字符并返回
* String retainFrom(CharSequence sequence): 保留sequence中匹配到的字符并返回
* String replaceFrom(CharSequence sequence, char replacement): 替换sequence中匹配到的字符并返回
* String trimFrom(CharSequence sequence): 删除首尾匹配到的字符并返回
* String trimLeadingFrom(CharSequence sequence): 删除首部匹配到的字符
* String trimTrailingFrom(CharSequence sequence): 删除尾部匹配到的字符
* String collapseFrom(CharSequence sequence, char replacement): 将匹配到的组(连续匹配的字符)替换成replacement
* String trimAndCollapseFrom(CharSequence sequence, char replacement): 先trim在replace
* */
匹配器及常用方法
@Test
public void testSplitter(){
String str = ",b,c,d,,f,";
//JDK会自动丢掉最后一个分隔符 且 中间的无论是什么，都作为一个元素 放到数组中
String[] strs = str.split(",");
for(String s:strs){
System.out.println("JDK-split:" + s + "-");
}
System.out.println("----------------------------");
//Guava 提供了更多的可供选择的模式
Iterable<String> iterable = Splitter.on(",")
.trimResults() //去除元素中的前导空格和后导空格
.omitEmptyStrings() //省略空字符串
.limit(3) //限制拆分元素的数量 前 n-1个正常拆分，最后的全部的作为1个元素,共拆出n个元素
.split(str);
Iterator<String> iterator = iterable.iterator();
while (iterator.hasNext()) {
System.out.print(iterator.next() + "-" );
System.out.println();
}
//正则表达式匹配拆分
System.out.println("--------------正则表达式--------------");
String patternStr = "abc12def34ffg78jip";
Iterable<String> iterable2 = Splitter.onPattern("[0-9]").split(patternStr);
Iterator<String> iterator2 = iterable2.iterator();
while (iterator2.hasNext()) {
System.out.print(iterator2.next() + "&" );
}
System.out.println();
System.out.println("----------------------------");
//拆分器返回List
ArrayList<String> list = Lists.newArrayList(
iterable);
System.out.println(list.get(0) + "-" + list.get(1));
//数字匹配器
String matchStr = "ab12c*(3de45你好jio：潘腾jA@#B6%7fC^&";
System.out.println("保留数字：" + CharMatcher.DIGIT.retainFrom(matchStr));//保留所有数字
System.out.println("去除数字：" + CharMatcher.DIGIT.removeFrom(matchStr));
System.out.println("数字替换：" + CharMatcher.DIGIT.replaceFrom(matchStr,"*"));
//大写字母匹配器
System.out.println("获取所有大写字母：" + CharMatcher.JAVA_UPPER_CASE.retainFrom(matchStr));
//单字节匹配器（汉字是双字节）
System.out.println("去除单字节，获取双字节：" + CharMatcher.SINGLE_WIDTH.removeFrom(matchStr));
拆分 + 匹配器示例程序
2、集合
不可变集合：优点-线程安全，不需要考虑变化，节省空间和时间，效率高
注意：不可变集合不允许有null对象
/**
* 测试不可变集合
* @method: testImmutableSet() -by fjt
* @TODO: void
*/
@Test
public void testImmutableSet(){
List<String> list = new ArrayList<String>(Arrays.asList("black","white","red","blue"));
Map<String, String> map = new TreeMap<>();
map.put("id", "20111907");
map.put("name", "panteng");
//创建的三种方式copyOf of Builder方法
//ImmutableList<String> finalList = ImmutableList.copyOf(list);
ImmutableList<String> finalList = ImmutableList.of("black","white","red","blue");//括号内写 list变量 会报错
try{
//finalList.add("yellow"); //抛出空指针异常
//finalList.remove(0); //抛出空指针异常
}catch(Exception ex){
System.out.println("List 异常信息：" + ex.getMessage());
} ImmutableMap<String, String> finalMap = ImmutableMap.copyOf(map);
try{
System.out.println(finalMap.get("name"));
finalMap.put("aa", "abcd"); //报异常
}catch(Exception ex){
System.out.println("Map 异常信息：" + ex.getMessage());
}
/** 不可变集合类型
* ImmutableCollection
* ImmutableList
* ImmutableSet
* ImmutableSortedSet
* ImmutableMap
* ImmutableSortedMap
* ImmutableMultiset
* ImmutableSortedMultiset
* ImmutableMultimap
* ImmutableListMultimap
* ImmutableSetMultimap
* ImmutableBiMap
* ImmutableClassToInstanceMap
* ImmutableTable
*/
}
不可变集合
可重复元素的集合，可以将元素看为key，value为出现次数，用于统计。
/**
* 1. 可以将MultiSet看成map, 作为计数器，key 为元素，值为计数器
* 2.
*/
@Test
public void testMultiSet(){
Multiset<String> multisets = HashMultiset.create();
String[] strArray = new String[]{"one","one","two","three"}; //添加元素
multisets.addAll(Arrays.asList(strArray));
multisets.add("four"); //添加指定个数的元素
multisets.add("five", 3);
//[two, five x 3, one x 2, three, four]
System.out.println("打印multiset：" + multisets);
//返回元素总个数
System.out.println("元素总个数：" + multisets.size()); //遍历
Iterator<String> iterator = multisets.iterator();
//two,five,five,five,one,one,three,four,
while(iterator.hasNext()){
System.out.print(iterator.next() + ",");
}
System.out.println();
Set<Entry<String>> entitySet = multisets.entrySet();//?????
System.out.println("???" + entitySet); //返回给定元素的个数
System.out.println("返回指定元素的重复次数：" + multisets.count("one")); //移除某元素的一个
multisets.remove("one");
System.out.println("移除后：" + multisets.count("one"));
//移除某元素的所有
multisets.setCount("one",0);
System.out.println("移除one所有后：" + multisets); //将不同元素放入一个Set
Set<String> uniqueSet = multisets.elementSet();
System.out.println("不同元素放入一个SET：" + uniqueSet); //设定一个元素的重复次数
multisets.setCount("three", 3);
System.out.println("打印multiset：" + multisets); }
可重复集合
MultiMap - 一个key可以对应多个值，可以认为是一个key对应一个集合，解决一对多的问题
@Test
/**
* ArrayListMultimap
HashMultimap
LinkedListMultimap*
LinkedHashMultimap**
TreeMultimap
ImmutableListMultimap
ImmutableSetMultimap
*/
public void testMultiMap(){
Multimap<String, String> mutimap = HashMultimap.create();
mutimap.put("father_a", "son_a1");
mutimap.put("father_a", "son_a2");
mutimap.put("father_a", "son_a3"); mutimap.put("father_b", "son_b1");
mutimap.put("father_b", "son_b2");
mutimap.put("father_b", "son_b3"); //{father_a=[son_a1, son_a3, son_a2], father_b=[son_b3, son_b2, son_b1]}
System.out.println("mutimap = " + mutimap); //整体添加
ArrayList<String> father_c = new ArrayList<String>();
father_c.add("son_C1");
father_c.add("son_C2");
mutimap.putAll("father_c", father_c); //获取某个key对应的元素
Collection<String> father_a = mutimap.get("father_c");
Iterator<String> iterator = father_a.iterator();
while (iterator.hasNext()) {
System.out.print(iterator.next() + ",");
}
System.out.println(); //获取键值
System.out.println("获取所有的键值：" + mutimap.keySet()); //
}
一对多
双向Map,即可以通过key获取value 也可以很容易的通过value获取key 实现一对一的关系；需要注意的是，必须保证值是唯一的
/**
* 实际上是调用反转方法 获取到一个新的Map
*/
@Test
public void testBiMap(){
Map<String, String> genMap = new HashMap<String, String>();
genMap.put("one", "1");
genMap.put("two", "2");
genMap.put("three", "3");
BiMap<String, String> twoDirectMap = HashBiMap.create();
twoDirectMap.putAll(genMap);
System.out.println("one = " + twoDirectMap.get("one"));
System.out.println("1 = " + twoDirectMap.get("1")); //获取反转Map
BiMap<String, String> twoDirectMap_mirror = twoDirectMap.inverse();
System.out.println("one = " + twoDirectMap_mirror.get("one"));
System.out.println("1 = " + twoDirectMap_mirror.get("1")); }
双向Map