【Java入門】コマンドライン引数の使い方を完全解説｜String[] argsの基本・応用・実践例まで

1. はじめに

この章の目的

Javaの「コマンドライン引数」は、プログラム実行時に外部から値を受け取り、挙動を切り替えるための基本機能です。本記事では、String[] args の意味から実践的な設計パターンまでを段階的に扱います。この章ではまず、「何ができるのか」「どんな場面で役に立つのか」を明確にします。

コマンドライン引数とは

Javaアプリケーションは通常、次のシグネチャを持つ main メソッドから始まります。

public class App {
    public static void main(String[] args) {
        // args は実行時に渡された文字列の配列
    }
}

args は文字列（String）の配列で、起動コマンドに付与した値が格納されます。例えば:

javac App.java
java App Tokyo 2025 debug

このとき args には ["Tokyo", "2025", "debug"] が入ります。
引数が1つもない場合、args.length は 0 です。

どんな場面で使うのか（ユースケース）

• 環境や対象を切り替える：本番／検証モード、地域コード、言語、ログレベルなど。
• 処理対象を外部指定：入力ファイル名、ディレクトリ、URL、IDリストなど。
• バッチ・自動化：定時実行ジョブで日付や範囲を与える、CI/CD からパラメータを注入する。

いずれも再コンパイル不要で振る舞いを変更でき、シェルスクリプトやジョブスケジューラ（cron など）との相性が良いのが特徴です。

設計視点で押さえるべきポイント

• 「必須」と「任意」を分ける：最低限必要な引数が満たされない場合はヘルプ表示や終了コードで明確に失敗させる。
• バリデーションを先に：数値や日付などの型変換は早めに行い、不正値を検知したら丁寧に案内する。
• デフォルト値の設計：任意引数には安全な既定値を用意し、未指定でも実行できる体験を提供する。
• 可読性と保守性：配列の生アクセスを散在させず、引数を解析して構造化（DTOや設定クラス）してから利用する。

設定ファイル・環境変数との使い分け

• コマンドライン引数：一時的な上書きやジョブ単位の切り替えに向く（最優先の“局所設定”として扱う）。
• 環境変数：デプロイ環境ごとに変わる秘密情報・エンドポイントなどを外出しするのに適する。
• 設定ファイル（properties/JSON/YAML など）：複数項目を体系的に保持し、再利用・レビュー・バージョン管理したい場合に有効。

実務では、設定ファイル＋環境変数＋引数の三層で設計し、引数が最も強い優先度で設定を上書きする構成が扱いやすくなります。

最小サンプル（全引数を列挙）

public class ArgsEcho {
    public static void main(String[] args) {
        if (args.length == 0) {
            System.out.println("引数は指定されていません。");
            System.out.println("例: java ArgsEcho input.txt debug");
            return;
        }
        System.out.println("受け取った引数:");
        for (int i = 0; i < args.length; i++) {
            System.out.printf("args[%d] = %s%n", i, args[i]);
        }
    }
}

この先で扱う内容（ロードマップ）

• String[] args の基本操作（長さチェック、要素アクセス）
• 型変換（int/double/boolean、例外対策）
• オプション形式（-v / --help / --mode=prod など）のパースパターン
• IDEでの設定とテスト時の引数の渡し方
• エラー処理・セキュリティ上の注意（不正入力、例外の扱い）
• 実践例（ファイル処理、モード切替、ログレベル制御 など）

まずは「引数はすべて文字列として渡され、必要に応じて安全に変換・検証して使う」—この原則を押さえておきましょう。続く章では、基本文法と頻出パターンを具体的なコードで解説します。

2. コマンドライン引数とは何か？

mainメソッドとString[] argsの関係

Javaアプリケーションのエントリーポイントは、以下のような main メソッドです。

public static void main(String[] args)

ここで args は「arguments（引数）」を意味し、プログラム起動時に外部から与えられる値を格納する文字列配列です。
プログラムを実行するとき、java クラス名 の後ろにスペース区切りで値を指定すると、それらが順番に args に格納されます。

例：引数を渡して実行する

javac Sample.java
java Sample apple orange banana

このとき、args の内容は次のようになります。

つまり args は 可変長の文字列リスト のようなもので、何個でも自由に値を渡すことができます。
引数をひとつも指定しなかった場合、args.length は 0 になります（null にはなりません）。

実行例と出力

public class Sample {
    public static void main(String[] args) {
        System.out.println("引数の数：" + args.length);
        for (int i = 0; i < args.length; i++) {
            System.out.println("args[" + i + "] = " + args[i]);
        }
    }
}

java Sample dog cat

出力結果：

引数の数：2
args[0] = dog
args[1] = cat

ここで重要なのは、すべての引数が文字列として受け取られるという点です。
数値や真偽値として使いたい場合は、後で明示的に変換を行う必要があります。

どんなときに使うのか

コマンドライン引数は、次のようなケースでよく使われます。

• 動作モードの切り替え
  例：java Server start と java Server stop で異なる処理を行う。
• ファイルパスや設定値の指定
  例：java ReportGenerator /data/input.csv
• スクリプト実行時の一時的なパラメータ渡し
  例：日付、ユーザー名、環境変数代替としての利用。

こうした使い方により、プログラムの柔軟性が高まり、コンパイルし直さずに外部入力で制御できるようになります。

引数を受け取らない場合の挙動

