【入門】Java `concat` メソッドで文字列を結合する方法

By /

【入門】Java concat メソッドで文字列を結合する方法

Javaプログラミングにおいて、文字列（String）を操作することは非常に頻繁に行われます。その中でも、複数の文字列を一つに繋ぎ合わせる「文字列結合」は、最も基本的な操作の一つです。Javaには文字列を結合するためのいくつかの方法が用意されており、それぞれに特徴があります。

この記事では、Javaの文字列結合方法の一つである String.concat() メソッドに焦点を当て、その基本的な使い方から、内部的な仕組み、他の方法との比較、そしてどのような場合に利用するのが適切なのかまでを、初心者の方にも分かりやすく、しかし詳細に解説していきます。約5000語に及ぶ詳細な解説を通して、concat メソッドだけでなく、Javaにおける文字列操作の理解を深めていきましょう。

1. はじめに：Javaにおける文字列結合の多様性

プログラムを書いていると、「名字と名前を組み合わせてフルネームを作る」「ファイルパスとファイル名を繋げる」「複数の単語を連結して文章を作る」といった、文字列を結合する場面に必ず遭遇します。Javaでは、このような文字列結合を行うために、主に以下の方法が提供されています。

  • + 演算子: 最も直感的で一般的に使われる方法です。
  • String.concat() メソッド: String クラスが提供するメソッドです。
  • StringBuilder / StringBuffer クラス: 可変な文字列を扱うためのクラスで、効率的な結合が可能です。
  • String.join() メソッド: Java 8で追加された、コレクションや配列を区切り文字で結合するのに便利なメソッドです。
  • String.format() メソッド: 書式を指定して文字列を生成する際に利用します。

これらの方法は、それぞれ異なる特性、パフォーマンス、そして使いやすさを持っています。どの方法を選ぶべきかは、結合する文字列の数、操作の頻度、パフォーマンス要件など、状況によって異なります。

この記事では、これらの方法の中でも特に String.concat() メソッドに焦点を当てて詳しく解説します。concat メソッドはシンプルに見えますが、その背後にはJavaの String クラスの重要な特性である「不変性（Immutability）」が深く関わっています。この不変性を理解することは、concat メソッドだけでなく、Javaにおける効率的かつ安全な文字列操作を行う上で非常に重要です。

次章では、まずJavaの String クラス、特にその不変性について詳しく見ていきましょう。

2. Javaの文字列（String）とは：不変性という重要な特性

String はJavaにおける最も基本的なデータ型の一つであり、文字の並び（シーケンス）を表します。Javaにおいて String オブジェクトが持つ最も重要な特性は、「不変性（Immutability）」です。これは、一度 String オブジェクトが作成されると、その内容（格納している文字の並び）は二度と変更できないという性質を指します。

たとえば、以下のように文字列を宣言したとします。

java
String name = "Alice";

このとき、メモリ上には "Alice" という内容を持つ String オブジェクトが生成され、変数 name はそのオブジェクトを参照します。

次に、以下のような操作を考えます。

java
name = name.concat(" Wonderland");

もし String が可変であったなら、元の "Alice" というオブジェクトの内容が "Alice Wonderland" に書き換えられることを期待するかもしれません。しかし、String は不変であるため、そうはなりません。実際には、"Alice" という元のオブジェクトはそのまま残り、新しく "Alice Wonderland" という内容を持つ別の String オブジェクトが生成されます。そして、変数 name は、この新しく生成されたオブジェクトを参照するように変更されます。元の "Alice" オブジェクトは、もし他のどこからも参照されなくなれば、そのうちJavaのガベージコレクタによってメモリから解放される対象となります。

なぜJavaのStringは不変なのか？

String が不変であることには、いくつかの重要な理由があります。

  1. スレッドセーフティ: 不変なオブジェクトは、複数のスレッドから同時にアクセスされても、その状態が予期せず変更される心配がありません。これは、マルチスレッドプログラミングにおいて非常に安全です。Stringオブジェクトは、スレッド間で自由に共有できます。
  2. セキュリティ: データベースの接続情報、ネットワークアドレス、ファイルパスなど、セキュリティ上重要な情報が文字列として扱われることがあります。もし String が可変で、あるメソッドに渡された文字列がそのメソッド内で勝手に変更されてしまうとしたら、プログラム全体のセキュリティや整合性が損なわれる可能性があります。不変であれば、渡した文字列の内容が勝手に変わる心配はありません。
  3. パフォーマンス（特にハッシュコード）: String オブジェクトのハッシュコード（hashCode() メソッドで得られる値）は、その内容に基づいて計算されます。不変であるため、一度計算したハッシュコードはキャッシュしておくことができ、何度も再計算する必要がありません。これは、HashMap や HashSet のようなハッシュベースのコレクションで String オブジェクトをキーとして使う場合に、パフォーマンス上の大きな利点となります。もし String が可変で、内容が変わるたびにハッシュコードを再計算する必要があったら、これらのコレクションの効率が著しく低下します。
  4. String Poolの実現: Javaには「String Pool」と呼ばれる領域があり、同じ内容の文字列リテラルはメモリ上で一つのオブジェクトとして共有されます。例えば、String s1 = "Hello"; String s2 = "Hello"; と書いた場合、通常 s1 と s2 は同じ "Hello" オブジェクトを参照します。これも、String が不変であるからこそ安全に実現できる仕組みです。もし可変で、一方の変数から文字列の内容を変更できてしまうと、もう一方の変数から見える文字列も予期せず変わってしまい、混乱が生じます。

