Java 8 Stream API にテキストを流してみる（生成編）

* Java 8 Stream API にテキストを流してみる（生成編）- Qiita
* [Java 8 Stream API にテキストを流してみた（終端操作編）- Qiita](http://qiita.com/kumazo/items/284098c530fceb05805c)
* [Java 8 Stream API にテキストを流してみて（中間操作編）- Qiita](http://qiita.com/kumazo/items/104fa685da8705b8cfd8)

## Java 8 が出てからだいぶたつわけだが
その目玉機能の一つだった Stream API は今、開発現場でどれだけ使われているのだろうか。自分も出始めたころにちょっと触って理解しきれないまま敬遠してきた一人だが、最近また使う機会があったので情報など漁っている。

しかしまだ入門的な紹介かディープな検証ばかりで、どうもピンと来ない。もし Stream が便利で広く開発現場で使われているなら、そろそろもう少し実践的な情報が上がってきていいと思うのだが。

現状、Stream をちゃんとは理解しようとするなら、やはり自分の手で具体的なコードを書いてみるしかないようだ。

とりあえず、ありがちなテキスト処理をネタにロジックを Stream API で書いてみようと思う。よくある要件の実装を通じて、Stream 流の作法とその優位性、またその限界などを浮き彫りにしていきたい。

調べながらなので、間違いや慣習にそぐわないところがあったら指摘して欲しい。

> **[2016/05/28]**　文章とコードを見直し、間違いや分かりにくい箇所を修正した。また、サンプルコードもいくつか追加した。

## 1　テキスト Stream の生成

Stream を生成するメソッドはあちこちに仕込まれていてわかりにくい。API ドキュメントを漁ってテキスト処理に使えそうなものを拾えば、だいたい以下のようなところか。

* `java.util.stream.Stream#of(T...) : Stream<T>`
* `java.util.stream.Stream.Builder#build() : Stream<T>`
* `java.util.Collection#stream() : Stream<T>`
* `java.util.Arrays#stream(T[]) : Stream<T>`
* `java.io.BufferedReader#lines() : Stream<String>`
* `java.nio.Files#lines(Path) : Stream<String>`
* `java.nio.Files#lines(Path, Charset) : Stream<String>`
* `java.util.regex.Pattern#splitAsStream(CharSequence)  : Stream<String>`
* `java.lang.CharSequence#chars() : IntStream`
* `java.lang.CharSequence#charPoints() : IntStream`

Stream とテキスト処理は相性が良さそうなものだが、従来のテキスト関連 API には今のところ反映されてない。 `Scanner/StringTokenizer` をはじめ `java.text.*`、 `java.nio.*`、`javax.swing.text.*`、XML関連等を見ても特筆すべき Stream のサポートはないようだ。

テキスト系 API 以外にも Stream を生成するクラスはある。たとえば`java.util.Random` には、乱数数列を無限 Stream として生成する各種メソッドが追加されている。`Random#ints()`などはランダム文字列の生成に使えるかもしれない。

### 1.1　Stream#of()

まずは本家 `Stream` クラス。
`Stream#of()` メソッドは可変長引数に渡されたデータ列を要素とする Stream を生成する。

```java:List.1-1_Stream.of()の基本

    // 可変長引数
    Stream<String> stream = Stream.of("She", "He", "Me", "We", "We");
    stream.forEach(s -> {
        System.out.println(s + "go!");
    });

    // 配列
    String[] array = {"おそ", "カラ", "チョロ", "一", "十四", "トド"};
    Stream<String> stream = Stream.of(array);
    stream.forEach(s -> {
        System.out.println(s + "松");
    });
```

要素の型は、引数に渡したオブジェクトの型から判断される。

`of()` の引数は可変長任意の個数の要素を列挙できるが、実際のプログラムでは String 配列で渡すことのほうが多いだろう。

```java:List.1-2_ファイル名のフルパス
// コマンド引数に渡されたファイル名をフルパスにして表示する。
public class FullPath {
    public static void main(String[] args) {
        // コマンド引数の String 配列をそのままof()に渡して Stream<String> にする
        Stream.of(args)
                .forEach(arg -> {
                    System.out.println(Paths.get(arg).toAbsolutePath().normalize());
                });
    }
}
```

```java:List.1-3_スネークケースをキャメルケースに変換する
    String snake = "looks_like_a_snaked";
    String camel = Stream.of(snake.split("_+")) // String.split() は String[] を返す
            .map(s -> String.format("%S%s", s.split("",2)))
            .collect(Collectors.joining());
    // LooksLikeASnaked
```

Stream クラスには`of()`のほかにも様々な Stream 生成メソッドが提供されてはいるが、テキスト処理の文脈ではあまり使い道がなさそうだ。

* `concat(Stream<String>, Stream<String>) : Stream<String>`
* `empty() : Stream<String>` 
* `generate(Supplier<String>) : Stream<String>`
* `iterate(String, UnaryOperator<String>) : Stream<String>`
* `builder() : Stream.Builder<String>`

`concat()` メソッドは2本の Stream を連結して1本にする。もし引数が２つだけでなく可変だったら、色々使い道があったのに、と思う。（`zip()`も欲しい）

```java:List.1-4_２つのリストをマージする
    List<String> marged = Stream.concat(list1.stream(), list2.stream())
            .distinct()
            .sorted()
            .collect(Collectors.toList());
```

`empty()` は空（要素０）の Stream を返すが、何に使うのか。

`generate()`、`iterate()`、`builder()`は、データ列からではなくロジックで Stream を生成する。`generate()`, `iterate()`は無限の Stream の生成を前提としていて、要素列生成側のロジックで終了させる手段がないので注意が必要だ。無限の Stream を止めるには `limit()` や `findFirst()` などの短絡操作を使う。
> 追記: Java 9 の Stream API では、for 文のように条件で打ち切れるバージョンの `iterate()` が追加されるようだ。

```java:List.1-5_パスワード用文字列を生成する
// Stream.generate()の例
// len パスワード長、patterns パスワード文字列の要求パターンを正規表現で表したもの 
public static Optional<String> passgen(int len, String... patterns) {
    Random random = new Random(System.currentTimeMillis());
    // ランダム文字列の Stream を生成する
    Stream<String> stream = Stream.generate(() ->
                new String(random.ints('!', '~' + 1).limit(len).toArray(), 0, len)
            )
            .limit(10000); // 適当かつ重要

    // Stream に要求パターンで適合テストするフィルタを追加する。
    for (String p : patterns)
        stream = stream.filter(s -> s.matches(p));

    // 最初にすべてのテストをパスした文字列を返す。
    return stream.findFirst();
}

...

    // 20文字であること
    System.out.println(passgen(20).get()); 
    // CEIJC'Hvd{&C9@!,T][7

    // 英数字のみ、8文字
    System.out.println(passgen(8, "\\w+", "[^_]+").get()); 
    // 5cPvpSXd

    // 組み合わせ
    System.out.println(
            passgen(8,                      // 8文字
                "[\\w!?#$%&~^:;|=+*/-]+",   // 使用可能な文字
                ".*[A-Z].*",                // 英大文字必須
                ".*[a-z].*",                // 英子文字必須 
                ".*[0-9].*",                // 数字必須 
                ".*[!?#$%&~^:;|=+*/-].*",   // 記号必須 
                "(?!.*(.).*\\1).+"          // 重複排除
            ).get());
    // /|DsG9^!
```

```java:List.1-6_簡易カレンダー表示
// cal コマンド的に今月のカレンダーを出力する

// LocalDateなど日時 API も Java 8 で追加されたので使ってみる
import java.stream.Stream
import java.time.LocalDate
import static java.time.temporal.TemporalAdjusters.*;

...

    // 今月の第１週の日曜日を取得する。
    LocalDate start = LocalDate.now()
            .with(firstDayOfMonth())
            .with(previousOrSame(DayOfWeek.SUNDAY));

    // 日付を１日ずつ進めた Stream<LocalDate> を生成する
    Stream.iterate(start, d -> d.plusDays(1L))
            .limit(7 * 6)      // 6週間分の要素で打ち切る
            .map(d -> {
                // 日(day)の文字列にする
                String day = String.format("%3d", d.getDayOfMonth());
                switch (d.getDayOfWeek()) {
                    case SATURDAY: return day += "\n"; // 土曜日なら改行
                    default: return day;
                }
            }).forEach(s -> {
                System.out.print(s);
            });       
```

```text
 26 27 28 29 30  1  2
  3  4  5  6  7  8  9
 10 11 12 13 14 15 16
 17 18 19 20 21 22 23
 24 25 26 27 28 29 30
 31  1  2  3  4  5  6
```

```java:List-1-38_文字bigramの抽出

// 指定の文字列から文字の bigram の Stream を生成する。
public Stream<String> bigramOf(final String text) {
    // Stream.Builderでは遅延処理にならないのが残念。
    // generate()やiterate()が使えれば遅延処理になるが無限Streamなので止められない。
    Stream.Builder<String> builder = Stream.builder();
    Pattern bigram = Pattern.compile("(?=(..))");
    Matcher m = bigram.matcher(text);
    while (m.find()) {
        builder.add(m.group(1));
    }
    return builder.build();
}

...

    String text = "おれはジャイアン";
    bigramOf(text)
            .forEach(bi -> {
                System.out.println(bi);
            });
```
```
おれ
れは
はジ
ジャ
ャイ
イア
アン
```
### 1.2. Collection#stream()

テキスト処理では Stream を自前で生成すことはあまりなくて、ほとんどの場合何らかの Source から Stream を引き出して使うことになる。

`List` や `Set` など `java.util.Collection` インターフェースを継承するクラスは、格納する要素を Stream 化する `stream()` メソッドを備えている。`Collection` 自体は Stream ではない。

```java:List.1-31_Collection.stream()の基本
    // List
    List<String> list = Arrays.asList("boo", "foo", "woo");
    list.stream()
            .forEach(s -> {
                System.out.println(s);
            });

    // Set
    Set<String> set = new HashSet<>(list);
    set.stream()
            .forEach(s -> {
                System.out.println(s);
            });

    // Mapはstream()を持たない。
    Map<String, String> map = new HashMap<>();
    map.entrySet().stream()
            .forEach(s -> {
                System.out.println(s);
            });
    
    // map.values()はCollectionを返す
    map.values().stream()
            .forEach(s -> {
                System.out.println(s);
            });
```

```java:List.1-7_先頭文字を合わせる
    List<String> words = new ArrayList<>();
    words.add("あいしてる");
    words.add("きらい");
    words.add("すき");
    words.add("ともだち");
    words.add("ぜっこう");
    words.add("ねっちゅう");
    words.add("こいびと");

    String name = words.stream()
            .map(s -> s.substring(0, 1))
            .collect(Collectors.joining());
```

```java:List.1-8_オブジェクトのListを文字列のListへ変換する
    List<Bookmark> bookmarks = dao.findBookmarks(userId);

    List<String> links = bookmarks.stream()
            .sorted(b -> b.getTitle())
            .map(b -> {
                // markdown
                return String.format("* [%s](%s)", e.getTitle(), e.getUrl());
            })
            .collect(Collectors.toList());
```

```java:List.1-9_システムプロパティを列挙する
    // java.util.Property は委譲関係の子オブジェクトを持てる。
    // Map 系メソッドでは委譲先まで拾いきれない。
    Set<String> keys = System.getProperties().stringPropertyNames();
    keys.stream()
            .filter(k -> k.startsWith("user.")) // キーのプレフィックス
            .sorted()
            .forEach(k -> {
                System.out.println(k + "=" + System.getProperty(k));
            }); 
```

### 1.3　Arrays#stream()

配列の要素も Stream 化できる。
java.util.Arrays に追加された`stream()`メソッドに配列を渡すだけでよい。

```java:List.1-32_Arrays.stream()の基本
    String[] array = {"Tokyo", "Osaka", "Nagoya", ... };       
    Arrays.stream(array)
            .forEach(s -> {
                System.out.println(s);
            });
    }
```

```java:List.1-10_配列の空要素を除去する
public static String[] removeBlanks(String[] values) {
    return Arrays.stream(values)
        .filter(s -> s != null)
        .map(s -> s.trim())
        .filter(s -> !s.isEmpty())
        .toArray(String[]::new);
} 
```

```java:List.1-11_配列を連結する
    String[] arr1 = {"txt", "csv", "tsv"};
    String[] arr2 = {"rtf", "doc", "html"};       
    
    String[] concat = Stream.concat(Arrays.stream(arr1), Arrays.stream(arr2))
            .toArray(String[]::new);
    // [txt, csv, tsv, rtf, doc, html]
```

気分的には先の `Stream#of()` が単発の短めの配列用、こちらは長い配列データ用などと使い分けられそうだが、`Stream#of()` は中で `Arrays#stream()` に引数配列を丸投げしているだけなので実質的な違いはない。

String の長大な配列を使う状況というのはあまり思い当たらないのだが、もしあれば並列化によるの高速化が見込めるという話題もある。

たとえばドキュメントのテキストを大量の NG ワードでチェックするプログラムがあって判定時間を改善したい。パターンの検索に順序は関係ないので並列処理による高速化が望めそうだが、どの程度の効果があるのか試してみる価値はある。

Stream なら並列化するのは笑っちゃうほど簡単だ。

```java:List.1-12_NGワードの存在をチェックする
public static boolean hasNGWords(final String doc, final String[] ngwords) {
    return Arrays.stream(ngwords)
            .parallel()  // 並列化しちゃった
            .map(w -> Pattern.compile(w).matcher(doc)) // 正規表現あり
            .filter(m -> m.find())
            .findAny()
            .isPresent();
}
```

部分配列から Stream を得る事もできる。ページングするように領域のはじめと終わりの位置が分かっているなら、全体 Stream で skip/limit するよりも効率がいいだろう。

```java:List.1-13_メール本文を引用する
    final String br = "\r\n";
    String[] arr = message.split(br);
    List<String> lines = Arrays.asList(arr);
    final int begin = lines.indexOf("") + 1; // 最初の空行までヘッダ
    final int end = lines.indexOf("-- ");    // sig-dashes 以降は署名
    if (end < begin) end = lines.size();     // 書名はないかもしれない

    String quoted = Arrays.stream(arr, begin, end)
            .map(line -> "> " + line)        // 本文引用
            .collect(Collectors.joining(br));
```

### 1.4　CharSequence#chars() / codePoints()

インターフェース `java.lang.CharSequence` には `chars()` と `codePoints()` が追加され、文字を `IntStream` で取得できるようになった。`CharSequence` を継承する `String` や `StringBuiler` などで使用できる。

```java:List.1-14_文字情報を表示する
    "ヽ(`Д´)ﾉ彡┻━┻".chars()
            .forEach(c -> {
                System.out.format("%05d %04X %c %s", c, c, c, Character.getName(c)).println();
            });
```
```text
12541 30FD ヽ KATAKANA ITERATION MARK
00040 0028 ( LEFT PARENTHESIS
00096 0060 ` GRAVE ACCENT
01044 0414 Д CYRILLIC CAPITAL LETTER DE
00180 00B4 ´ ACUTE ACCENT
00041 0029 ) RIGHT PARENTHESIS
65417 FF89 ﾉ HALFWIDTH KATAKANA LETTER NO
24417 5F61 彡 CJK UNIFIED IDEOGRAPHS 5F61
09531 253B ┻ BOX DRAWINGS HEAVY UP AND HORIZONTAL
09473 2501 ━ BOX DRAWINGS HEAVY HORIZONTAL
09531 253B ┻ BOX DRAWINGS HEAVY UP AND HORIZONTAL
```

```java:List.1-15_Unicodo補助文字の存在チェック
    if (text.codePoints().anyMatch(Character::isSupplementaryCodePoint)) {
        throw new IllegalArgumentException("Unicode補助文字はサポートされません。");
    }
```

```java:List.1-16_コードポイントで文字数を数える。
    String text = "𠀀𠀁𠀂𠀃𠀄𠀅𠀆𠀇𠀈𠀉"; // Unicode補助文字
    int  size  = text.length(); // 20
    long count = text.codePoints().count(); // 10
```

しかし `int` で文字を貰っても意外とできる事が少なくて途方に暮れる。せめて `chars()` は `int` ではなく `char` で返してほしいものだが、Java 8 では `CharStream` クラス自体の提供が見送られている。

```java:List.1-17_汎用文字の収集
    Set<Character> letters = text.chars()
            .filter(c -> Character.isLetter((char)c))
            .mapToObj(c -> (char)c) // autoboxing
            .collect(Collectors.toSet());
```

テキスト処理では文字 Stream を最終的に `String` に戻す事がよくあるだろうが、char にしろコードポイントにしろ、素直に `String` に変換する方法がないようだ。

```java:List.1-18_文字IntStreamからStringに変換してみる
    // 案１
    int[] seq = text.codePoints().toArray();
    text = new String(seq, 0, seq.length);
    
    // 案２
    text = text.chars()
                .mapToObj(c -> String.valueOf((char) c))
                .collect(Collectors.joining());

    // 案３
    text = text.codePoints()
                .mapToObj(cp -> String.format("%c", cp))
                .collect(Collectors.joining());
    
    // 案４
    text = text.codePoints()
                .collect(StringBuilder::new,
                    (sb, cp) -> sb.appendCodePoint(cp),
                    (sbl, sbr) -> sbl.append(sbr))
                .toString();

```

int 文字コードは結局どこかで Integer/Character/String などのオブジェクトに変換する必要があって、パフォーマンス的によくない。文字コードに関心がないならあえて文字を IntStream で扱う理由もないだろう。


```java:List.1-19_Unicode補助文字を数値文字参照に置換する
   // Chromeだと表示されない？？
    String text = "𠮷野屋で𠮟られる𠀋一郎"; 
    text = text.codePoints().mapToObj( c -> {
            return c > 0xFFFF ? String.format("&#x%x;", c) : String.valueOf((char) c);
    }).collect(Collectors.joining());
    // &#x20bb7;野屋で&#x20b9f;られる&#x2000b;一郎
```

```java:List.1-20_文字の出現回数
    String text = "I can't can a can you can can, but you can't can a can I can can, can you ?";

    // 文字ごとの出現回数
    Map<Integer, Long> occ = text.codePoints()
            .boxed()
            .collect(Collectors.groupingBy(cp -> cp, Collectors.counting()));

    // カウントの多い順にソートしたMapにする
    occ = occ.entrySet().stream()
            .sorted((l, r) -> - l.getValue().compareTo(r.getValue()))
            .collect(Collectors.toMap(
                    e -> e.getKey(),
                    e -> e.getValue(),
                    (l,r) -> r,
                    LinkedHashMap::new));
    occ.forEach((cp, count) -> {
        System.out.format("%c\t%d\n", cp, count);
    });

    // 単純に文字列を１文字ずつに分解したいだけなら`split()`に
    // 区切りパターンとして "" を渡すのが手っ取り早い。
    // ただし、補助文字のサロゲートペアは泣き別れになる。
    // それで困るなら、補助文字を壊さずに文字分解するパターンとして 
    // "(?!\\p{InLowSurrogates})" などが使える。
    Map<String, Long> occ2 = Stream.of(text.split(""))
            .collect(Collectors.groupingBy(s -> s, Collectors.counting()));

```

```java:List.1-21_ひらがなカタカナ相互置換
    String text = "あんたバカぁ?";
    text = text.chars().mapToObj(c -> {
        switch (UnicodeBlock.of(c).toString()) {
            case "HIRAGANA": c += 'ァ' - 'ぁ'; break;
            case "KATAKANA": c -= 'ァ' - 'ぁ'; break;
            default: break;
        }
        return String.valueOf((char) c);
    }).collect(Collectors.joining());
    // アンタばかァ?
```

### 1.5　BufferedReader#lines() / Files#lines()

Java に IO ストリーム系（ややこしい）のクラスは多いが、テキストファイルを読み込む場合は、`java.io.BufferedReader` がほとんど唯一の選択肢だ。

それは Java 8 になっても相変わらずだが、その代り BufferedReaderクラスに Stream のサポートが提供された。

`BufferedReader` に追加された `lines()` メソッドは、`InputStream` のテキスト行を要素にした Stream を返す。改行コードは含まない。

```java:java1-33_BufferedReader.lines()の基本

    BufferedReader br = .... .. . . .  .    ;
    Stream<String> lines = br.lines();
    lines.forEach(line -> {
        System.out.println(line);
    });
    br.close();
```

テキスト行の読み込みは遅延的だ。つまり内部にデータがいったん溜め込まれるわけでなく、終端操作で要素が要求されるたびに逐次読み込まれている。

```java:List.1-22_文字コード変換フィルタ
// iconv コマンドのマネ。
// 指定の文字コードに従い、標準入力のテキストの文字コードを変換して標準出力に表示する。
public class Conv {
    public static void main(String[] args) throws IOException {
        // 入力側の文字コード
        String dec = args.length > 0 ? args[0] : "UTF-8";
        // 出力用の文字コード
        String enc = args.length > 1 ? args[1] : Charset.defaultCharset().name();
        
        BufferedReader br = new BufferedReader(
                new InputStreamReader(System.in, dec));       
        br.lines()
                .map(line -> line + "\n") // 改行も付加
                .forEach(line -> {
                    try {
                        System.out.write(line.getBytes(enc));
                        System.out.flush();
                    } catch (IOException e) {
                        // ラムダ内からチェック例外を投げられない。
                        throw new UncheckedIOException(e);
                    }
                });
    }
}
```

```bash:Windowsでの使用例
C:\>chcp
現在のコード ページ: 932

C:\>type readme.utf8
縺ｿ縺・◆縺√↑縺√≠
C:\>type readme.utf8 | java Conv
みぃたぁなぁあ

C:\>type readme.utf8 | java Conv utf-8 euc-jp > readme1st.euc

```

ところで Java では昔からたかがテキストファイルを読み込む手順がひどく面倒であった。Java 7 からは API 側が折れて`Files#newBUfferedReader()` メソッドが用意されたためすこし労力が減っている。Java 8 ではさらに文字コード指定を省略した UTF-8 限定版が追加されている。（システムのdefault Charset ではないので注意）

* [Javaで1行ずつテキストデータを読み込むイディオムの変遷 - argius note](http://argius.hatenablog.jp/entry/2015/06/06/234315)

```java:List-1-34_UTF-8のテキストファイルを読み込む

    String file = "sample.txt";

    // Java 8 世代のやり方
    BufferedReader br = Files.newBufferedReader(Paths.get(file)) ;
    Stream<String> lines = br.lines();
    lines.forEach(line -> {
        System.out.println(line);
    });
    br.close();

    // いにしえのやり方
    BufferedReader br = new BufferedReader(
                                new InputStreamReader(
                                        new FileInputStream(file),
                                        StandardCharsets.UTF_8));
    String line;
    while ((line = br.readLine()) != null) {
        System.out.println(line);
    }
    br.close();
```

あぁ便利だ。確かに便利なのだが、なにか釈然としないものを感じるのはおっさんだからなのか。

```java:List.1-23_CSVファイルをMapのListに変換する

@SuppressWarnings("serial")
public static List<Map<String, String>> csvToMap(Path csvPath) throws IOException {
    try (BufferedReader csv = Files.newBufferedReader(csvPath)) { // UTF-8

        // １行めを見出しとして読み込む
        final String head = csv.readLine(); 
        if (head == null)
            return Collections.emptyList();

        // フィールド名の配列
        final String[] flds = head.split(",\\s*");

        // データ行読み込み
        // 2行目から Stream にして読み込む
        return csv.lines()  
                .map(line -> line.split(",\\s*", flds.length))
                .map(vals -> new LinkedHashMap<String,String>(){{
                    for (int i = 0; i < flds.length; i++)
                        put(flds[i], vals[i]);
                }})
                .collect(Collectors.toList());
    } catch (IOException e) {
        throw e;
    }
}
```

さらに便利なことに、その`Files`クラス自体にも `lines()` メソッドが追加されている。

```java:List-1-35_Files.lines()の基本
    String fileName;

    Stream<String> lines = Files.lines(Paths.get(fileName));
    files.forEach(line -> {
        System.out.println(line);
    });
    // lines.close();


    // try-with-resources構文を使う
    try (Stream<String> lines = Files.lines(Paths.get(fileName))) {
        files.forEach(line -> {
            System.out.println(line);
        });
    } catch (IOException e) {
        e.printStackTrace();
    }

```

`Files#lines()` メソッドはファイルパスを指定するだけでテキスト行を `Stream<String>` として返す。これも Charset指定ありと、なしの UTF-8 限定版がある。

定番のテキスト読み込みループが簡潔に書けるようになってうれしい。うれしいはずなのだが、これもまた素直に喜べないのはなぜなのか。

```java:List.1-24_テキストファイルの末尾行を表示（その１）
// tail コマンドのエミュレート
// Stream を close しないのはお行儀が悪い（後述）が単発ですぐ終了するので気にしない。
public class Tail {
    public static void main(String[] args) throws IOException {
        if (args.length < 2) {
            System.out.println("java Tail n file");
            return;
        }

        final long n = Long.parseLong(args[0]); // 取得する行数
        final Path file = Paths.get(args[1]);

        // ファイル行数を得るため一回空読みする。
        final long total = Files.lines(file).count();

        // ファイル行数からtail行数を引いた位置までスキップする。
        final long skip = total > n ? total - n : 0;
        Files.lines(file)
                .skip(skip)
                .forEach(line -> {
                    System.out.println(line);
                });
    }
}
```

```java:List.1-25_テキストファイルを連結する
// cat コマンドのエミュレート
// 引数で与えたファイルのテキストを連結して標準出力に吐き出す
public class Cat {
    public static void main(String[] args) {
        Stream.of(args)
                .flatMap(f -> {
                    try {
                        return Files.lines(Paths.get(f)); // flatMap が close する
                    } catch (IOException e) {
                        // ラムダ内からチェック例外を投げられない。
                        throw new UncheckedIOException(e);
                    }
                })
                .forEach(l -> {
                    System.out.println(l);
                });
    }
}
```                    

ところで `Files#lines()` の返す Stream は内部で開いたファイルを抱えているはずだが、それがどういうタイミングで close されるのか気になるだろう。ファイルストリームが EOF になったらなのか、Stream の終端処理が終了した時か、あるいは Stream オブジェクトが GC に破棄される時なのか。

ぶっちゃけ言うとどれもあてにできない。

`lines()` の返す Stream の内部のファイルを close する処理は、Stream の `onClose()` ハンドラで行われるが、それは Stream オブジェクト自身が自分のタイミングで呼ぶわけではない。

`onClose()` に登録されたハンドラが実行されるのは、Stream の `close()` メソッドが外部から呼ばれた時だ。この `close()` は `java.lang.AutoCloseable` インターフェース由来のメソッドで、直接呼び出しも可能ではあるが、基本的には Java 7 で導入された try-with-resources 構文を使った自動解放を利用する前提になっている。Stream でも try-with-resources 構文を使えば、内部のファイルリソースは適切なタイミングで確実にリリースされる。


* [StreamはAutoCloseableであると認識していないとアレな件 - mike-neckのブログ](
http://mike-neck.hatenadiary.com/entry/2014/10/12/133434)

ちょ、ちょっとまてよ。

 Stream が（正確には `BaseStream` が） `AutoCloseable` を継承した閉じられるべき定めのあるものなら、List や配列から生成したこれまでの例の Stream オブジェクトも、実は `close()` の呼び出しを意識しておかなければならなかったのでは？

改めて Java 8 API の JavaDoc の AutoCloseable の説明をよく読むと、注が追加されていて、Listなんかの場合には close しなくても問題ないよ、的なことがものすごい難解な日本語で書いてあるようだ。

* [インタフェースAutoCloseable](http://docs.oracle.com/javase/jp/8/docs/api/index.html?java/lang/AutoCloseable.html) - Java(tm) Platform, Standard Edition 8 API仕様

Venkat Subramaniam 先生の「[Javaによる関数型プログラミング――Java 8ラムダ式とStream](http://www.oreilly.co.jp/books/9784873117041/)」 p113 の解説によれば

> Java 8 では AutoCloseable に関連する変更がいくつか行われました。《中略》 これに伴い、AutoCloseable は以前の厳密な「リソースは閉じられなければならない」ではなく、より緩い「リソースは閉じられる可能性がある」という取り決めに変更されました。《後略》

...だ、そうです。

```java:List.1-26_試しに普通のStreamをcloseしてみる
    Stream<String> stream = Stream.of("流されたいー", "おれもー");
    stream.onClose(() -> System.out.println("だが断る"));
    System.out.println("準備OK！");

    // close() を呼んでみる。
    stream.close();
    
    System.out.println("スタート！");
    stream.forEach(s -> {
        System.out.println(s);
    });

    // 準備OK！
    // だが断る
    // スタート！
    // java.lang.IllegalStateException: stream has already been operated upon or closed
    // ↑
    // Stream の終了と close 後の状態が違いがよくわからん。
    // 上記 close() 行をコメントアウトするとハンドラ呼ばれない。
```

結局、`Files#lines()` は、内部のファイルを適切に close するため、try-with-resouces 構文で使用するのが定石になる。その代り当初の期待された簡潔さは幾分損なわれる。

```java:List.1-27_テキストファイルの末尾行を表示（その２）
// tail コマンドのエミュレート
// Stream を close する行儀がよいバージョン
public class Tail2 {
    public static void main(String[] args) {
        if (args.length < 2) {
            System.out.println("java Tail2 n file");
            return;
        }

        final long n = Long.parseLong(args[0]); // last n lines
        final Path file = Paths.get(args[1]);

        // 行数を得るため一回空読みする。
        final long total;
        try (Stream<String> lines = Files.lines(file)) {
            total = lines.count();
        } catch (IOException e) {
            e.printStackTrace();
            return;
        }

        // ファイル行数からtail行数を引いた位置までスキップする。
        final long skip = total > n ? total - n : 0;
        try (Stream<String> lines = Files.lines(file)) {
            lines.skip(skip)
                    .forEach(line -> {
                        System.out.println(line);
                    });
        } catch (IOException e) {
            e.printStackTrace();
            return;
        }
    }
}
```

`Files`には`find()`という `Stream<Path>` を返すメソッドもあるが、これも内部的になんらかのシステムリソースをつかんでいるようでそのcloseのタイミングのために try-with-resouces 構文を使った方がいいようだ。

ちなみに `flatMap()` や `concat()` などで Stream に預けた Stream は、内部で終了後適切に close してもらえるそうなので、そこはあてにしていい。

```java:List.1-28_テキストファイルを正規表現で検索する
// grep コマンドのエミュレート
// grep オプションの -E -r に相当する。
public class GrepEr {
    public static void main(String[] args) throws IOException {
        if (args.length < 1) {
            // showUsage();
            return;
        }
　　　　 // 最初の引数に検索するパターンを正規表現として与える
        final Pattern pattern = Pattern.compile(args[0]);
        // 2盤目の引数で対象ファイルを指定する。ディレクトリが指定された場合、
        // 再帰的ディレクトリ内のファイルの内容を検索する。
        final Path basePath = Paths.get(args.length > 1 ? args[1] : ".");
        final String margin = "                              "; // 30
        
        // Path の Stream
        // 本当はtry-with-resoucesしたほうがいいが、１回限りですぐに終了するので気にしない。
        Files.find(basePath, 100, (path, attr) -> attr.isRegularFile())
                .parallel()         // パラっちゃおー
                .forEach(path -> {
                    try (Stream<String> lines = Files.lines(path)) {
                        lines.forEach(line -> {
                            final Matcher m = pattern.matcher(line);
                            while(m.find()) {
                                final String window = margin.concat(line).concat(margin)
                                        .substring(m.start(), m.start() + margin.length() * 2 );
                                
                                synchronized (System.out) {
                                    System.out
                                            .format("%s\t%s", window, path.getFileName())
                                            .println();
                                }
                            }
                        });
                    } catch (Exception e) {
                        System.err.println(e.getMessage() + " with " + path);
                    }
                });
        System.out.println("END");
    }
}
```

```text:使用例
$ java GrepEr "FIXME" ./jdk1.8.0_45/src
                           // FIXME: is the right exception     SnmpAdaptorServer.java
                           // FIXME: is the right exception     SnmpAdaptorServer.java
                           // FIXME: may be it's not the bes    SnmpInformRequest.java
utBytes/*, byteCount */) ; // FIXME                             SnmpMessage.java
                            //FIXME: This method is not used    ThreadPoolManagerImpl.java
                            //FIXME: This method is not used    ThreadPoolManagerImpl.java
                            //FIXME: This method is not used    ThreadPoolManagerImpl.java
                            //FIXME: This method is not used    ThreadPoolManagerImpl.java
                        // [[[FIXME:  WDW - we probably shou    JComponent.java
                           // FIXME:  [[[WDW - should also r    JFrame.java
                           // FIXME:  [[[WDW - probably shou    JMenu.java
                           // FIXME: [[[WDW - Should also ad    JSplitPane.java
                           // FIXME:  [[[WDW - need to add o    JToolBar.java
                           // FIXME:  [[[WDW - need to do SE    JToolBar.java
                           // FIXME: // This is a _hack_ to     RECompiler.java
         return null; // fredxFIXME Not implemented yet         List.java
                        // [[[FIXME]]] need to finish implem    List.java
                        // [[[FIXME]]] needs to work like is    List.java

:
:
:
```

I/O リソースの扱いに気を使いたくなければ、`Files#readAllLines()` というこれまた安直なメソッドを使う手もある。これは Stream API というわけではないが、これも Java 8 で Chaset 指定を省略した UTF-8 限定版が追加されている。

`readAllLines()`は指定のテキストファイルを全て読み込み、テキスト行を `List<String>` にして返す。ファイル 処理が隠蔽され内部で完結するので、戸締りの心配もいらない。

たとえば Stream では行をまたぐような処理は難しいが、これで全行のリストで得てからまとめて処理してしまえれば楽だろう。一発でお手軽だが、当然メモリを圧迫するのでファイルサイズには気を付けなればならない。

```java:List.1-29_HTMLタグを除去する
    // タグ内改行にも対応する。
    String htmlfile = "index.html";
    List<String> lines = Files.readAllLines(Paths.get(htmlfile));
    String text = String.join("\n", lines)
            .replaceAll("(?s)<!--.+?-->", "")   // コメント削除
            .replaceAll("(?si)<(script|style).+?/\\1>", "") // script/style は要素ごと削除
            .replaceAll("(?s)<.+?>", "")        // HTML タグ削除
            .replaceAll("(?m)^\\s+$", "")       // 空白うぜー
            .replaceAll("\\n{3,}", "\n\n");     // 空行うぜー
    Files.write(Paths.get(htmlfile + ".txt"), Arrays.asList(text), StandardCharsets.UTF_8);
```

## 1.6　Pattern#splitAsStream()

正規表現エンジンである `java.util.regex.Pattern` に追加された `splitAsStream()` メソッドの存在は、一般に見過ごされている感がある。

`splitAsStream()` メソッドはテキストを指定の正規表現パターンで区切った文字列を要素とする Stream を生成する。

```java:List-1-36_java:splitAsStream()の基本
    String text = "A very very long story ...";
    Pattern pattern = Pattern.compile("\\s");
    Stream<String> stream = pattern.splitAsStream(text);
    stream.forEach(s -> {
        System.out.println(s);
    });
```

```java:List.1-30_分ち書きの単語生起頻度を集計する
    final Path file = Paths.get("hamlet.txt");
    final Pattern delim = Pattern.compile("\\s+"); // 空白区切り
    Map<String, Long> wordCounts = null;
    
    try(Stream<String> lines = Files.lines(file)) { // UTF-8
        wordCounts = lines
                .flatMap(line -> delim.splitAsStream(line)) // 行 Stream ->単語 Stream  
                .collect(Collectors.groupingBy(
                        w -> w,
                        TreeMap::new,  // 単語順
                        Collectors.counting()));
    } catch (IOException e) {
        e.printStackTrace();
    }

    wordCounts.forEach((w, c) -> {
        System.out.println(w + " " + c);
    });
```

結果的に `Stream.of(text.split(pattern))` と同じで、ちょっとお手軽になっただけのようだが、それだけではない。

従来の `String#split()` や `Pattern#split()` は、文字列全体を解析後、結果の全要素をString 配列に詰めなおしてから返している。

一方 `splitAsStream()` は実装的にパターンマッチの逐次結果を Stream に回している。つまり、Stream の次の要素の検出パターンの適用は、遅延的に実行される。

文字列全体を解析せずに途中までで中断することもできるし、コンパイル済みの正規表現も再利用できるので、長いテキストでなら `splitAsStream()` の方がパフォーマンス的に有利になるはずだ。

ところで、テキスト処理の実用としては、正規表現を区切りではなく抽出対象そのもののパターンで与えたいところだ。しかし残念ながらそのようなメソッドは用意されていない。ちょっと考えれば `splitAsStream()` でも、抽出対象の正規表現の反転（否定）パターンを与えれば結果的に同じことが実現できるはずと思うかもしれないが、それは正規表現の特性上言うほど簡単なことではない。天才的な職人の技で何とかなるかもしれないが、誰もメンテナンスできない。

ここは多少面倒でも`Macher`で取り回したほうがずっと処理効率もいいし、なにより安全だ。

```java:List-1-37_テキストファイルからURLを抽出する

// splitAsStream() を使った実装
// 指定の正規表現を反転し、splitAsStream()を使ってテキストから文字列を抽出する。
public List<String> extract1(String file, String regex) throws IOException {
    // 任意の正規表現を反転（否定）した正規表現にするが、保証はできない。
    // バックトラックがかかりまくるので重くなる。ものによっては帰ってこれないかもしれない。
    final String inverse = String.format("(?<=^|(%1$s))((?!(%1$s)).)+", regex);
    final Pattern invertedPattern = Pattern.compile(inverse);
    try(Stream<String> lines = Files.lines(Paths.get(file))) {
        return lines
                .flatMap(line -> {
                    // 対象文字列「以外」で区切る
                    return invertedPattern.splitAsStream(line);
                })
                .filter(s -> !s.isEmpty()) // 最初の要素は大抵空になる
                .distinct()
                .sorted()
                .collect(Collectors.toList());
    }
}

// Macher を使った素直な実装。
public List<String> extract2(String file, String regex) throws IOException {
    final Pattern pattern = Pattern.compile(regex);
    try(Stream<String> lines = Files.lines(Paths.get(file))) {
        return lines
                .map(line -> pattern.matcher(line))
                .flatMap(m -> {
                    // マッチした文字列を Stream.Builder に詰める。
                    Stream.Builder<String> builder = Stream.builder(); 
                    while (m.find())
                        builder.add(m.group());
                    return builder.build();
                })
                .distinct()
                .sorted()
                .collect(Collectors.toList());
    }
}

    {
        // splitAsStream()による実装
        // 内部的に先読み後読みを使っているので、パターンに長さ制限をつけないと動かない。
        final String HTTP_URL_PATTERN = "(https?:)?//[-\\w:/._-~%?=+&#]{1,1000}(?=\"|'|\\s)";
        //final String HTTP_URL_PATTERN = "(?<=(href|src)=[\"'])https?://.{1,1000}?(?=\\s*[\"'])";
        List<String> urls = extract1("index.html", HTTP_URL_PATTERN);
        urls.forEach(url -> System.out.println(url));
    }
    System.out.println();
    {
        // Matcher による実装
        // 長さ制限は特に求められない。
        final String HTTP_URL_PATTERN = "(https?:)?//[-\\w:/._-~%?=+&#]+(?=\"|\\s)";
        //final String HTTP_URL_PATTERN = "(?<=(href|src)=[\"'])https?://.+?(?=\\s*[\"'])";
        List<String> urls = extract2("index.html", HTTP_URL_PATTERN);
        urls.forEach(url -> System.out.println(url));
    }
}
```
## つづく…

* [Java 8 Stream API にテキストを流してみた（終端操作編）- Qiita](http://qiita.com/kumazo@github/items/284098c530fceb05805c)
* [Java 8 Stream API にテキストを流してみて（中間操作編）- Qiita](http://qiita.com/kumazo/items/104fa685da8705b8cfd8)

## 参考資料

* パッケージjava.util.stream　- Java(tm) Platform, Standard Edition 8 API仕様
http://docs.oracle.com/javase/jp/8/docs/api/index.html?java/util/stream/package-summary.html

* Java Streamメモ(Hishidama's Java8 Stream Memo) - Ne
http://www.ne.jp/asahi/hishidama/home/tech/java/stream.html

* Javaによる関数型プログラミング――Java 8ラムダ式とStream
(Venkat Subramaniam 著/株式会社プログラミングシステム社 訳/オライリー・ジャパン)
http://www.oreilly.co.jp/books/9784873117041/

* Stream カテゴリーの記事一覧 - エンタープライズギークス (Enterprise Geeks)
http://enterprisegeeks.hatenablog.com/archive/category/Stream

* StreamはAutoCloseableであると認識していないとアレな件 - mike-neckのブログ
http://mike-neck.hatenadiary.com/entry/2014/10/12/133434