Javaの main メソッドは、引数がなくても必ず String[] args を持ちます。
もし引数を渡さずに実行した場合、args.length == 0 なので、次のように条件分岐を加えると安全です。

if (args.length == 0) {
    System.out.println("引数が指定されていません。終了します。");
    return;
}

このように、プログラムの開始時に外部から可変の情報を受け取れるのがコマンドライン引数の最大の特徴です。

まとめ

• String[] args はプログラム実行時に渡された引数の一覧を保持する。
• すべての引数は 文字列型 として扱われる。
• 引数がない場合も args は null ではなく長さ0の配列。
• 引数を利用することで、プログラムを柔軟・再利用可能・自動化しやすくできる。

次の章では、この args を実際に使って値を取り出し、プログラムを制御する基本的な使い方とコード例を紹介します。

3. 基本的な使い方とコード例

コマンドライン引数の基本構文

コマンドライン引数を利用するには、まず main メソッドに渡される String[] args の中身を取り出して使います。
配列であるため、インデックス番号を指定して要素を参照できます。

public class CommandExample {
    public static void main(String[] args) {
        System.out.println("引数の数: " + args.length);
        if (args.length > 0) {
            System.out.println("最初の引数: " + args[0]);
        } else {
            System.out.println("引数が指定されていません。");
        }
    }
}

上記を次のように実行します。

javac CommandExample.java
java CommandExample hello

出力結果：

引数の数: 1
最初の引数: hello

このように、args[0] には最初に指定した値が格納されます。
複数の引数を渡した場合、それぞれ args[1], args[2] … のようにアクセスできます。

すべての引数をまとめて処理する

渡された引数の数が可変な場合、ループで一括処理するのが一般的です。
次の例では、全ての引数を順に表示しています。

public class PrintArgs {
    public static void main(String[] args) {
        if (args.length == 0) {
            System.out.println("引数がありません。");
            System.out.println("例: java PrintArgs apple orange banana");
            return;
        }

        System.out.println("引数一覧:");
        for (int i = 0; i < args.length; i++) {
            System.out.printf("args[%d] = %s%n", i, args[i]);
        }
    }
}

実行結果：

java PrintArgs apple orange banana

引数一覧:
args[0] = apple
args[1] = orange
args[2] = banana

このようにループを使うと、どんな数の引数にも対応できます。
初心者のうちは、まず「配列の長さを確認してからアクセスする」習慣を身につけましょう。

コマンドライン引数の順番に意味を持たせる

引数の順番によって、意味を変えることも可能です。
例えば「ファイル名」「出力モード」「上書き可否」を順に指定する例を見てみましょう。

public class FileProcessor {
    public static void main(String[] args) {
        if (args.length < 3) {
            System.out.println("使い方: java FileProcessor <ファイル名> <モード> <上書き可否>");
            System.out.println("例: java FileProcessor data.txt verbose true");
            return;
        }

        String fileName = args[0];
        String mode = args[1];
        boolean overwrite = Boolean.parseBoolean(args[2]);

        System.out.println("ファイル名: " + fileName);
        System.out.println("モード: " + mode);
        System.out.println("上書き可否: " + overwrite);
    }
}

実行例：

java FileProcessor data.txt simple false

出力：

ファイル名: data.txt
モード: simple
上書き可否: false

このように、引数の位置ごとに役割を決めることで、柔軟なプログラム制御が可能になります。

例：引数を数値として扱う

すべての引数は文字列として渡されるため、数値として扱いたい場合は型変換を行います。
以下は2つの整数を受け取り、その合計を表示するプログラムです。

public class SumArgs {
    public static void main(String[] args) {
        if (args.length < 2) {
            System.out.println("整数を2つ指定してください。");
            return;
        }

        int a = Integer.parseInt(args[0]);
        int b = Integer.parseInt(args[1]);
        int sum = a + b;

        System.out.println("合計: " + sum);
    }
}

実行：

java SumArgs 7 13

出力：

合計: 20

ここで、もし "abc" のような文字列を渡すと NumberFormatException が発生します。
このような場合には例外処理を組み込むことで、エラーに強いプログラムにできます。

例外処理を加えた安全な実装

public class SafeSum {
    public static void main(String[] args) {
        try {
            if (args.length < 2) {
                throw new IllegalArgumentException("引数が足りません。2つの整数を指定してください。");
            }
            int a = Integer.parseInt(args[0]);
            int b = Integer.parseInt(args[1]);
            System.out.println("合計: " + (a + b));
        } catch (NumberFormatException e) {
            System.out.println("数値として解釈できない引数があります。");
        } catch (IllegalArgumentException e) {
            System.out.println(e.getMessage());
        }
    }
}

こうして例外処理を行うことで、ユーザーが誤った引数を渡した際にも、プログラムが異常終了せずにメッセージを返すようになります。

まとめ

• コマンドライン引数は args 配列に文字列として渡される。
• args.length をチェックしてからアクセスする。
• forループを使えば柔軟に引数を処理できる。
• 数値を扱う場合は Integer.parseInt() などで変換する。
• 例外処理でユーザーフレンドリーな動作を実現する。

次の章では、こうした基礎を踏まえて、よくある誤りと注意点を整理し、安全で再利用性の高いコードにする方法を解説します。

4. よくある誤りと注意点

コマンドライン引数はシンプルな仕組みですが、初学者がつまずきやすいポイントがいくつかあります。
ここでは、典型的なミスとそれを防ぐための実践的な対策を紹介します。

