Javaによる関数型プログラミングJava8ラムダ式とStream#

1
// 自殺点パターンと呼ぶ
2
    for(int i = 0; i < friends.size(); i++) {
3
      System.out.println(friends.get(i));
4
    }
5
// 冗長でエラーが発生しやすいから
6
// <i だったかな？ <=i だったかな？と悩む
7

8
// 上記よりは儀式が少なくなっている
9
// 特定のインデックスに対する操作がなければ、上記より優れているパターン
10
    for(String name : friends) {
11
      System.out.println(name);
12
    }
13

14
// これら両方とも命令形のコードであり、モダンなJavaでは捨て去ることができる

1
    System.out.println("//" + "START:INTERNAL_OUTPUT");
2
    friends.forEach((final String name) -> System.out.println(name));
3
    System.out.println("//" + "END:INTERNAL_OUTPUT");
4

5
    friends.forEach((name) -> System.out.println(name));
6

7
    // 型推論されたパラメータはfinalが保証されなくなる
8
    // 引数を変更しない習慣を開発者自身が身につける必要がある
9
    friends.forEach(name -> System.out.println(name));
10

11
    friends.forEach(System.out::println);

1
{
2
    final List<String> startsWithN = new ArrayList<String>();
3
    for(String name : friends) {
4
      if(name.startsWith("N")) {
5
        startsWithN.add(name);
6
      }
7
    }
8
    System.out.println(String.format("Found %d names", startsWithN.size()));
9
}
10
{
11
    final List<String> startsWithN =
12
      friends.stream()
13
             .filter(name -> name.startsWith("N"))
14
             .collect(Collectors.toList());
15
    System.out.println(String.format("Found %d names", startsWithN.size()));
16
}

1
    final Predicate<String> startsWithN = name -> name.startsWith("N");
2

3
    final long countFriendsStartN =
4
      friends.stream()
5
             .filter(startsWithN)
6
             .count();
7
    final long countEditorsStartN =
8
      editors.stream()
9
             .filter(startsWithN)
10
             .count();
11
    final long countComradesStartN =
12
      comrades.stream()
13
              .filter(startsWithN)
14
              .count();

1
    final Function<String, Predicate<String>> startsWithLetter =
2
      letter -> name -> name.startsWith(letter);
3

4
    final long countFriendsStartN =
5
      friends.stream()
6
             .filter(startsWithLetter.apply("N")).count();
7
    final long countFriendsStartB =
8
      friends.stream()
9
             .filter(startsWithLetter.apply("B")).count();

1
// エレガントな例
2
  public static void pickName(
3
    final List<String> names, final String startingLetter) {
4
    final Optional<String> foundName =
5
      names.stream()
6
           .filter(name ->name.startsWith(startingLetter))
7
           .findFirst();
8
    System.out.println(String.format("A name starting with %s: %s",
9
      startingLetter, foundName.orElse("No name found")));
10
  }

1
System.out.println("//" + "START:SUM_OUTPUT");
2
      System.out.println("Total number of characters in all names: " +
3
        friends.stream()
4
               .mapToInt(name -> name.length())
5
               .sum());
6
    }
7
System.out.println("//" + "END:SUM_OUTPUT");
8

9
System.out.println("//" + "END:AVERAGE_OUTPUT");
10
System.out.println("//" + "START:REDUCE_OUTPUT");
11
    final Optional<String> aLongName =
12
      friends.stream()
13
             .reduce((name1, name2) ->
14
                name1.length() >= name2.length() ? name1 : name2);
15
    aLongName.ifPresent(name ->
16
      System.out.println(String.format("A longest name: %s", name)));
17
System.out.println("//" + "END:REDUCE_OUTPUT");
18

19
    final String steveOrLonger =
20
      friends.stream()
21
             .reduce("Steve", (name1, name2) ->
22
                name1.length() >= name2.length() ? name1 : name2);
23

24
    System.out.println(steveOrLonger);

1
System.out.println("//" + "START:MAP_JOIN_OUTPUT");
2
    System.out.println(
3
      friends.stream()
4
             .map(String::toUpperCase)
5
             .collect(joining(", ")));
