JavaSE lambda

2024-12-042024
92.4% (338.3/366)
December
10.8% (3.3/31)
Week 49
33.6% (2.3/7)
Day 04 Wed
35.6% (8.5/24)

訪問者

total: 10091
today: 1
yesterday: 1
now: 1

↑

更新

MenuBar

lambda 概略
まずは lambda を使わないリスト処理
lambda版
関数インタフェース
Function Object - lambda式で再帰処理 -
lambda式の変数スコープ
List と lambda
Map と lambda

lambda 概略 †

今まで、他の言語を使ってるおともだちから、「お前ん家(ち)クロジャー無いでやんの。やーいやーい」といじめられていたけど、ようやく Java8 で導入
主な用途はリストの処理。lambda を使って書くと、勝手に並列化される。

↑

まずは lambda を使わないリスト処理 †

package com.mycompany.lambdaexam;

import java.util.ArrayList;
import java.util.Collections;
import java.util.Comparator;
import java.util.List;
import lombok.AllArgsConstructor;
import lombok.Data;

@Data
@AllArgsConstructor
class Person {

    private String name;
    private int age;
}

public class Main {

    public static void main(String[] args) {
        List<Person> list = new ArrayList<>();
        list.add(new Person("Zach", 18));
        list.add(new Person("Albert", 59));
        list.add(new Person("Donna", 38));
        list.add(new Person("Erich", 40));
        list.add(new Person("Brenda", 16));

        Collections.sort(list, new Comparator<Person>() {
            @Override
            public int compare(Person p1, Person p2) {
                return p1.getName().compareTo(p2.getName());
            }
        });
        
        for (Person p : list) {
            System.out.println(p);
        }
    }
}

Person(name=Albert, age=59)
Person(name=Brenda, age=16)
Person(name=Donna, age=38)
Person(name=Erich, age=40)
Person(name=Zach, age=18)

↑

lambda版 †

package com.mycompany.lambdaexam;

import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
import lombok.AllArgsConstructor;
import lombok.Data;

@Data
@AllArgsConstructor
class Person {

    private String name;
    private int age;
}

public class Main {

    public static void main(String[] args) {
        List<Person> list = new ArrayList<>();
        list.add(new Person("Zach", 18));
        list.add(new Person("Albert", 59));
        list.add(new Person("Donna", 38));
        list.add(new Person("Erich", 40));
        list.add(new Person("Brenda", 16));

        Collections.sort(list,
            (p1, p2) -> p1.getName().compareTo(p2.getName())
        );

        list.forEach(System.out::println);
    }
}

abstract メソッドが一つだけある抽象クラスを lambda 式で記述できる
- Collections.sort(list, Comparator) の Comparator を lambda 式で記述できる
- Collection.forEach(Consumer) の Consumer を lambda 式で記述できる。(そう見えないけど後述)

構文

(型 引数, 型 引数) -> {処理; 処理; return 返値;}
(Person p1, Person p2) -> { return p1.getName().compareTo(p2.getName()); };

型の省略可能。型推論で解決できるので

(引数, 引数) -> {処理; 処理; return 返値;}
(p1, p2) -> { return p1.getName().compareTo(p2.getName()); };

{}の省略可能。一文の場合は {} と return を省略できる

(引数, 引数) -> return 返値;
(p1, p2) -> p1.getName().compareTo(p2.getName());

引数が一つなら () は省略可能

list.forEach(s -> System.out.println(s));

渡されたパラメータを同じ順番でメソッドに渡すだけならば、メソッド参照を書くだけでいい
```
list.forEach(System.out::println); // Static Method
```
```
list.forEach(this::doSomething()); // Class Method
```

↑

関数インタフェース †

関数インタフェース : 実装を lambda 式で記述できるインタフェース

未実装の抽象メソッドが一つだけのインタフェースは自動的に関数インタフェースになる

package com.mycompany.lambdaexam;

interface MyFunctionIf {

    String pre(String arg);

    String main(String arg);

    String post(String arg);
}

@FunctionalInterface
interface MyFunctionImpl extends MyFunctionIf {

    @Override
    default String pre(String arg) {
        return "(PRE-" + arg + ")";
    }

    @Override
    default String post(String arg) {
        return "(" + arg + "-POST)";
    }
}

class StringProcessor {

    public static String process(String str, MyFunctionImpl func) {
        return func.post(func.main(func.pre(str)));
    }
}

public class FunctionExam {

    public static void main(String[] args) {
        System.out.println(StringProcessor.process("aBcDeF", s -> s.toLowerCase()));
        System.out.println(StringProcessor.process("aBcDeF", s -> s.toUpperCase()));
    }
}

((pre-abcdef)-POST)
((PRE-ABCDEF)-POST)