このように、String の不変性はJavaの設計において非常に重要な役割を果たしています。しかし、この不変性は文字列を「結合」する際にパフォーマンス上の課題をもたらすことがあります。

3. String.concat() メソッドの基本

さて、本題である String.concat() メソッドについて見ていきましょう。

String.concat() メソッドは、その名の通り、現在の String オブジェクトの末尾に別の String オブジェクトを結合するためのメソッドです。

メソッドのシグネチャ（定義）は以下のようになっています。

java
public String concat(String str)

  • public: どの場所からも呼び出せるメソッドです。
  • String: このメソッドの戻り値の型です。結合結果である新しい String オブジェクトを返します。
  • concat: メソッド名です。
  • String str: このメソッドが受け取る引数です。結合したいもう一方の文字列（String オブジェクト）を指定します。

最も基本的な使い方は以下のようになります。

“`java
public class ConcatBasicExample {
public static void main(String[] args) {
String str1 = “Hello”;
String str2 = ” World”;

    // str1 に str2 を結合
    String result = str1.concat(str2);

    System.out.println("元の文字列1: " + str1);    // 出力: 元の文字列1: Hello
    System.out.println("元の文字列2: " + str2);    // 出力: 元の文字列2:  World
    System.out.println("結合結果: " + result);     // 出力: 結合結果: Hello World
}

}
“`

このコード例では、str1 ("Hello") に対して concat(str2) を呼び出しています。メソッドは str2 (" World") を引数として受け取り、str1 と str2 を結合した新しい文字列 "Hello World" を生成し、それを result 変数に返しています。

重要な点として、出力結果からも分かるように、concat メソッドを呼び出しても元の str1 オブジェクトや str2 オブジェクトの内容は一切変更されません。str1 は "Hello" のまま、str2 は " World" のままです。これは、前章で説明した String の「不変性」によるものです。concat は常に新しい String オブジェクトを作成して返すため、元のオブジェクトが変更されることはありません。

4. concat() メソッドの詳細な動作と注意点

concat() メソッドはシンプルに見えますが、その挙動にはいくつか知っておくべき詳細があります。

4.1. 引数が null の場合

concat() メソッドの引数 str に null を渡した場合、どうなるでしょうか？

“`java
public class ConcatNullExample {
public static void main(String[] args) {
String base = “Hello”;
String toConcat = null;

    try {
        String result = base.concat(toConcat); // ここでエラーが発生する
        System.out.println("結合結果: " + result);
    } catch (NullPointerException e) {
        System.out.println("NullPointerExceptionが発生しました: " + e.getMessage());
        // 出力: NullPointerExceptionが発生しました: null
    }
}

}
“`

このコードを実行すると、NullPointerException がスローされます。concat() メソッドは、引数が null であることをチェックし、内部でその文字列の内容にアクセスしようとした際にこの例外を発生させます。

これは、concat() メソッドが「与えられた文字列の内容を現在の文字列に物理的に連結する」という操作を行うためです。null は有効な文字列オブジェクトではないため、連結しようとするとエラーになるわけです。

他の文字列結合方法、例えば + 演算子や StringBuilder.append() では、null を結合しようとした場合に "null" という文字列として扱われることがあります。しかし、concat() メソッドでは NullPointerException となるため、引数が null になり得る場合は事前に null チェックを行うか、別の結合方法を検討する必要があります。

4.2. 引数が空文字列 ("") の場合

引数に空文字列 ("") を渡した場合はどうなるでしょうか？

“`java
public class ConcatEmptyExample {
public static void main(String[] args) {
String base = “Hello”;
String empty = “”;

    String result = base.concat(empty);

    System.out.println("元の文字列: " + base);   // 出力: 元の文字列: Hello
    System.out.println("結合結果: " + result);  // 出力: 結合結果: Hello

    // 結果オブジェクトは元のオブジェクトと同じか？
    System.out.println("結果は元の文字列と同じオブジェクトか？: " + (result == base)); // 出力: 結果は元の文字列と同じオブジェクトか？: false
}

}
“`

この場合、"Hello".concat("") の結果は "Hello" となり、元の文字列と論理的には同じ内容の文字列が得られます。

しかし、注目すべき点は、result == base が false を返すことです。これは、concat() メソッドが空文字列を引数として受け取った場合でも、原則として新しい String オブジェクトを生成することを意味します。文字列の内容が元の文字列と全く同じであっても、メモリ上では別個のオブジェクトとして存在します。

（注: Javaの特定のバージョンやJVMの実装によっては、コンパイラやJVMの最適化により、内容が同じ場合は既存のオブジェクトを返すように最適化される可能性もゼロではありませんが、concat メソッドの基本的な仕様としては新しいオブジェクトを生成すると理解しておくのが安全です。）

