Java SE 8 lambdaで変わるプログラミングスタイル

Java SE 8 lambdaで変わる
プログラミングスタイル
2013/11/15 きしだなおき

ラムダがきたよ
●
●
●

匿名関数
関数型スタイルには必須
流行！

JavaOneでのラムダ
●
●
●

関連セッションが大人気！！
どのセッションも行列！！
人数オーバーで入れない！！

ラムダの目的
●
●

建前：並列化
本音：Cool！！

ラムダ構文
●
●
●
●

関数型インタフェース
ラムダ記法
メソッド参照
interfaceのデフォルトメソッド

関数型インタフェース
●

実装すべきメソッドがひとつだけのインタフェース
–

Runnable
●

–

ActionListener
●

●

実装すべきメソッド:run()
実装すべきメソッド:actionPerformed(ActionEvent)

@FuncationalInterfaceで検査可能

用意された関数型インタフェース

http://d.hatena.ne.jp/nowokay/20130824#1377300917

ラムダ構文の基礎
ActionListener al = new ActionListener() {
@Override
public void actionPerformed(ActionEvent e) {
taOutput.append(txtMessage.getText() + "n");
}
};

@Override
}
};
インタフェース名やメソッド名は推論される

@Override
}
};
引数とメソッド本体の間に「->」が入る

->

@Override
}
};

ActionListener al = (ActionEvent e) -> {
};

->

●

IDEで変換

@Override
}
};

};
引数の型も省略できる

->

@Override
}
};

};
引数がひとつならカッコが省略できる

->

@Override
}
};

};
本文が一行ならカッコとセミコロンが省略できる
(return文のときはreturnも省略)

->

@Override
}
};

ActionListener al = e ->taOutput.append(txtMessage.getText() + "n");

->

メソッド参照
●

引数ひとつのインスタンスメソッド
–

●

インスタンス::メソッド

引数ひとつのstaticメソッド
引数なしのインスタンスメソッド
–

クラス::メソッド
public void init() {
btnInput.addActionListener(this::inputClicked);
}
public void inputClicked(ActionEvent ae){
}

デフォルトメソッド
●

Listなどへのラムダ対応が必要

●

interfaceがメソッドをもてる

●

ついでに多重継承もできる
@FunctionalInterface
interface Hoge{
String foo();
default void bar(){
System.out.println(foo() + "ですってバー");
}
}
void proc(){
Hoge h = () -> "やあ";
h.bar();
}

Stream
●

外部イテレーションから内部イテレーションへ
–

外部イテレーション(for)

–

内部イテレーション(Stream)

Stream
外部イテレーション
for(String s : strs){
if(!s.startsWith("h")){
continue;
}
String u = s.toUpperCase();
System.out.println(u);
}

内部イテレーション

strs.stream()
.filter(s -> s.startsWith("h"))
.map(s -> s.toUpperCase())
.forEach(System.out::println);

操作種別
●

ソース
–

●

中間操作
–

●

操作対象になる
他のStreamを生成する

終端操作
–

結果の実行

ソース
ソース

並列性

特徴

ArrayList、配列

良い

SIZED, ORDERED

LinkedList

悪い

SIZED, ORDERED

HashSet

まあまあ

SIZED, DISTINCT

TreeSet

まあまあ

SIZED, DISTINCT, SORTED, ORDERED

IntStream.range

良い

SIZED, DISTINCT, SORTED, ORDERED

BufferedReader.lines

悪い

ORDERED

特徴

説明

SIZED

サイズが決まっている

DISTINCT

重複なし

ORDERED

順番つき

SORTED

整列済

中間操作
操作

効果

追記

fiter()

SIZEDがはずれる

map()

DISTINCT, SORTEDがはずれる

sorted()

SORTED, ORDEREDが追加

SORTEDならなにもしない

distinct()

DISTINCTが追加

DISTINCTならなにもしない

limit()

すべてそのまま

終端操作
集計

toArray
reduce
collect
sum,min,max,count
anyMatch, allMatch

イテレーション

forEach

検索

findFirst
findAny

プログラムモデルの変化
●
●
●
●
●
●

