[JavaSE8 Goldへの道] その5 ラムダ式を使用したコレクション・ストリームの操作(1)

Iterable#forEachメソッドによるコレクションの反復処理

List<string> names = new ArrayList<string>();
names.add("すず");
names.add("モモ");
names.add("ねね");
for (String name : names) {
    System.out.println(name);
}

default void forEach(Consumer<? super T> action);

names.forEach(name -> System.out.println(name));
//さらにこの例では前回説明したメソッド参照を使うと以下のように書ける
names.forEach(System.out::println);

default void forEach(BiConsumer<? super K, ? super V> action);

Map<String, String> breed = new HashMap<>();
breed.put("すず", "茶トラ");
breed.put("モモ", "白茶トラ");
breed.put("ねね", "三毛");
breed.forEach((name, hair)->
  System.out.println(name + "の毛色は" + hair));

モモの毛色は白茶トラ
ねねの毛色は三毛
すずの毛色は茶トラ

ストリームAPIとパイプライン

//ソース
List<String> list = Arrays.asList("bb", "aa", "cc");

//従来のやり方(配列のままやれというのは無しで)
List<String> result = new ArrayList<>();
for(String s : list){
  result.add(s.toUpperCase());
}
Collections.sort(result);
for(String s : result){
  System.out.println(s);
}

//ストリームAPI
list.stream()
  .map(s -> s.toUpperCase())
  .sorted()
  .forEach(System.out::println);

ストリームの生成

//Collection#stream
List<String> list = Arrays.asList("a", "b", "c");
Stream<String> stream1 = list.stream();
//Arrays#stream
int[] intarray = {1, 2, 3};
IntStream stream2 = Arrays.stream(intarray);
//Stream#of
Stream<String> stream3 = Stream.of("abc", "def");
LongStream stream4 = LongStream.of(1L, 2L, 3L);

Stream<T> filter(Predicate<? super T> predicate);
stream.filter(s -> !s.startsWith("n"));

Stream<T> distinct();
List<String> list = Arrays.asList("aA","AA","Aa", "Aa", "AA");
list.stream()
    .distinct()
    .forEach(System.out::println);

aA
AA
Aa

<R> Stream<R> map(Function<? super T, ? extends R> mapper)

//Stream<String> → Stream<String>
Stream<String> s1 = Stream.of("naoki", "akiko", "ami");
Stream<String> s2 = s1.map(s -> s.toUpperCase());

//Stream<String> → Stream<Integer>
Stream<String> s3 = Stream.of("naoki", "akiko", "ami");
Stream<Integer> s4 = s3.map(s -> s.length());

//ストリームの型変換
Stream<String> s5 = Stream.of("naoki", "akiko", "ami");
IntStream is = s5.mapToInt(s -> s.length());

<R> Stream<R> flatMap(Function<? super T,? extends Stream<? extends R>> mapper)

List<Integer> list1 = Arrays.asList(1, 2, 3);
List<Integer> list2 = Arrays.asList(4);
List<Integer> list3 = Arrays.asList(5, 6);
List<List<Integer>> src = Arrays.asList(list1, list2, list3);
src.stream()
  .flatMap(list -> list.stream())
  .forEach(System.out::print);

123456

Stream<T> peek(Consumer<? super T> action)

Stream.of("one", "two", "three", "four")
  .filter(e -> e.length() > 3)
  .peek(e -> System.out.println("フィルタ後: " + e))
  .map(String::toUpperCase)
  .peek(e -> System.out.println("マップ後  : " + e))
  .forEach(System.out::println);

フィルタ後: three
マップ後  : THREE
THREE
フィルタ後: four
マップ後  : FOUR
FOUR

終端操作

long count()

Optional<T> max(Comparator<? super T> comparator);
Optional<T> min(Comparator<? super T> comparator);