これは、String の不変性と密接に関わっています。concat メソッドは、現在の文字列と引数の文字列の内容を組み合わせた「新しい文字シーケンス」を作成し、その内容を持つ新しい String オブジェクトを生成します。引数が空文字列の場合、新しい文字シーケンスは元の文字列と同じ内容になりますが、それでも新しいオブジェクトとしての生成プロセスが実行されます。

4.3. 複数の concat() をチェーンした場合

複数の文字列を順番に concat() メソッドを使って結合したい場合、メソッド呼び出しをチェーンすることが考えられます。

“`java
public class ChainedConcatExample {
public static void main(String[] args) {
String str1 = “Java”;
String str2 = ” is”;
String str3 = ” powerful”;
String str4 = “!”;

    // 複数のconcatをチェーン
    String result = str1.concat(str2).concat(str3).concat(str4);

    System.out.println("結合結果: " + result); // 出力: 結合結果: Java is powerful!
}

}
“`

このコードは期待通りに動作し、最終的な結果として "Java is powerful!" という文字列が得られます。しかし、この書き方にはパフォーマンス上の大きな問題があります。

str1.concat(str2).concat(str3).concat(str4) という式が評価される過程を追ってみましょう。

  1. str1.concat(str2) が実行されます。str1 ("Java") と str2 (" is") を結合した新しい String オブジェクト "Java is" が生成されます。これを仮に temp1 とします。
  2. temp1.concat(str3) が実行されます。temp1 ("Java is") と str3 (" powerful") を結合した新しい String オブジェクト "Java is powerful" が生成されます。これを仮に temp2 とします。
  3. temp2.concat(str4) が実行されます。temp2 ("Java is powerful") と str4 ("!") を結合した新しい String オブジェクト "Java is powerful!" が生成されます。これが最終的な result となります。

この例では、合計4つの文字列を結合するために、最終結果の他に temp1 と temp2 という2つの中間的な String オブジェクトが生成されています。一般に、N個の文字列を concat() をチェーンして結合する場合、最終結果とは別に N-1個の中間的な String オブジェクトが生成されます。

中間オブジェクトが多数生成されることの問題点は以下の通りです。

  • メモリ使用量の増加: 短期間しか使われない中間オブジェクトが大量にメモリ（ヒープ領域）上に作成されます。
  • パフォーマンスの低下:
    • 新しいオブジェクトを作成するオーバーヘッド。
    • 新しいオブジェクトの内容を構築するために、元の文字列の内容をコピーする処理。文字列が長くなるほど、コピーにかかる時間は増えます。
    • 生成された中間オブジェクトは、不要になった後にガベージコレクション（GC）によって回収される必要があります。中間オブジェクトが多いとGCの頻度が増えたり、GCに時間がかかったりして、プログラム全体のパフォーマンスに影響を与えます。

特に、ループ内で文字列を繰り返し concat() で結合するようなコードは、非常に非効率になります。例えば、100個の短い単語を concat() で順番に結合する場合、約99個の中間 String オブジェクトが生成され、その過程で大量の文字列コピーが発生します。結合後の文字列が長くなるほど、各 concat 呼び出しでコピーされるデータ量が増えるため、全体の処理時間は文字列の合計長に対してほぼ二乗（O(N^2)）に比例して増加する傾向があります。

このパフォーマンスの問題は、concat() メソッドを複数の文字列結合に使う際の最大の注意点です。

5. concat() メソッドの内部実装（概要）

String.concat() メソッドが内部で具体的に何を行っているのかを知ることは、そのパフォーマンス特性を理解する上で役立ちます。

Javaの String オブジェクトは、内部的に文字のシーケンスを格納するために、通常は文字の配列 (char[]) を保持しています。Java 9以降では、ほとんどの文字列がASCII文字のみを含む場合は、よりメモリ効率の良いバイト配列 (byte[]) で文字を表現する「Compact Strings」という仕組みが導入されました。

concat() メソッドが呼び出されると、基本的な手順は以下のようになります（Compact Stringsでない、従来の char[] の場合を例に説明します）。

  1. 呼び出し元の String オブジェクト（例: "Hello") の文字配列と、引数の String オブジェクト（例: " World") の文字配列の両方の内容を保持できる、新しい文字配列が必要なサイズでヒープメモリ上に確保されます。新しい配列のサイズは、元の文字列の長さと引数の文字列の長さの合計になります。
  2. 呼び出し元の String オブジェクトの文字配列から、その内容が新しい配列の先頭にコピーされます。
  3. 引数の String オブジェクトの文字配列から、その内容が新しい配列の、先ほどコピーした内容の末尾に続けてコピーされます。
  4. この新しく作成され、内容がコピーされた文字配列を内部に持つ、新しい String オブジェクトが生成され、その参照がメソッドの呼び出し元に返されます。

元の String オブジェクトも引数の String オブジェクトも、内部の文字配列を含めて一切変更されません。

