「Stream API」タグアーカイブ

Java, ブログ, プログラミング

Java Streamsで文字列リストを加工・整形する便利テクニック

2025年11月14日管理者コメントする

Java 8 以降で利用できる Stream API は、文字列リストの加工・整形に非常に便利です。
filter / map / collect を組み合わせるだけで、複雑な処理もスッキリ書けるようになります。

この記事では、**業務システムで頻出する「文字列リストの加工」**を中心に、すぐに使えるサンプルをまとめています。

✔ よくある文字列リストの処理

業務プログラムの中で、以下のようなケースはよくあります。

空文字・null を除去したい
前後の空白を trim したい
大文字/小文字変換をしたい
任意の条件で絞り込みたい
区切り文字にまとめたい（CSV・ログなど）

こうした処理は Stream API を使うと 1 行で書ける ことが多いです。

1. 空文字・null を除去する

List<String> list = Arrays.asList("A", "", null, "B", "  ", "C");

List<String> result = list.stream()
        .filter(Objects::nonNull)      // null除外
        .map(String::trim)              // trim
        .filter(s -> !s.isEmpty())      // 空文字除外
        .collect(Collectors.toList());

System.out.println(result); // [A, B, C]

List<String> list = Arrays.asList("A", "", null, "B", " ", "C");

List<String> result = list.stream()

.filter(Objects::nonNull) // null除外

.map(String::trim) // trim

.filter(s -> !s.isEmpty()) // 空文字除外

.collect(Collectors.toList());

System.out.println(result); // [A, B, C]

2. 全要素を大文字 or 小文字に変換する

List<String> list = List.of("java", "Spring", "HELLO");

List<String> upper = list.stream()
        .map(String::toUpperCase)
        .collect(Collectors.toList());

List<String> lower = list.stream()
        .map(String::toLowerCase)
        .collect(Collectors.toList());

List<String> list = List.of("java", "Spring", "HELLO");

List<String> upper = list.stream()

.map(String::toUpperCase)

.collect(Collectors.toList());

List<String> lower = list.stream()

.map(String::toLowerCase)

.collect(Collectors.toList());

3. 特定の文字を含む要素だけ抽出する

List<String> list = List.of("apple", "orange", "banana");

List<String> containsA = list.stream()
        .filter(s -> s.contains("a"))
        .collect(Collectors.toList());

// 結果: [apple, orange, banana]

List<String> list = List.of("apple", "orange", "banana");

List<String> containsA = list.stream()

.filter(s -> s.contains("a"))

.collect(Collectors.toList());

// 結果: [apple, orange, banana]

部分一致の他に、
startsWith / endsWith / 正規表現なども活用できます。

4. trim＋フィルタ＋整形をまとめて 1 行で

業務コードで頻発する「整形 → フィルタ → 出力」を 1 行で書く例です。

List<String> raw = List.of("  ABC  ", " 123 ", " xyz ", "", "  ");

List<String> normalized = raw.stream()
        .map(String::trim)
        .filter(s -> !s.isEmpty())
        .map(String::toLowerCase)
        .collect(Collectors.toList());
// -> [abc, 123, xyz]

List<String> raw = List.of(" ABC ", " 123 ", " xyz ", "", " ");

List<String> normalized = raw.stream()

.map(String::trim)

.filter(s -> !s.isEmpty())

.map(String::toLowerCase)

.collect(Collectors.toList());

// -> [abc, 123, xyz]

5. 重複要素を除外する（distinct）

6. 文字列リストを区切り文字で join する（CSV など）

改行やタブ区切りにも応用できます。

7. リスト内の文字列長でソートする（Comparator）

List<String> list = List.of("aaa", "b", "cccc");

List<String> sorted = list.stream()
        .sorted(Comparator.comparingInt(String::length))
        .collect(Collectors.toList());

// -> [b, aaa, cccc]

List<String> list = List.of("aaa", "b", "cccc");

List<String> sorted = list.stream()

.sorted(Comparator.comparingInt(String::length))

.collect(Collectors.toList());

// -> [b, aaa, cccc]

降順にしたい場合：

8. 正規表現で加工する（replaceAll 等）

List<String> phones = List.of("090-1234-5678", "03-9999-8888");

List<String> normalized = phones.stream()
        .map(s -> s.replaceAll("-", "")) // ハイフン除去
        .collect(Collectors.toList());

// -> ["09012345678", "0399998888"]