6
System.out.println("//" + "END:MAP_JOIN_OUTPUT");

1
    System.out.println("//" + "START:ITERATE_OUTPUT");
2

3
    final String str = "w00t";
4

5
    str.chars()
6
       .forEach(ch -> System.out.println(ch));
7
    System.out.println("//" + "END:ITERATE_OUTPUT");
8

9
    str.chars()
10
       .forEach(System.out::println);
11

12
    System.out.println("//" + "START:FIX_OUTPUT");
13
    str.chars()
14
       .forEach(IterateString::printChar);
15
    System.out.println("//" + "END:FIX_OUTPUT");
16

17
        str.chars()
18
           .mapToObj(ch -> Character.valueOf((char)ch))
19
           .forEach(System.out::println);
20

21
    System.out.println("//" + "START:FILTER_OUTPUT");
22
    str.chars()
23
       .filter(ch -> Character.isDigit(ch))
24
       .forEach(ch -> printChar(ch));
25
    System.out.println("");
26
    System.out.println("//" + "END:FILTER_OUTPUT");
27

28
    str.chars()
29
       .filter(ch -> Character.isDigit(ch));
30

31
    str.chars()
32
       .filter(Character::isDigit);
33

34
    str.chars()
35
       .filter(Character::isDigit)
36
       .forEach(IterateString::printChar);

1
people.sorted((person1,person2) -> person1.ageDifference(person2)).collect(toList());
2
// ↓改善
3
people.stream().sorted(Person::ageDifference).collect(toList());

1
people.stream().sorted((person1, person2) -> person2.ageDifference(person1)).collect(toList());
2
// パラメータの順番が引数受け渡しの規約に従っていないため、メソッド参照を使うようにリファクタリングすることはできません。