Compact Stringsが有効な場合（Java 9+）、内部表現が byte[] であっても基本的なプロセスは似ています。結合結果が全てASCII文字であれば新しい byte[] が、ASCII以外の文字を含む場合は新しい char[] が必要に応じて確保され、内容がコピーされます。ASCIIからUTF-16への変換コストなどが加わる可能性はありますが、根本的な「新しい配列の確保と内容のコピー」という操作は変わりません。

この「新しい配列の確保と内容のコピー」という操作は、結合する文字列の長さが長くなるほど時間とメモリがかかります。特に、前述のように複数の concat をチェーンしたり、ループ内で concat を繰り返したりすると、中間結果の文字列が徐々に長くなっていき、その度に長くなった文字列全体をコピーする必要が出てくるため、処理時間が増大してしまうのです。

対照的に、StringBuilder や StringBuffer は可変であり、内部に可変長のバッファ（文字配列）を持っています。append() メソッドで文字列を追加する場合、現在のバッファに空きがあれば、文字をそのまま末尾に追加できます。バッファが一杯になった場合でも、新しい（より大きな）バッファを確保して既存の内容を一度だけコピーし、その後は再び末尾追加が可能になります。このため、多数の文字列結合においては StringBuilder や StringBuffer の方がはるかに効率的です。

6. 他の文字列結合方法との比較（concatの立ち位置）

concat メソッドの特性を理解したところで、Javaにおける他の文字列結合方法と比較し、concat メソッドがどのような立ち位置にあるのかを見ていきましょう。

6.1. + 演算子との比較

+ 演算子は、Javaで最も一般的に使われる文字列結合の方法です。

java
String firstName = "John";
String lastName = "Doe";
String fullName = firstName + " " + lastName;
System.out.println(fullName); // 出力: John Doe

見た目のシンプルさ、直感的な分かりやすさでは + 演算子が一番です。では、その実体はどうなっているのでしょうか？

Javaコンパイラは、文字列リテラルや String 変数に対する + 演算子による結合を、多くの場合、自動的に StringBuilder を使用したコードに変換します。例えば、"Hello" + " " + "World" という式は、コンパイル時に

java
new StringBuilder("Hello").append(" ").append("World").toString();

のようなコードに最適化されます。この最適化により、複数の + 演算子を使っても、中間的な String オブジェクトが大量に生成されるのを避けることができます。StringBuilder は可変であり、効率的に文字列を追加していけるため、この最適化は多くのケースでパフォーマンスを向上させます。

しかし、この最適化は常に完璧に働くわけではありません。 特に、ループ内で + 演算子を使って文字列結合を繰り返すような場合、期待する最適化が行われないことがあります。

java
// ループ内で + 演算子を使用する（非効率になる可能性があるコード）
String result = "";
for (int i = 0; i < 100; i++) {
result = result + i; // 非効率になる可能性がある
}
System.out.println(result); // 出力: 0123...99

このコードは、コンパイラのバージョンによっては、ループの各反復で new StringBuilder().append(result).append(i).toString() のような処理に変換される可能性があります。つまり、ループが100回繰り返されるたびに、新しい StringBuilder オブジェクトが作成され、既存の result の内容がコピーされ、新しい内容が追加され、そして新しい String オブジェクトが作成されて result に代入される、という一連の処理が行われます。これは、前述の concat をチェーンした場合と同様に、中間オブジェクトの大量生成と、繰り返し行われる文字列全体のコピーにより、非常に非効率になります。

+ 演算子と concat の比較:

  • 可読性/使いやすさ: + 演算子の方が圧倒的に直感的で書きやすいです。特に、リテラルや少数の変数結合には適しています。
  • パフォーマンス:
    • 単純な2つの文字列結合: 多くのケースで、"str1".concat("str2") と "str1" + "str2" のパフォーマンスに大きな違いはありません。どちらも内部的に新しい String オブジェクトを生成します。コンパイラが + を StringBuilder に最適化する場合、オーバーヘッドがわずかに増える可能性はありますが、ほとんど無視できる差でしょう。
    • 複数の文字列結合（リテラルや定数）: "a" + "b" + "c" のような結合は、コンパイル時に "abc" という単一の文字列リテラルに解決される（コンパイル時定数として扱われる）ため、最も効率的です。
    • 複数の文字列結合（変数を含む）: str1 + str2 + str3 のような結合は、通常 StringBuilder に最適化されるため、str1.concat(str2).concat(str3) のように concat をチェーンするよりもはるかに効率的です。concat のチェーンは中間オブジェクトを多数生成しますが、+ 演算子の最適化版はほとんど中間オブジェクトを生成せず、StringBuilder 内で効率的に構築します。
    • ループ内での結合: ループ内で result = result + element; のように + 演算子を使用するのは、中間オブジェクトの生成により非効率になる可能性があります。この場合は、StringBuilder を使うべきです。concat をループ内で使うのは、+ 演算子以上に非効率になることが一般的です。

結論として、 + 演算子は、その直感的な記法とコンパイラによる最適化のおかげで、ほとんどの場合において concat メソッドよりも推奨される文字列結合方法と言えます。特に、少数の文字列を結合する場合や、文字列リテラルを含む結合では、+ 演算子がコードの可読性とパフォーマンスのバランスが良い選択肢となります。ただし、ループ内での繰り返し結合だけは注意が必要で、その場合は明示的に StringBuilder を使うべきです。

