commons的Closure——高琪JAVA300讲笔记之commons

案例一：

其中，Employee类就是与上一篇的相同，这里不重复贴了。

还用到了一个Goods类：

package com.bjsxt.others.commons;

public class Goods {
    private String name;
    private double price;
    //折扣
    private boolean discount;
    //无参构造器
    public Goods() {
        super();
    }
    //有参构造器
    public Goods(String name, double price, boolean discount) {
        super();
        this.name = name;
        this.price = price;
        this.discount = discount;
    }
    //setter和getter方法
    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?"是":"否")+")";
    }
    
}

最后是主函数：

package com.bjsxt.others.commons;

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 Demo03 {
    public static void main(String[] args) {
        basic();
        System.out.println("=============");
        ifClosure();
        System.out.println("=============");
        whileClosure();
        System.out.println("=============");
        chainClosure();
    }
    
    /** 
     * 折上折 先打折商品，进行9折，满百再减20
     */
    public static void chainClosure() {
        List<Goods> goodList = new ArrayList<Goods>();
        goodList.add(new Goods("javase视频",120,true));
        goodList.add(new Goods("javaee视频",100,false));
        goodList.add(new Goods("高新技术视频",80,false));
        
        //满百减20
        Closure<Goods> substract = new Closure<Goods>() {
            @Override
            public void execute(Goods goods) {
                if(goods.getPrice() >= 100) {
                    goods.setPrice(goods.getPrice()-20);
                }
            }
        };
        //打折
        Closure<Goods> discount = new Closure<Goods>() {
            @Override
            public void execute(Goods goods) {
                if(goods.isDiscount()) {
                    goods.setPrice(goods.getPrice()*0.9);
                }
            }
        };
        
        
        //链式操作
        Closure<Goods> chainClo = ChainedClosure.chainedClosure(discount,substract);
        
        //关联
        CollectionUtils.forAllDo(goodList, chainClo);
        
        //查看操作后的数据
        for(Goods temp:goodList) {
            System.out.println(temp);
        }
        
        
    }
    
    /**
     * 确保所有的员工工资都大于10000，如果已经超过的不再上涨
     */
    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> cols = new Closure<Employee>() {

            @Override
            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> whileCols = WhileClosure.whileClosure(empPre, cols, false);
        
        //工具类
        CollectionUtils.forAllDo(empList, whileCols);
        
        //操作后的数据
        Iterator<Employee> empIt = empList.iterator();
        while(empIt.hasNext()) {
            System.out.println(empIt.next());
        }
    }
    
    
    /** 
     * 二选一 如果是打折商品，进行9折，否则满百减20
     */
    public static void ifClosure() {
        List<Goods> goodList = new ArrayList<Goods>();
        goodList.add(new Goods("javase视频",120,true));
        goodList.add(new Goods("javaee视频",100,false));
        goodList.add(new Goods("高新技术视频",80,false));
        
        //满百减20
        Closure<Goods> substract = new Closure<Goods>() {
            @Override
            public void execute(Goods goods) {
                if(goods.getPrice() >= 100) {
                    goods.setPrice(goods.getPrice()-20);
                }
            }
        };
        //打折
        Closure<Goods> discount = new Closure<Goods>() {
            @Override
            public void execute(Goods goods) {
                if(goods.isDiscount()) {
                    goods.setPrice(goods.getPrice()*0.9);
                }
            }
        };
        
        //判断
        Predicate<Goods> pre = new Predicate<Goods>() {
            @Override
            public boolean evaluate(Goods goods) {
                return goods.isDiscount();
            }
        };
        
        //二选一
        Closure<Goods> ifClo = IfClosure.ifClosure(pre,discount,substract);
        
        //关联
        CollectionUtils.forAllDo(goodList, ifClo);
        
        //查看操作后的数据
        for(Goods temp:goodList) {
            System.out.println(temp);
        }
        
        
    }
    
    
    /**
     * 基本操作
     */
    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> cols = new Closure<Employee>() {

            @Override
            public void execute(Employee emp) {
                emp.setSalary(emp.getSalary()*1.2);
                
            }
            
        };
        
        //工具类
        CollectionUtils.forAllDo(empList, cols);
        
        //操作后的数据
        Iterator<Employee> empIt = empList.iterator();
        while(empIt.hasNext()) {
            System.out.println(empIt.next());
        }
        
    }
    
}

运行结果：

(码农：bjsxt，敲砖钱：24000.0)
(码农：is，敲砖钱：12000.0)
(码农：good，敲砖钱：6000.0)
=============
(商品：javase视频，价格：108.0，是否打折：是)
(商品：javaee视频，价格：80.0，是否打折：否)
(商品：高新技术视频，价格：80.0，是否打折：否)
=============
(码农：bjsxt，敲砖钱：20000.0)
(码农：is，敲砖钱：10000.0)
(码农：good，敲砖钱：10368.0)
=============
(商品：javase视频，价格：88.0，是否打折：是)
(商品：javaee视频，价格：80.0，是否打折：否)
(商品：高新技术视频，价格：80.0，是否打折：否)