1
  public static void main(String[] args) {
2
    final List<Person> people = Arrays.asList(
3
      new Person("John", 20),
4
      new Person("Sara", 21),
5
      new Person("Jane", 21),
6
      new Person("Greg", 35));
7

8
{
9
    System.out.println("//" + "START:AGE_ASCEND_OUTPUT");
10
    List<Person> ascendingAge =
11
      people.stream()
12
            .sorted((person1, person2) -> person1.ageDifference(person2))
13
            .collect(toList());
14
    printPeople("Sorted in ascending order by age: ", ascendingAge);
15
    System.out.println("//" + "END:AGE_ASCEND_OUTPUT");
16
}
17

18
{
19
  // メソッド参照（Method Reference）
20
    System.out.println("//" + "START:AGE_ASCEND_MR_OUTPUT");
21
    List<Person> ascendingAge =
22
      people.stream()
23
            .sorted(Person::ageDifference)
24
            .collect(toList());
25

26
    printPeople("Sorted in ascending order by age: ", ascendingAge);
27
    System.out.println("//" + "END:AGE_ASCEND_MR_OUTPUT");
28
}
29

30
{
31
    System.out.println("//" + "START:AGE_DESCEND_OUTPUT");
32
    printPeople("Sorted in descending order by age: ",
33
      people.stream()
34
            .sorted((person1, person2) -> person2.ageDifference(person1))
35
            .collect(toList()));
36
    System.out.println("//" + "END:AGE_DESCEND_OUTPUT");
37

38
    System.out.println("//" + "START:REVERSE_ORDER_OUTPUT");
39
    Comparator<Person> compareAscending =
40
      (person1, person2) -> person1.ageDifference(person2);
41
      // reversed()を使うことで降順の関数を事前に用意できる
42
    Comparator<Person> compareDescending = compareAscending.reversed();
43

44
    printPeople("Sorted in ascending order by age: ",
45
      people.stream()
46
            .sorted(compareAscending)
47
            .collect(toList())
48
    );
49
    printPeople("Sorted in descending order by age: ",
50
      people.stream()
51
            .sorted(compareDescending)
52
            .collect(toList())
53
    );
54
    System.out.println("//" + "END:REVERSE_ORDER_OUTPUT");
55

56
    // 名前の昇順に並び替え
57
    System.out.println("//" + "START:NAME_ASCEND_OUTPUT");
58
    printPeople("Sorted in ascending order by name: ",
59
      people.stream()
60
            .sorted((person1, person2) ->
61
               person1.getName().compareTo(person2.getName()))
62
            .collect(toList()));
63
    System.out.println("//" + "END:NAME_ASCEND_OUTPUT");
64
}
65

66
{
67
    // min()メソッドはOptionalを返す！
68
    System.out.println("//" + "START:YOUNGEST_OUTPUT");
69
    people.stream()
70
          .min(Person::ageDifference)
71
          .ifPresent(youngest -> System.out.println("Youngest: " + youngest));
72
System.out.println("//" + "END:YOUNGEST_OUTPUT");
73
}
74

75
{
76
    System.out.println("//" + "START:ELDEST_OUTPUT");
77
    people.stream()
78
          .max(Person::ageDifference)
79
          .ifPresent(eldest -> System.out.println("Eldest: " + eldest));
80
    System.out.println("//" + "END:ELDEST_OUTPUT");
81
}

1
{
2
    // 名前のアルファベット順にするために以下の関数を用意した
3
    // 従来の内部クラス構文と比較すると非常に簡潔
4
    people.stream()
5
          .sorted((person1, person2) ->
6
             person1.getName().compareTo(person2.getName()));
7

8
    printPeople("Sorted in ascending order by name: ",
9
    people.stream()
10
          .sorted(comparing((Person person) -> person.getName()))
11
          .collect(toList()));
12

13
    // Comparatorインターフェースのコンビニエンス関数を使用することで、より自由にコードの目的を表現できる
14
    // Comparaotrインターフェースのcomparing()メソッドを静的にインポートしました。comparing()メソッドは与えられた
15
    // ラムダ式のロジックを使用してComparatorを生成する！
16
    // つまり、関数（Function）を引数に取り、関数（Comparator）を返す高階関数
17
    final Function<Person, String> byName = person -> person.getName();
18
    people.stream()
19
          .sorted(comparing(byName));
20
}
21

22
{
23
    System.out.println("//" + "START:SORT_NAME_AND_AGE_OUTPUT");
24

25
    final Function<Person, Integer> byAge = person -> person.getAge();
26
    final Function<Person, String> byTheirName = person -> person.getName();
27

28
    printPeople("Sorted in ascending order by age and name: ",
29
      people.stream()
30
            .sorted(comparing(byAge).thenComparing(byTheirName))
31
            .collect(toList()));
32
    System.out.println("//" + "END:SORT_NAME_AND_AGE_OUTPUT");
33
}

1
// 20歳以上の人を抽出してリストを取得する
2
{
3
    // 従来の書き方
4
    System.out.println("//" + "START:MUTABLE_OUTPUT");
5
    List<Person> olderThan20 = new ArrayList<>();
6
      people.stream()
7
            .filter(person -> person.getAge() > 20)
8
            .forEach(person -> olderThan20.add(person));
9
    System.out.println("People older than 20: " + olderThan20);
10
    System.out.println("//" + "END:MUTABLE_OUTPUT");
11
    // 問題点：
12
    // ターゲットとするコレクションに要素を１つずつ追加する保s理はとても低レベルなもので、宣言型ではなく命令形のコード
13
    // 並列に実行させる場合にはスレッドセーフ問題を適切に処理しなければならない
14
    // 可変性を持つコードを並列化するのは難しいものです。
15
}
16

17
// この問題はcollect()を使うことで緩和できる
18
// collect()メソッドの以下の３つについて知っておく
19
// サプライヤ　　：結果を収めるコンテナの精製方法（例えば、ArrayList::new）
20
// アキュムレータ：結果コンテナに単一の要素を追加する方法（例えばArrayList::add）
21
// コンバイナ　　：結果コンテナを他のコンテナと結合する方法（例えばArrayList::addAll）
22

23
{
24
    // 便利な書き方！
25
    System.out.println("//" + "START:COLLECT_OUTPUT");
26
    List<Person> olderThan20 =
27
      people.stream()
28
            .filter(person -> person.getAge() > 20)
29
            .collect(ArrayList::new, ArrayList::add, ArrayList::addAll);
30
    System.out.println("People older than 20: " + olderThan20);
31
    System.out.println("//" + "END:COLLECT_OUTPUT");
32
}
33
// メリット：
34
// より明確で意図を持ったプログラミングを行っている→ArrayListに処理結果を集めることがこのコードの目的
35
// コード内で状態変更を行っていないため、イテレーションを簡単に並列化できる

1
{
2
    System.out.println("//" + "START:COLLECT_TO_LIST_OUTPUT");
3
    List<Person> olderThan20 =
4
      people.stream()
5
            .filter(person -> person.getAge() > 20)
6
            .collect(Collectors.toList());
7
    System.out.println("People older than 20: " + olderThan20);
8
    System.out.println("//" + "END:COLLECT_TO_LIST_OUTPUT");
9
}

1
{
2
    System.out.println("//" + "START:GROUP_BY_OUTPUT");
3
    Map<Integer, List<Person>> peopleByAge =
4
      people.stream()
5
            .collect(Collectors.groupingBy(Person::getAge));
6
    System.out.println("Grouped by age: " + peopleByAge);
7
    System.out.println("//" + "END:GROUP_BY_OUTPUT");
8
}
9

10
{
11
    System.out.println("//" + "START:GROUP_BY_AGE_NAME_OUTPUT");
12
    Map<Integer, List<String>> nameOfPeopleByAge =
13
      people.stream()
14
            .collect(
15
              groupingBy(Person::getAge, mapping(Person::getName, toList())));
16
    System.out.println("People grouped by age: " + nameOfPeopleByAge);
17
    System.out.println("//" + "END:GROUP_BY_AGE_NAME_OUTPUT");
18
}
19

20
{
21
    System.out.println("//" + "START:OLDEST_IN_EACH_LETTER_OUTPUT");
22
    Comparator<Person> byAge = Comparator.comparing(Person::getAge);
23
    Map<Character, Optional<Person>> oldestPersonOfEachLetter =
24
      people.stream()
25
            .collect(groupingBy(person -> person.getName().charAt(0),
26
               reducing(BinaryOperator.maxBy(byAge))));
27
    System.out.println("Oldest person of each letter:");
28
    System.out.println(oldestPersonOfEachLetter);
29
    System.out.println("//" + "END:OLDEST_IN_EACH_LETTER_OUTPUT");
30
}

1
  // 以下の２つとも古いjavaより格段にシンプル
2
  Files.list(Paths.get("."))
3
       .forEach(System.out::println);
4
  }