配列のインデックスエラー（ArrayIndexOutOfBoundsException）

最も多いのが、「存在しないインデックスにアクセスする」エラーです。
args は配列なので、範囲外を指定すると次のような例外が発生します。

例：誤ったコード

public class ErrorExample {
    public static void main(String[] args) {
        System.out.println(args[0]); // ← 引数なしで実行するとエラー
    }
}

実行：

java ErrorExample

出力：

Exception in thread "main" java.lang.ArrayIndexOutOfBoundsException: 0

対策

必ず args.length をチェックしてからアクセスしましょう。

if (args.length == 0) {
    System.out.println("引数が指定されていません。");
    return;
}
System.out.println("最初の引数: " + args[0]);

ポイント：
args は null ではありません。
引数がない場合でも「長さ0の配列」として存在します。

引数はすべて文字列（String型）

コマンドライン引数は すべて文字列として受け取られます。
そのため、数値計算を行うには型変換が必要です。

int num = Integer.parseInt(args[0]);

ただし、変換できない文字列（例：「abc」）を渡すと NumberFormatException が発生します。

対策：例外処理を組み込む

try {
    int num = Integer.parseInt(args[0]);
    System.out.println("入力された数値: " + num);
} catch (NumberFormatException e) {
    System.out.println("数値として解釈できません。正しい値を入力してください。");
}

ポイント：
引数をそのまま数値として使うのは危険です。
「人間が自由に入力する値」は常に不正データの可能性を考慮するべきです。

スペースを含む引数

コマンドラインでは、スペースが引数の区切りとして扱われます。
そのため、スペースを含む文字列を渡したい場合は ダブルクォーテーションで囲む 必要があります。

例：

java Message "Hello World"

結果：

args[0] = Hello World

もし引用符を付けずに実行すると、 "Hello" と "World" が別々の引数として扱われます。

マルチバイト文字（日本語など）の扱い

日本語などマルチバイト文字を引数に渡す場合、文字化けが発生することがあります。
特に Windows 環境では、コンソールの文字コードが MS932（Shift_JIS）になっていることが多いため、UTF-8ベースのJavaとの間で不一致が起きやすいです。

対策：

• コマンドプロンプトを UTF-8 に設定して実行する（chcp 65001）
• IDE（Eclipse / IntelliJ）の実行設定で文字エンコーディングを UTF-8 に統一する
• Javaの起動オプション -Dfile.encoding=UTF-8 を指定する

java -Dfile.encoding=UTF-8 Sample こんにちは

引数が多すぎる／長すぎる場合

OSによっては、コマンドライン引数の総文字数に制限があります。
Windowsではおよそ 8,000 文字、Linuxでは 128KB 程度が上限です。
ファイル内容を直接渡すなど、大きなデータを扱いたい場合は、ファイル入力や標準入力（Scannerなど）を利用しましょう。

特殊記号とエスケープ

シェル（コマンドプロンプト・ターミナル）では、< や >、& など一部の記号が特別な意味を持ちます。
そのまま引数として渡したい場合、引用符で囲むかバックスラッシュでエスケープします。

例：

java SymbolTest "<tag>" "&value"

これにより、シェルがこれらをリダイレクトやパイプと誤解することを防げます。

引数の順番を間違える

順番に意味を持たせる場合、ユーザーが誤って引数を逆に指定することがあります。
特に「入力ファイル名」「出力ファイル名」などの順序は混同しやすいです。

対策：

• --input=input.txt のような名前付きオプション形式にする（後述の応用編で解説）
• または help オプションで使用方法を明示する

まとめ

次の章では、これらの注意点を踏まえ、型変換・オプション形式・デフォルト値などを活用した実践的な設計パターンを紹介します。

5. 実践活用：型変換・オプション引数・デフォルト値

ここからは、コマンドライン引数をより柔軟かつ実務的に扱うためのテクニックを紹介します。
単に文字列を受け取るだけでなく、型変換・オプション形式・デフォルト値の設計を行うことで、ユーザーにとって使いやすく、安全なプログラムを作ることができます。

数値・真偽値への型変換

すべての引数は String 型として渡されますが、プログラム内で演算や条件分岐を行うには、適切な型に変換する必要があります。

数値に変換する

int count = Integer.parseInt(args[0]);
double rate = Double.parseDouble(args[1]);

真偽値に変換する

boolean debugMode = Boolean.parseBoolean(args[2]);

例：数値演算プログラム

public class Multiply {
    public static void main(String[] args) {
        if (args.length < 2) {
            System.out.println("使い方: java Multiply <数値1> <数値2>");
            return;
        }

        try {
            double a = Double.parseDouble(args[0]);
            double b = Double.parseDouble(args[1]);
            System.out.println("結果: " + (a * b));
        } catch (NumberFormatException e) {
            System.out.println("数値以外の値が入力されています。");
        }
    }
}

実行：

java Multiply 4.5 3

出力：

結果: 13.5

ポイント：

• 変換時にエラーが出る可能性があるため、try-catch で例外処理を行う。
• Boolean.parseBoolean() は "true"（大文字小文字を問わず）の場合のみ true を返す。

名前付きオプション形式の設計

順番に依存する設計は、人が使う上でミスが起こりやすいです。
そのため、--key=value や -v のように「名前付き引数」を採用すると直感的になります。

例：名前付きオプションを使った引数解析