concat メソッドが + 演算子よりも優位になる場面は、非常に限られています。例えば、コンパイラが + 演算子を StringBuilder に最適化しないような極めて特殊なケース（非常に古いJavaバージョンなど）や、あるいは単に concat を使いたい、という意図がある場合などです。しかし、現代的なJava開発においては、ほとんどの場合、+ 演算子か StringBuilder が優先されます。

6.2. StringBuilder / StringBuffer クラスとの比較

StringBuilder クラス（とそれに似た StringBuffer クラス）は、Javaで最もパフォーマンスが要求される文字列結合の場面で推奨される方法です。これらのクラスは、String とは異なり、可変（Mutable）な文字シーケンスを扱います。

“`java
public class StringBuilderExample {
public static void main(String[] args) {
StringBuilder sb = new StringBuilder();

    sb.append("Hello");
    sb.append(" ");
    sb.append("World");
    sb.append("!");

    String result = sb.toString(); // 最後にStringに変換

    System.out.println(result); // 出力: Hello World!
}

}
“`

StringBuilder の主な利点は、その可変性にあります。append() メソッドなどで文字列を追加しても、原則として新しい String オブジェクトを生成しません。代わりに、内部で持っている文字配列（バッファ）の末尾に追加していきます。バッファの容量が足りなくなった場合、より大きな新しいバッファを確保して既存の内容をコピーするという操作が発生しますが、これは文字列全体のコピーではなく、新しいバッファへのコピーなので、concat や非最適化 + のように結合の度にコピーが発生するよりはるかに効率的です。特に、多数の文字列を結合する場合や、ループ内で動的に文字列を構築する場合には、StringBuilder は concat や + 演算子よりも圧倒的に優れたパフォーマンスを発揮します。

StringBuilder と StringBuffer は非常によく似ていますが、唯一の大きな違いはスレッドセーフティです。

  • StringBuilder: スレッドセーフではありません（メソッドに synchronized キーワードが付いていない）。単一スレッド内での利用に最適化されており、StringBuffer よりも高速です。
  • StringBuffer: スレッドセーフです（ほとんどのメソッドに synchronized キーワードが付いている）。複数のスレッドから同時にアクセスされても安全ですが、その分 StringBuilder よりもオーバーヘッドが大きく、低速です。

現代のJava開発では、特別な理由（複数のスレッドから同じ文字列バッファを共有する場合など）がない限り、通常は StringBuilder を使用します。

concat と StringBuilder/StringBuffer の比較:

  • 可変性 vs 不変性: concat は不変な String を操作し、常に新しい String オブジェクトを生成します。StringBuilder/StringBuffer は可変であり、既存のバッファを操作し、中間オブジェクトの生成を最小限に抑えます。
  • パフォーマンス: 複数の文字列結合、特にループ内での動的な結合においては、StringBuilder/StringBuffer が concat よりはるかに高速で効率的です。concat は前述のように中間オブジェクト生成と配列コピーのコストがかかります。
  • 使いやすさ: 単に2つの文字列を結合するだけであれば、concat の方がコードはシンプルかもしれません。しかし、複数の文字列を結合する場合は、StringBuilder の append を複数回呼び出す方が、concat をチェーンするよりコードの意図（「この文字列バッファに順番に追加していく」）が明確になることもあります。
  • 戻り値: concat は String オブジェクトを返します。StringBuilder の append メソッドは自身の StringBuilder オブジェクトを返すため、メソッドチェーンが可能です。最終的な String を得るためには toString() メソッドを呼び出す必要があります。

結論として、多数の文字列を結合する場合や、ループ処理などで動的に文字列を構築する場合には、迷わず StringBuilder または StringBuffer を使用するべきです。これは、パフォーマンスとメモリ効率の観点から最も推奨される方法です。concat は、このようなケースには全く適していません。

6.3. String.join() メソッドとの比較

Java 8で導入された String.join() メソッドは、コレクション（List, Set など）や配列の要素を、指定した区切り文字（デリミタ）で連結する際に非常に便利な方法です。

“`java
public class StringJoinExample {
public static void main(String[] args) {
String[] words = {“Java”, “is”, “great”};
String result1 = String.join(” “, words); // 配列の要素をスペースで結合
System.out.println(result1); // 出力: Java is great

    List<String> fruits = Arrays.asList("Apple", "Banana", "Cherry");
    String result2 = String.join(", ", fruits); // リストの要素を ", " で結合
    System.out.println(result2); // 出力: Apple, Banana, Cherry
}

}
“`

String.join() は内部的に StringBuilder を使用して文字列を構築します。そのため、多数の要素を結合する場合でも効率的です。