リダクション(畳み込み)
並列処理
遅延実行
無限ストリーム
メモ化(実行結果キャッシュ)
null排除

リダクション(畳み込み)
●

ストリームの値をひとつにまとめる

3

5

3

8

6

1

3

9

38

int s = IntStream.of(3, 5, 3, 8, 6, 1, 3, 9)
.sum();

リダクション:集計
int[] ar = {3, 5, 3, 8, 6, 1, 3, 9};
int total = 0;
for(int i : ar){
total += i;
}
System.out.println(total);

int[] ar = {3, 5, 3, 8, 6, 1, 3, 9};
System.out.println(Arrays.stream(ar).sum());

リダクションリスト変換
List<Integer> al = Arrays.asList(3, 5, 3, 8, 6, 1, 3, 9);
List<Integer> pows = new ArrayList<>();
for(int i : al){
if(i >= 5){
continue;
}
int pow = i * i;
pows.add(pow);
}

List<Integer> pows = al.stream()
.filter(i -> i < 5)
.map(i -> i * i)
.collect(Collectors.toList());

リダクション:判定
boolean flag = true;
for(int i : al){
if(i >= 10){
flag = false;
}
}

boolean flag = al.stream()
.allMatch(i -> i < 10);

リダクション:グループ化
List<String> strs = Arrays.asList("hello", "paul", "heaven", "tatsuro");
Map<String, List<String>> result = new HashMap<>();
for(String s : strs){
String head = s.substring(0, 1);
List<String> list = result.get(head);
if(list == null){
list = new ArrayList<>();
result.put(head, list);
}
list.add(s);
}
for(Map.Entry<String, List<String>> me : result.entrySet()){
System.out.println(me.getKey() + ":" + me.getValue());
}

List<String> strs = Arrays.asList("hello", "paul", "heaven", "tatsuro");
Map<String, List<String>> result = strs.stream()
.collect(Collectors.groupingBy(s -> s.substring(0, 1)));
result.forEach((k, v) -> System.out.println(k + ": " + v));

リダクション:reduce
●

例：合計
–

(((0 + a1) + a2) + a3)

–

.sum() ⇒.reduce(0, (s, e) -> s + e)

–

.count() ⇒.map(e -> 1).sum()

リダクション:reduce
●

reduce(単位元, (s, e) -> s ＊ e)
–

–

●

s ＊ e：結合則のある2項演算
結合則：(s1 ＊ s2) ＊ s3=s1 ＊ (s2 ＊ s3)
単位元：zを単位元とすると、
s＊z=z＊s=s

例:
–

a + b[単位元0]

–

a × b[単位元1]

–

a and b[単位元 true]

–

list.add(b)[単位元 new ArrayList()]

リダクション(畳み込み)で何が変わるか
●
●
●

中間状態の隠蔽
中間状態の管理が不要になる
畳み込み操作でのバグは中間状態の操作ミスが
多かった

並列処理
●

stream()の代わりにparallelStream()にするだけ
–

もしくはparallel()の呼び出し
3

5

3

38
8

8

6

38
11

1

3

38
7

9

12
38
19
38

19

38
int s = IntStream.of(3, 5, 3, 8, 6, 1, 3, 9)
.parallel()
.sum();

遅延実行
●
●

●

Javaは即時評価の言語
メソッド内で使われない値でも引数に渡すときに計
算が必要だった
ほとんどの場合に表示されないログやエラーでの
メッセージ生成が無駄
logger.info(objWithManyFields.toString());

Objects.requireNonNull(objWithManyFields.getHoge(),
objWithManyFields.toString());

遅延実行
●
●

ラムダ式を渡すことで、必要なときに式を評価
LoggerやObjects.requireNonNullは対応
logger.info(() -> objWithManyFields.toString());
Objects.requireNonNull(objWithManyFields.getHoge(),
() -> objWithManyFields.toString());

遅延実行：Stream Pipeline
●

Streamの中間操作は、終端操作のときに実行され
る

無限ストリーム(リスト)
●

Hondaストリームの無限チューンではありません

●

終端の決まらないストリーム
初期値