public class OptionParser {
    public static void main(String[] args) {
        boolean verbose = false;
        String mode = "normal";
        String file = "default.txt";

        for (String arg : args) {
            if (arg.equals("-v") || arg.equals("--verbose")) {
                verbose = true;
            } else if (arg.startsWith("--mode=")) {
                mode = arg.substring("--mode=".length());
            } else if (arg.startsWith("--file=")) {
                file = arg.substring("--file=".length());
            }
        }

        System.out.println("モード: " + mode);
        System.out.println("ファイル: " + file);
        System.out.println("詳細表示: " + verbose);
    }
}

実行：

java OptionParser --mode=debug --file=log.txt -v

出力：

モード: debug
ファイル: log.txt
詳細表示: true

ポイント：

• startsWith() を使うことで --key=value 形式を簡単に判定可能。
• 順序に依存せず柔軟に指定できる。
• シェルスクリプトや自動実行ジョブとの連携にも向く。

デフォルト値を設ける

引数が省略された場合に備えて、安全なデフォルト値を設定しておくことが重要です。
これにより、ユーザーが最低限の操作で実行でき、プログラムも異常終了しません。

例：デフォルト値付きプログラム

public class Greeting {
    public static void main(String[] args) {
        String name = "Guest";
        String lang = "ja";

        if (args.length > 0) name = args[0];
        if (args.length > 1) lang = args[1];

        if (lang.equals("en")) {
            System.out.println("Hello, " + name + "!");
        } else if (lang.equals("fr")) {
            System.out.println("Bonjour, " + name + "!");
        } else {
            System.out.println("こんにちは、" + name + "さん！");
        }
    }
}

実行：

java Greeting Taro en

出力：

Hello, Taro!

引数なしで実行：

java Greeting

出力：

こんにちは、Guestさん！

ポイント：

• 想定外の引数不足にも安全に対応。
• args.length を活用して「指定された数」に応じて挙動を変える。

オプション解析を汎用化する

複雑なツールを作る場合、手動で args を処理するよりも、パーサークラスを用意すると保守性が向上します。

例：簡易オプションパーサー

import java.util.HashMap;

public class SimpleParser {
    public static void main(String[] args) {
        HashMap<String, String> options = new HashMap<>();

        for (String arg : args) {
            if (arg.startsWith("--") && arg.contains("=")) {
                String[] pair = arg.substring(2).split("=", 2);
                options.put(pair[0], pair[1]);
            }
        }

        System.out.println("解析結果:");
        for (String key : options.keySet()) {
            System.out.println(key + " = " + options.get(key));
        }
    }
}

実行：

java SimpleParser --user=admin --port=8080 --mode=test

出力：

解析結果:
user = admin
port = 8080
mode = test

ポイント：

• HashMap を使うことでキーと値のペアを柔軟に保持。
• コマンドラインツールの基盤として再利用できる。

実務での設計パターン

• 少数の引数 → 位置指定で十分
• 多数の設定値 → 名前付きオプション (--key=value) 形式を採用
• 任意項目が多い → デフォルト値を設ける
• システム連携・スクリプト化 → 一貫したオプション設計（例：--help、--config）

まとめ

次の章では、実際に現場で使われる コマンドライン引数の応用例 を紹介し、ファイル操作やバッチ処理など、より実務的な使い方に踏み込んでいきます。

6. 応用例：現場でよく使われるパターン

ここでは、コマンドライン引数を実務でどのように活用できるかを、具体的なユースケースで紹介します。
引数の柔軟な指定によって、ファイル操作・モード切り替え・ログ設定 など、再利用性の高いツールが作れるようになります。

ファイル名を引数で指定して処理する

もっとも一般的な使い方は、処理対象のファイルを引数で受け取る パターンです。
ファイルの読み書きを自動化するときに便利です。

例：ファイル内容を読み込んで表示する

import java.nio.file.*;
import java.io.IOException;

public class FileReaderTool {
    public static void main(String[] args) {
        if (args.length == 0) {
            System.out.println("使用方法: java FileReaderTool <ファイルパス>");
            return;
        }

        String filePath = args[0];
        try {
            String content = Files.readString(Paths.get(filePath));
            System.out.println("=== " + filePath + " の内容 ===");
            System.out.println(content);
        } catch (IOException e) {
            System.out.println("ファイルを読み込めませんでした: " + e.getMessage());
        }
    }
}

実行例：

java FileReaderTool data.txt

出力例：

=== data.txt の内容 ===
Sample data line 1
Sample data line 2

ポイント：

• ファイルの存在チェック・例外処理を入れることで安全に実行可能。
• バッチ処理（大量ファイルを順に処理）にも応用しやすい。

処理モードを切り替える

引数によって動作を切り替えることで、1つのプログラムに複数の役割を持たせることができます。

例：モード指定で動作を変える

public class ModeSelector {
    public static void main(String[] args) {
        if (args.length == 0) {
            System.out.println("使い方: java ModeSelector <mode>");
            System.out.println("利用可能モード: test / prod / debug");
            return;
        }

        String mode = args[0].toLowerCase();

        switch (mode) {
            case "test":
                System.out.println("テストモードで実行中...");
                break;
            case "prod":
                System.out.println("本番モードで実行中...");
                break;
            case "debug":
                System.out.println("デバッグモードで詳細ログを出力します。");
                break;
            default:
                System.out.println("不明なモードです: " + mode);
        }
    }
}

実行：

java ModeSelector debug

出力：

デバッグモードで詳細ログを出力します。

ポイント：

