「Java」カテゴリーアーカイブ

XML解析の基本！Javaで要素や属性を取得する方法

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

システム開発やデータ連携の現場では、設定ファイルやAPIレスポンスなどでXML形式のデータを扱う機会が多くあります。
この記事では、Javaを使ってXMLを解析し、要素（タグ内の値）や属性を取得する基本的な方法を解説します。

XML解析の代表的な方法

JavaではXMLを解析するために、いくつかのAPIが用意されています。

解析方法	特徴
DOM（Document Object Model）	メモリ上にXML全体を読み込み、ツリー構造で扱う。小規模ファイル向き。
SAX（Simple API for XML）	イベント駆動型で順次読み込む。大規模ファイル向き。
StAX（Streaming API for XML）	ストリーム処理を行いながら解析。SAXより柔軟。

今回は最も基本的なDOMパーサを使用します。

DOMパーサでXMLを解析する手順

以下のサンプルXMLを例にします。

<books>
    <book id="1" category="novel">
        <title>風の谷のナウシカ</title>
        <author>宮崎 駿</author>
    </book>
    <book id="2" category="science">
        <title>宇宙への旅</title>
        <author>野口 聡一</author>
    </book>
</books>

<books>

<title>風の谷のナウシカ</title>

</book>

<title>宇宙への旅</title>

</book>

</books>

Javaサンプルコード

import org.w3c.dom.*;
import javax.xml.parsers.DocumentBuilder;
import javax.xml.parsers.DocumentBuilderFactory;