5
  Files.list(Paths.get("."))
6
       .filter(Files::isDirectory) // filterはPredicateを期待する
7
       .forEach(System.out::println);
8
  }

1
  final String[] files =
2
    new File("fpij").list(new java.io.FilenameFilter() {
3
      public boolean accept(final File dir, final String name) {
4
        return name.endsWith(".java");
5
      }
6
    });

1
    Files.newDirectoryStream(
2
         Paths.get("fpij"), path -> path.toString().endsWith(".java"))
3
     .forEach(System.out::println);
4
  }

1
  public static void listTheHardWay() {
2
    List<File> files = new ArrayList<>();
3

4
    File[] filesInCurrentDir = new File(".").listFiles();
5
    for(File file : filesInCurrentDir) {
6
      File[] filesInSubDir = file.listFiles();
7
      if(filesInSubDir != null) {
8
        files.addAll(Arrays.asList(filesInSubDir));
9
      } else {
10
        files.add(file);
11
      }
12
    }
13

14
    System.out.println("Count: " + files.size());
15
  }
16

17
  public static void betterWay() {
18
    List<File> files =
19
      Stream.of(new File(".").listFiles())
20
            .flatMap(file -> file.listFiles() == null ?
21
                Stream.of(file) : Stream.of(file.listFiles()))
22
            .collect(toList());
23
    System.out.println("Count: " + files.size());
24
  }

1
  public static void main(String[] args) throws Exception {
2
    new Thread(() -> watchFileChange()).start();
3
    final File file = new File("sample.txt");
4
    file.createNewFile();
5
    Thread.sleep(5000);
6
    file.setLastModified(System.currentTimeMillis());
7
  }
8