• 環境（開発・検証・本番）に応じた設定切り替えが可能。
• 実務の自動化スクリプトで非常に多用される構造。

複数引数を使って計算処理を自動化する

バッチ処理や定時スクリプトでは、引数を使ってパラメータを動的に渡します。
例として、指定した2つの数値を操作する簡単な電卓ツールを作成します。

public class Calculator {
    public static void main(String[] args) {
        if (args.length < 3) {
            System.out.println("使い方: java Calculator <num1> <num2> <op>");
            System.out.println("例: java Calculator 10 5 add");
            return;
        }

        double a = Double.parseDouble(args[0]);
        double b = Double.parseDouble(args[1]);
        String op = args[2];

        switch (op) {
            case "add": System.out.println(a + b); break;
            case "sub": System.out.println(a - b); break;
            case "mul": System.out.println(a * b); break;
            case "div":
                if (b == 0) {
                    System.out.println("0では割り算できません。");
                } else {
                    System.out.println(a / b);
                }
                break;
            default:
                System.out.println("不明な演算指定です。");
        }
    }
}

実行：

java Calculator 8 2 mul

出力：

16.0

このように、引数を通じて演算内容を指定すれば、スクリプト連携にも使える小型ツールを簡単に作れます。

オプション形式の引数で設定を指定する

より柔軟な操作のためには、--key=value のような形式が便利です。

public class ConfigLoader {
    public static void main(String[] args) {
        String config = "default.conf";
        boolean verbose = false;

        for (String arg : args) {
            if (arg.startsWith("--config=")) {
                config = arg.substring("--config=".length());
            } else if (arg.equals("--verbose")) {
                verbose = true;
            }
        }

        System.out.println("設定ファイル: " + config);
        System.out.println("詳細ログ: " + (verbose ? "ON" : "OFF"));
    }
}

実行：

java ConfigLoader --config=prod.conf --verbose

出力：

設定ファイル: prod.conf
詳細ログ: ON

ポイント：

• 名前付きオプションは順序を問わないため、人為的な入力ミスを減らせる。
• 実務では設定ファイルパスやモード指定に使われることが多い。

引数を組み合わせた実践例：ログ付きファイル処理ツール

import java.nio.file.*;
import java.io.*;

public class FileCopyTool {
    public static void main(String[] args) {
        if (args.length < 2) {
            System.out.println("使い方: java FileCopyTool <入力ファイル> <出力ファイル> [--verbose]");
            return;
        }

        String input = args[0];
        String output = args[1];
        boolean verbose = (args.length > 2 && args[2].equals("--verbose"));

        try {
            Files.copy(Paths.get(input), Paths.get(output), StandardCopyOption.REPLACE_EXISTING);
            if (verbose) {
                System.out.println("ファイルをコピーしました: " + input + " → " + output);
            }
        } catch (IOException e) {
            System.out.println("コピーに失敗しました: " + e.getMessage());
        }
    }
}

実行：

java FileCopyTool report.txt backup.txt --verbose

出力：

ファイルをコピーしました: report.txt → backup.txt

ポイント：

• オプションでログを制御することで、開発・運用どちらにも使える。
• 実務的なスクリプト処理の基礎構造として再利用可能。

まとめ

次の章では、IDEやテスト環境での引数指定方法を取り上げ、Eclipse / IntelliJ でコマンドライン引数を設定する方法、および テストやデバッグでの活用テクニック を解説します。

7. テスト・デバッグ時のTips／IDEでの引数設定

コマンドライン引数を使ったプログラムは、ターミナル（コンソール）だけでなく、Eclipse や IntelliJ IDEA などの開発環境でも実行・テストできます。
この章では、開発時に役立つ設定方法と、デバッグを効率化するコツを紹介します。

Eclipseでの引数設定方法

Eclipseでは、実行構成（Run Configuration）を利用して引数を設定できます。
手動でコマンドを打たなくても、ボタンひとつで引数付き実行が可能です。

手順：

1. メニューバーから
   ［実行］→［実行構成…（Run Configurations…）］ を選択。
2. 左のリストから、実行したいクラス（Java Application）を選択。
3. 上部のタブから ［Arguments］（引数） をクリック。
4. 「Program arguments」欄に引数をスペース区切りで入力。
   例： data.txt debug true
5. ［適用（Apply）］→［実行（Run）］をクリック。

これで、次回以降も同じ引数で実行できます。
テストパターンを切り替える場合も、複数の設定を保存して使い分けられます。

ポイント：

• 引数ごとに改行してもOK（Eclipseが自動的にスペース区切りで扱います）。
• "Hello World" のようなスペースを含む文字列は必ずダブルクォーテーションで囲む必要があります。
• 文字コードを変更したい場合は「VM arguments」に -Dfile.encoding=UTF-8 を指定。

IntelliJ IDEAでの引数設定方法

IntelliJ IDEAでは、さらにシンプルに設定可能です。

手順：

1. メニューバーから Run → Edit Configurations… を開く。
2. 実行したいクラスの構成を選択。
3. Program arguments フィールドに引数を入力。
   例： --mode=debug --file=log.txt --verbose
4. ［OK］または［Apply］で保存して実行。

ポイント：

• 設定はプロジェクトごとに保持されます。
• デバッグ実行（Debug）でも同じ設定が利用される。
• 環境変数を同時に設定できるので、実運用と同様のテストが可能。

コマンドライン実行との違いを理解する