concat と String.join の比較:

  • 用途: concat は2つの String オブジェクトを単純に連結するのに使います。String.join は、複数の要素（通常は配列やコレクション）を、共通の区切り文字を挟んで結合するのに使います。
  • 引数: concat は1つの String 引数のみを取ります。String.join は区切り文字と、結合したい要素の配列または Iterable オブジェクトを取ります。
  • シンプルさ: 2つの文字列を結合するだけであれば concat や + がシンプルです。しかし、3つ以上の文字列を区切り文字付きで結合する場合、concat を繰り返すのはコードが冗長になり、かつ非効率です。String.join はこのようなケースを非常に簡潔に記述できます。

結論として、複数の文字列（特に配列やコレクションの要素）を特定の区切り文字で結合したい場合は、String.join() メソッドが最適な選択肢です。コードの可読性と簡潔さが向上し、内部で StringBuilder を利用するためパフォーマンスも優れています。concat はこのような用途には向いていません。

6.4. String.format() メソッドとの比較

String.format() メソッドは、C言語の printf 関数のような書式指定文字列を使って、複数の型のデータを整形し、一つの文字列として生成する方法です。

“`java
public class StringFormatExample {
public static void main(String[] args) {
String name = “Alice”;
int age = 30;
double height = 1.65;

    String message = String.format("名前: %s, 年齢: %d歳, 身長: %.2fメートル", name, age, height);
    System.out.println(message); // 出力: 名前: Alice, 年齢: 30歳, 身長: 1.65メートル
}

}
“`

String.format() は、文字列だけでなく、数値、日付など様々な型のデータを文字列に変換し、決められたテンプレートに組み込むことができるため、非常に柔軟な文字列生成が可能です。内部的には、書式指定を解釈して文字列を構築する処理が行われます。

concat と String.format の比較:

  • 用途: concat は既存の2つの文字列を単純に結合します。String.format は、様々な型のデータを文字列に変換し、複雑な書式を指定して新しい文字列を「生成」します。
  • 機能: String.format は、数値の桁数指定、小数点以下の桁数指定、日付の表示形式指定、文字列のパディングなど、豊富な書式設定機能を提供します。concat にそのような機能はありません。
  • 型変換: String.format は自動的に様々な型のデータを適切な文字列形式に変換します。concat は String 型の引数しか取らないため、他の型のデータを結合したい場合は事前に String.valueOf() などを使って明示的に文字列に変換する必要があります。

結論として、複数の異なる型のデータを組み合わせて整形された文字列を生成したい場合は、String.format() メソッドが最適な選択肢です。単に2つの文字列を結合する concat とは用途が全く異なります。

7. パフォーマンスに関する詳細な考察

ここまで見てきたように、Javaにおける文字列結合の方法は複数あり、それぞれパフォーマンス特性が異なります。特に、concat メソッドを複数の文字列結合に使う場合の非効率性は重要な論点です。ここでは、その理由をさらに深く掘り下げ、他の方法とのパフォーマンスの違いを明確に理解しましょう。

7.1. concat や非最適化 + 演算子のパフォーマンス問題の核心：O(N^2)

concat メソッドや、ループ内で使用される非最適化な + 演算子による文字列結合が非効率になる最大の理由は、結合処理にかかる時間が、結合後の文字列全体の長さに対してほぼ二乗に比例する傾向があるためです。これは、計算量のオーダーで言うと O(N^2) に近い特性を持ちます（Nは最終的な文字列の長さ）。

なぜこうなるのでしょうか？ 文字列結合のプロセスを、文字列の長さに着目して考えてみましょう。

  • 最初の文字列の長さ: L1
  • 2番目の文字列の長さ: L2
  • 3番目の文字列の長さ: L3
  • …
  • N番目の文字列の長さ: LN

これらの文字列を s1.concat(s2).concat(s3)...concat(sN) のように順に結合していくとします。

  1. s1.concat(s2): 長さ L1 + L2 の新しい文字列を生成します。これには、L1 + L2 個の文字をコピーするコストがかかります。
  2. (s1.concat(s2)).concat(s3): 先ほど生成した長さ (L1 + L2) の文字列と、長さ L3 の文字列を結合します。新しい文字列の長さは (L1 + L2) + L3 です。これには、(L1 + L2) + L3 個の文字をコピーするコストがかかります。
  3. …
  4. 最終的な結合: 長さ (L1+…+L(N-1)) の中間文字列と、長さ LN の文字列を結合します。これには、(L1+…+L(N-1)) + LN 個の文字をコピーするコストがかかります。

全体としてかかるコピーの総数は、おおよそ以下の合計になります。
(L1+L2) + (L1+L2+L3) + … + (L1+L2+…+LN)

もし全ての文字列が同じ長さ（例えば L）であった場合、N個の文字列を結合した最終的な長さは N * L になります。上記の合計は、おおよそ以下のようになります。
(2L) + (3L) + … + (NL) = L * (2 + 3 + … + N)

括弧の中の合計は、Nの二乗に比例する項（約 N^2 / 2）を含みます。最終的な文字列の長さ N * L を S とすると、N は S / L に相当します。したがって、全体のコストは (S/L)^2 * L 、つまり S^2 / L に比例する傾向があります。元の短い文字列の長さ L が一定であれば、最終的な文字列の長さ S の二乗に比例するコストがかかる、ということになります。これが O(N^2) の性質です（ここで言うNは最終的な文字列の長さ）。