List<String> phones = List.of("090-1234-5678", "03-9999-8888");

List<String> normalized = phones.stream()

.map(s -> s.replaceAll("-", "")) // ハイフン除去

.collect(Collectors.toList());

// -> ["09012345678", "0399998888"]

9. Stream API を使うメリットまとめ

✔ コードが短く読みやすい

for文で数十行になる処理が、Stream だと数行に。

✔ null などの例外ケースを潰しやすい

filter → map → collect の流れが明確で安全。

✔ 並列処理（parallelStream）にも切り替えやすい

データ量が多い場合に性能改善も期待できる。

まとめ

Stream API を使うと、文字列リストの加工・整形が圧倒的にシンプルになります。

null / 空白除去
大文字・小文字変換
条件フィルタ
重複削除
join で CSV 形式へ変換
ソート

これらは業務アプリで頻出するため、覚えておくとコード品質・保守性が確実に上がります。

Java, ブログ, プログラミング

Java 8以上でリストをマージ・変換・フィルタリングするプロ向け実践術

2025年10月27日管理者コメントする

✅ はじめに：Java 8以降の開発では「リスト操作力」が問われる

Java 8以降、Stream APIの登場によってListの操作が劇的に効率化されました。
しかし──

✅ addAllやfor文と混在してコードが読みづらくなる
✅ mapとflatMapを使い分けられない
✅ filterの順序ミスでパフォーマンス劣化
✅ null対策が甘く実行時例外が発生
✅ collectの最適な書き方がわからない

…といった悩みを抱える開発者は少なくありません。

本記事では、**「プロが実務で使うリスト処理の実践術」**を、マージ・変換・フィルタリングに焦点を当てて徹底解説します。

✅ Stream APIの基本構造

✅ Streamは元のリストを壊さない（非破壊的）
✅ 中間操作は評価されず蓄積 → 終端操作で初めて実行
✅ メソッドチェーンで可読性UP

✅ 1. リストをマージ（結合）する３つの実践パターン

❗ 従来の書き方（非推奨）

✅ ① Stream.concat()

✅ ② flatMapを使った複数リスト統合

✅ リストを動的に渡す場合にも有効

✅ 2. リストの変換（map・flatMap）実践術

✅ map（1対1変換）

✅ flatMap（1対多変換に最適）

✅ 「map + 非Stream返却」ならmap
✅ 「map + Stream返却」ならflatMap

✅ 3. フィルタリング（filter）応用パターン

✅ 基本

✅ 複数条件

✅ Optional併用（null安全）

✅ 4. プロが多用する応用操作

操作	用途	サンプル
distinct	重複削除	.distinct()
sorted	並び替え	.sorted(Comparator.comparing(User::getAge))
groupingBy	グループ化	Collectors.groupingBy(User::getDepartment)
collectingAndThen	集約後処理	.collect(Collectors.collectingAndThen(Collectors.toList(), Collections::unmodifiableList))

✅ Before / Afterで理解：IDの重複を削って並べる

❌ 従来（冗長）

List<Integer> ids = new ArrayList<>();
for (User u : users) {
    if(u.getId() != null && u.getId() > 0) {
        if(!ids.contains(u.getId())) {
            ids.add(u.getId());
        }
    }
}
Collections.sort(ids);

List<Integer> ids = new ArrayList<>();