IDE上での実行と、実際のターミナル実行では、環境変数や作業ディレクトリが異なることがあります。

対策：

• ファイルパスは 相対パスではなく絶対パスで指定 する。
• Paths.get("").toAbsolutePath() などで現在の作業ディレクトリを確認。
• 実際の本番環境に近い条件で動作を検証する。

デバッグ時に便利なテクニック

1. 引数をログ出力する

開発中は、どの値が渡っているかをログで確認するとトラブルを防げます。

System.out.println("引数: " + Arrays.toString(args));

出力例：

引数: [--mode=debug, --file=config.txt]

2. 条件付きブレークポイントを活用

IDEのデバッガで「条件付きブレークポイント」を設定すれば、特定の引数値のときだけ止めることができます。
例：args[0].equals("debug") のときのみ停止。

3. 標準入力と組み合わせる

一部の設定値を引数で、残りをユーザー入力で指定する方法もあります。

Scanner sc = new Scanner(System.in);
System.out.print("ユーザー名を入力: ");
String name = sc.nextLine();
System.out.println("Hello, " + name);

こうすることで、コマンドライン引数と対話的入力の両方に対応できます。

JUnitなどでの自動テストへの応用

コマンドライン引数を扱うプログラムでも、JUnitなどのテストフレームワークで自動テストを行えます。
引数は main() メソッドに直接渡せるため、ユニットテストの対象にできます。

例：

@Test
void testMain() {
    String[] args = {"5", "7"};
    SumArgs.main(args);
}

このようにして、引数を模擬的に与えることで自動テストやCIパイプラインでの検証が容易になります。

まとめ

次の章では、コマンドライン引数を安全かつ確実に扱うための セキュリティ・運用上の留意点 に進みます。
誤入力や例外処理の設計、想定外の入力値からプログラムを守る方法を解説します。

8. セキュリティ・運用面での留意点

コマンドライン引数は便利な一方で、外部から値を受け取る仕組みであるため、入力内容によってはプログラムが誤作動したり、セキュリティ上の問題を引き起こす可能性があります。
ここでは、安全かつ運用しやすい設計を行うための実践的な注意点を整理します。

1. 入力値の検証（バリデーション）は必須

コマンドライン引数はユーザーが自由に指定できるため、不正な値や想定外の形式が渡されることを前提に考えましょう。
最初に入力値を検証しておくことで、異常動作を防げます。

例：ファイル名の検証

String fileName = args[0];
if (!fileName.endsWith(".txt")) {
    System.out.println("エラー: 拡張子が .txt のファイルを指定してください。");
    return;
}

例：数値範囲の検証

int count = Integer.parseInt(args[1]);
if (count < 1 || count > 1000) {
    System.out.println("エラー: count は 1〜1000 の範囲で指定してください。");
    return;
}

ポイント：

• 文字列のパターンチェックには String.matches() や正規表現を活用。
• 数値・ファイル・パスなどは明確な制約を設ける。
• 想定外の引数があっても即座にエラー終了させる（fail-fast原則）。

2. 例外処理を徹底する

想定外の入力やI/Oエラーが発生した際、例外を無視したままプログラムを終了させるのは危険です。
エラー内容をログに残し、ユーザーに原因を伝えるメッセージを出力することが重要です。

安全な例外処理の例

try {
    int num = Integer.parseInt(args[0]);
    System.out.println("入力値: " + num);
} catch (NumberFormatException e) {
    System.err.println("エラー: 数値として解釈できません。入力値=" + args[0]);
}

推奨ポイント：

• System.err を使用してエラーメッセージを分離する。
• ログファイルにエラーを出力しておくと運用時に便利。
• 複数の例外をまとめてキャッチする場合は、エラー内容を詳細に分類する。

3. 引数に機密情報を渡さない

パスワードやAPIキーなどの機密情報を直接引数に渡すのは避けましょう。
コマンドライン引数は、以下の理由で安全とは言えません。

• OSによっては、他のプロセスから引数内容が参照可能（例：ps コマンドで閲覧できる）。
• シェル履歴にコマンドが残り、後から第三者に見られる可能性がある。

NG例：

java LoginApp admin superSecretPassword

対策：

• 機密情報は環境変数または設定ファイルで管理。
• Java内では System.getenv("PASSWORD") などで取得する。

String password = System.getenv("PASSWORD");
if (password == null) {
    System.out.println("環境変数 PASSWORD が設定されていません。");
    return;
}

4. コマンドインジェクションの防止

外部コマンドを呼び出すプログラムでは、引数をそのままOSコマンドに渡すとコマンドインジェクションの危険があります。
（例：Runtime.exec() や ProcessBuilder の使用時）

危険な例：

String cmd = "ping " + args[0];
Runtime.getRuntime().exec(cmd);

ユーザーが 127.0.0.1 && rm -rf / のような入力を渡すと、意図しないコマンドが実行される恐れがあります。

安全な例：

ProcessBuilder pb = new ProcessBuilder("ping", args[0]);
pb.inheritIO().start();

対策：

• 引数を直接文字列連結しない。
• ProcessBuilder で配列として安全に渡す。
• 入力値に制約（IP形式など）を設ける。

5. ログと監査対応

実運用では、引数をログに出力することがデバッグに役立ちますが、個人情報や機密データを含む場合はマスク処理を行うことが必要です。

例：ログに引数を出力する（マスク付き）