明示的に @FunctionalInterface? を記述すると、コンパイラ (IDE) が関数インタフェースになっているかをチェックしてくれる
Java 8 から、Interface に、メソッドを定義できるようになった : [default method]
- 後方互換のため。特に、Collection の lambda 向け拡張のため
- 具象クラス (ArrayList? や LinkedList? や HashSet? ... ) をいじりだすと収集がつかなくなるので、親玉の Collection インタフェースにメソッド実装を実装できるようにしたというのが本音のところ
Java 8 の関数インタフェース java.util.function
- Supplier (引数なし、値を返す。遅延評価で使う)
  - interface BooleanSupplier? {boolean getAsBoolean?();}
  - interface IntSupplier? {int getAsInt?();}
  - interface LongSupplier? {long getAsLong?();}
  - interface DoubleSupplier? {double getAsDouble?();}
- Consumer (引数あり、値を返さない)
  - interface Consumer<T> {void accept(T t);}
  - interface IntConsumer? {void accept(int t);}
  - interface LongConsumer? {void accept(long t);}
  - interface DoubleConsumer? {void accept(double t);}
  - interface BiConsumer?<T,U> {void accept(T t, U u);}
  - interface ObjIntConsumer?<T,U> {void accept(T t, int u);}
  - interface ObjLongConsumer?<T,U> {void accept(T t, long u);}
  - interface ObjDoubleConsumer?<T,U> {void accept(T t, double u);}
- Predicate (引数あり、booleanを返す。条件判定を行う)
  - interface Predicate<T> {boolean test(T t);}
  - interface IntPredicate? {boolean test(int t);}
  - interface LongPredicate? {boolean test(long t);}
  - interface DoublePredicate? {boolean test(double t);}
  - interface BiPredicate?<T,U> {boolean test(T t, U u);}
- Function (引数あり、R を返す。)
  - interface Function<T,R> {R apply(T t);}
  - interface IntFunction?<R> {R apply(int t);}
  - interface LongFunction?<R> {R apply(long t);}
  - interface DoubleFunction?<R> {R apply(double t);}
  - interface BiFunction?<T,U,R> {R apply(T t, U u);}
- ToIntFunction? (引数あり、int を返す。)
  - interface ToIntFunction?<T> {int applyAsInt?(T t);}
  - interface ToIntFunction? {int applyAsInt?(int t);}
  - interface LongToIntFunction? {int applyAsInt?(long t);}
  - interface DoubleToIntFunction? {int applyAsInt?(double t);}
  - interface ToIntBiFunction?<T,U> {int applyAsInt?(T t, U u);}
- ToLongFunction? (引数あり、long を返す。)
  - interface ToLongFunction?<T> {long applyAsLong?(T t);}
  - interface IntToLongFunction? {long applyAsLong?(int t);}
  - interface ToLongFunction? {long applyAsLong?(long t);}
  - interface DoubleToLongFunction? {long applyAsLong?(double t);}
  - interface ToLongBiFunction?<T,U> {long applyAsLong?(T t, U u);}
- ToDoubleFunction? (引数あり、double を返す。)
  - interface ToDoubleFunction?<T> {double applyAsDouble?(T t);}
  - interface IntToDoubleFunction? {double applyAsDouble?(int t);}
  - interface LongToDoubleFunction? {double applyAsDouble?(long t);}
  - interface ToDoubleFunction? {double applyAsDouble?(double t);}
  - interface ToDoubleBiFunction?<T,U>{double applyAsDouble?(T t, U u);}
- UnaryOperator? (引数あり、引数と同じ型を返す)
  - interface UnaryOperator?<T> {T apply(T t);}
  - interface IntUnaryOperator? {int applyAsInt?(int t);}
  - interface LongUnaryOperator? {long applyAsLOng(long t);}
  - interface DoubleUnaryOperator? {double applyAsDouble?(double t);}
- BinaryOperator? (引数あり、引数と同じ型を返す)
  - interface BinaryOperator?<T> {T apply(T t1, T t2);}
  - interface IntBinaryOperator? {int applyAsInt?(int t1, int t2);}
  - interface LongBinaryOperator? {long applyAsLOng(long t1, long t2);}
  - interface DoubleBinaryOperator? {double applyAsDouble?(double t1, double t2);}
- Runnable も代表的な関数インタフェース
```
interface Runnable { public void run(); }

new Thread(new Runnable() {
  @Override
  public void run() {
    System.out.prinltn("Hello");
  }
});

new Thread(() -> System.out.println("Hello"));
```

↑

Function Object - lambda式で再帰処理 - †

package com.mycompany.lambdaexam;

import java.util.function.ToLongBiFunction;
import java.util.function.ToLongFunction;

public class LambdaRecursive {