次の値を求める処理

IntStream.iterate(0, i -> i + 1)
.limit(10)

IntStream.iterate(321, i -> (i * 211 + 2111) % 1999)
.limit(10)

メモ化
●
●

実行結果キャッシュ
ex:再帰フィボナッチ
public static void main(String... args){
LongStream.iterate(1, i -> i + 1)
.map(i -> fib(i))
}
public static long fib(long x){
if(x <= 2) return 1;
return fib(x - 1) + fib(x - 2);
}

メモ化：再帰フィボナッチ
●

1回ごとに2回の呼び出し
–

●

O(2^n)

なかなか進まない！
run:
1
1
2
3
5
8
13
・
・
・
1836311903
2971215073
4807526976←このあたりで止まる

メモ化：メモ化再帰フィボナッチ
●
●
●

同じパラメータで何度も呼び出される
結果キャッシュ⇒メモ化！
computeIfAbsentが便利
static Map<Long, Long> cache = new HashMap<>();
public static long fib(long i){
return cache.computeIfAbsent(i, x -> {
if(x <= 2) return 1L;
return fib(x - 1) + fib(x - 2);
});
}
あっという間にlongも桁あふれ
-415292901391291839
-7413871255405604094
-7829164156796895933
3203708661507051589
-4625455495289844344

null排除
●

みんな大好きNullPointerException！
static String foo(int x){
return x > 0 && x < 10
? IntStream.range(0, x)
.mapToObj(c -> (char)('a' + c) + "")
.collect(Collectors.joining())
: null;
}
static String bar(String s){
return s.chars().max().orElse(0) % 2 == 0
? null : s;
}
for(int i = 0; i < 20; ++i){
String s = bar(foo(i)).toUpperCase();
System.out.println(s);
}
}

nullを返す可能性

nullを返す可能性

NullPointerException
の可能性

null排除：確実なnullチェックは面倒
for(int i = 0; i < 20; ++i){
String s = bar(foo(i)).toUpperCase();
System.out.println(s);
}

IntStream.range(0, 20)
.mapToObj(MyClass::foo)
.map(MyClass::bar)
.map(String::toUpperCase)

要nullチェック
呼び出しの分
解も必要

Streamでも要
nullチェック

for(int i = 0; i < 20; ++i){
String s = foo(i);
if(s == null) continue;
String s2 = bar(s);
if(s2 == null) continue;
String up = s2.toUpperCase();
System.out.println(up);
}

.filter(Objects::nonNull)
.map(MyClass::bar)
.filter(Objects::nonNull)

null排除：Optional
●
●

型としてnullの可能性を示せる
nullへの対処が
書きやすい

Optionalが返る
一度Optionalにくるまれると
nullが返っても気にならない

static Optional<String> foo(int x){
return x > 0 && x < 10
? Optional.of(IntStream.range(0, x)
.collect(Collectors.joining()))
: Optional.empty();
}
static String bar(String s){
? null : s;
}
for(int i = 0; i < 20; ++i){
foo(i)
.map(MyClass::bar)
.ifPresent(System.out::println);
}
}

null排除:Optional#flatMap
return x > 0 && x < 10
: Optional.empty();
}
static Optional<String> bar(String s){
? Optional.empty() : Optional.of(s);
}
for(int i = 0; i < 20; ++i){
foo(i)
.flatMap(MyClass::bar)
}
}

Optionalが返るものを
はさむならflagMap

null排除：Streamだとちょっと面倒かも
.forEach(op -> {
op.flatMap(MyClass::bar)
});

null排除：完璧ではない
●

Optional自体がnullだとNullPointerException
return x > 0 && x < 10
: null;
}
static Optional<String> bar(String s){
? null : Optional.of(s);
}
for(int i = 0; i < 20; ++i){
foo(i)
.flatMap(MyClass::bar)
}
}

nullを返してしまっている

NullPointerException!

Java SE 8 lambdaで変わる プログラミングスタイル

More Related Content

What's hot

Viewers also liked

Similar to Java SE 8 lambdaで変わる プログラミングスタイル

More from なおき きしだ