for (String arg : args) {
    if (arg.toLowerCase().contains("password")) {
        System.out.println("引数: [パスワードは非表示]");
    } else {
        System.out.println("引数: " + arg);
    }
}

ポイント：

• 引数をそのままログに残さない。
• 運用中に誤って情報漏洩しないように配慮する。
• ログ出力は java.util.logging や Log4j などのフレームワークを使うと管理しやすい。

6. 大量引数・長大文字列への対処

OSによっては引数の総文字数に制限（例：Windowsで約8KB、Linuxで約128KB）があります。
そのため、設定データやJSONを直接引数に渡すのは推奨されません。

対策：

• 設定ファイルや標準入力（System.in）から読み込む。
• もしくは複数回に分けて実行する仕組みを設ける。

7. 運用上のチェックリスト

8. まとめ

• コマンドライン引数はユーザー入力扱いとして常に検証する。
• 機密情報や外部コマンド連携には細心の注意を払う。
• 安全設計（fail-fast）＋適切な例外処理で安定運用を実現する。
• ログや履歴から情報漏洩しないよう、マスク・暗号化・削除方針を定める。

9. まとめ

ここまで、Javaのコマンドライン引数（String[] args）について、基本構文から応用・運用までを体系的に解説してきました。
この章では、これまでの内容を総括し、実務で活かすための指針を整理します。

コマンドライン引数の本質とは？

コマンドライン引数とは、プログラム実行時に外部から動作を制御する仕組みです。
一度コンパイルしたプログラムでも、引数を変えるだけで動作を切り替えられるため、再利用性・柔軟性が非常に高いのが特徴です。

主な利点

• 環境依存を排除：同じプログラムを、異なる条件で簡単に動かせる。
• 設定変更が容易：コンパイルし直さずに挙動を調整できる。
• 自動化に最適：シェルスクリプトやタスクスケジューラから実行可能。
• 外部システム連携が容易：バッチ処理やCI/CDでの引数注入に対応できる。

章ごとの要点整理

現場で役立つ設計指針

1. 引数は「設定の上書き」レイヤーとして使う
   • 設定ファイルや環境変数と組み合わせ、引数は最優先で上書きするよう設計。
   • 例：--config=config.yml + --mode=prod → 柔軟に運用可能。
2. シンプルな設計を保つ
   • 引数の数が多くなりすぎたら構造を見直す。
   • 必須／任意を明確に分ける。
3. 「ヘルプ（–help）」オプションを用意する
   • コマンドラインツールは説明書付きが基本。
   • 例： if (args.length == 0 || args[0].equals("--help")) { System.out.println("使い方: java App [--mode=xxx] [--file=name]"); return; }
4. ログを残して再現性を確保する
   • 実行時の引数・設定・時刻をログに残すことで、後から原因分析が容易になる。
5. 異常時は即エラー終了（fail-fast）
   • 入力ミスや環境不整合を放置せず、分かりやすいメッセージで停止する。
6. 安全設計を優先する
   • 機密情報を渡さない・例外を握りつぶさない・入力値を信用しない。
   • 「想定外の入力が来る」前提で設計する。

コマンドライン引数を超えて

引数の扱いをマスターすると、より高機能なCLI設計や自動化へ発展させることができます。

発展的トピック例

• java.util.Properties や YAML設定との統合
• Apache Commons CLI / PicoCLI などのライブラリ導入
• GradleやMavenでの引数渡し (-P / -Dオプション)
• Docker・CI環境での変数連携

これらを組み合わせれば、JavaでもPythonやGoのような高度なCLIツールを実現できます。

最後に

Javaのコマンドライン引数は単なる“文字列配列”ですが、設計次第で 設定管理・自動化・運用効率化の要 になります。
初心者のうちは配列アクセスや基本的なバリデーションを練習し、慣れてきたら --key=value 形式や設定ファイル連携に進むのがおすすめです。

プログラムを「外部から動的に制御できる」ようにすることが、
スクリプト化・クラウド化・自動化の第一歩 となります。

次の章では、この理解をより実践的に深めるために、よくある質問（FAQ） を通して細かな疑問点を整理します。
特に「argsの扱い」「配列操作」「実行エラー」など、読者がつまずきやすいポイントをQ&A形式で明確にします。

10. よくある質問（FAQ）

ここでは、Javaのコマンドライン引数に関して、初学者から実務レベルまでによく寄せられる質問を整理しました。
細かな挙動や設計上の注意点を明確にすることで、誤解やエラーを防ぎ、実際の開発現場でも迷いなく対応できるようになります。

Q1. String[] args の「args」は変更してもいいの？

A. はい、名前は自由に変更できます。
args は慣例的な名前であり、他の識別子にしても問題ありません。

public static void main(String[] parameters) {
    System.out.println(parameters.length);
}

Javaではメソッドのシグネチャが
public static void main(String[] 任意名) であれば正しい構文です。
ただし、一般的なチュートリアルやIDEは args を前提にしているため、統一しておくほうが可読性は高まります。

Q2. 引数を渡さなかった場合、args は null になりますか？

A. いいえ、nullにはなりません。
引数がない場合でも、Javaは長さ0の配列として args を生成します。

java MyApp

の場合、args.length == 0 となります。
このため、if (args == null) というチェックは不要です。
安全に args.length で判定できます。

Q3. スペースを含む文字列を引数にしたい場合は？

A. ダブルクォーテーションで囲みます。

java Hello "Hello World"

結果：

args[0] = Hello World

