2. 程式人生 > >Java函數語言程式設計

Java函數語言程式設計

阿新 • • 發佈：2019-02-18

摘要： 在Java重構的過程中，巧妙的運用函式式思想能夠便捷地去掉重複。

函數語言程式設計是宣告式的。也就是說，她應該指定“什麼要做”而非“怎麼做”。這種方式使得我們可以工作更高的抽象層次。而傳統的過程式以及面向物件的語言，則是命令式的，因而更關注於“怎麼做”這個層面。站在面向物件思想的角度來看，函數語言程式設計將函式看成一等公民的思想，使得我們處理的粒度從類變小為函式，從而可以更好地滿足系統對重用性和擴充套件性的支援。也就是說，我們可以從函式的粒度，而非物件的粒度去思考領域問題。

例如，有這樣一個場景：我的業務模型是個Person，已經有業務介面能返回給我所有Person的list集合，我需要把根據一些條件返回符合對應關係的Person。

Person.java

public class Person {
    private String name;
    private String gender;
    private int age;

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    public String getGender() {
        return gender;
    }

    public
 
 void setGender(String gender) {
        this.gender = gender;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }
}

首先，根據業務需求，寫出第一個方法 通過姓名找出符合的Person

PersonService.java

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

public
 
 class PersonService {
    //假設這個list是通過已有介面返回的所有Person集合
    private static List<Person> list = new ArrayList<Person>();

    public static List<Person> findByName(String name){
        List<Person> people = new ArrayList<Person>();
        for (Person p : list){
            if(name.equals(p.getName())){
                people.add(p);
            }
        }
        return people;
    }
}

接下來，第二個方法根據性別找出符合的Person

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

public class PersonService {
    //假設這個list是通過已有介面返回的所有Person集合
    private static List<Person> list = new ArrayList<Person>();

    public static List<Person> findByName(String name){
        List<Person> people = new ArrayList<Person>();
        for (Person p : list){
            if(name.equals(p.getName())){
                people.add(p);
            }
        }
        return people;
    }

    public static List<Person> findByGender(String gender){
        List<Person> people = new ArrayList<Person>();
        for (Person p : list){
            if(gender.equals(p.getGender())){
                people.add(p);
            }
        }
        return people;
    }
}