文字列が長くなるほど、新しい配列の確保や大量のデータコピーにかかる時間が増大するため、処理時間が爆発的に増加する可能性があります。

7.2. StringBuilder の効率性：償却定数時間

一方、StringBuilder の append() メソッドは、平均的には償却定数時間（Amortized Constant Time）で実行されると言えます。これは、ほとんどの append 呼び出しは非常に高速（定数時間）に完了するが、時々バッファの拡張が必要になり、その場合は少しコストがかかるという特性を指します。

StringBuilder は内部に可変長の文字配列（バッファ）を持っています。このバッファには現在の文字列内容と、将来の追加に備えた予備の容量があります。

append(str) が呼び出されると、StringBuilder はまず現在のバッファに str を追加するのに十分な容量があるかを確認します。

  • 十分な容量がある場合: str の内容を現在のバッファの末尾に直接コピーします。これは非常に高速な操作で、コピーする文字数（str の長さ）に比例しますが、バッファ自体を変更するだけで新しいオブジェクトは生成しません。
  • 容量が足りない場合: StringBuilder は新しい（通常は現在の2倍程度の）より大きなバッファを確保し、現在のバッファの内容を新しいバッファにコピーし、その後で str の内容を新しいバッファの末尾に追加します。このバッファ拡張にはコストがかかります（古いバッファ全体をコピーする必要があるため）。しかし、バッファのサイズを指数関数的に増やしていく戦略をとるため、多数の append 呼び出し全体で平均すると、各 append にかかるコストは（コピーする文字数にもよりますが）非常に小さくなります。

このように、StringBuilder は中間オブジェクトの生成を最小限に抑え、バッファ拡張のコストを複数回の append 呼び出しに分散させることで、多数の文字列結合において高いパフォーマンスを発揮します。N個の文字列（合計長 S）を StringBuilder で結合する場合、全体としてかかる時間はほぼ S に比例する傾向があります（O(S)）。これは、concat や非最適化 + の O(N^2) に比べて桁違いに高速です。

7.3. JVMによる最適化の影響

前述のように、JavaコンパイラやJVMのJITコンパイラは、文字列結合に関する最適化を行います。特に、+ 演算子による複数の文字列結合は、多くの場合 StringBuilder を利用した効率的なコードに変換されます。

java
// コンパイラが最適化する例
String result = "Name: " + name + ", Age: " + age;

このコードは、ほぼ確実に以下のように最適化されます。

java
String result = new StringBuilder()
.append("Name: ")
.append(name)
.append(", Age: ")
.append(age)
.toString();

このような最適化が行われるため、開発者が明示的に StringBuilder を使わなくても、ある程度の効率は保証されます。しかし、この最適化には限界があります。特にループ内での + 演算子を使った結合は、現在の result 変数の値がループの各反復で変化するため、コンパイラが静的に StringBuilder による結合に変換するのが難しく、前述のような非効率なコードが生成される可能性があります。

concat メソッドに関しては、メソッド呼び出しであるため、コンパイラがこれを自動的に StringBuilder による結合に変換するような高度な最適化は、通常は行われません。そのため、concat を連続して使用したり、ループ内で使用したりした場合は、中間オブジェクトが生成され、パフォーマンスの問題が発生しやすいのです。

7.4. ガベージコレクション（GC）への影響

非効率な文字列結合（concat チェーンやループ内の +）によって大量の中間 String オブジェクトが生成されると、それらのオブジェクトはしばらくすると不要になり、ガベージコレクション（GC）の対象となります。

GCは、不要になったオブジェクトが占めていたメモリを解放する重要な役割を果たしますが、GCの実行自体にもCPU時間とリソースが必要です。大量の短い寿命の中間オブジェクトが頻繁に生成されると、GCがより頻繁に実行されたり、一度のGCで処理するオブジェクトが増えたりして、GCにかかる時間が増大し、プログラム全体の実行性能（スループット）や応答性（レイテンシ）に悪影響を与える可能性があります。

効率的な StringBuilder による結合は、中間オブジェクトの生成を抑えるため、GCの負荷を軽減する効果もあります。

8. concat() メソッドの使い分けとベストプラクティス

これまでの解説から、String.concat() メソッドは、Javaにおける文字列結合の方法としては、多くの場面で + 演算子（最適化される場合）や StringBuilder よりもパフォーマンスが劣る可能性があることが分かりました。では、どのような場合に concat メソッドを使うのが適切なのでしょうか？

正直なところ、現代のJava開発において、concat メソッドが他の方法（特に + 演算子や StringBuilder）よりも明確に優位になる場面は非常に少ないです。

