138-139_容器_commons之函數語言程式設計_Predicate_Transformer_Closure

阿新 • • 發佈：2018-11-09

這裡寫圖片描述

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);
        }
    }
}

138-139_容器_commons之函數語言程式設計_Predicate_Transformer_Closure

Predicate Test01_Predicate.java package commons.collection; import java.util.ArrayList; import java.util.List; import org.apache

聰哥哥教你學Python之函數語言程式設計

今天主要圍繞這麼幾個方面談談函數語言程式設計？ 1.高階函式 2.返回函式 3.匿名函式 4.裝飾器 5.偏函式有人會有疑問，聰哥哥請問什麼是函數語言程式設計? 引用百度百科的話說: 函數語言程式設計是一種程式設計方式，它將電腦運算視為函式的計算。函式程式語言最重要

Apache的commons之函數語言程式設計集合及佇列(三)

集合並集 CollectionUtils.union(集合1, 集合2) 集合交集 CollectionUtils.intersection(集合1, 集合2) 或者 CollectionUtils.retainAll(集合1, 集合2) 集合差集 Coll

Appache的commons之函數語言程式設計(一)

注意 : 我使用jar包是commons-collections4-4.1.jar appache下的各位不要導錯 Predicate簡單的使用 package com.hp.common; import org.apache.commons.collec

Apache的commons之函數語言程式設計Closure(二)

Closure 閉包封裝特定的業務功能員工類 //員工類 static class Staff { private String name;

Java 8程式設計進階-Stream之函數語言程式設計

1、什麼是Stream Java 8 API添加了一個新的抽象稱為流Stream，可以讓你以一種宣告的方式處理資料。Stream 使用一種類似用 SQL 語句從資料庫查詢資料的直觀方式來提供一種對 Java 集合運算和表達的高階抽象。Stream API可以極大提

JDK 8 新特性之函數語言程式設計 → Stream API

開心一刻　　今天和朋友們去K歌，看著這群年輕人一個個唱的賊嗨，不禁感慨道：年輕真好啊！　　想到自己年輕的時候，那也是拿著麥克風不放的人　　現在的我沒那激情了，只喜歡坐在角落裡，默默的聽著他們唱，就連旁邊的妹子都勸我說：大哥別摸了，唱首歌吧 Stream 初體驗　　很多時候，我們往往會選擇在資料庫層面

135_容器_guava之_只讀_函數語言程式設計(過濾、轉換、組合 )_約束_集合

只讀設定 Test01_ReadOnly.java package guava.collection; import java.util.ArrayList; import java.util.Collections; import java.util.Li

Python之路-Day08函數語言程式設計與內建函式

return可以返回任何值當你在一個函式當中返回一個函式名的時候,其實返回的是這個函式在記憶體當中的地址,如果你用一個變數去接收它,然後以這個變數名執行的話,就會執行你返回的記憶體地址對應的那個函式. def test1(): print("in the test1")

Python之路Python作用域、匿名函式、函數語言程式設計、map函式、filter函式、reduce函式 Python之路Python作用域、匿名函式、函數語言程式設計、map函式、filter函式、reduce函式

Python之路Python作用域、匿名函式、函數語言程式設計、map函式、filter函式、reduce函式一、作用域 return 可以返回任意值例子 def test1(): print("test1") def test(): print("te

函數語言程式設計之 Python

　　1 函數語言程式設計概述　　　　前提：函式在 Python 中是⼀等物件　　　　工具：built-in ⾼階函式；lambda 函式；operator 模組；functools 模組　　　　模式：閉包與裝飾器　　　　替代：⽤用 List Comprehension 可輕鬆替代 m

函數語言程式設計之陣列的函數語言程式設計

5. 陣列的函數語言程式設計在本章中，我們將建立一組用於陣列的函式，並用函式式的方法而非命令式的方法來解決常見的問題 5.1 陣列的函式式方法本節將建立一組有用的函式，並用它們解決陣列的常見問題本節所建立的所有函式稱為投影函式，把函式應用

函數語言程式設計之組合與管道

7. 組合與管道昨天我們學習了柯里化與偏函式，當然不能學完就完了，一些經典的函式什麼的還是需要記一下的，比如今天重寫新寫一下看看能不能寫出來，也能加深自己對這方面的理解。今天我們將要學習的是函式式組合的含義及其實際應用。 Q 函式式組合在函數語言程式設計中被

函數語言程式設計之-bind函式

Bind函式 Bind函式在函數語言程式設計中是如此重要，以至於函數語言程式設計語言會為bind函式設計語法糖。另一個角度Bind函式非常難以理解，幾乎很少有人能通過簡單的描述說明白bind函式的由來及原理。這篇文章試圖通過“人話”來描述bind函式，並通過淺顯的例項為零函數語言程式設計語言的開發者揭祕bi