for (User u : users) {

if(u.getId() != null && u.getId() > 0) {

if(!ids.contains(u.getId())) {

ids.add(u.getId());

}

Collections.sort(ids);

✅ Stream版（たった1行）

List<Integer> ids = users.stream()
                         .map(User::getId)
                         .filter(Objects::nonNull)
                         .filter(id -> id > 0)
                         .distinct()
                         .sorted()
                         .collect(Collectors.toList());

List<Integer> ids = users.stream()

.map(User::getId)

.filter(Objects::nonNull)

.filter(id -> id > 0)

.distinct()

.sorted()

.collect(Collectors.toList());

✅ 5. パフォーマンス注意点

NG	OK	理由
filter後にmap	map後にfilter	マッピングが無駄になる
distinct前にmap	map後にdistinct	重複を早く削る
flatMap多用	必要時のみ	ネストが深いと重い
無闇なparallel()	データ量が少ないと逆効果

✅ 最後に：Stream APIは「読みやすく・壊さない」が正解

✅ 冗長なfor文はStreamで置き換え
✅ mapとflatMapは「1対1」「1対多」で使い分け
✅ filterは前処理に最適
✅ Optional併用でnull対策
✅ groupByやdistinctで実務効率化

「使える」から「読みやすい」「安全」「再現性のある」コードへ。

Java, ブログ, プログラミング

Java：Stream APIのparallelStream()で並列処理を簡単に実現する方法

2025年10月17日管理者コメントする

🔷 はじめに

JavaのStream APIは、コレクション操作を簡潔に記述できる便利な仕組みですが、
parallelStream()を使うことで マルチスレッド処理（並列処理） を手軽に実現できます。

この記事では、parallelStream()の基本的な使い方から、注意点・パフォーマンスの最適化方法までをわかりやすく解説します。

🔷 StreamとparallelStreamの違い

種類	説明	特徴
stream()	通常の逐次処理	1スレッドで順次実行される
parallelStream()	並列処理	ForkJoinPoolを使って複数スレッドで分割実行される

List<Integer> numbers = Arrays.asList(1, 2, 3, 4, 5);

// 通常のストリーム
numbers.stream()
       .forEach(System.out::println);

// 並列ストリーム
numbers.parallelStream()
       .forEach(System.out::println);

List<Integer> numbers = Arrays.asList(1, 2, 3, 4, 5);

// 通常のストリーム

numbers.stream()

.forEach(System.out::println);

// 並列ストリーム

numbers.parallelStream()

.forEach(System.out::println);

上記のparallelStream()では、スレッドごとに要素を分割して処理するため、
出力順が異なる（順不同になる）点に注意が必要です。

🔷 並列処理の仕組み（ForkJoinPool）

parallelStream()は内部的に ForkJoinPool（フォーク・ジョイン・プール）を使用します。
デフォルトでは、Runtime.getRuntime().availableProcessors() の値（CPUコア数）に応じてスレッド数が自動決定されます。

例えば、4コアCPUの場合は最大4スレッドで同時実行されます。

🔷 実行例：リストの重い処理を並列化する

以下の例では、重い計算を伴う処理を並列実行して速度を比較します。

import java.util.*;
import java.util.stream.*;

public class ParallelExample {
    public static void main(String[] args) {
        List<Integer> numbers = IntStream.rangeClosed(1, 10).boxed().toList();

        long startSequential = System.currentTimeMillis();
        numbers.stream().forEach(ParallelExample::heavyTask);
        long timeSequential = System.currentTimeMillis() - startSequential;

        long startParallel = System.currentTimeMillis();
        numbers.parallelStream().forEach(ParallelExample::heavyTask);
        long timeParallel = System.currentTimeMillis() - startParallel;

        System.out.println("逐次処理時間：" + timeSequential + "ms");
        System.out.println("並列処理時間：" + timeParallel + "ms");
    }

    private static void heavyTask(int n) {
        try { Thread.sleep(500); } catch (InterruptedException e) {}
        System.out.println("完了：" + n + " [" + Thread.currentThread().getName() + "]");
    }
}

import java.util.*;

import java.util.stream.*;

public class ParallelExample {

public static void main(String[] args) {

List<Integer> numbers = IntStream.rangeClosed(1, 10).boxed().toList();

long startSequential = System.currentTimeMillis();

numbers.stream().forEach(ParallelExample::heavyTask);

long timeSequential = System.currentTimeMillis() - startSequential;

long startParallel = System.currentTimeMillis();

numbers.parallelStream().forEach(ParallelExample::heavyTask);

long timeParallel = System.currentTimeMillis() - startParallel;

System.out.println("逐次処理時間：" + timeSequential + "ms");

System.out.println("並列処理時間：" + timeParallel + "ms");

}

private static void heavyTask(int n) {

try { Thread.sleep(500); } catch (InterruptedException e) {}

System.out.println("完了：" + n + " [" + Thread.currentThread().getName() + "]");

}

結果例：

CPUコア数にもよりますが、並列処理では約3倍の高速化が期待できます。

🔷 並列処理時の注意点

注意点	内容
スレッド安全性	共有リソースを操作すると競合が発生する可能性あり
出力順	forEach()は順序が保証されない（順序を保つにはforEachOrdered()を使用）
外部API呼び出し	同時実行でAPI制限に抵触する可能性があるため注意

🔷 並列処理の最適化テクニック

処理が軽い場合は使わない
- 並列化のオーバーヘッドが大きく、逆に遅くなる場合があります。
データ量が多い処理に限定する
- 数千件以上の要素を扱う場合に効果的。
カスタムスレッド数を指定

Java

numbers.parallelStream() .forEachOrdered(System.out::println); // 並列でも順序維持

1
2

numbers.parallelStream()
.forEachOrdered(System.out::println); // 並列でも順序維持
- これで並列スレッド数を8に固定できます。

🔷 parallelStream()を使うべきケース

✅ CPUバウンド処理（計算中心）
✅ データが多い場合
✅ スレッド安全な処理のみを行う場合

❌ I/Oバウンド処理（ファイル操作・DBアクセス）は非推奨です。
並列化よりも非同期I/O（CompletableFutureなど）を使うほうが効率的です。

🔷 まとめ

項目	内容
メリット	複雑なスレッド処理を書かずに並列化できる
デメリット	順序保証がない・スレッド安全性に注意
向いている処理	CPU負荷の高いループ・数値計算・マッピング処理
非推奨の処理	I/O、同期が必要な共有データ操作

parallelStream()は数行で並列化を実現できる強力なツールですが、
適切な場面で使うことが重要です。
CPUをフル活用して処理時間を短縮したい場面で、ぜひ活用してみてください。

Java, ブログ, プログラミング

Java Stream API入門：リスト操作を効率化する実用サンプル集

2025年10月13日管理者コメントする

■ 導入：Stream APIでコードを劇的に簡潔化

Java 8以降で導入された Stream API は、リストや配列の操作を「宣言的」「関数型スタイル」で記述できる強力な仕組みです。
従来の for ループを使った処理に比べて、コード量を大幅に削減し、バグを防止 できます。

本記事では、List 操作を中心に、Stream APIの実践サンプルを多数紹介します。

■ 基本構文：Streamの流れを理解する

Streamの基本構成は以下の3ステップです。

イメージ：

■ サンプル①：条件でフィルタリングする

例えば「偶数だけを抽出する」処理は、以下のように書けます。

処理内容	コード例	説明
偶数のみ抽出	filter(n -> n % 2 == 0)	条件に一致する要素だけを残す

■ サンプル②：要素を変換する（map）

全ての要素を2倍にする変換も簡単です。

処理内容	コード例	出力例
2倍変換	map(n -> n * 2)	[2, 4, 6, 8]

■ サンプル③：ソート・並び替え

文字列リストをアルファベット順にソートする例です。

降順にする場合は：

処理内容	メソッド	説明
昇順ソート	sorted()	自然順序（A→Z, 1→9）
降順ソート	sorted(Comparator.reverseOrder())	逆順に並び替え

■ サンプル④：重複を除去する（distinct）

処理内容	メソッド	効果
重複削除	distinct()	同一要素を1つにまとめる

■ サンプル⑤：合計・平均・最大値を求める

数値リストの集計処理も簡単です。

処理	メソッド	結果型
合計	sum()	int
平均	average()	OptionalDouble
最大	max()	OptionalInt

■ サンプル⑥：複数条件の処理（filter + map）

処理順序	内容
①	Aで始まる要素のみ抽出
②	すべて大文字に変換
③	新しいリストに収集

■ サンプル⑦：グルーピング（groupingBy）

Stream APIでは、SQLのように「グループ化」も可能です。

処理内容	メソッド	結果
長さごとにグループ化	groupingBy(String::length)	{3=[Tom, Ken], 4=[John]}

■ サンプル⑧：並列処理で高速化（parallelStream）

大量データを高速処理したい場合は parallelStream() を使います。

ただし、順序が保証されない ため、結果の順序が重要な場合は通常の stream() を使用しましょう。

■ Stream APIを使うメリットまとめ

メリット	内容
コードの簡潔化	for文やif文のネストを削減
可読性向上	処理の流れが直感的に理解できる
パフォーマンス	並列処理で大量データにも対応
安全性	NullPointerExceptionを防ぎやすい

■ まとめ：Stream APIを使いこなして効率化

Stream APIは一度慣れてしまえば、リスト処理を格段に楽にしてくれます。
特にJava 11以降では、ラムダ式やメソッド参照との相性も良く、業務アプリのコード品質を底上げできます。

覚え書き.com

「Stream API」タグアーカイブ

Java Streamsで文字列リストを加工・整形する便利テクニック

✔ よくある文字列リストの処理

1. 空文字・null を除去する

2. 全要素を大文字 or 小文字に変換する

3. 特定の文字を含む要素だけ抽出する

4. trim＋フィルタ＋整形をまとめて 1 行で

5. 重複要素を除外する（distinct）

6. 文字列リストを区切り文字で join する（CSV など）

7. リスト内の文字列長でソートする（Comparator）

8. 正規表現で加工する（replaceAll 等）

9. Stream API を使うメリットまとめ

✔ コードが短く読みやすい

✔ null などの例外ケースを潰しやすい

✔ 並列処理（parallelStream）にも切り替えやすい

まとめ

Java：Stream APIのparallelStream()で並列処理を簡単に実現する方法

🔷 はじめに

🔷 StreamとparallelStreamの違い

🔷 並列処理の仕組み（ForkJoinPool）

🔷 実行例：リストの重い処理を並列化する

🔷 並列処理時の注意点

🔷 並列処理の最適化テクニック

🔷 parallelStream()を使うべきケース

🔷 まとめ

Java Stream API入門：リスト操作を効率化する実用サンプル集

■ 導入：Stream APIでコードを劇的に簡潔化

■ 基本構文：Streamの流れを理解する

■ サンプル①：条件でフィルタリングする

■ サンプル②：要素を変換する（map）

■ サンプル③：ソート・並び替え

■ サンプル④：重複を除去する（distinct）

■ サンプル⑤：合計・平均・最大値を求める

■ サンプル⑥：複数条件の処理（filter + map）

■ サンプル⑦：グルーピング（groupingBy）

■ サンプル⑧：並列処理で高速化（parallelStream）

■ Stream APIを使うメリットまとめ

■ まとめ：Stream APIを使いこなして効率化

「駑馬十駕」を信念に IT系情報を中心に調べた事をコツコツ綴っています。

✔ よくある文字列リストの処理

1. 空文字・null を除去する

2. 全要素を大文字 or 小文字に変換する

3. 特定の文字を含む要素だけ抽出する

4. trim＋フィルタ＋整形をまとめて 1 行で

5. 重複要素を除外する（distinct）

6. 文字列リストを区切り文字で join する（CSV など）

7. リスト内の文字列長でソートする（Comparator）

8. 正規表現で加工する（replaceAll 等）

9. Stream API を使うメリットまとめ

✔ コードが短く読みやすい

✔ null などの例外ケースを潰しやすい

✔ 並列処理（parallelStream）にも切り替えやすい

まとめ

関連記事

✅ はじめに：Java 8以降の開発では「リスト操作力」が問われる

✅ Stream APIの基本構造

✅ 1. リストをマージ（結合）する３つの実践パターン

❗ 従来の書き方（非推奨）

✅ ① Stream.concat()

✅ ② flatMapを使った複数リスト統合

✅ 2. リストの変換（map・flatMap）実践術

✅ map（1対1変換）

✅ flatMap（1対多変換に最適）

✅ 3. フィルタリング（filter）応用パターン

✅ 基本

✅ 複数条件

✅ Optional併用（null安全）

✅ 4. プロが多用する応用操作

✅ Before / Afterで理解：IDの重複を削って並べる

❌ 従来（冗長）

✅ Stream版（たった1行）

✅ 5. パフォーマンス注意点

✅ 最後に：Stream APIは「読みやすく・壊さない」が正解

関連記事

🔷 はじめに

🔷 StreamとparallelStreamの違い

🔷 並列処理の仕組み（ForkJoinPool）

🔷 実行例：リストの重い処理を並列化する

🔷 並列処理時の注意点

🔷 並列処理の最適化テクニック

🔷 parallelStream()を使うべきケース

🔷 まとめ

関連記事

■ 導入：Stream APIでコードを劇的に簡潔化

■ 基本構文：Streamの流れを理解する

■ サンプル①：条件でフィルタリングする

■ サンプル②：要素を変換する（map）

■ サンプル③：ソート・並び替え

■ サンプル④：重複を除去する（distinct）

■ サンプル⑤：合計・平均・最大値を求める

■ サンプル⑥：複数条件の処理（filter + map）

■ サンプル⑦：グルーピング（groupingBy）

■ サンプル⑧：並列処理で高速化（parallelStream）

■ Stream APIを使うメリットまとめ

■ まとめ：Stream APIを使いこなして効率化

関連記事

「駑馬十駕」を信念に IT系情報を中心に調べた事をコツコツ綴っています。

　関連記事

　関連記事

　関連記事

　関連記事