9
  public static void watchFileChange() {
10
    try {
11
      final Path path = Paths.get(".");
12
      final WatchService watchService =
13
        path.getFileSystem()
14
            .newWatchService();
15

16
      path.register(watchService, StandardWatchEventKinds.ENTRY_MODIFY);
17

18
      System.out.println("Report any file changed within next 1 minute...");
19

20
      final WatchKey watchKey = watchService.poll(1, TimeUnit.MINUTES);
21

22
      if(watchKey != null) {
23
        watchKey.pollEvents()
24
                .stream()
25
                .forEach(event ->
26
                   System.out.println(event.context()));
27
      }
28
    } catch(InterruptedException | IOException ex) {
29
      System.out.println(ex);
30
    }
31
  }

1
  private FluentMailer() {}
2

3
  public FluentMailer from(final String address) { /*... */; return this; }
4
  public FluentMailer to(final String address)   { /*... */; return this; }
5
  public FluentMailer subject(final String line) { /*... */; return this; }
6
  public FluentMailer body(final String message) { /*... */; return this; }
7

8
  public static void send(final Consumer<FluentMailer> block) {
9
    final FluentMailer mailer = new FluentMailer();
10
    block.accept(mailer);
11
    System.out.println("sending...");
12
  }
13

14
  //...
15
  public static void main(final String[] args) {
16
    FluentMailer.send(mailer ->
17
      mailer.from("build@agiledeveloper.com")
18
            .to("venkats@agiledeveloper.com")
19
            .subject("build notification")
20
            .body("...much better..."));
21
  }

1
public class FileWriterEAM  {
2
  private final FileWriter writer;
3

4
  private FileWriterEAM(final String fileName) throws IOException {
5
    writer = new FileWriter(fileName);
6
  }
7
  private void close() throws IOException {
8
    System.out.println("close called automatically...");
9
    writer.close();
10
  }
11
  public void writeStuff(final String message) throws IOException {
12
    writer.write(message);
13
  }
14
  //...
15

16
  public static void use(final String fileName,
17
    final UseInstance<FileWriterEAM, IOException> block) throws IOException {
18

19
    final FileWriterEAM writerEAM = new FileWriterEAM(fileName);
20
    try {
21
      block.accept(writerEAM);
22
    } finally {
23
      writerEAM.close();
24
    }
25
  }
26

27
  public static void main(final String[] args) throws IOException {
28

29
    System.out.println("//" + "START:EAM_USE_OUTPUT");
30
    FileWriterEAM.use("eam.txt", writerEAM -> writerEAM.writeStuff("sweet"));
31
    System.out.println("//" + "END:EAM_USE_OUTPUT");
32

33
    FileWriterEAM.use("eam2.txt", writerEAM -> {
34
        writerEAM.writeStuff("how");
35
        writerEAM.writeStuff("sweet");
36
      });
37

38
  }
39

40
}
41

42
// interface
43
// @FunctionalInterfaceは関数型インターフェースであることの宣言
44
// 例外を考慮する必要がなければ、Consumerインターフェースを使えばよかったが、ラムダ式は、合成されるabstratメソッドのシグネチャの一部として定義されたチェック例外を投げることができるため実装
45
@FunctionalInterface
46
public interface UseInstance<T, X extends Throwable> {
47
  void accept(T instance) throws X;
48
}

1
public class Locker {
2
  public static void runLocked(Lock lock, Runnable block) {
3
    lock.lock();
4

5
    try {
6
      block.run();
7
    } finally {
8
      lock.unlock();
9
    }
10
  }
11
}

1
public class RodCutter {
2
  private boolean mustFail;
3

4
  public RodCutter(final boolean fail) { mustFail = fail; }
5

6
  public void setPrices(final List<Integer> prices) {
7
    //...
8
    if(mustFail)
9
      throw new RodCutterException();
10
  }
11

12
  public int maxProfit(final int length) {
13
    if (length == 0) throw new RodCutterException();
14

15
    return 0;
16
  }
17
}
18

19