それでもあえて concat が使われる（あるいは使っても大きな問題にならない）可能性があるケースを挙げるとすれば、以下のようになります。

  • 2つの文字列を一度だけ、非常にシンプルに結合したい場合: 例えば、"file".concat(".txt") のようなケースです。この場合、中間オブジェクトは1つだけしか生成されず、結合する文字列の長さも通常は短いため、パフォーマンス上のオーバーヘッドは無視できる範囲であることがほとんどです。コードの意図として、「この文字列に、この文字列を後から付け加える」という操作を明確に表現したい場合に concat を選択するかもしれません。
  • パフォーマンスが全く問題にならない、ごく限られた状況: 学習目的の簡単なコードや、実行頻度が極めて低い処理の一部など、パフォーマンス特性をほとんど考慮する必要がない場面であれば、concat を使っても実害は少ないでしょう。

しかし、これらのケースでも、+ 演算子（"file" + ".txt") の方が一般的には可読性が高いですし、コンパイラの最適化も期待できます。また、将来的に結合する文字列が増える可能性などを考えると、最初から StringBuilder を使っておく方が拡張性が高い場合もあります。

ベストプラクティスとしての使い分けのガイドライン:

  1. 最も一般的で簡単な結合、特にリテラルを含む場合: + 演算子を使用しましょう。可読性が高く、コンパイラが StringBuilder に最適化してくれるため効率的です。
    例: "Hello, " + name + "!"
  2. 多数の文字列を結合する場合、またはループ内で動的に文字列を構築する場合: StringBuilder を使用しましょう。最もパフォーマンスとメモリ効率が良い方法です。
    例:
    java
    StringBuilder sb = new StringBuilder();
    for (String word : words) {
    sb.append(word).append(" ");
    }
    String result = sb.toString().trim(); // 最後にStringに変換
  3. 配列やコレクションの要素を区切り文字で結合する場合: String.join() を使用しましょう。コードが非常に簡潔になります。
    例: String.join(", ", myList)
  4. 異なる型のデータを組み合わせて、書式を整えたい場合: String.format() を使用しましょう。
    例: String.format("数値: %d, 浮動小数点数: %.2f", count, value)
  5. concat メソッド: 上記のいずれにも当てはまらない、あるいは特別な意図がない限り、積極的に使用する理由はあまりありません。特に、複数の concat をチェーンしたり、ループ内で concat を使ったりすることは避けるべきです。

9. concat() 利用時の注意点

concat メソッドを使う際に、改めて注意すべき点をまとめます。

  1. NullPointerException: concat() メソッドは引数に null を渡すと NullPointerException をスローします。引数が null になり得る場合は、事前に null チェックを行うか、+ 演算子や StringBuilder の append（これらは null を "null" という文字列として扱います）など、他の方法を利用することを検討してください。
  2. パフォーマンス問題: 複数の concat をチェーンしたり、ループ内で concat を繰り返し呼び出したりすると、中間オブジェクトが大量に生成され、文字列が長くなるにつれて処理時間が非線形に増大する可能性があります。多数の文字列結合や動的な文字列構築には、必ず StringBuilder を使用してください。
  3. 不変性の誤解: concat メソッドを呼び出しても、メソッドを呼び出した元の String オブジェクトは変更されません。常に新しい String オブジェクトが生成されて返されます。この不変性を理解していないと、「なぜ文字列の内容が変わらないのだろう？」と混乱したり、バグの原因になったりすることがあります。

10. まとめ

この記事では、Javaの String.concat() メソッドを使った文字列結合について、その基本的な使い方から詳細な挙動、内部実装、他の方法との比較、パフォーマンスに関する考察、そして適切な使い分けまでを詳細に解説しました。

concat メソッドは、現在の文字列の末尾に別の文字列を結合し、その結果として新しい String オブジェクトを返します。Javaの String が不変であるため、concat は常に新しいオブジェクトを生成する点が重要です。この特性は、複数の concat をチェーンしたり、ループ内で繰り返し使用したりした場合に、中間オブジェクトの大量生成とそれに伴うパフォーマンス問題（特に文字列が長くなるにつれて顕著になる O(N^2) に近いコスト）を引き起こす原因となります。

Javaには concat 以外にも + 演算子、StringBuilder/StringBuffer、String.join、String.format など、様々な文字列結合方法があります。それぞれの方法は異なる利点と欠点を持っており、状況に応じて最適な方法を選択することが、効率的で保守しやすいJavaコードを書く上で非常に重要です。

  • 最もシンプルで一般的なケースには、コンパイラに最適化される + 演算子。
  • 多数の文字列結合や動的な文字列構築には、パフォーマンスに優れた StringBuilder（または StringBuffer）。
  • コレクションや配列を指定の区切り文字で結合するには、簡潔な String.join。
  • 様々な型のデータを書式指定して文字列にするには、柔軟な String.format。

そして、String.concat() メソッドは、現代のJava開発においては、これらの他の方法と比べて積極的に選ぶべき場面は限定的であり、特にパフォーマンスが重要な状況での複数回利用は避けるべきである、という結論になります。

この記事を通して、concat メソッドの仕組みやJavaにおける文字列結合の多様性について、より深く理解していただけたなら幸いです。適切な文字列結合方法を選択することは、プログラムのパフォーマンスと可読性に大きく影響しますので、ぜひこれらの知識を今後のJavaプログラミングに活かしてください。

コメントする

メールアドレスが公開されることはありません。 ※ が付いている欄は必須項目です

上部へスクロール