版权声明:本文为博主原创文章,未经博主允许不得转载。 https://blog.csdn.net/qq_21122243/article/details/77101104
Predicate
- Test01_Predicate.java
package commons.collection;
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;
/**
* 函数式编程之 Predicate(断言)
* --封装条件或判别式 if..else 替代
* 1.比较相等判断
* new EqualPredicate<类型>(值)
* EqualPredicate.equalPredicate(值);
* 2.判断非空
* NotNullPredicate.INSTANCE
* 3.判断唯一
* UniquePredicate.uniquePredicate()
* 4.自定义
* new Predicate() + evaluate
* PredicateUtils.allPredicate(pre1,pre2...) andPredicate anyPredicate
* PredicatedXxx.predicatedXxx(容器,predicate)
*/
public class Test01_Predicate {
public static void main(String[] args) {
//equalPredicate();
//notNullPredicate();
//uniquePredicate();
//defined();
}
/**
* 1.比较相等判断-EqualPredicate
*/
public static void equalPredicate(){
System.out.println("======相等判断======");
//Predicate<String> pre =new EqualPredicate<String>("bjsxt");
Predicate<String> pre =EqualPredicate.equalPredicate("bjsxt");
boolean flag =pre.evaluate("bj");
System.out.println(flag);
}
/**
* 2.判断非空-NotNullPredicate
*/
public static void notNullPredicate(){
System.out.println("====非空判断====");
//Predicate notNull=NotNullPredicate.INSTANCE;
Predicate<Object> notNull=NotNullPredicate.notNullPredicate();
//String str ="bjs";
String str =null;
System.out.println(notNull.evaluate(str)); //如果非空为true ,否则为false
//添加容器值的判断
List<Long> list =PredicatedList.predicatedList(new ArrayList<Long>(), notNull);
list.add(1000L);
list.add(null); //验证失败,出现异常
}
/**
* 3.判断唯一-UniquePredicate
*/
public static void uniquePredicate(){
System.out.println("====唯一性判断====");
Predicate<Long> uniquePre =UniquePredicate.uniquePredicate();
List<Long> list =PredicatedList.predicatedList(new ArrayList<Long>(), uniquePre);
list.add(100L);
list.add(200L);
list.add(100L); //出现重复值,抛出异常
}
/**
* 4.自定义判断-new Predicate() + evaluate
*/
public static void defined(){
System.out.println("======自定义判断======");
//自定义的判别式
Predicate<String> selfPre =new Predicate<String>(){
@Override
public boolean evaluate(String object) {
return object.length()>=5 && object.length()<=20;
}};
Predicate<String> notNull=NotNullPredicate.notNullPredicate();
@SuppressWarnings("unchecked")
Predicate<String> all =PredicateUtils.allPredicate(notNull,selfPre);
List<String> list =PredicatedList.predicatedList(new ArrayList<String>(),all);
list.add("bjsxt");
list.add(null);
list.add("bj");
}
}
Transformer
- Employee.java
package commons.collection;
/**
* 员工类
*/
public class Employee {
private String name;
private double salary;
//alt +/
public Employee() {
}
//alt+shift+s o
public Employee(String name, double salary) {
super();
this.name = name;
this.salary = salary;
}
//alt+shift+s +r tab 回车 shift+tab 回车
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public double getSalary() {
return salary;
}
public void setSalary(double salary) {
this.salary = salary;
}
@Override
public String toString() {
return "(码农:"+this.name+",敲砖钱:"+this.salary+")";
}
}
- Level.java
package commons.collection;
/**
* 等级类
*/
public class Level {
private String name;
private String level;
public Level() {
}
public Level(String name, String level) {
super();
this.name = name;
this.level = level;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public String getLevel() {
return level;
}
public void setLevel(String level) {
this.level = level;
}
@Override
public String toString() {
return "(码农:"+this.name+",水平:"+this.level+")";
}
}
- Test02_Transformer.java
package commons.collection;
import java.text.SimpleDateFormat;
import java.util.ArrayList;
import java.util.Collection;
import java.util.Iterator;
import java.util.List;
import org.apache.commons.collections4.CollectionUtils;
import org.apache.commons.collections4.Predicate;
import org.apache.commons.collections4.Transformer;
import org.apache.commons.collections4.functors.SwitchTransformer;
/**解耦,业务处理与判断进行分类
* 函数式编程之Transformer(类型转化)
* Transformer<I, O> transformer=new Transformer<I, O>() {
@Override
public O transform(I input) {
return null;
}
};
* 1.内置类型的转换
* new Transformer() +transform
* CollectionUtils.collect(容器,转换器)
* 2.自定义类型转换
* SwitchTransformer
* CollectionUtils.collect(容器,转换器)
*/
public class Test02_Transformer {
public static void main(String[] args) {
innerTransformer();//内置类型转换
definedTransformer();//自定义类型转换
}
/**
* 1.内置类型的转换-new Transformer() +transform
*/
public static void innerTransformer(){
System.out.println("===内置类型转换 长整型时间日期,转成指定格式的字符串==");
//类型转换器
Transformer<Long,String> trans =new Transformer<Long,String>(){
@Override
public String transform(Long input) {
return new SimpleDateFormat("yyyy年MM月dd日").format(input);
}};
//容器
List<Long> list =new ArrayList<Long>();
list.add(999999999999L);
list.add(300000000L);
//工具类 程序猿出钱---开发商---农民工出力
Collection<String> result=CollectionUtils.collect(list, trans);
//遍历查看结果
for(String time:result){
System.out.println(time);
}
}
/**
* 2.自定义类型转换-SwitchTransformer
*/
public static void definedTransformer(){
System.out.println("===自定义类型转换==");
//判别式
Predicate<Employee> isLow=new Predicate<Employee>(){
@Override
public boolean evaluate(Employee emp) {
return emp.getSalary()<10000;
}
};
Predicate<Employee> isHigh=new Predicate<Employee>(){
@Override
public boolean evaluate(Employee emp) {
return emp.getSalary()>=10000;
}
};
@SuppressWarnings("rawtypes")
Predicate[] pres ={isLow,isHigh};
//转换
Transformer<Employee,Level> lowTrans =new Transformer<Employee,Level>(){
@Override
public Level transform(Employee input) {
return new Level(input.getName(),"卖身中");
}};
Transformer<Employee,Level> highTrans =new Transformer<Employee,Level>(){
@Override
public Level transform(Employee input) {
return new Level(input.getName(),"养身中");
}};
@SuppressWarnings("rawtypes")
Transformer[] trans ={lowTrans,highTrans};
//二者进行了关联
@SuppressWarnings("unchecked")
Transformer<Employee, Level> switchTrans =new SwitchTransformer<Employee, Level>(pres, trans, null);
//容器
List<Employee> list =new ArrayList<Employee>();
list.add(new Employee("老马",1000000));
list.add(new Employee("老裴",999));
Collection<Level> levelList = CollectionUtils.collect(list,switchTrans);
//遍历容器
Iterator<Level> levelIt =levelList.iterator();
while(levelIt.hasNext()){
System.out.println(levelIt.next());
}
}
}
Closure
- Employee.java
package commons.collection;
/**
* 员工类
*/
public class Employee {
private String name;
private double salary;
//alt +/
public Employee() {
}
//alt+shift+s o
public Employee(String name, double salary) {
super();
this.name = name;
this.salary = salary;
}
//alt+shift+s +r tab 回车 shift+tab 回车
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public double getSalary() {
return salary;
}
public void setSalary(double salary) {
this.salary = salary;
}
@Override
public String toString() {
return "(码农:"+this.name+",敲砖钱:"+this.salary+")";
}
}
- Goods.java
package commons.collection;
public class Goods {
private String name;
private double price;
//折扣
private boolean discount;
public Goods() {
// TODO Auto-generated constructor stub
}
public Goods(String name, double price, boolean discount) {
super();
this.name = name;
this.price = price;
this.discount = discount;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public double getPrice() {
return price;
}
public void setPrice(double price) {
this.price = price;
}
public boolean isDiscount() {
return discount;
}
public void setDiscount(boolean discount) {
this.discount = discount;
}
@Override
public String toString() {
return "(商品:"+this.name+",价格:"+this.price+",是否打折:"+(discount?"是":"否")+")";
}
}
- Test03_Closure.java
package commons.collection;
import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;
import org.apache.commons.collections4.Closure;
import org.apache.commons.collections4.CollectionUtils;
import org.apache.commons.collections4.Predicate;
import org.apache.commons.collections4.functors.ChainedClosure;
import org.apache.commons.collections4.functors.IfClosure;
import org.apache.commons.collections4.functors.WhileClosure;
/**
* 函数式编程之Closure(闭包 封装特定的业务功能)
* 1.基本操作
* Closure
* 2.IfClosure
* IfClosure.ifClosure(断言,功能1,功能2)
* 3.WhileClosure
* WhileClosure.whileClosure(断言,功能,标识)
* 4.ChainedClosure.chainedClosure(功能列表);
* CollectionUtils.forAllDo(容器,功能类对象);
*/
public class Test03_Closure {
public static void main(String[] args) {
//basic();
//ifClosure();
//whileClosure();
//chainClosure();
}
/**
* 1.基本操作-Closure
*/
@SuppressWarnings("deprecation")
public static void basic(){
//数据
List<Employee> empList =new ArrayList<Employee>();
empList.add(new Employee("bjsxt",20000));
empList.add(new Employee("is",10000));
empList.add(new Employee("good",5000));
//业务功能
Closure<Employee> closure=new Closure<Employee>(){
public void execute(Employee emp) {
emp.setSalary(emp.getSalary()*1.2);
}};
//工具类
CollectionUtils.forAllDo(empList, closure) ;
//操作后的数据
Iterator<Employee> empIt=empList.iterator();
while(empIt.hasNext()){
System.out.println(empIt.next());
}
}
/**
* 2.二选一 如果是打折商品,进行9折,否则满百减20
* IfClosure
*/
@SuppressWarnings("deprecation")
public static void ifClosure(){
List<Goods> goodsList =new ArrayList<Goods>();
goodsList.add(new Goods("javase视频",120,true));
goodsList.add(new Goods("javaee视频",100,false));
goodsList.add(new Goods("高新技术视频",80,false));
//满百减20
Closure<Goods> subtract=new Closure<Goods>(){
public void execute(Goods goods) {
if(goods.getPrice()>=100){
goods.setPrice(goods.getPrice()-20);
}
}};
//打折
Closure<Goods> discount=new Closure<Goods>(){
public void execute(Goods goods) {
if(goods.isDiscount()){
goods.setPrice(goods.getPrice()*0.9);
}
}};
//判断
Predicate<Goods> pre=new Predicate<Goods>(){
public boolean evaluate(Goods goods) {
return goods.isDiscount();
}};
//二选一
Closure<Goods> ifClosure=IfClosure.ifClosure(pre, discount,subtract);
//关联
CollectionUtils.forAllDo(goodsList,ifClosure);
//查看操作后的数据
for(Goods temp:goodsList){
System.out.println(temp);
}
}
/**
* 3.确保所有的员工工资都大于10000,如果已经超过的不再上涨
* WhileClosure
*/
@SuppressWarnings("deprecation")
public static void whileClosure(){
//数据
List<Employee> empList =new ArrayList<Employee>();
empList.add(new Employee("bjsxt",20000));
empList.add(new Employee("is",10000));
empList.add(new Employee("good",5000));
//业务功能 每次上涨0.2
Closure<Employee> closure=new Closure<Employee>(){
public void execute(Employee emp) {
emp.setSalary(emp.getSalary()*1.2);
}};
//判断
Predicate<Employee> empPre=new Predicate<Employee>(){
@Override
public boolean evaluate(Employee emp) {
return emp.getSalary()<10000;
}
};
//false 表示 while结构 先判断后执行 true do..while 先执行后判断
Closure<Employee> whileclosure =WhileClosure.whileClosure(empPre, closure, false);
//工具类
CollectionUtils.forAllDo(empList, whileclosure) ;
//操作后的数据
Iterator<Employee> empIt=empList.iterator();
while(empIt.hasNext()){
System.out.println(empIt.next());
}
}
/**
* 4.折上减 先打折商品,进行9折,满百再减20
* ChainedClosure
*/
@SuppressWarnings({ "deprecation", "unchecked" })
public static void chainClosure(){
List<Goods> goodsList =new ArrayList<Goods>();
goodsList.add(new Goods("javase视频",120,true));
goodsList.add(new Goods("javaee视频",100,false));
goodsList.add(new Goods("高新技术视频",80,false));
//满百减20
Closure<Goods> subtract=new Closure<Goods>(){
public void execute(Goods goods) {
if(goods.getPrice()>=100){
goods.setPrice(goods.getPrice()-20);
}
}};
//打折
Closure<Goods> discount=new Closure<Goods>(){
public void execute(Goods goods) {
if(goods.isDiscount()){
goods.setPrice(goods.getPrice()*0.9);
}
}};
//链式操作
Closure<Goods> chainclosure=ChainedClosure.chainedClosure(discount,subtract);
//关联
CollectionUtils.forAllDo(goodsList,chainclosure);
//查看操作后的数据
for(Goods temp:goodsList){
System.out.println(temp);
}
}
}