boolean allMatch(Predicate<? super T> predicate)
boolean anyMatch(Predicate<? super T> predicate)
boolean noneMatch(Predicate<? super T> predicate)

OptionalInt result =  IntStream.range(0, 100)
  .parallel()  //並列ストリーム化
  .filter(n -> n%2==0)
  .findAny();
System.out.println(result);

Object[] toArray()
<A> A[] toArray(IntFunction<A[]> generator)
Person[] men = people.stream()
    .filter(p -> p.getGender() == MALE)
    .toArray(Person[]::new);

T reduce(T identity, BinaryOperator<T> accumulator)
Optional<T> reduce(BinaryOperator<T> accumulator)
<U> U reduce(U identity,
             BiFunction<U,? super T,U> accumulator,
             BinaryOperator<U> combiner)

int result = IntStream.of(10, 20, 30)
          .reduce(0, (a, b) -> a + b);
          //これでも同じ
          //.reduce(0, Integer::sum);
System.out.println(result);

60

<R,A> R collect(Collector<? super T,A,R> collector)
<R> R collect(Supplier<R> supplier,
              BiConsumer<R,? super T> accumulator,
              BiConsumer<R,R> combiner)

String str = Stream.of("すず", "もも", "まお", "ねね")
  .collect(Collectors.joining("/"));
System.out.println(str);

すず/もも/まお/ねね

【注意】ストリームを使い回してはいけない

Stream<String> s1 = Stream.of("naoki", "akiko", "ami");
Stream<String> s2 = s1.map(s -> s.toUpperCase());
Stream<Integer> s4 = s1.map(s -> s.length());

Exception in thread "main" java.lang.IllegalStateException: stream has already been operated upon or closed
  at java.util.stream.AbstractPipeline.<init>(AbstractPipeline.java:203)
  at java.util.stream.ReferencePipeline.<init>(ReferencePipeline.java:94)
  at java.util.stream.ReferencePipeline$StatelessOp.<init>(ReferencePipeline.java:618)
  at java.util.stream.ReferencePipeline$3.<init>(ReferencePipeline.java:187)
  at java.util.stream.ReferencePipeline.map(ReferencePipeline.java:186)
  at test.Main.main(Main.java:14)

ストリームの各操作では毎回Streamオブジェクトを返しますが、すでに何かしらの操作を行ったオブジェクトにもう一度操作を行うとIllegalStateExceptionが発生します。
まあメソッドチェーンで文字通り流れるように書いていくのがストリームだと思うので、いちいち変数に入れて・・・とやらなければ問題無いでしょうが、念のため。

おしまいのひとこと

今回からOracleの公式サイトにあるテスト内容チェックリストと、その英語版の解説記事を元にしてみました。

• Upgrade Java SE 7 to Java SE 8 OCP Programmer | Oracle Certification Exam（テスト内容チェックリストのタブを選択）
• Exam 1Z0-810: Upgrade Java SE 7 to Java SE 8 OCP Programmer Study Guide

「ラムダ式を使用してコレクションをフィルタリングする」「ストリーム上での遅延操作」は、collectの補足と合わせて次回にします。

2016年中の試験代割引キャンペーンには間に合わなそうですが、必ず記事を完遂して試験を受けるので、Java8の新機能に興味のある方はお付き合いいただければと思います。一連の記事は「JavaSE8Gold」ラベルを付けていきます。

それではみなさまよきガジェットライフを(´∀`)ノ

オラクル認定資格教科書 Javaプログラマ Gold SE 8 (EXAMPRESS)

posted with ヨメレバ

山本 道子 翔泳社 2016-07-21

Amazonで探す

Kindleで探す

楽天ブックスで探す

楽天koboで探す

7netで探す

徹底攻略 Java SE 8 Gold 問題集[1Z0-809]対応

posted with ヨメレバ

米山 学 インプレス 2016-10-14

Amazonで探す

Kindleで探す

楽天ブックスで探す

楽天koboで探す

7netで探す