功能是實現了，但是要是這樣交差，估計得捱罵了，這麼多重複程式碼。仔細觀察剛新增的兩個方法。發現，除了下面兩行以外全都相同：
- if(name.equals(p.getName())){
- if(gender.equals(p.getGender())){

這裡的name和gender是兩個字串引數，可以給它們用同樣的名字，比如str，這樣的話：
- if(str.equals(p.getName())){
- if(str.equals(p.getGender())){

這下，不同點就是getName()和getGender()，是兩個方法，而Java是不能把函式當引數的，這樣重構起來就麻煩很多。
想到Java中還有一種迂迴的方式傳遞函式，那就是介面。
新建一個介面Criteria，在這個接口裡隱藏if條件語句裡面的實現細節。這樣就可以把findByName()和findByGender高度抽象為一個方法find()。

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

public class PersonService {
    //假設這個list是通過已有介面返回的所有Person集合
    private static List<Person> list = new ArrayList<Person>();

    public List<Person> findByName(String name) {
        return null;
    }

    public List<Person> findByGender(String gender) {
        return null;
    }

    public List<Person> find(Criteria criteria){
        List<Person> people = new ArrayList<Person>();
        for (Person p : list){
            if(criteria.matches(p)){
                people.add(p);
            }
        }
        return people;
    }
}

interface Criteria{
    boolean matches(Person person);

}

對於具體的findByName()方法，只需要實現匹配的細節即可：

public List<Person> findByName(String name) {
        return find(new Criteria() {
            @Override
            public boolean matches(Person person) {
                return person.getName().equals(name);
            }
        });
    }

經過改裝後的PersonService.java大致像下面這樣：

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

public class PersonService {
    //假設這個list是通過已有介面返回的所有Person集合
    private List<Person> list = new ArrayList<>();

    public List<Person> findByName(String name) {
        return find(new Criteria() {
            @Override
            public boolean matches(Person person) {
                return name.equals(person.getName());
            }
        });
    }

    public List<Person> findByGender(String gender) {
       return find(new Criteria() {
           @Override
           public boolean matches(Person person) {
               return gender.equals(person.getGender());
           }
       });
    }

    public List<Person> find(Criteria criteria){
        List<Person> people = new ArrayList<>();
        for (Person p : list){
            if(criteria.matches(p)){
                people.add(p);
            }
        }
        return people;
    }

}

interface Criteria{
    boolean matches(Person person);
}

看到這，估計有人要發飆了，說好的重構去重複，結果為了一行程式碼，增加了無數行無關程式碼，還無故多了一個類（介面Criteria）。原始程式碼才25行左右，現在將近40行程式碼。這個findByName()和findByGender方法除了return後面的不同，剩下的完全一樣，雖然那些程式碼都是IDE自動生成的，但是看起來，這次重構沒有起到簡化程式碼的目的。甚至，如果你沒有用Java8，那上面的程式碼需要改動才能編譯通過。
當然，如果使用過java8，那麼應該也聽說過Lambda表示式。如果使用的IDE是Intellij的話，那應該慶幸一下，因為它已經識別到了需要改進的地方。
這裡寫圖片描述
這樣，看起來，程式碼會整潔許多：

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

public class PersonService {
    //假設這個list是通過已有介面返回的所有Person集合
    private List<Person> list = new ArrayList<>();

    public List<Person> findByName(String name) {
        return find(p-> name.equals(p.getName()));
    }

    public List<Person> findByGender(String gender) {
       return find(p-> gender.equals(p.getGender()));
    }

    public List<Person> find(Criteria criteria){
        List<Person> people = new ArrayList<>();
        for (Person p : list){
            if(criteria.matches(p)){
                people.add(p);
            }
        }
        return people;
    }

}

interface Criteria{
    boolean matches(Person person);
}

我定義了一個看起來多餘，但是又必須存在的介面Criteria。如果專案中有很多需要這樣重構的程式碼，不是得寫很多類似的介面？當然，JDK的設計者已經想到了這一點，於是就有了一個公用的介面Predicate。這樣，再整理一下程式碼：

import java.util.ArrayList;
import java.util.List;
import java.util.function.Predicate;

public class PersonService {
    //假設這個list是通過已有介面返回的所有Person集合
    private List<Person> list = new ArrayList<>();

    public List<Person> findByName(String name) {
        return find(p-> name.equals(p.getName()));
    }

    public List<Person> findByGender(String gender) {
       return find(p-> gender.equals(p.getGender()));
    }

    public List<Person> find(Predicate<Person> predicate){
        List<Person> people = new ArrayList<>();
        for (Person p : list){
            if(predicate.test(p)){
                people.add(p);
            }
        }
        return people;
    }
}

如果覺得這裡的find寫的臃腫，也可以改進：
這裡寫圖片描述

整理後的程式碼：

import java.util.ArrayList;
import java.util.List;
import java.util.function.Predicate;
import java.util.stream.Collectors;

public class PersonService {
    //假設這個list是通過已有介面返回的所有Person集合
    private List<Person> list = new ArrayList<>();

    public List<Person> findByName(String name) {
        return find(p -> name.equals(p.getName()));
    }

    public List<Person> findByGender(String gender) {
       return find(p -> gender.equals(p.getGender()));
    }

    public List<Person> find(Predicate<Person> predicate){
        return list.stream().filter(p -> predicate.test(p)).collect(Collectors.toList());
    }
}

這樣看起來就比剛開始複製/貼上的程式碼清爽許多。如果第三個業務需求是根據年齡找出符合條件的Person，你可以這樣寫：

public List<Person> findByAge(int age){
        List<Person> people = new ArrayList<>();
        for (Person person : list) {
            if(age == person.getAge()){
                people.add(person);
            }
        }
     return people;
}

中規中矩，沒有問題，但是如果寫成下面這樣，是不是更容易抓住方法的要點：

public List<Person> findByAge(int age){
     return find(p -> age == p.getAge());
}

剛開始重構花了很多時間，但是現在要新新增業務方法，我只需要一行程式碼：

import java.util.ArrayList;
import java.util.List;
import java.util.function.Predicate;
import java.util.stream.Collectors;

public class PersonService {
    //假設這個list是通過已有介面返回的所有Person集合
    private List<Person> list = new ArrayList<>();

    public List<Person> findByName(String name) {
        return find(p -> name.equals(p.getName()));
    }

    public List<Person> findByGender(String gender) {
       return find(p -> gender.equals(p.getGender()));
    }
    //根據年齡找出符合條件的Person
    public List<Person> findByAge(int age){
        return find(p -> age == p.getAge());
    }

    public List<Person> find(Predicate<Person> predicate){
        return list.stream().filter(p -> predicate.test(p)).collect(Collectors.toList());
    }
}

之後又有一個新的業務需求找出在給定年齡段的Person，依然只需要一行程式碼：

import java.util.ArrayList;
import java.util.List;
import java.util.function.Predicate;
import java.util.stream.Collectors;

public class PersonService {
    //假設這個list是通過已有介面返回的所有Person集合
    private List<Person> list = new ArrayList<>();

    public List<Person> findByName(String name) {
        return find(p -> name.equals(p.getName()));
    }

    public List<Person> findByGender(String gender) {
       return find(p -> gender.equals(p.getGender()));
    }

    public List<Person> findByAge(int age){
        return find(p -> age == p.getAge());
    }
    //找出在給定年齡段的Person
    public List<Person> findByAgeRange(int startAge,int endAge){
        return find(p -> startAge <= p.getAge() && endAge >= p.getAge());
    }

    public List<Person> find(Predicate<Person> predicate){
        return list.stream().filter(p -> predicate.test(p)).collect(Collectors.toList());
    }
}

相關推薦

Java-函數語言程式設計（三）流（Stream）

流使程式猿可以在抽象層上對集合進行操作。 從外部迭代到內部迭代 什麼是外部迭代和內部迭代呢？ 個人認為，外和內是相對集合程式碼而言。 如果迭代的業務執行在應用程式碼中，稱之為外部迭代。 反之，迭代的業務執行在集合程式碼中，稱為內部迭代（函數語言程式設計）。 語言描述可能有點抽象，下面看例項。

Java-函數語言程式設計（一）初識篇

原文連結：https://www.javazhiyin.com/20249.html 開發者使用Java8編寫複雜的集合處理演算法，只需要簡單的程式碼就能在多喝cpu上高效執行，這就是Lambda表示式的初衷。 提示：函數語言程式設計和語言無關，它是一種思想，任何語言都可以實現

Java-函數語言程式設計（三）流（掃雷原始碼出售）

什麼是掃雷原始碼出售QQ2952777280【話仙原始碼論壇】hxforum.com外部迭代和內部迭代呢？ 個人認為，外和內是相對集合程式碼而言。 如果迭代的業務執行在應用程式碼中，稱之為外部迭代。 反之，迭代的業務執行在集合程式碼中，稱為內部迭代（函數語言程式設計）。 語言

用java函數語言程式設計——Lambda表示式

函數語言程式設計 很多開發語言都開始支援函數語言程式設計，其中最具備代表性的就是haskell。函數語言程式設計和麵向物件程式設計可以理解為兩大開發陣營。 在函數語言程式設計中，所有的資料都是不可變的，不同的函式之間通過資料流來交換資訊，函式享有跟資料一樣的地位，可以作為引數傳遞給下一個函式

scala、Java函數語言程式設計比較初步~

今天我們就先來講一下Java8引入的Lambda表示式，以及由此引入的函數語言程式設計，以及函式式介面。 什麼是函數語言程式設計 函數語言程式設計並不是Java新提出的概念，其與指令程式設計相比，強調函式的計算比指令的計算更重要；與過程化程式設計相比，其中函式的計算可以隨時呼叫。 當

java函數語言程式設計入門教程

什麼是函數語言程式設計 在介紹函數語言程式設計前，先了解一下平時我們所使用指令式程式設計，指令式程式設計是告訴計算機如何一步一步執行程式設計風格。 比如我們要在一個蘋果的物件集合中篩選出顏色為紅色的蘋果集合。我們需要寫以下程式碼： 建立儲存蘋果的集合list 遍歷這個集合 判斷蘋果顏色是不

java-函數語言程式設計-函式式介面以及方法應用

一、lambda表示式     1、 Lambda表示式是匿名內部類的簡化寫法。     Lambda標準格式：     (引數型別 引數名) -> {         方法體;         return 返回值;         }     

java函數語言程式設計:流

java8對核心類庫的改進主要包括集合類的API和新引入的流(Stream) 流使程式設計師得以站在更高層次上對集合進行操作 介紹Stream類中的一組方法,每個方法都對應集合上的一種操作 外部迭代->內部迭代 計算倫敦藝術家人數: int count

Java函數語言程式設計:初識Lambda表示式

一,Lambda表示式 隨著多核CPU和大資料的流行,為了寫出在多核CPU上執行良好的程式 人們開發出了java.util.concurrent包和很多第三方類庫,試圖將併發抽象化 面對大型資料集合,java還欠缺高效的並行操作,開發者能夠使用java8編寫複雜

《深入理解Java函數語言程式設計》系列文章

Introduction 本系列文將幫助你理解Java函數語言程式設計的用法、原理。 Java 8已經發行兩年多，但很多人仍然在使用JDK7。對企業來說，技術上謹慎未必是壞事，但對個人學習而言，不去學習新技術就很可能被技術拋棄。Java 8一個重要的變更是引入函數語言程式設計和Lambda表示式(lambd

java函數語言程式設計之Supplier

描述：Supplier< T>介面沒有入參，返回一個T型別的物件，類似工廠方法。 原始碼： public interface Supplier<T> { /** * Gets a result. *

【java函數語言程式設計01】函數語言程式設計定義

函數語言程式設計 what? 在電腦科學中， 函數語言程式設計是一種程式設計正規化一種構建計算機程式結構和元素的方式 - 將計算視為函式（數學）數學樂趣可變資料的評估。 它是一種宣告性程式設計範例，這意味著使用表示式或宣告而不是語句來完成程式設計。 在函式程式碼

【java函數語言程式設計02】lambda表示式與雙冒號

java lambda表示式 0 總結在前面： lambda表示式是java函數語言程式設計正規化的一個表現形式，將單方法類或介面的實現，直接看成一個可直接定義的函式方法，以更緊湊簡潔形式，提高可讀性，減少程式碼量； Lambda表示式允許您更緊湊地表達單方

Java函數語言程式設計

摘要： 在Java重構的過程中，巧妙的運用函式式思想能夠便捷地去掉重複。 函數語言程式設計是宣告式的。也就是說，她應該指定“什麼要做”而非“怎麼做”。這種方式使得我們可以工作更高的抽象層次。而傳統的過程式以及面向物件的語言，則是命令式的，因而更關注於“怎麼做”

Java函數語言程式設計整理

Java函數語言程式設計的第一個作用是可以將匿名類改寫成函式式表示式，由系統自動判斷型別 我們先定義一個介面 public i

Java函數語言程式設計原理以及應用

一. 函數語言程式設計 Java8所有的新特性基本基於函數語言程式設計的思想，函數語言程式設計的帶來，給Java注入了新鮮的活力。 下面來近距離觀察一下函數語言程式設計的幾個特點： 函式可以作為變數、引數、返回值和資料型別。 基於表示式來替代方法的呼叫 函式無狀態，可以併發和獨立使用 函式無副

測試下java函數語言程式設計的幾個介面

//看著很簡潔，就是有點難理解 public class Iterator_test { public static void m

3.Java面向物件程式設計OOA/OOP/OOD/OOAD()/UML類圖、函數語言程式設計Scala(JVM)---類與物件、封裝繼承多型、構造方法、覆寫/重寫/override

一、緒論 1.面向物件程式設計正規化（C++、Java、Go）------能進行現實生活的抽象。             每個物件都是一個類。類中包含屬性與方法。 OOA：面向物件分析 OOP：面向物件程式設計

Streams filter 例子 （函數語言程式設計 ） Java 8

在本教程中，我們將向你展示一些java 8個例子來演示的流filter()，collect()使用，findany()和orelse(). 1. Streams filter() and collect()   1.1 Java 8之前, 過濾一 List 

Java程式設計邏輯-函數語言程式設計1

第一章 你好，lambda表示式！ 第一節 Java的編碼風格正面臨著翻天覆地的變化。我們每天的工作將會變成更簡單方便，更富表現力。Java這種新的程式設計方式早在數十年前就已經出現在別的程式語言裡面了。這些新特性引入Java後，我們可以寫出更簡潔，優雅，表達性更強，錯誤更少的程式碼。我