java commons之函数式编程练习1_Predicate 位置判断

package commons之函数式编程1_Predicate_Transformer;

import java.util.ArrayList;
import java.util.List;

import org.apache.commons.collections4.Predicate;
import org.apache.commons.collections4.PredicateUtils;
import org.apache.commons.collections4.functors.EqualPredicate;
import org.apache.commons.collections4.functors.NotNullPredicate;
import org.apache.commons.collections4.functors.UniquePredicate;
import org.apache.commons.collections4.list.PredicatedList;

/**

• Commons-Collections:提供一个类包来扩展和增加标准的java;
• Collection框架,处理数据灵活
• 函数式编程之Predicate 位置判断也称断言
• 也可理解为封装条件或判别式:是if…else替代
• 1.内置的:相等判断 ;new EqualPredicate<泛型类型>(值);

•  	     或者 :(EqualPredicate<String>) EqualPredicate.equalPredicate(值);
  

• 2.非空: NotNullPredicate.INSTANCE

•    容器:PredicatedXxx.predicatedXxx(容器,判断)
  

• 3.唯一性:UniquePredicate.uniquePredicate()
• 4.自定义:new Predicate()+evaluate()重写方法

•  1):PredicatedXxx.predicatedXxx(容器,判断)
  

•  2):PredicateUtils.allPredicate(allPredicate可以传递2个以上的)
  

•  		andPredicate(只能传递2个相对于且),anyPredicate(只要其中一个为true就可以相当于或)
  

*/
public class Demo01 {

public static void main(String[] args) {
	equal();//equal相等
	notNull();//非空判断
	unique();//唯一性判断
	self();//自定义
}
//比较相等的判断)
public static void equal(){//equal相等
	System.out.println("======相等判断------");
	//使用多态;Predicate谓语;
	EqualPredicate<String> pre = new EqualPredicate<String>("bjsxt");
	//判断是否相等
	boolean fiag = pre.evaluate("bj");//evaluate评估,评价;返回值是boolean
	System.out.println(fiag);//结果false
	//或者用另一个方法;用内置方法创建对象
	EqualPredicate<String> pre1 = (EqualPredicate<String>) EqualPredicate.equalPredicate("bjsxt");
	//判断是否相等
	boolean fiag1 = pre1.evaluate("sx");//evaluate评估,评价;返回值是boolean
	System.out.println(fiag1);//结果false
	//List<String> immutableList = ImmutableList.of("a","b");
}
//非空判断
public static void notNull(){//nonNull非空
	System.out.println("======非空判断------");
	Predicate pd = NotNullPredicate.INSTANCE;//注意:导包一定要看准,否则就会出现报错;INSTANCE实例
	
	//或者另一个方法
	Predicate pde = NotNullPredicate.notNullPredicate();
	//测试
	String str = "bjs";
	String str2 = null;
	System.out.println(pd.evaluate(str));//如果非空为true否则为false
	System.out.println(pde.evaluate(str2));
	//添加容器值的判断;要借助一个工具PredicatedList
	List<Long> list = PredicatedList.predicatedList(new ArrayList<Long>(),pd);//PredicatedList建立列表(一个工具)
	//放入数据
	list.add(1000L);
	//如果是空数据
	//list.add(null);//测试失败,报错异常
	for(Long b:list){
		System.out.println(b);	
	}
	
}
//判断唯一性
public static void unique(){
	System.out.println("======唯一性判断------");
	Predicate<Long> uniquePre = UniquePredicate.uniquePredicate();
	//添加容器值的判断;要借助一个工具PredicatedList
	List<Long> list = PredicatedList.predicatedList(new ArrayList<Long>(),uniquePre);//PredicatedList建立列表(一个工具)
	//放入数据
	list.add(2000L);
	list.add(3000L);
	//如果重复加入
	//list.add(2000L);//报错异常;不能重复添加
	for(Long c:list){
		System.out.println(c);	
	}
	
}
//自定义
public static void self(){
	System.out.println("======自定义判断------");
	//判断长度5-20位
	Predicate<String> selfPre = new Predicate<String>() {//创建匿名内部类
		//重写evaluate()方法
		@Override
		public boolean evaluate(String object) {//别忘改成object
			
			return object.length()>=5 && object.length()<=20;
		}
	};
	//判断非空
	Predicate pde = NotNullPredicate.notNullPredicate();
	//借用工具;PredicateUtils.allPredicate ;Predicate all返回值
	Predicate all = PredicateUtils.allPredicate(selfPre,pde);//选择predicates 复数,多个;然后换成(selfPre,pde)即不断往容器里面丢数据
	//放进容器
	List<String> list = PredicatedList.predicatedList(new ArrayList<String>(),all);
	//测试
	list.add("abcdex");//必须>=5,<=20;否则就会报异常
	for(String a :list){
		System.out.println(a.length());	
	}
}

}
//结果----------------------------------------------
======相等判断------
false
false
======非空判断------
true
false
1000
======唯一性判断------
2000
3000
======自定义判断------
6