20
public class RodCutterTest {
21
  private RodCutter rodCutter;
22
  private List<Integer> prices;
23

24
  protected RodCutter createCutter() {
25
    return new RodCutter(false);
26
  }
27

28
  @Before public void initialize() {
29
    rodCutter = createCutter();
30
    prices = Arrays.asList(1, 1, 2, 2, 3, 4, 5);
31
  }
32

33
  @Test public void VerboseExceptionTest() {
34
    rodCutter.setPrices(prices);
35
    try {
36
      rodCutter.maxProfit(0);
37
      fail("Expected exception for zero length");
38
    } catch(RodCutterException ex) {
39
      assertTrue("expected", true);
40
    }
41
  }
42

43
  @Test(expected = RodCutterException.class)
44
  public void TerseExceptionTest() {
45
    rodCutter.setPrices(prices);
46
    rodCutter.maxProfit(0);
47
  }
48

49
  // Lamda式を利用したテスト方法
50
  @Test
51
  public void ConciseExceptionTest() {
52
    rodCutter.setPrices(prices);
53
    assertThrows(RodCutterException.class, () -> rodCutter.maxProfit(0));
54
  }
55

56
  public static void main(String[] args) {
57
    junit.textui.TestRunner.run(new JUnit4TestAdapter(RodCutterTest.class));
58
  }
59
}
60

61

62
// HELPERの実装
63
public class TestHelper {
64
  public static <X extends Throwable> Throwable assertThrows(
65
    final Class<X> exceptionClass, final Runnable block) {
66

67
    try {
68
      block.run();
69
    } catch(Throwable ex) {
70
      if(exceptionClass.isInstance(ex))
71
        return ex;
72
    }
73
    fail("Failed to throw expected exception ");
74
    return null;
75
  }
76
}

1
public class Holder {
2
  private Supplier<Heavy> heavy = () -> createAndCacheHeavy();
3

4
  public Holder() {
5
    System.out.println("Holder created");
6
  }
7

8
  public Heavy getHeavy() {
9
    return heavy.get();
10
  }
11
  //...
12

13
  private synchronized Heavy createAndCacheHeavy() {
14
    class HeavyFactory implements Supplier<Heavy> {
15
      private final Heavy heavyInstance = new Heavy();
16

17
      public Heavy get() { return heavyInstance; }
18
    }
19

20
    if(!HeavyFactory.class.isInstance(heavy)) {
21
      heavy = new HeavyFactory();
22
    }
23

24
    return heavy.get();
25
  }
26

27
  public static void main(final String[] args) {
28
    final Holder holder = new Holder();
29
    System.out.println("deferring heavy creation...");
30
    System.out.println(holder.getHeavy());
31
    System.out.println(holder.getHeavy());
32
  }
33
}

1
public class Evaluation {
2
  public static boolean evaluate(final int value) {
3
    System.out.println("evaluating ..." + value);
4
    simulateTimeConsumingOp(2000);
5
    return value > 100;
6
  }
7
  //...
8

9
  public static void simulateTimeConsumingOp(final int millseconds) {
10
    try {
11
      Thread.sleep(2000);
12
    } catch(Exception ex) { throw new RuntimeException(ex); }
13
  }
14

15
  public static void eagerEvaluator(
16
    final boolean input1, final boolean input2) {
17
    System.out.println("eagerEvaluator called...");
18
    System.out.println("accept?: " + (input1 && input2));
19
  }
20

21
  /**
22
  * 遅延評価のためのメソッド
23
  * ラムダ式を引数に取り、実行自体はこのメソッドの中で行う
24
  */
25
  public static void lazyEvaluator(
26
    final Supplier<Boolean> input1, final Supplier<Boolean> input2) {
27
    System.out.println("lazyEvaluator called...");
28
    System.out.println("accept?: " + (input1.get() && input2.get()));
29
  }
30

31
  public static void main(final String[] args) {
32

33
    System.out.println("//" + "START:EAGER_OUTPUT");
34
    eagerEvaluator(evaluate(1), evaluate(2));
35
    System.out.println("//" + "END:EAGER_OUTPUT");
36

37
    // ４秒かかっていた処理が２秒でfalseを返却するようになる
38
    System.out.println("//" + "START:LAZY_OUTPUT");
39
    lazyEvaluator(() -> evaluate(1), () -> evaluate(2));
40
    System.out.println("//" + "END:LAZY_OUTPUT");
41
  }
42
}