Java 要逐漸導入 Functional Programming，多了 Lambda、Stream 及現在要說明的 java.util.function 這個 package 下的四個 interface。
這四個 interface 都標注有 @FunctionalInterface，這表示這些 interface 只能剛剛好有一個未實作的 method! 要特別注意，Java 8 開始，interface 的 method 是可以實作非僅有宣告。
- Consumer
@FunctionalInterface
public interface Consumer<T> {
void accept(T t);
default Consumer<T> andThen(Consumer<? super T> after) {
Objects.requireNonNull(after);
return (T t) -> { accept(t); after.accept(t); };
}
}
上面是 Consumer 本身的程式碼，這個 interface 有兩個 method，僅有一個未實作的 method - accept。從名稱猜測，可以知道這是個消費者，即實作 Consumer interface 的類別要透過 accept 吃進資料並進行處理。至於 andThen 這個 method 並沒有強制要用，當有使用時，會在 accept 執行完後接著執行。@DisplayName("ConsumerTest")
@SpringBootTest
@Slf4j
class ConsumerTest {
@Test
void accept() {
Consumer<Integer> display = a -> log.debug(a.toString());
display.accept(10);
Consumer<List<Integer> > modify = list ->
{
for (int i = 0; i < list.size(); i++)
list.set(i, 2 * list.get(i));
};
Consumer<List<Integer> >
dispList = list -> list.stream().forEach(a -> log.debug(a + " "));
List<Integer> list = new ArrayList<Integer>();
list.add(2);
list.add(1);
list.add(3);
modify.accept(list);
dispList.accept(list);
}
@Test
void andThen() {
Consumer<List<Integer> > modify = list ->
{
for (int i = 0; i < list.size(); i++)
list.set(i, 2 * list.get(i));
};
Consumer<List<Integer> >
dispList = list -> list.stream().forEach(a -> log.debug(a + " "));
List<Integer> list = new ArrayList<Integer>();
list.add(2);
list.add(1);
list.add(3);
modify.andThen(dispList).accept(list);
}
}
上面單元測試程式，執行後第一個 method (accept) 會輸出 10 4 2 6，第二個 method (andThen) 會輸出 4 2 6，程式說明如下:(1) 第一個單元測試 - accept()
- 第 8 行: 實做一個命名為 display 的 Consumer 實做類別，實做出 accept() method，很簡單的將收到的值輸出。
- 第 10 行: 將 10 傳入給 display 這個 Consumer 實做類別，程式會輸出 10。
- 第 12~16 行: 實做一個命名為 modify 的 Consumer 實做類別，這個類別會接收一個 List<Integer>，並將 List 的每個值乘以 2。
- 第 18 行: 實做一個命名為 dispList 實做類別，這個類別會接收一個 List<Integer>，並將 List 裡所有值輸出。
- 第 21~24 行: 產生一個 3 個元素的 List，值分別為2、1、3。
- 第 26 行: modify 將傳入的 List 裡的元素都乘以 2。
- 第 28 行: dispList 將傳入的 List 裡的元素依序輸出為 4 2 6。
(2) 第二個單元測試 - andThen()
- 第 33~37 行: 實做一個命名為 modify 的 Consumer 實做類別，這個類別會接收一個 List<Integer>，並將 List 的每個值乘以 2。
- 第 39 行: 實做一個命名為 dispList 實做類別，這個類別會接收一個 List<Integer>，並將 List 裡所有值輸出。
- 第 42~45 行: 產生一個 3 個元素的 List，值分別為2、1、3。
- 第 47 行: 會先執行 accept 將值乘 2，接著執行 andThen 將值輸出。
- Supplier
@FunctionalInterface
public interface Supplier<T> {
T get();
}
Supplier 是生產者，上面是 Supplier 的程式碼，只有一個 method - get()，讓外界可以透過這個 method 取得 Supplier 實做類別裡的值。
@DisplayName("SupplierTest")
@SpringBootTest
@Slf4j
class SupplierTest {
@Test
void random() {
Supplier<Double> randomValue = Math::random;
log.debug(randomValue.get().toString());
}
}
上面單元測試程式執行後，輸出 0.4077113851887808，這是個隨機值，程式說明如下:
- 第 8 行: 實做一個命名為 rendomValue 的實做類別，覆寫 get() method 為 Math:: random。
- 第 10 行: 從 randomValue 中取出值並輸出。
- Predicate
@FunctionalInterface
public interface Predicate<T> {
boolean test(T t);
default Predicate<T> and(Predicate<? super T> other) {
Objects.requireNonNull(other);
return (t) -> test(t) && other.test(t);
}
default Predicate<T> negate() {
return (t) -> !test(t);
}
default Predicate<T> or(Predicate<? super T> other) {
Objects.requireNonNull(other);
return (t) -> test(t) || other.test(t);
}
static <T> Predicate<T> isEqual(Object targetRef) {
return (null == targetRef)
? Objects::isNull
: object -> targetRef.equals(object);
}
@SuppressWarnings("unchecked")
static <T> Predicate<T> not(Predicate<? super T> target) {
Objects.requireNonNull(target);
return (Predicate<T>)target.negate();
}
}
Predicate 的 test method 是用來測試邏輯運算是 true 或 false，其餘 method 用來和 test 搭配出更複雜的邏輯判斷。
@DisplayName("PredicateTest")
@SpringBootTest
@Slf4j
class PredicateTest {
@Test
void greaterThanFive() {
Predicate<Integer> predicate = (i) -> i > 5;
Stream<Integer> stream = Stream.of(1, 23, 3, 4, 5, 56, 6, 6);
List<Integer> list = stream.filter(predicate).collect(Collectors.toList());
list.forEach(item -> log.debug(Integer.toString(item)));
}
@Test
void betweenTenAndTwenty() {
Predicate<Integer> greaterThanTen = (i) -> i > 10;
Predicate<Integer> lowerThanTwenty = (i) -> i < 20;
boolean result = greaterThanTen.and(lowerThanTwenty).test(15);
log.debug("result = " + result);
boolean result2 = greaterThanTen.and(lowerThanTwenty).negate().test(15);
log.debug("result2 = " + result2);
}
}
上面單元測試程式，執行後第一個 method (greaterThanFive) 會輸出 23 56 6 6，第二個 method (betweenTenAndTwenty) 會輸出 result = true、result2 = false，程式說明如下:
- 第 8 行: 實做一個 Predicate 類別，測試傳入值是否大於 5。
- 第 10 行: 產生一個有 8 個數字的串流。
- 第 11 行: 利用第 8 行實做的 Predicate 類別過瀘第 10 行的串流資料，過瀘出來的資料放入一個 List。
- 第 12 行: 輸出 List 裡的值，可以看到只輸出大於 5 的元素。
- 第 17、19 行: 實做兩個 Predicate 類別，用來篩選大於 10 及小於 20 的值。
- 第 20 行: 用 greaterThanTen 搭配 Predicate 介面中的 and method 整合 lowerThanTwenty 篩選同時滿足大於 10 及小於 20 兩個條件的值。
- 第 23 行: 將第 20 行的結果透過 Predicate 介面中提供的 negate method 將值反向，所以原本是 true，反向變 false。
上面程式第 8、17、19 宣告的是 Integer 型別，實際傳入的是 int 型別，在 Java 中執行時，會先把 int 轉型成 Integer，在效能上會比較差, 為了避免這個問題，Java 另外提供了 IntPredicate，以第 17 行來說，可以改成如下:
IntPredicate greaterThanTen = (i) -> i > 10;
這樣避免了轉型，速度會快些。
- Function
@FunctionalInterface
public interface Function<T, R> {
R apply(T t);
default <V> Function<V, R> compose(Function<? super V, ? extends T> before) {
Objects.requireNonNull(before);
return (V v) -> apply(before.apply(v));
}
default <V> Function<T, V> andThen(Function<? super R, ? extends V> after) {
Objects.requireNonNull(after);
return (T t) -> after.apply(apply(t));
}
static <T> Function<T, T> identity() {
return t -> t;
}
}
Function 的 apply method 類似於 Stream 的 map，將 T 經運算後傳出 R。
@DisplayName("FunctionTest")
@SpringBootTest
@Slf4j
class FunctionTest {
@Test
void apply() {
Function<Integer, Double> half = a -> a / 2.0;
log.debug(half.apply(10).toString());
}
}
上面程式執行後傳回 5.0，程式說明如下:
- 第 7 行: 實傳一個 Function 類別，將傳入值除以 2 傳回。
- 第 8 行: 傳入 10，傳回 5.0。
上面程式也有轉型的問題，要避開這個問題，程式可以改成如下:
IntToDoubleFunction half = a -> a / 2.0;
log.debug(Double.toString(half.applyAsDouble(10)));
如下圖，輸入 project 名稱後按【Create project】。
出現如下畫面後按【New Key】。
popup 出如下畫面，加一把公鑰，這裡為公鑰命名為 demo-key，按【Add】。
我程式早寫好，所以偷懶的按上面紅色的複製，並且在本機一個空目錄 git clone 一份，把 .git 版控設定建立好，然後把我的程式碼搬進該目錄後，commit、push 到 Azure DevOps 的 git repos，push 進去後，可以看到如下的結果。
如上，點選左邊選單的【Pipelines】，再點選中間的【Create Pipeline】，可以建立 CI pipeline。當出現如下畫面，選擇「Azure Repos Git」，因為在上一個步驟我們是把程式碼版控在 Azure Repos Git。
如下，「spring-security-authentication」是前面建立的專案，裡面已經有程式碼，點選進入下一步驟。
剛剛匯入的程式，根目錄有一個 build.gradle，是以 Gradle 進行 artifacts 管控的專案，所以，這裡就選擇用 Gradle，這樣 pipeline 會在 build 的過程採用 Gradle。
當彈出如下畫面時，commit message 就隨意填一些讓自己看的懂的訊息，然後按【Save and run】。
為什麼會出現下面的錯誤訊息呢? 因為這個 organization 沒有綁定到某個 Azure 的訂閱帳號!
