commons的Predicate和Transformer——高淇JAVA300讲笔记之commons

案例一：Predicate 断言

package com.bjsxt.others.commons;

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 andPredicate anyPredicate
 *       PredicatedXxx.predicatedXxx(容器，判断)
 * 
 * 
 */
public class Demo01 {
    public static void main(String[] args) {
        System.out.println("======自定义判断==========");
        //自定义的判别式
        Predicate<String> selfPre = new Predicate<String>() {
            @Override
            public boolean evaluate(String object) {
                return object.length() >=5 && object.length() <=20;
                
            }
            
        };
        Predicate notNull = NotNullPredicate.notNullPredicate();
        
        Predicate all = PredicateUtils.allPredicate(selfPre,notNull);
        
        List<String> list = PredicatedList.predicatedList(new ArrayList<String>(), all);
        list.add("bjsxt");
//        list.add(null);  //会抛异常
        list.add("bj");  //长度不符合，也会抛异常
        
        
    }
    
    
    /**
     * 判断唯一
     */
    public static void unique() {
        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);  //出现重复值，抛出异常
    }
    
    /**
     * 判断非空
     */
    public static void notNull() {
        System.out.println("=========非空判断========");
//        Predicate notNull = NotNullPredicate.INSTANCE;
        Predicate 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);  //会抛异常
    }
    
    
    /**
     * 比较相等判断
     */
    public static void equal() {
        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);
    }
}

案例二：Transformer 类型转化

先写一个Employee类

package com.bjsxt.others.commons;

/**
 * 员工类
 *
 */
public class Employee {
    private String name;
    private double salary;
    //无参构造器
    public Employee() {
        super();
    }
    //有参构造器
    public Employee(String name, double salary) {
        super();
        this.name = name;
        this.salary = salary;
    }
    //setter和getter方法
    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类

package com.bjsxt.others.commons;

/**
 * 等级类
 *
 */
public class Level {
    private String name;
    private String level;
    //无参构造器
    public Level() {
        super();
    }
    //有参构造器
    public Level(String name, String level) {
        super();
        this.name = name;
        this.level = level;
    }
    //setter和getter方法
    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+")";
    }
        
}

最后是主函数

package com.bjsxt.others.commons;

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 类型转化
 * 1、new Transformer() + 重写transform方法
 * 2、SwitchTransformer
 * CollectionUtils.collect(容器，转换器)
 * 
 */
public class Demo02 {
    public static void main(String[] args) {
        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;
            }
            
        };
        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(),"养身中");
            }        
        };
        Transformer[] trans = {lowTrans,highTrans};
        
        //二者进行了关联
        Transformer switchTrans = new SwitchTransformer(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());
        }
        
    }
    
    /**
     * 内置类型的转换
     */
    public static void inner() {
        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);
        }
        
    }
}

运行结果：

===自定义类型转换===
(码农：老马，水平：养身中)
(码农：老裴，水平：卖身中)