    public static void main(String[] args) {
        ToLongBiFunction<ToLongBiFunction ,Long> fibonacciInner = (me, value) -> {
          if (0L == value) return 0L;
          if (1L == value) return 1L;
          return me.applyAsLong(me, value - 1L) + me.applyAsLong(me, value - 2L);
        };
        
        ToLongFunction<Long> fibonacci = (value) -> fibonacciInner.applyAsLong(fibonacciInner, value);
        
        System.out.println(fibonacci.applyAsLong(10L));
    }
}

lambda 式は、名前を付けずに匿名クラスの代わりに使う場合が多いが、名前をつけて Object として使うこともできる
再帰処理で必要になる
- 再帰処理の中では、自分自身を参照できないので、引数で渡された何かの関数を実行する
- 再帰処理を呼び出すところで、引数に再帰関数自体を指定する fibonacciInner.applyAsLong?(fibonacciInner, value)

↑

lambda式の変数スコープ †

package com.mycompany.lambdaexam;

public class ScopeExam {

    public static void main(String[] args) {
        ScopeExam thisObj = new ScopeExam();
        thisObj.scope();
    }

    public void scope() {
        int num = 123;
        Runnable runner = () -> {
            System.out.println(this.getClass().getName());
            System.out.println(num);
        };
        runner.run();
    }
}

com.mycompany.lambdaexam.ScopeExam
123

thisは、lambda式が記述されている Object になる
lambda式の外側の変数を使える。事実上のfinal として扱われる

「ラムダ式から参照されるローカル変数は、final または事実上の final である必要があります」
引数名がかぶっているとエラー
コレは OK。実行すると 124 が出力される

「変数 num は、すでにメソッド scope() で定義されています」
匿名クラスであれば、別クラスなので別スコープになるが、lambda 式では外側の変数と同じスコープになる

↑

List と lambda †

package com.mycompany.lambdaexam;

import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
import lombok.AllArgsConstructor;
import lombok.Data;

@Data
@AllArgsConstructor
class Person {

    private String name;
    private int age;
}

public class Main {

    public static void main(String[] args) {
        List<Person> list = new ArrayList<>();
        list.add(new Person("Zach", 18));
        list.add(new Person("Albert", 59));
        list.add(new Person("Donna", 38));
        list.add(new Person("Erich", 40));
        list.add(new Person("Brenda", 16));

        // Collections#sort(List, Comparator)
        Collections.sort(list,
            (p1, p2) -> p1.getName().compareTo(p2.getName())
        );

        // List#forEach(Consumer)
        list.forEach(p -> System.out.println(p));
        System.out.println("--");
        
        // List#removeIf(Predicate)
        list.removeIf(p -> p.getAge() > 20);
        list.forEach(p -> System.out.println(p));
        System.out.println("--");
        
        // List#removeAll(UnaryOperator)
        list.replaceAll(p -> new Person(p.getName(), p.getAge() + 10));
        list.forEach(p -> System.out.println(p));
    }
}

Person(name=Albert, age=59)
Person(name=Brenda, age=16)
Person(name=Donna, age=38)
Person(name=Erich, age=40)
Person(name=Zach, age=18)
--
Person(name=Brenda, age=16)
Person(name=Zach, age=18)
--
Person(name=Brenda, age=26)
Person(name=Zach, age=28)

Set にも forEach() removeIf() がある

↑

Map と lambda †

package com.mycompany.lambdaexam;

import java.util.ArrayList;
import java.util.Collections;
import java.util.LinkedHashMap;
import java.util.List;
import java.util.Map;
import lombok.AllArgsConstructor;
import lombok.Data;

@Data
@AllArgsConstructor
class Person {

    private String name;
    private int age;
}

public class Main {

    public static void main(String[] args) {
        Map<String, Integer> personMap = new LinkedHashMap<>();
        
        // lambda 式の返り値を格納する
        personMap.compute("Zach", (key, existValue) -> null == existValue ? 18 : existValue);
        // 値がない場合にのみ lambda 式の返り値を格納する
        personMap.computeIfAbsent("Albert", (key) -> 59);

        personMap.put("Donna", 38);
        personMap.put("Erich", 40);
        personMap.put("Brenda", 16);
        
        // 値がある場合にのみ lambda 式の返り値を上書きする
        personMap.computeIfPresent("Donna", (key, existValue) -> existValue + 10);
        personMap.computeIfPresent("Alphons", (key, existValue) -> 99);
        
        // 値があったら lambda 式の返り値を格納。なかったら設定値を格納
        personMap.merge("Erich", 50, (oldValue, newValue) -> oldValue);
        personMap.merge("Sonton", 3, (oldValue, newValue) -> oldValue);

        // Map#forEach(Consumer)
        personMap.forEach((key, value) -> System.out.println(key + "=" + value));
        System.out.println("--");
    }
}

Zach=18
Albert=59
Donna=48
Erich=40
Brenda=16
Sonton=3

Java#JavaSE

目次

訪問者

更新

最新の10件

人気の10件