0 提供功能有：
过滤器
函数
约束
集合的操作:交集、差集、并集
统计单词出现的次数--->分拣存储 Google版封装类写法
1 过滤器 函数使用案例：
/**
* Guava好处就是 将容器和业务解耦 。
* 函数式编程 :解耦
* 1、Predicate 断言
* 2、Function 函数
*
* 工具:Collections2.filter() 过滤器
* Collections2.transfer() 转换
* Functions.compose()组合式函数编程
* @author Administrator
*
*/
public class Demo02 {
/**
* @param args
*/
public static void main(String[] args) {
// 组合函数
//composeFun();
// Guava 过滤器
//filter();
// Guava 函数
functionApp();
}
private static void composeFun() {
//组合式函数编程
//确保容器中的字符串长度不超过5，超过进行截取，后全部大写
List<String> list =Lists.newArrayList("bjsxt","good","happiness");
//功能1：确保容器中的字符串长度不超过5，超过进行截取
Function<String,String> f1 =new Function<String,String>(){
@Override
public String apply(String input) {
return input.length()>5?input.substring(0,5):input;
}
};
//功能2：转成大写
Function<String,String> f2 =new Function<String,String>(){
@Override
public String apply(String input) {
return input.toUpperCase();
}
};
//String =f2(f1(String)) 组合上面定义的两个功能
Function<String,String> f =Functions.compose(f1, f2);
Collection<String> resultCol =Collections2.transform(list, f);
for(String temp:resultCol){
System.out.println(temp);
}
}
/**
* 函数 使用Guava Function 函数
* 转换
*/
public static void functionApp(){
//类型转换
Set<Long> timeSet =Sets.newHashSet();
timeSet.add(10000000L);
timeSet.add(99999999999L);
timeSet.add(333311L);
Collection<String> timeStrCol =Collections2.transform(timeSet, new Function<Long,String>(){
@Override
public String apply(Long input) {
Date date = new Date(input);
return new SimpleDateFormat("yyyy-MM-dd").format(date);
}});
for(String temp:timeStrCol){
System.out.println(temp);
}
}
/**
* 过滤器 使用Guava Predicate 断言
* 此案例中， 过滤数组中 字符串为回文的集合 并打印输出这些单词
* 结果：
* moom
dad
refer
*/
public static void filter(){
//创建List 静态初始化
List<String> list =Lists.newArrayList("moom","son","dad","bjsxt","refer");
//找出回文 palindrome backwords mirror words
// Predicate 表示断言的意思
//匿名内部类对象: 匿名内部类，同时创建类对象
Collection<String> palindromeList =Collections2.filter(list, new Predicate<String>(){
@Override
public boolean apply(String input) {
//业务逻辑
return new StringBuilder(input).reverse().toString().equals(input);
}
});
for(String temp:palindromeList){
System.out.println(temp);
}
}
}
2 约束条件使用案例：
/**
* 加入约束条件:非空、长度验证
* Constraint
* Preconditions
* Constraints
* @author Administrator
*
*/
public class Demo03 {
/**
* @param args
*/
public static void main(String[] args) {
Set<String> sets =Sets.newHashSet();
//创建约束
Constraint<String> constraint =new Constraint<String>(){
@Override
public String checkElement(String element) { // 如果不符合 则报错
//非空验证
Preconditions.checkNotNull(element);
//长度验证 5-20为字符串
Preconditions.checkArgument(element.length()>=5 && element.length()<=20);
return element;
}
};
// 给set集合加入约束条件，后返回含有约束条件的set集合
Set<String> cs =Constraints.constrainedSet(sets, constraint);
//cs.add(null); // 报错 --->java.lang.NullPointerException
cs.add("good"); // 报错 --->java.lang.IllegalArgumentException
cs.add("helloworld");
for(String str:cs){
System.out.println(str);
}
}
}
2 集合的操作:交集、差集、并集
/**
* 集合的操作:交集、差集、并集
* Sets.intersection()
* Sets.difference()
* Sets.union();
* @author Administrator
*
*/
public class Demo04 {
/**
* @param args
*/
public static void main(String[] args) {
Set<Integer> sets =Sets.newHashSet(1,2,3,4,5,6);
Set<Integer> sets2 =Sets.newHashSet(6,7,8,9);
//交集
/*System.out.println("交集为:");
SetView<Integer> intersection =Sets.intersection(sets, sets2);
for(Integer temp:intersection){
System.out.println(temp);
}*/
//差集 以第一个集合为基准，第一个集合中的所有元素减去和第二个集合中相同的那些元素，得到的第一个集合剩下的元素就是差集
System.out.println("差集为:");
SetView<Integer> diff =Sets.difference(sets, sets2);
for(Integer temp:diff){
System.out.println(temp);
}
/*//并集
System.out.println("并集为:");
SetView<Integer> union =Sets.union(sets, sets2);
for(Integer temp:union){
System.out.println(temp);
}*/
}
}
4 统计单词出现的次数1 分拣思想 HashMultiset的使用：
/**
* 统计单词出现的次数
* 1、HashMap 分拣存储+面向对象思维 -->判断
* 2、Multiset :无序+可重复 .count() 增强了可读性 +操作简单
* @author Administrator
*
*/
public class Demo05 {
/**
* mice-->1
that-->1
cat-->1
is-->3
food-->1
a-->2
the-->1
where-->1
this-->1
and-->1
*/
public static void main(String[] args) {
String str ="this is a cat and that is a mice where is the food";
//分割字符串
String[] strArray =str.split(" ");
//存储到Multiset中
Multiset<String> set =HashMultiset.create();
for(String strTemp:strArray){
set.add(strTemp);
}
//获取所有的单词 Set
Set<String> letters =set.elementSet();
for(String temp:letters){
System.out.println(temp+"-->"+set.count(temp));
}
}
}
5 分拣思想使用 ArrayListMultimap的使用
/**
* 分析查看 教师 教授的每门课程
* Multimap :key-value key可以重复
*
* 老江-->[三个代表]
老胡-->[科学发展观, 八荣八耻, 和谐社会]
邓爷爷-->[改革开放]
老习-->[....]
* @author Administrator
*
*/
public class Demo06 {
/**
* @param args
*/
public static void main(String[] args) {
Map<String,String> cours =new HashMap<String,String>();
//加入测试数据
cours.put("改革开放", "邓爷爷");
cours.put("三个代表", "老江");
cours.put("科学发展观", "老胡");
cours.put("和谐社会", "老胡");
cours.put("八荣八耻", "老胡");
cours.put("....", "老习");
//Multimap
Multimap<String,String> teachers =ArrayListMultimap.create();
//迭代器
Iterator<Map.Entry<String,String>> it =cours.entrySet().iterator();
while(it.hasNext()){
Map.Entry<String,String> entry =it.next();
String key =entry.getKey(); //课程
String value =entry.getValue(); //教师
//教师 -->课程
teachers.put(value, key);
}
//查看Multimap
Set<String> keyset =teachers.keySet();
for(String key:keyset){
Collection<String> col =teachers.get(key);
System.out.println(key+"-->"+col);
}
}
}
6 双key: