Java SE8 ラムダ式による関数型プログラミング

1. Java SE 8
ラムダ式による関数型プログラミング

2. はじめに
2
 Java Standard Edition 8の新機能
 インタフェースの仕様拡張
 ラムダ式
 ・・・
 ストリームAPI（未）
 参照
 書籍「Java SE 8 実践プログラミング」Cay S. Horstmann

3. インタフェースの仕様拡張
3
 【Java 7】インタフェースは抽象メソッドの集まり
 インタフェースに処理（関数の中身）を書くことはできなかった
 【Java 8】インタフェースに処理を書くことができる
 defaultメソッド
 staticメソッド
 関数型インタフェース
 関数のように扱えるインタフェース

4. インタフェースのdefaultメソッド
4
 インタフェースにデフォルトの処理を記述できる
 従来のインタフェース⇔defaultメソッド
<interface>
PersonString getName()
<abstract>
AbstractPerson
String getName() {
// 処理
}
Student1 Student2
String
getName()
<interface> Person
default String getName()
{
// 処理
}
Student1 Student2
String
getName()デフォルト実装の
オーバーライド
抽象メソッド定義
デフォルト実装
デフォルト
実装の利用
defaultメソッド定義
defaultメソッドの
オーバーライド
defaultメソッド
の利用
インタフェース
抽象クラス
具象クラス

5. 従来のインタフェース⇔defaultメソッド
5
// インタフェースは抽象メソッドのみ
interface Person {
String getName();
}
// 抽象クラスでgetName()のデフォルト実装を提
供
abstract class AbstractPerson implements
Person {
public String getName() {
return this.getClass().getSimpleName();
}
}
// 具象クラスでデフォルト実装を利用
class Student1 extends AbstractPerson {
// getName()は抽象クラスの実装を利用
}
// 具象クラスでデフォルト実装をオーバーライド
class Student2 extends AbstractPerson {
// 抽象クラスの実装をオーバーライド
public String getName() { return "abc"; }
}
// インタフェースにdefaultメソッド定義
interface Person {
default String getName() {
return this.getClass().getSimpleName();
}
}
// デフォルト実装を提供する抽象クラスは不要
// 具象クラスでdefaultメソッドを利用
class Student1 implements Person {
// getName()はdefaultメソッドを利用
}
// 具象クラスでdefaultメソッドをオーバーライド
class Student2 implements Person {
// defaultメソッドをオーバーライド
public String getName() { return "abc"; }
}
// 実行
System.out.println(new Student1().getName()); // -> Student1
System.out.println(new Student2().getName()); // -> abc

6. defaultメソッドの衝突（クラス優先）
6
 ①自クラスにメソッドが無い
 ②スーパークラスのメソッドを探す
 スーパークラスとdefaultメソッドに同じものがあった場合
 (インタフェースの)defaultメソッドより、(スーパー)クラスのメ
ソッドが優先する
<interface> Person
default String getName() {
return
this.getClass().getSimpleName();
}
Student3
Citizen
String getName() {
return “xyz";
}
System.out.println(new Student3().getName()); // -> xyz
getName衝突
クラス優先

7. defaultメソッドの衝突（オーバーロード解決）
7
 ①自クラスにメソッドが無い
 ②スーパクラスにもメソッドが無い
 ③(インタフェースの)defaultメソッドを探す
 defaultメソッドが衝突した場合は、オーバーロードで解決する
<interface> Person
default String getName() {
return
this.getClass().getSimpleName();
}
Student4
String getName() {
return
Person.super.getName();
}
System.out.println(new Student4().getName()); // -> Student4
<interface> Named
default String getName()
{
return "No Name";
}
抽象メソッドであって
も衝突する
String getName();
衝突を解決しないと
コンパイルエラー
getName衝突
Citizen
オーバーロードで解決

8. defaultメソッドの解決ルール
8
 【Java7】クラスの継承木をたどってメソッドの実装をさがす
 メソッドの探索順
① 自クラスのメソッド
② スーパークラスのメソッド
 【Java8】クラスとインタフェースの継承木をたどってメソッドを探
す
 インタフェースは多重継承が可能なので、メソッドの候補が複
数ある
 メソッドの探索順
① 自クラスのメソッド
② スーパークラスのメソッド
③ インタフェースのdefaultメソッド
⇒衝突した場合、自クラスでメソッドをオーバーライドして解決する

9. defaultメソッドの用途
9
 抽象クラスの削減
 デフォルトの処理を提供するだけの抽象クラスは不要
 (既存)インタフェースの(安全な)拡張
 インタフェースにメソッドを追加したい
 全ての実装クラスの修正が必要（メソッドの実装）だった
 defaultメソッドにできれば、実装クラスの修正は不要
 インタフェースと抽象クラスの違いは？
 ？？？

10. インタフェースのstaticメソッド
10
 【Java7】インタフェースとコンパニオンクラス
 インタフェースのユーティリティ処理を、コンパニオンクラスのstaticメ
ソッドで提供する
 【Java8】インタフェースにstaticメソッドが定義できる
 もはや、コンパニオンクラスは不要
<interface> Path Paths
static Path get(String first, String… more) {
return FileSystems.getDefault().getPath(first,
more);
}
System.out.println(Paths.get("a", "b", "c.java")); // -> a/b/c.java
System.out.println(Path.get("a", "b", "c.java")); // -> a/b/c.java
<interface> Path
static Path get(String first, String… more) {
return FileSystems.getDefault().getPath(first,
more);
}
Paths
※こうすることが可能
なのであって、実際は
こうなってません

11. 関数型インタフェース
11
 抽象メソッドが１個だけのインタフェース
 を関数型インタフェースと呼ぶ
 defaultメソッドやstaticメソッドは何個あってもよい
 @FunctionalInterfaceアノテーションを付けるのが望ましい
 例） Runnable
 例） Comparator
@FunctionalInterface
public interface Comparator<T> {
int compare(T o1, T o2);
staticメソッド …
}
@FunctionalInterface
public interface Runnable {
void run();
}

12. 関数型インタフェースでないもの
12
 抽象メソッドが複数あると関数型インタフェースではない
public interface Abc {
void foo();
int bar();
}

13. 【まとめ】インタフェースの仕様拡張
13
 【Java 7】インタフェースは抽象メソッドの集まり
 インタフェースに処理（関数の中身）を書くことはできなかった
 【Java 8】インタフェースに処理を書くことができる
 defaultメソッド
 staticメソッド
 関数型インタフェース
 関数のように扱えるインタフェース
 ⇒ラムダ式につづく

14. ラムダ式
14
 ラムダ式とは
 引数を持つコードブロック
 利用方法
 関数型インタフェースのオブジェクトの代わりにラムダ式を使
用できる
 これもラムダ式
 メソッド参照
 コンストラクタ参照

15. ラムダ式の基本形
15
 旧スタイル（非ラムダ式）
 ラムダ式スタイル：基本形
 ラムダ式とは引数を持つコードブロック
 (引数型1 仮引数1, 引数型2 仮引数2, …) -> { 文1; 文2;
… }
Compatator<String> comp = new Comparator<String>() {
public int compare(String str1, String str2) {
return Integer.compare(str1.length(), str2.length()); // 文字列の長さで比較
}
};
String[] strings = "May had a little lamb".split(" ");
Arrays.sort(strings, comp); // 文字列の長さ順にソート
Compatator<String> comp =
(String str1, String str2) -> {
Integer.compare(str1.length(), str2.length());
} ;
String[] strings = "May had a little lamb".split(" ");
Arrays.sort(strings, comp);

16. ラムダ式の分解
16
 ラムダ式とは、引数を持つコードブロック
 引数とコードブロックは->でつなぐ
 関数型インタフェースのオブジェクトの代わりに使える
 オブジェクトなので変数に代入すれば文となる
 直接利用することもできる（後述）
(String str1, String str2)
->
Compatator<String> comp =
;
{
Integer.compare(str1.length(), str2.length());
}
引数
コードブロック
ラムダ式
文

17. ラムダ式に表れないもの
17
 関数名は不要
 関数は1個しかないので自明⇒不要（書けない）
 戻り値の型は不要
 インタフェース側で定義されているので自明⇒不要（書けない）
 return文は必要に応じて
 [次スライド]
Compatator<String> comp = new Comparator<String>() {
public int compare(String str1, String str2) {
return Integer.compare(str1.length(), str2.length());
}
};
Compatator<String> comp =
(String str1, String str2) -> {
Integer.compare(str1.length(), str2.length());
} ;
不要省略

18. returnが省略できるケース
18
 コードブロックの最後の文をリターンする⇒省略可能
Compatator<String> comp =
(String str1, String str2) -> {
Integer.compare(str1.length(), str2.length()); // compare()の戻り値が返
る
} ;
Compatator<String> comp =
(String str1, String str2) -> {
return Integer.compare(str1.length(), str2.length());
} ;
Compatator<String> comp =
(String str1, String str2) -> {
if (str1.length() < str2.length()) return -1;
else if (fiirst.length() > str2.length()) return 1;
else return 0;
} ;
 returnを書いてもよい
 複数個所でリターンする⇒return必要
省略

19. ラムダ式：引数型省略
19
 基本形
Compatator<String> comp =
(String str1, String str2) -> {
Integer.compare(str1.length(), str2.length());
} ;
 型省略：引数型は省略可能
Compatator<String> comp =
(str1, str2) -> { // Stringを省略 (コンパイラによる型推定)
Integer.compare(str1.length(), str2.length());
} ;
省略

20. ラムダ式：コードブロックの{}省略
20
 基本形
Compatator<String> comp =
(String str1, String str2) -> {
Integer.compare(str1.length(), str2.length());
} ;
 型省略
Compatator<String> comp =
(str1, str2) -> {
Integer.compare(str1.length(), str2.length());
} ;
Compatator<String> comp =
(str1, str2) -> Integer.compare(str1.length(), str2.length()) ; // {}を省略
 {}省略：１文だけの場合はコードブロックの{}を省略可能
省略

21. ラムダ式：引数の()省略
21
 旧スタイル（非ラムダ式）
EventHandler<ActionEvent> listener = new EventHandler<ActionEvent>() {
public void handle(ActionEvent event) {
System.out.println(event);
}
};
Button button = new Button("Click");
button.setOnAction(listener);
 ラムダ式：引数が１個の場合は()を省略可能
// 基本形
EventHandler<ActionEvent> listener = (ActionEvent event) ->
{ System.out.println(event); };
// 型省略
EventHandler<ActionEvent> listener = (event) -> { System.out.println(event); };
// {}省略
EventHandler<ActionEvent> listener = (event) -> System.out.println(event) ;
// ()省略
EventHandler<ActionEvent> listener = event -> System.out.println(event) ;

22. ラムダ式：空の()
22
 旧スタイル（非ラムダ式）
 引数がない場合は空の()とする
Runnable runner = new Runnable() {
public void run() {
doWork();
}
};
new Thread(runner).start();
Runnable runner = () -> {
doWork();
} ;
new Thread(runner).start();

23. 【まとめ】ラムダ式の書式
23
 ラムダ式とは
 引数を持つコードブロック
 基本書式
 (引数型1 仮引数1,引数型2 仮引数2, …) -> { 文1; 文2; … }
 引数型は省略可能
 (仮引数1,仮引数2, …) -> { 文1; 文2; … }
 引数が１個の場合は()を省略可能
 仮引数1 -> { 文1; 文2; … }
 引数が無い場合は空の()
 () -> { 文1; 文2; … }
 コードブロックが１文だけの場合は{}を省略可能
 (仮引数1,仮引数2, …) -> 文1;

24. ラムダ式の利用：単一コードブロック
24
 ラムダ式を変数に代入して利用する
// 基本形
Compatator<String> comp =
(String str1, String str2) -> { Integer.compare(str1.length(), str2.length()); } ;
// 型省略
Compatator<String> comp = (str1, str2) -> { Integer.compare(str1.length(),
str2.length()); } ;
// {}省略
Compatator<String> comp = (str1, str2) -> Integer.compare(str1.length(),
str2.length()) ;
// 基本形
Arrays.sort(strings, (String str1, String str2) -> { Integer.compare(str1.length(),
str2.length()); } );
// 型省略
Arrays.sort(strings, (str1, str2) -> { Integer.compare(str1.length(), str2.length()); } );
// {}省略
Arrays.sort(strings, (str1, str2) -> Integer.compare(str1.length(), str2.length()) );
// ラムダ式の利用
Arrays.sort(strings, comp);
 ラムダ式を直接利用する

25. ラムダ式の利用：複数コードブロック
25
 複数コードブロックのラムダ式を直接利用する
 長すぎると読みにくくなるので注意
// ラムダ式の利用
Arrays.sort(strings, (str1, str2) -> {
if (str1.length() < str2.length()) return -1;
else if (fiirst.length() > str2.length()) return 1;
else return 0;
} );

26. ラムダ式の利用：単一引数
26
 ラムダ式を変数に代入して利用する
// 基本形
EventHandler<ActionEvent> listener = (ActionEvent event) ->
{ System.out.println(event); };
// 型省略
EventHandler<ActionEvent> listener = (event) -> { System.out.println(event); };
// {}省略
EventHandler<ActionEvent> listener = (event) -> System.out.println(event) ;
// ()省略
EventHandler<ActionEvent> listener = event -> System.out.println(event) ;
// ラムダ式の利用
button.setOnAction(listener);
 ラムダ式を直接利用する
// 基本形
button.setOnAction( (ActionEvent event) -> { System.out.println(event); } );
// 型省略
button.setOnAction( (event) -> { System.out.println(event); } );
// {}省略
button.setOnAction( (event) -> System.out.println(event) );
// ()省略
button.setOnAction( event -> System.out.println(event) );

27. 注意）乱用しすぎ
27
public void func() {
new Thread(new MyTask()).start();
}
class MyTask implements Runnable {
public void run() {
for (boolean cont = true; cont; ) {
// any task…
try {
Thread.sleep(1000);
} catch (InterruptedException e)
{
cont = false;
}
}
}
}
public void func() {
new Thread( () -> {
for (boolean cont = true; cont; ) {
// any task…
try {
Thread.sleep(1000);
} catch (InterruptedException e)
{
cont = false;
}
}
} ).start();
}
public void func() {
Runnable task = () -> {
for (boolean cont = true; cont; ) {
// any task…
try {
Thread.sleep(1000);
} catch (InterruptedException e)
{
cont = false;
}
}
};
new Thread(task).start();
やりすぎ？
この程度
まで？

28. 注意）ラムダ式はObjectではない
28
 無名クラスのインスタンスはObjectである
Compatator<String> comp = (str1, str2) -> Integer.compare(str1.length(),
str2.length()) ;
Object comp = new Comparator<String>() {
public int compare(String str1, String str2) {
return Integer.compare(str1.length(), str2.length());
}
};
// Error: The target type of this expression must be functional interface
Object comp = (str1, str2) -> Integer.compare(str1.length(), str2.length()) ;
 ラムダ式はObjectではない
 Objectに代入しようとするとコンパイルエラー
BiFunction<String, String, Integer> comp =
(str1, str2) -> Integer.compare(str1.length(), str2.length()) ;
 ラムダ式は汎用関数型インタフェースに代入できる
 ただし、・・・

29. 特殊なラムダ式
メソッド参照とコンストラクタ参照
29
 ラムダ式のコードブロックが関数1個だけの場合はメソッ
ド参照を、コンストラクタだけの場合はコンストラクタ参照
を利用できる
 メソッド参照
 object::instanceMethod⇒インスタンスメソッドの参照
 Class::staticMethod⇒クラスメソッドの参照
 Class::instanceMethod ⇒（第２の）インスタンスメソッドの参
照
 コンストラクタ参照
 Class::new⇒コンストラクタ参照

30. インスタンスメソッド参照によるラムダ式
30
 通常のラムダ式
// 変数経由
EventHandler<ActionEvent> listener = event -> System.out.println(event) ;
button.setOnAction(listener);
// 直接利用
button.setOnAction(event -> System.out.println(event));
// 変数経由
EventHandler<ActionEvent> listener = System.out::println ;
button.setOnAction(listener);
// 直接利用
button.setOnAction(System.out::println);
 メソッド参照（object::instanceMethod）によるラムダ式
 インスタンスメソッドを参照するだけで、ラムダ式に変換される

31. ３段活用（１）
31
 関数型インタフェース
EventHandler<ActionEvent> listener = new EventHandler<ActionEvent>() {
public void handle(ActionEvent event) {
System.out.println(event);
}
};
// 基本形
EventHandler<ActionEvent> listener = (ActionEvent event) ->
{ System.out.println(event); };
// 型省略
EventHandler<ActionEvent> listener = (event) -> { System.out.println(event); };
// {}省略
EventHandler<ActionEvent> listener = (event) -> System.out.println(event) ;
// ()省略
EventHandler<ActionEvent> listener = event -> System.out.println(event) ;
 ラムダ式
 （インスタンス）メソッド参照
EventHandler<ActionEvent> listener = System.out::println ; // (event)引数
を補完

32. 32
// 基本形
button.setOnAction( (ActionEvent event) -> { System.out.println(event); } );
// 型省略
button.setOnAction( (event) -> { System.out.println(event); } );
// {}省略
button.setOnAction( (event) -> System.out.println(event) );
// ()省略
button.setOnAction( event -> System.out.println(event) );
button.setOnAction(System.out::println); // (event)引数を補完
button.setOnAction( new EventHandler<ActionEvent>() {
public void handle(ActionEvent event) {
System.out.println(event);
}
} );
 関数型インタフェース
 ラムダ式
 （インスタンス）メソッド参照
３段活用（２）
ActionEventを引数とする、戻り値voidの関数

33. クラスメソッド参照によるラムダ式
33
 通常のラムダ式
 メソッド参照（Class::staticMethod）によるラムダ式
 クラスメソッドを参照するだけでラムダ式に変換される
Integer[] ints = { 2, 9, 4, 7 };
// 変数経由
Comparator<Integer> comp = (i1, i2) -> Integer.compare(i1, i2);
Arrays.sort(ints, comp);
// 直接利用
Arrays.sort(ints, (i1, i2) -> Integer.compare(i1, i2) );
// 変数経由
Comparator<Integer> comp = Integer::compare; // (x, y)引数を補完
Arrays.sort(ints, comp);
// 直接利用
Arrays.sort(ints, Integer::compare ); // (x, y)引数を補完
public interface Comparator<T> {
int compare(T o1, T o2);
}
public class Integer extends
Number {
static int compare(int x, int y);
(Integer, Integer)を引数とする、戻り値intの関数

34. （第２の）インスタンスメソッド参照によるラムダ式
34
 通常のラムダ式
 メソッド参照（Class::instanceMethod）によるラムダ式
 第一引数を対象オブジェクトとするラムダ式に変換される
String[] strings = { "foo", "bar", "taro" };
// 変数経由
Comparator<String> comp = (s1, s2) -> s1.compareTo(s2);
Arrays.sort(strins, comp);
// 直接利用
Arrays.sort(strings, (s1, s2) -> s1.compareTo(s2) );
// 変数経由
Comparator<String> comp = String::compareTo; // s1オブジェクトと(s2)引数を
補完
Arrays.sort(strings, comp);
// 直接利用
Arrays.sort(strings, String::compareTo ); // s1オブジェクトと(s2)引数を補完
public interface Comparator<T> {
int compare(T o1, T o2);
}
public class String {
int compareTo(String s);
(String, String)を引数とする、戻り値intの関数。ただし、第一引数は
this

35. コンストラクタ参照
35
 コンストラクタ参照（Class::new）
// 無名クラス
Creator creator = new Creator() {
public Button create(String label) {
return new Button(label);
}
};
String labelStr = "OK";
Button button = Factory.getButton(creator, labelStr);
// ボタン生成工場
class Factory {
static Button getButton(Creator creator, String
label) {
return creator.create(label);
}
}
// ラムダ式
Creator creator = label -> new Button(label);
Button button = Factory.getButton(creator, labelStr);
Button button = Factory.getButton(label -> new Button(label), labelStr);
// コンストラクタ参照
Creator creator = Button::new;
Button button = Factory.getButton(creator, labelStr);
Button button = Factory.getButton(Button::new, labelStr);
// ボタン生成インタフェース
interface Creator {
Button create(String label);
}
// ボタンクラスのコンストラクタ
class Button … {
Button();
Button(String label);
}
Stringを引数とする、戻り値Buttonの関数

36. 注意）
36
 メソッド参照（やコンストラクタ参照）は、ラムダ式のパラメ
タをそのままメソッド（やコンストラクタ）に渡すだけ
 パラメタを加工する必要があったり、文が複数ある場合は、メ
ソッド参照（やコンストラクタ参照）はできません
// ラムダ式が単純な引数渡しだけでない
Compatator<String> comp = (str1, str2) -> Integer.compare(str1.length(),
str2.length()) ;
// メソッド参照にはできない
Compatator<String> comp = Integer::compare ;

37. 【まとめ】メソッド参照とコンストラクタ参照
37
 インスタンスメソッド参照
 object::instanceMethod⇔(param…) ->
object.instanceMethod(param…)
 例）System.out::println ⇔ (event) -> System.out.println(event)
 クラスメソッド参照
 Class::staticMethod⇔(param…) -> Class.staticMethod(param…)
 例) Integer::compare ⇔ (i1, i2) -> Integer.compare(i1, i2)
 （第２の）インスタンスメソッド参照
 Class::instanceMethod⇔(param…) ->
param1.instanceMethod(param2…)
 例) String::compareTo ⇔ (s1, s2) -> s1.compareTo(s2)
 コンストラクタ参照
 Class::new ⇔ (param…) -> new Class(param…)
 例) String::new ⇔ new String(param…)

38. ストリームAPIで効力発揮
38
 ストリームAPIでは、ストリーム内に流れてくるデータに
関数を適用して計算していきます。⇒例
 Stringのリストをstream()関数でストリーム状にする
 ストリームを流れてくる文字列１つ１つについてmap()を実行
 map()にはStringを引数としてButtonを返す関数を渡す
 つまり、こう
List<String> labels = Arrays.asList("Ok", "Cancel", "Reset");
Stream<Button> buttons = labels.stream().map(Button::new);
Function<String, Button> f = Button::new; // コンストラクタ参照
Stream<Button> buttons = labels.stream().map(f);
Function<String, Button> f = label -> new Button(label); // ラムダ式
Stream<Button> buttons = labels.stream().map(f);
Stream<Button> map(Function<String, Button> mapper)

39. ストリームAPI
39
 未
 力尽きました

40. 最後に
40
 Java 8のインパクト
 関数型プログラミングを理解しないと、開発できなくなります
 （ラムダ式で書かれた）他人のプログラムが読めなくなる
 ライブラリがラムダ式化されると、分かってないとプログラム書けない
 インタフェースの仕様拡張
 オブジェクト指向の設計や実装が柔軟になる
 インタフェースと抽象クラスを混同しないよう
 ラムダ式
 遅ればせながら関数型プログラミングが可能に
 スクリプト言語に比べるとコンパイラの助けが得られる
 ストリームAPI
 処理の手順を記述するのではなく、処理したいことを記述する
 処理の手順は、言語処理系に任せる
 並列・分散処理が可能に