引用符で囲まない場合、スペースで分割され "Hello" と "World" が別々の引数として扱われます。
WindowsでもLinuxでもこの挙動は共通です。

Q4. 数値を引数で渡すと自動的に数値型として扱われますか？

A. いいえ、すべて文字列として渡されます。
Javaの main() メソッドは必ず String[] を受け取ります。
数値として使う場合は、自分で変換する必要があります。

int x = Integer.parseInt(args[0]);
double y = Double.parseDouble(args[1]);

変換できない文字列を渡すと NumberFormatException が発生するため、
try-catch で囲むのが安全です。

Q5. 引数の数を可変にすることはできますか？

A. すでに String[] args が可変長の仕組みになっています。
コマンドラインでいくつ引数を渡しても、すべて args 配列に格納されます。

java Example one two three

この場合、args.length == 3 で
args[0], args[1], args[2] にそれぞれ代入されます。

Q6. EclipseやIntelliJでコマンドライン引数を設定しても、反映されないことがあります。

A. 実行構成（Run Configuration）の設定ミスが原因のことが多いです。

• Eclipseでは「Arguments」タブの「Program arguments」に設定されているか確認。
• IntelliJでは「Run → Edit Configurations → Program arguments」を確認。
• 保存後に**[Apply] → [Run]** をクリックし直さないと反映されません。

また、実行対象クラス（Mainクラス）が異なっている場合もあるため、
クラスパス設定やプロジェクト構成も確認してみましょう。

Q7. コマンドライン引数で渡された値を他のメソッドに使いたいのですが？

A. メソッドの引数として渡すか、クラス変数に保存します。

public class MainApp {
    public static void main(String[] args) {
        runProgram(args);
    }

    static void runProgram(String[] params) {
        System.out.println("最初の引数: " + params[0]);
    }
}

args は通常の配列と同じ扱いなので、必要に応じて他のメソッドに引き継げます。

Q8. main() のシグネチャを間違えると、プログラムが実行されません。

A. Javaはエントリーポイントを厳密に定義しています。

次のどれかでなければ java コマンドがクラスを実行できません。

public static void main(String[] args)

または（可変長引数構文も可）：

public static void main(String... args)

NG例：

static void main(String[] args)      // publicがない
public void main(String[] args)      // staticがない
public static int main(String[] args) // 戻り値がvoidでない

これらの場合、「Main method not found」エラーが出ます。

Q9. 引数に特殊文字（&, <, >, |）を含めたい場合は？

A. シェルがそれらを予約記号として扱うため、エスケープが必要です。

例（Linux/macOS）：

java Test "<tag>" "&value"

例（Windows PowerShell）：

java Test "`<tag`>" "`&value`"

ヒント：

• OSやシェルごとにエスケープ方法が異なります。
• 基本的に「ダブルクォーテーションで囲む」または「バックスラッシュで逃がす」ことが共通対策です。

Q10. コマンドライン引数の総数に上限はありますか？

A. OSによって制限があります。

これは全コマンド文字列の長さに対する制限です。
大きな設定データを渡したい場合は、ファイルや標準入力 (System.in) を利用しましょう。

Q11. コマンドライン引数をユニットテストする方法は？

A. main() メソッドを直接呼び出せます。

@Test
void testMain() {
    String[] args = {"input.txt", "verbose"};
    MyApp.main(args);
}

このように、テストメソッドから main() を呼び出すことで、
特定の引数をシミュレートしたテストが可能です。

Q12. 引数に日本語を使うと文字化けします。

A. 実行環境の文字コード設定が異なっている可能性があります。

対策：

• ターミナルを UTF-8 に設定する（Windows: chcp 65001）。
• 実行時オプションでエンコーディング指定： java -Dfile.encoding=UTF-8 MyApp
• IDEでも、プロジェクトの文字コード設定をUTF-8に統一。

Q13. コマンドライン引数をすべてまとめて1つの文字列として受け取れますか？

A. 直接はできませんが、結合すれば可能です。

String joined = String.join(" ", args);
System.out.println(joined);

これにより、引数が "apple", "banana", "cherry" の場合、
出力は "apple banana cherry" となります。

Q14. 実行中に新しい引数を追加できますか？

A. できません。
args はプログラム起動時に固定されます。
実行後に新たな引数を追加することはできません。
ただし、ユーザー入力（Scanner）や設定ファイル読み込みを組み合わせることで、
動的にデータを受け取ることは可能です。

Q15. コマンドライン引数と環境変数、どちらを使うべき？

A. 目的によって使い分けましょう。

多くの実務アプリでは、
「設定ファイル → 環境変数 → コマンドライン引数」
の順で上書きする階層構造を採用しています。

まとめ：FAQから学ぶポイント

• args はnullではなく長さ0の配列。
• すべて文字列型として扱われる。
• IDEでの引数設定は実行構成に依存する。
• スペース・特殊文字・文字コードに注意。
• 機密情報は引数ではなく環境変数で管理。

これで「Javaのコマンドライン引数」についての体系的な解説は完結です。
ここまで学べば、単純な学習用サンプルから、実際のバッチ処理・設定制御プログラムまで自在に構築できるようになります。

🟢 次のステップ（応用編）

• Apache Commons CLI や PicoCLI を使って、本格的なCLIツールを構築する。
• 設定ファイル・環境変数との統合を学ぶ。
• Gradle/Mavenでの引数渡しや、Docker実行時の環境連携にも挑戦してみましょう。