public class XmlParserExample {
    public static void main(String[] args) {
        try {
            // XMLファイルをパース
            DocumentBuilderFactory factory = DocumentBuilderFactory.newInstance();
            DocumentBuilder builder = factory.newDocumentBuilder();
            Document doc = builder.parse("books.xml");

            // ルート要素を取得
            Element root = doc.getDocumentElement();
            System.out.println("Root: " + root.getNodeName());

            // book要素を取得
            NodeList bookList = doc.getElementsByTagName("book");

            for (int i = 0; i < bookList.getLength(); i++) {
                Element book = (Element) bookList.item(i);

                // 属性を取得
                String id = book.getAttribute("id");
                String category = book.getAttribute("category");

                // 子要素を取得
                String title = book.getElementsByTagName("title").item(0).getTextContent();
                String author = book.getElementsByTagName("author").item(0).getTextContent();

                System.out.println("ID: " + id + " / カテゴリ: " + category);
                System.out.println("タイトル: " + title);
                System.out.println("著者: " + author);
                System.out.println("--------------------");
            }

        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

import org.w3c.dom.*;

import javax.xml.parsers.DocumentBuilder;

import javax.xml.parsers.DocumentBuilderFactory;

public class XmlParserExample {

public static void main(String[] args) {

try {

// XMLファイルをパース

DocumentBuilderFactory factory = DocumentBuilderFactory.newInstance();

DocumentBuilder builder = factory.newDocumentBuilder();

Document doc = builder.parse("books.xml");

// ルート要素を取得

Element root = doc.getDocumentElement();

System.out.println("Root: " + root.getNodeName());

// book要素を取得

NodeList bookList = doc.getElementsByTagName("book");

for (int i = 0; i < bookList.getLength(); i++) {

Element book = (Element) bookList.item(i);

// 属性を取得

String id = book.getAttribute("id");

String category = book.getAttribute("category");

// 子要素を取得

String title = book.getElementsByTagName("title").item(0).getTextContent();

String author = book.getElementsByTagName("author").item(0).getTextContent();

System.out.println("ID: " + id + " / カテゴリ: " + category);

System.out.println("タイトル: " + title);

System.out.println("著者: " + author);

System.out.println("--------------------");

}

} catch (Exception e) {

e.printStackTrace();

}

実行結果

Root: books
ID: 1 / カテゴリ: novel
タイトル: 風の谷のナウシカ
著者: 宮崎 駿
--------------------
ID: 2 / カテゴリ: science
タイトル: 宇宙への旅
著者: 野口 聡一
--------------------

Root: books

ID: 1 / カテゴリ: novel

タイトル: 風の谷のナウシカ

著者: 宮崎駿

--------------------

ID: 2 / カテゴリ: science

タイトル: 宇宙への旅

著者: 野口聡一

--------------------

ポイント解説

DocumentBuilderFactory：XML解析のためのインスタンスを生成
getDocumentElement()：ルート要素を取得
getElementsByTagName()：指定タグのノードリストを取得
getAttribute()：要素の属性値を取得
getTextContent()：タグ内のテキスト値を取得

よくあるエラー例

エラー内容	原因と対処法
FileNotFoundException	XMLファイルのパスが誤っている。絶対パスまたは相対パスを確認。
SAXParseException	XML構文が正しくない（タグの閉じ忘れやエンコーディング不一致など）。
NullPointerException	該当タグが存在しない場合にitem(0)でNullを参照している。要素の存在チェックを追加する。

まとめ

XML解析ではDOM・SAX・StAXなどの手法がある。
小規模なXMLではDOMパーサが使いやすい。
ElementやNodeListを通じて要素・属性を自由に操作できる。

JavaでXMLを扱う基本を押さえておくと、設定ファイルや外部システム連携処理をスムーズに開発できます。

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

Javaメモリ管理の仕組み：ガーベジコレクションとヒープの基本

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

1. Javaのメモリ管理とは？

Javaはプログラマーが手動でメモリを解放しなくても良い言語です。
C・C++のように free() を使う必要はありません。

Javaでは、必要なくなったオブジェクトを自動で回収（解放）する仕組みが備わっています。
これを**ガーベジコレクション（Garbage Collection, GC）**と呼びます。

「解放漏れによるメモリリークが発生しづらい」
→ Javaが幅広く使われる理由の1つ

2. Javaのメモリ領域：ヒープとスタック

Javaアプリのメモリは主に次の2領域で管理されます。

領域	役割	特徴
ヒープ（Heap）	オブジェクト、配列を格納	GCの対象
スタック（Stack）	メソッド実行中の変数・参照	メソッド終了で自動解放

ヒープ領域の構造（JDK8以降）

領域	内容
Young Generation	新規オブジェクト領域（Eden、Survivor）
Old Generation	長生きするオブジェクト領域

多くのオブジェクトはすぐ不要になる → Young に多く配置するのが効率的

3. ガーベジコレクションの動き

ガーベジコレクションは、参照されなくなったオブジェクトを検出・削除します。

処理の流れ

オブジェクトを生成（ヒープに配置）
参照が切れる or 到達不能になる
GCが不要オブジェクトを回収

GCアルゴリズム（代表）

名称	特徴
Mark and Sweep	到達可能オブジェクトに印を付け、残りを削除
Copying	生きているオブジェクトを別領域に移動して残りを破棄
Generational GC	世代（Young/Old）でGC動作を変える効率化方式

4. Javaの主要GC方式（JDKバージョン別）

GC機能	特徴	対象バージョン
Serial GC	シングルスレッド、単純設計	軽量アプリ
Parallel GC	並列処理で高速	デフォルト（Java8）
G1 GC	大規模ヒープ向け、低停止時間	Java9以降推奨
ZGC	超低遅延GC、数百GB〜TB向け	Java15以降
Shenandoah	RedHat版、低遅延	OpenJDK系

5. よくあるメモリ関連エラー

❌ `java.lang.OutOfMemoryError`

ヒープ不足で発生
→ ヒープ拡張 or メモリリーク調査

❌ `StackOverflowError`

再帰のしすぎなどでスタック溢れ

❌ メモリリーク

Javaでも発生します（例：Listにaddしっぱなし）

6. メモリ管理・GCチューニングのポイント

対策	内容
不要な参照を早く消す	ローカル変数は小スコープ
大規模データは逐次処理	巨大Listを避けIterator活用
WeakReference活用	キャッシュ管理時に便利
GCログ・ツール利用	-Xmx設定、VisualVM/FlightRecorder

JVMオプション例

7. まとめ

ポイント	内容
Javaは自動メモリ管理	ガーベジコレクションが解放処理
ヒープが主な領域	Young/Old世代で効率化
GC方式は進化中	G1GC・ZGCが主流
最適化の余地あり	適切なコーディング＋JVM設定

「自動だから安心」ではなく、仕組み理解でパフォーマンス向上！

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

Java：IllegalArgumentExceptionの意味と例外設計のベストプラクティス

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

Javaアプリケーション開発では「想定外の入力」に対して適切にエラーを発生させ、プログラムの異常動作を防ぐことが重要です。その際によく使用される例外のひとつが IllegalArgumentException です。

本記事では、IllegalArgumentException の意味、発生するケース、使い方の例、そして例外設計のベストプラクティスまで徹底解説します。

IllegalArgumentExceptionとは？

IllegalArgumentException とは、

メソッドに不正な引数（値）が渡された場合にスローされる実行時例外（RuntimeException）

です。

例えば、年齢を受け取るメソッドに 負の値 が渡された場合など、
「引数の値が意味を成していない」状態で使われます。

なぜIllegalArgumentExceptionを使うのか？

✔ 不適切な入力を早期に検知
✔ 異常な状態を防ぎ、予測可能な動作を保証
✔ 開発者や利用側に明確なフィードバック

特に、ライブラリ・APIの開発時には重要です。
「どんな値が許容されるのか？」を明確にすることで利用者のミスを防げます。

IllegalArgumentExceptionの基本例

✅ 正の値のみ受け付けるメソッド例

チェックポイント

条件式で検証
明確なメッセージで何が悪いか伝える

Integerチューター：標準APIにも見る例

Java標準APIも積極的にこの例外を使っています。

例：Thread#setPriority(int priority)

Java公式の一貫性ある設計に従うことで、コード品質が向上します。

IllegalArgumentException vs 他の例外

例外	使う場面
IllegalArgumentException	引数の値が不正
NullPointerException	引数がnull不可なのにnull
IllegalStateException	オブジェクトの状態が不正
IOException	I/O操作中の問題

ポイント

値がおかしい→IllegalArgumentException
状態がおかしい→IllegalStateException

ベストプラクティス：例外設計ガイド

✅ 1. 早めにチェックする（Fail Fast）

異常はできるだけ早く発見しましょう。

✅ 2. メッセージで原因を明示

悪い例（NG）

何が悪いのか分からない…

✅ 3. Javadocで事前に仕様を明記

APIの信頼性が向上します。

✅ 4. nullチェックは`Objects.requireNonNull`で簡潔に

ユースケース：バリデーションロジックの整理方法

例外処理が肥大化しないよう、専用バリデータクラスを作るアプローチも有効です。

public class Validator {
    public static void requirePositive(int num, String field) {
        if (num <= 0) {
            throw new IllegalArgumentException(field + " must be > 0");
        }
    }
}

public class Validator {

public static void requirePositive(int num, String field) {

if (num <= 0) {

throw new IllegalArgumentException(field + " must be > 0");

}

利用例：

まとめ

ポイント	内容
例外名	IllegalArgumentException
意味	不正な引数が渡された
目的	予期しない動作を防ぐ
コツ	Fail Fast、明確なメッセージ、仕様明記

良い例外設計はコードの信頼性・保守性を大きく高めます。
実務でも積極的に活用していきましょう！

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

【Java初心者向け】staticって何？よくある質問を例付きで解説

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

Javaを学び始めると、最初に必ずと言っていいほど出てくるキーワードがstatic。
でも、

staticって具体的に何をしているの？
いつ使うべき？
staticをつけないとどうなるの？

という疑問を持つ方が多いです。

この記事では、できるだけ分かりやすく、staticの意味や使いどころを例を交えて解説します。

staticとは？

staticはクラスに属するという意味です。
通常の変数やメソッドはインスタンス（newで作ったオブジェクト）に属しますが、staticはクラス自体に属するため、オブジェクトを作らずに使うことができます。

よくある疑問と回答

Q1. なぜmainメソッドにはstaticが付いているの？

A：Javaプログラムを実行するとき、まず「クラス」を読み込むから。

プログラム開始時点ではまだオブジェクトがありません。
そこで、オブジェクト不要で実行できるようにするためstaticが付いています。

Q2. static変数と普通の変数の違いは？

種類	所属	使うタイミング
インスタンス変数	オブジェクト	オブジェクトごとに独立した値を持ちたいとき
static変数	クラス	全オブジェクトで共有したいとき

例：カウンター（全インスタンスで共有）

public class Counter {
    static int count = 0;

    public Counter() {
        count++;
    }
}

public class Main {
    public static void main(String[] args) {
        new Counter();
        new Counter();
        System.out.println(Counter.count); // 2
    }
}

public class Counter {

static int count = 0;

public Counter() {

count++;

}

public class Main {

public static void main(String[] args) {

new Counter();

System.out.println(Counter.count); // 2

}

countは全インスタンスで共有されるため、2回インスタンス化すると値が2になります。

Q3. staticメソッドっていつ使うの？

ユーティリティ処理
共通的な値や処理
インスタンスの状態に依存しないメソッド

例：Mathクラス

Mathクラスはnewしません。
staticの代表例です。

Q4. staticを付けすぎるとどうなる？

オブジェクト指向らしさが失われます。

何でもかんでもstatic → 関数型プログラムみたいになる
状態（フィールド）を持つ設計が難しくなる

✅ ルール

状態を持つもの → インスタンス
共通処理 → static

まとめ

用語	意味
static	クラスに属する（オブジェクト不要）
static変数	全インスタンスで共通の変数
staticメソッド	インスタンスに依存しない処理
mainメソッドがstaticな理由	最初はオブジェクトがないため

まずは「オブジェクト不要で使える」だけ覚えてOK！
使いながら感覚をつかみましょう ✅

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, ブログ, プログラミング

Mapの操作がここまで楽になる！Java 8のcomputeIfAbsent/merge徹底活用術

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

はじめに：Map操作、まだ「containsKey」で書いていませんか？

JavaでMapを使うとき、以下のようなコードを書いた経験はありませんか？

Java 8以前ではこれが一般的でした。しかしJava 8では、computeIfAbsentやmergeを使うことで、こうした冗長なコードをたった1行で表現できます！

本記事では、これらのメソッドの使い方から実践例まで徹底的に解説します。

✅ computeIfAbsentとは？

🔍 役割

キーが存在しないときに初期値を生成しMapに登録する。

📌 シグネチャ

✅ 使用例：リストを保持するMapに要素を追加する場合

📉 Before（従来のコード）

📈 After（computeIfAbsentで1行に）

👉 このように、存在確認不要でスッキリ！

✅ mergeとは？

🔍 役割

指定したキーに対して、既に値がある場合は「結合処理」を行い、新規ならそのまま値を格納。

📌 シグネチャ

✅ 使用例：カウントアップ処理

📉 Before（キー存在チェックあり）

📈 After（mergeで1行）

👉 キーがなければ1を設定。あれば現在値と1を足す。美しい！

✅ computeIfAbsentとmergeの使い分け

ケース	推奨メソッド
値を「初期化してから操作」したい	computeIfAbsent
「集計・加算・結合」したい	merge
ListやSetを使うMapに要素を追加したい	computeIfAbsent
数値や文字列をまとめたい	merge

✅ さらに活用例：文字列の出現回数カウント

List<String> words = Arrays.asList("apple", "banana", "apple", "orange", "banana");
Map<String, Integer> countMap = new HashMap<>();

for (String word : words) {
    countMap.merge(word, 1, Integer::sum);
}

System.out.println(countMap);

List<String> words = Arrays.asList("apple", "banana", "apple", "orange", "banana");

Map<String, Integer> countMap = new HashMap<>();

for (String word : words) {

countMap.merge(word, 1, Integer::sum);

}

System.out.println(countMap);

📤 出力：

✅ Listを使ったグルーピングも簡単に！

Map<String, List<String>> groupMap = new HashMap<>();
groupMap.computeIfAbsent("A", k -> new ArrayList<>()).add("Apple");
groupMap.computeIfAbsent("A", k -> new ArrayList<>()).add("Avocado");
groupMap.computeIfAbsent("B", k -> new ArrayList<>()).add("Banana");

System.out.println(groupMap);

Map<String, List<String>> groupMap = new HashMap<>();

groupMap.computeIfAbsent("A", k -> new ArrayList<>()).add("Apple");

groupMap.computeIfAbsent("A", k -> new ArrayList<>()).add("Avocado");

groupMap.computeIfAbsent("B", k -> new ArrayList<>()).add("Banana");

System.out.println(groupMap);

📤 出力：

✅ まとめ：Map操作はJava 8で劇的にスマートになる！

キーワード	内容
computeIfAbsent	値がない場合のみ初期化
merge	既存値と競合処理（加算・結合など）
メリット	if文不要・コードが短く読みやすくなる

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

if文から卒業！Java 8のPredicateで条件分岐をスマートに書く方法

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

Javaで複雑な条件分岐が増えてくると、if文がネストして読みにくくなる…という悩みを抱えたことはありませんか？
Java 8で追加された**Predicateインターフェース**を使えば、条件式をオブジェクトとして扱えるため、よりスマートで再利用可能な形にできます。

本記事では、Predicateの基本から複数条件の組み合わせ、実用的な活用例まで分かりやすく解説します。

✅ Predicateとは？

Predicate<T> はJava 8で導入された関数型インターフェースで、**「引数を1つ受け取り、booleanを返す関数」**を表します。

test()メソッドに条件式を実装することで、条件判定を行うことができます。

✅ 基本的な使い方

✔ Lambda式で判定条件を定義

ここで、age -> age >= 20 という条件式がPredicateとして表現されています。

✅ 条件を組み合わせる（and/or/negate）

Predicateは以下のような便利なメソッドを持っています。

メソッド	説明	使用例
and()	両方trueでtrue	AND条件
or()	どちらかtrueでtrue	OR条件
negate()	条件を反転	NOT条件

✔ 使用例

Predicate<Integer> isAdult = age -> age >= 20;
Predicate<Integer> isSenior = age -> age >= 65;

Predicate<Integer> isWorkingAdult = isAdult.and(isSenior.negate());

System.out.println(isWorkingAdult.test(30)); // true
System.out.println(isWorkingAdult.test(70)); // false

Predicate<Integer> isAdult = age -> age >= 20;

Predicate<Integer> isSenior = age -> age >= 65;

Predicate<Integer> isWorkingAdult = isAdult.and(isSenior.negate());

System.out.println(isWorkingAdult.test(30)); // true

System.out.println(isWorkingAdult.test(70)); // false

✅ 実用例①：従来のif文から置き換えてスマートに

❌ 従来のif文

✅ Predicateを使った場合

→ 条件式をPredicateとして切り出すことで、再利用しやすくなります。

✅ 実用例②：Listのフィルタリングに活用

stream().filter() と組み合わせるとさらに強力です。

List<Integer> ages = Arrays.asList(15, 22, 38, 67);

Predicate<Integer> isAdult = age -> age >= 20;

List<Integer> filtered = ages.stream()
                             .filter(isAdult)
                             .toList();

System.out.println(filtered); // [22, 38]

List<Integer> ages = Arrays.asList(15, 22, 38, 67);

Predicate<Integer> isAdult = age -> age >= 20;

List<Integer> filtered = ages.stream()

.filter(isAdult)

.toList();

System.out.println(filtered); // [22, 38]

→ 条件式が外部に切り出されることで、読みやすく拡張しやすいコードになります。

🎯 Predicateを使うメリット

項目	従来のif文	Predicate
可読性	ネストしやすい	条件名で意図が明確
再利用性	条件をコピペ	使い回し可能
拡張性	if追加が必要	and/orで柔軟に拡張

⚠ 濫用しすぎには注意！

Predicateは便利ですが、小規模な処理に無理に使うと逆に複雑化することがあります。
「条件が複数箇所で使い回せる場合」や「複雑なAND/OR条件を定義したい場合」に効果を発揮します。

✅ まとめ

項目	内容
Predicateとは	booleanを返す関数型インターフェース
基本	test() で条件判定
条件組み合わせ	and/or/negateでスマートに
実用例	if文の代替・Streamのfilterで活躍
メリット	可読性・再利用性UP

👉 if文が増えて可読性が下がってきたと感じたら、まずは小さな条件式からPredicate化してみましょう！

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以降では、ラムダ式やメソッド参照との相性も良く、業務アプリのコード品質を底上げできます。

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

Java初心者必見！Optionalでnullチェックを安全に行う方法【サンプル付き】

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

Javaで避けて通れないのが「nullチェック」。
しかし、if文を多用するとコードが読みにくくなり、思わぬNullPointerExceptionが発生することもあります。
そんな悩みを解消してくれるのが Optionalクラス です。

本記事では、Optionalを使った安全でスマートなnullチェックの方法を、サンプルコード付きで分かりやすく解説します。

💡 Optionalとは？

Optionalは、Java 8で追加されたクラスで、
「nullの代わりに値の有無を明示的に扱う」ためのラッパーです。

Optionalは「値がある」か「空（empty）」かを明確に区別できるため、
if (obj != null) のような古い書き方を減らせます。

✅ よくあるnullチェックの問題例

この書き方は一見安全ですが、
複数のフィールドをネストすると次のようにネスト地獄に陥ります。

→ これをスマートに書けるのがOptionalです。

🧩 Optionalを使った安全な書き方

これだけで「nullがあれば自動的にスキップ」されます。
つまり、nullチェックをネストせずに安全に値を取り出せるのです。

🔍 Optionalの主なメソッド一覧

メソッド	説明	使用例
of()	null禁止でOptionalを作成	Optional.of("Hello")
ofNullable()	null許可でOptionalを作成	Optional.ofNullable(obj)
isPresent()	値が存在するか判定	if(opt.isPresent())
ifPresent()	値がある場合に処理を実行	opt.ifPresent(System.out::println)
orElse()	値がない場合のデフォルト値を設定	opt.orElse("default")
orElseGet()	遅延生成のデフォルト値	opt.orElseGet(() -> "default")
orElseThrow()	値がない場合に例外を投げる	opt.orElseThrow()

🧠 orElseとorElseGetの違い

比較項目	orElse()	orElseGet()
評価タイミング	常に評価	値が空のときのみ評価
パフォーマンス	無駄な生成が起こる場合あり	必要なときだけ生成
例	opt.orElse(createDefault())	opt.orElseGet(() -> createDefault())

💬 ポイント：
createDefault() のような重い処理を含む場合は、orElseGet()を使う方が効率的です。

🧾 サンプルコード全体

import java.util.Optional;

public class OptionalExample {
    public static void main(String[] args) {
        String name = null;

        // Optionalを使用したnullチェック
        Optional<String> optName = Optional.ofNullable(name);

        // 値があれば大文字に変換して表示
        optName
            .map(String::toUpperCase)
            .ifPresentOrElse(
                System.out::println,
                () -> System.out.println("名前が未設定です。")
            );
    }
}

import java.util.Optional;

public class OptionalExample {

public static void main(String[] args) {

String name = null;

// Optionalを使用したnullチェック

Optional<String> optName = Optional.ofNullable(name);

// 値があれば大文字に変換して表示

optName

.map(String::toUpperCase)

.ifPresentOrElse(

System.out::println,

() -> System.out.println("名前が未設定です。")

);

}

✅ 出力結果：

🚀 Optionalを使うメリットまとめ

メリット	内容
可読性向上	if文のネストを削減できる
安全性向上	NullPointerExceptionのリスクを軽減
関数型スタイル	map, filter, flatMapなどと組み合わせ可能
メソッドチェーン	処理の流れを1行で表現できる

⚠️ 注意点：Optionalは「すべてに使う」ものではない

フィールド変数に使うと逆に可読性が下がる
シリアライズ対象（例：エンティティクラス）には不向き
「戻り値専用」として使うのが基本スタイルです。

🧭 まとめ

Optionalは「nullチェックを明示的に表現する」ための便利な仕組みです。
使い方を覚えることで、より安全で読みやすいJavaコードが書けるようになります。

XML解析の代表的な方法

DOMパーサでXMLを解析する手順

Javaサンプルコード

実行結果

ポイント解説

よくあるエラー例

まとめ

関連記事

1. Javaのメモリ管理とは？

2. Javaのメモリ領域：ヒープとスタック

ヒープ領域の構造（JDK8以降）

3. ガーベジコレクションの動き

処理の流れ

GCアルゴリズム（代表）

4. Javaの主要GC方式（JDKバージョン別）

5. よくあるメモリ関連エラー

❌ java.lang.OutOfMemoryError

❌ StackOverflowError

❌ メモリリーク

6. メモリ管理・GCチューニングのポイント

JVMオプション例

7. まとめ

関連記事

IllegalArgumentExceptionとは？

なぜIllegalArgumentExceptionを使うのか？

IllegalArgumentExceptionの基本例

✅ 正の値のみ受け付けるメソッド例

Integerチューター：標準APIにも見る例

IllegalArgumentException vs 他の例外

ベストプラクティス：例外設計ガイド

✅ 1. 早めにチェックする（Fail Fast）

✅ 2. メッセージで原因を明示

✅ 3. Javadocで事前に仕様を明記

✅ 4. nullチェックはObjects.requireNonNullで簡潔に

ユースケース：バリデーションロジックの整理方法

まとめ

関連記事

staticとは？

よくある疑問と回答

Q1. なぜmainメソッドにはstaticが付いているの？

Q2. static変数と普通の変数の違いは？

例：カウンター（全インスタンスで共有）

Q3. staticメソッドっていつ使うの？

例：Mathクラス

Q4. staticを付けすぎるとどうなる？

まとめ

関連記事

✅ はじめに：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は「読みやすく・壊さない」が正解

関連記事

はじめに：Map操作、まだ「containsKey」で書いていませんか？

✅ computeIfAbsentとは？

🔍 役割

📌 シグネチャ

✅ 使用例：リストを保持するMapに要素を追加する場合

📉 Before（従来のコード）

📈 After（computeIfAbsentで1行に）

✅ mergeとは？

🔍 役割

📌 シグネチャ

✅ 使用例：カウントアップ処理

📉 Before（キー存在チェックあり）

📈 After（mergeで1行）

　関連記事

❌ `java.lang.OutOfMemoryError`

❌ `StackOverflowError`

　関連記事

✅ 4. nullチェックは`Objects.requireNonNull`で簡潔に

　関連記事

　関連記事

　関連記事

　関連記事

　関連記事

　関連記事

　関連記事

　関連記事