Java Stringクラス完全ガイド！基本操作から高度な文字列処理まで

JavaのStringクラスの基本的な使い方から応用的な文字列操作まで包括的に解説した記事です。初期化・代入方法、length・equals・split・trim等の基本メソッド、正規表現を使った置換・マッチング、文字コード変換、数値との型変換など実務で頻繁に使用する操作を具体的なサンプルコードとともに学べます。文字列処理で困った時の解決策が見つかります。

JavaのStringクラスの基礎知識と概要

Java Stringクラスは、Javaプログラミングにおいて文字列を扱うための基本的なクラスです。このクラスはjava.langパッケージに含まれており、自動的にインポートされるため、特別なインポート文を記述する必要はありません。文字列操作はあらゆるプログラムで必要不可欠な機能であり、Stringクラスの理解はJava開発者にとって必須のスキルと言えるでしょう。

Stringクラスの特徴と役割

Java Stringクラスには重要な特徴がいくつかあります。最も重要な特徴の一つが不変性（immutable）です。これは一度作成されたStringオブジェクトの内容を変更できないことを意味します。

• 不変性により、スレッドセーフが保証される
• 文字列の内容が変更されないため、メモリ上で安全に共有できる
• ハッシュ値の計算結果をキャッシュできるため、HashMapなどでの性能が向上する
• セキュリティ面で安全性が確保される

また、Stringクラスはjava.lang.Objectクラスを継承し、java.io.Serializable、java.lang.Comparable、java.lang.CharSequenceインターフェースを実装しています。この設計により、文字列の比較、シリアライゼーション、文字シーケンス操作などの機能が提供されます。

文字列の基本的な記述方法

Java Stringでは文字列を記述する方法が複数存在します。最も一般的で推奨される方法は文字列リテラルを使用することです。

// 文字列リテラルによる記述
String str1 = "Hello, World!";
String str2 = "Java String";

// 空文字列の記述
String emptyStr = "";

// 改行を含む文字列の記述
String multiLine = "1行目\n2行目\n3行目";

// エスケープ文字を含む文字列
String escaped = "タブ文字:\t引用符:\"Hello\"";

文字列リテラルは二重引用符で囲んで記述します。Java 13以降では、複数行の文字列を扱いやすくするテキストブロック機能も利用できます。特殊文字を含む場合は、バックスラッシュを使用したエスケープシーケンスを使用します。

StringとChar型の相違点

JavaにおけるStringクラスとChar型には明確な違いがあります。理解を深めるために、両者の特徴を比較してみましょう。

// String型の例
String text = "Hello";  // 5文字の文字列
String single = "A";    // 1文字でもString型

// char型の例  
char character = 'A';   // 1文字のみ格納可能
char digit = '5';       // 数字も1文字として扱える

char型は単一引用符、String型は二重引用符を使用することに注意してください。また、char型からString型への変換、その逆の変換も可能ですが、適切なメソッドを使用する必要があります。

文字列の初期化と代入方法

Java Stringの初期化には複数の方法があります。それぞれの方法によってメモリ上での扱いが異なるため、適切な方法を選択することが重要です。

// 1. 文字列リテラルによる初期化（推奨）
String str1 = "Hello World";

// 2. newキーワードによる初期化
String str2 = new String("Hello World");

// 3. 文字配列からの初期化
char[] charArray = {'J', 'a', 'v', 'a'};
String str3 = new String(charArray);

// 4. バイト配列からの初期化
byte[] byteArray = {72, 101, 108, 108, 111};
String str4 = new String(byteArray);

// 5. 他のStringオブジェクトからの初期化
String str5 = new String(str1);

文字列リテラルを使用した初期化では、String Poolと呼ばれるメモリ領域に文字列が格納されます。同じ内容の文字列リテラルは同一のオブジェクトを参照するため、メモリ効率が向上します。一方、newキーワードを使用した場合は、毎回新しいオブジェクトがヒープ領域に作成されます。

• 文字列リテラル：String Poolで管理され、同一内容は同一オブジェクトを参照
• newキーワード：毎回新しいオブジェクトを生成
• 文字配列から：char[]の内容をコピーしてStringオブジェクトを生成
• バイト配列から：指定した文字コードでデコードしてStringオブジェクトを生成

パフォーマンスとメモリ効率を考慮すると、特別な理由がない限り文字列リテラルによる初期化が推奨されます。

Stringクラスの基本的な文字列操作

JavaのStringクラスでは、文字列を操作するための豊富なメソッドが提供されています。これらの操作を適切に使い分けることで、効率的な文字列処理が可能になります。以下では、文字列操作の基本的な処理について詳しく解説していきます。

文字列の生成と作成方法

Java Stringの文字列生成には複数の方法があります。最も基本的な方法は文字列リテラルを使用する方法です。

String str1 = "Hello World";
String str2 = new String("Hello World");
String str3 = new String();

文字列リテラルを使用した場合、Javaは文字列プールという特別な領域に文字列を格納し、同じ内容の文字列は同一のオブジェクトを参照します。一方、newキーワードを使用した場合は、毎回新しいStringオブジェクトが作成されます。

また、文字配列から文字列を生成することも可能です：

char[] charArray = {'J', 'a', 'v', 'a'};
String str4 = new String(charArray);

文字列の結合処理

Java Stringにおける文字列結合は、プログラミングで頻繁に使用される操作の一つです。主な結合方法として、プラス演算子とconcatメソッドの2つの手法があります。

プラス演算子による結合

最も直感的で広く使用される方法がプラス演算子（+）を使用した結合です。複数の文字列を簡単に連結できます。

String firstName = "田中";
String lastName = "太郎";
String fullName = firstName + lastName;  // "田中太郎"

String message = "こんにちは、" + fullName + "さん！";

プラス演算子は文字列以外のデータ型とも組み合わせることができ、自動的に文字列変換が行われます：

int age = 25;
String info = "年齢：" + age + "歳";  // "年齢：25歳"

concatメソッドによる結合

concatメソッドは、Stringクラスが提供する専用の結合メソッドです。メソッドチェーンを使用して複数の文字列を連結できます。

String str1 = "Java";
String str2 = "Programming";
String result = str1.concat(" ").concat(str2);  // "Java Programming"

concatメソッドの特徴として、引数がnullの場合にNullPointerExceptionが発生する点があります。また、空文字列を結合した場合は元の文字列がそのまま返されます。

文字列の分割処理

文字列の分割処理では、splitメソッドを使用して指定した区切り文字で文字列を配列に分割できます。この機能は、CSVデータの処理や文章の単語分割などに活用されます。

String data = "apple,orange,banana,grape";
String[] fruits = data.split(",");
// 結果：["apple", "orange", "banana", "grape"]

splitメソッドは正規表現を区切り文字として使用できるため、より複雑な分割パターンも指定可能です：

String text = "Java Programming Language";
String[] words = text.split("\\s+");  // 空白文字で分割
// 結果：["Java", "Programming", "Language"]

String numbers = "1-2_3.4";
String[] numArray = numbers.split("[-_.]");  // 複数の区切り文字
// 結果：["1", "2", "3", "4"]

文字列の切り出しと部分取得

Java Stringでは、文字列の一部を取得するためのメソッドが用意されています。substringメソッドを使用することで、指定した位置から部分文字列を抽出できます。

String original = "Java Programming";
String sub1 = original.substring(5);        // "Programming"
String sub2 = original.substring(0, 4);     // "Java"
String sub3 = original.substring(5, 12);    // "Program"

また、特定の文字を取得したい場合はcharAtメソッドを使用します：

String text = "Hello";
char firstChar = text.charAt(0);    // 'H'
char lastChar = text.charAt(4);     // 'o'

文字列の最初や最後の数文字を取得する際の便利なパターンとして、以下のような書き方も可能です：

String fileName = "document.pdf";
String extension = fileName.substring(fileName.lastIndexOf('.') + 1);  // "pdf"

空白文字の除去処理

文字列処理において、不要な空白文字の除去は重要な操作の一つです。Java Stringでは、trimメソッドを使用して文字列の先頭と末尾の空白文字を除去できます。

String original = "   Java Programming   ";
String trimmed = original.trim();  // "Java Programming"

Java 11以降では、より柔軟な空白除去メソッドが追加されました：

String text = "   Hello World   ";
String stripLeading = text.stripLeading();   // "Hello World   "
String stripTrailing = text.stripTrailing(); // "   Hello World"
String strip = text.strip();                 // "Hello World"

これらのメソッドは、従来のtrimメソッドと比較して、Unicode空白文字により適切に対応しています。また、文字列内部の空白を除去したい場合は、replaceAllメソッドと正規表現を組み合わせて使用します：

String textWithSpaces = "J a v a  P r o g r a m m i n g";
String noSpaces = textWithSpaces.replaceAll("\\s+", "");  // "JavaProgramming"

文字列の調査と検索機能

Javaでの文字列処理において、String型のデータに対する調査と検索は基本的かつ重要な操作です。文字列の長さを調べたり、内容を比較したり、特定の文字列が含まれているかを確認したりする機能は、アプリケーション開発の様々な場面で活用されます。これらの機能を適切に理解し使い分けることで、効率的で信頼性の高いプログラムを作成できます。

文字列長の取得方法

Java Stringクラスでは、文字列の長さを取得するためにlength()メソッドを使用します。このメソッドは文字列に含まれる文字数を整数値（int型）で返します。

String text = "Hello World";
int length = text.length();
System.out.println(length); // 出力: 11

日本語などのマルチバイト文字も1文字としてカウントされるため、バイト数ではなく文字数が返されます。空文字列の場合は0が返され、この特性を利用して文字列の存在確認にも活用できます。配列のlengthプロパティとは異なり、Stringのlength()はメソッドであることに注意が必要です。

文字列の比較処理

Java Stringの比較処理は、単純な等価演算子（==）では正しく動作しない場合があります。文字列の内容を正確に比較するためには、専用のメソッドを使用する必要があります。文字列比較は大文字小文字を区別する場合と区別しない場合で使い分けることが重要です。

equalsメソッドによる比較

equals()メソッドは、2つの文字列の内容が完全に一致するかを判定します。このメソッドは大文字小文字を区別し、文字列の内容を1文字ずつ比較してboolean値を返します。

String str1 = "Java";
String str2 = "Java";
String str3 = "JAVA";

System.out.println(str1.equals(str2)); // true
System.out.println(str1.equals(str3)); // false

null値を含む可能性がある場合は、Objects.equals()メソッドを使用することで、NullPointerExceptionを回避できます。また、定数文字列と変数を比較する場合は、定数を先に記述することで安全な比較が可能です。

大文字小文字を無視した比較

equalsIgnoreCase()メソッドは、大文字小文字の違いを無視して文字列を比較します。ユーザー入力の検証やファイル拡張子の判定など、大文字小文字の区別が不要な場面で重宝します。

String str1 = "Java";
String str2 = "JAVA";
String str3 = "java";

System.out.println(str1.equalsIgnoreCase(str2)); // true
System.out.println(str1.equalsIgnoreCase(str3)); // true

このメソッドは内部的に文字列を小文字に変換してから比較を行うため、パフォーマンスを重視する場合は事前に文字列を統一しておくことも検討できます。

文字列の空判定

プログラム開発において、文字列が空かどうかの判定は頻繁に行われる処理です。Javaでは空文字列とnull値は異なる概念として扱われるため、それぞれ適切な判定方法を理解する必要があります。これらの判定を正しく行うことで、予期しないエラーや不正な動作を防げます。

空文字列の確認方法

空文字列かどうかを確認するには、isEmpty()メソッドまたはlength()メソッドを使用します。isEmpty()メソッドは文字列の長さが0の場合にtrueを返し、より直感的で読みやすいコードになります。

String emptyString = "";
String nonEmptyString = "Hello";

System.out.println(emptyString.isEmpty()); // true
System.out.println(nonEmptyString.isEmpty()); // false

// length()を使用した場合
System.out.println(emptyString.length() == 0); // true

Java 11以降ではisBlank()メソッドも利用でき、このメソッドは空文字列だけでなく、空白文字のみで構成された文字列も空として判定します。

null値の判定方法

null値の判定は等価演算子（==）を使用して行います。null値に対してStringのメソッドを呼び出すとNullPointerExceptionが発生するため、メソッド呼び出し前にnullチェックを行うことが重要です。

String nullString = null;
String validString = "Hello";

System.out.println(nullString == null); // true
System.out.println(validString == null); // false

// nullチェックとemptyチェックの組み合わせ
if (nullString != null && !nullString.isEmpty()) {
    System.out.println("有効な文字列です");
} else {
    System.out.println("無効な文字列です"); // この行が実行される
}

実際の開発では、nullチェックと空文字列チェックを組み合わせたユーティリティメソッドを作成することで、コードの可読性と保守性を向上させることができます。

文字列の検索機能

Java Stringクラスには、文字列内での検索を行うための豊富なメソッドが用意されています。特定の文字列が含まれているか、文字列の開始や終了が特定のパターンと一致するかなど、様々な検索パターンに対応できます。これらの検索機能を使いこなすことで、データの validation や条件分岐を効率的に実装できます。

指定文字列の存在確認

contains()メソッドは、文字列内に指定した文字列が含まれているかを判定します。部分一致検索を行い、見つかった場合はtrue、見つからなかった場合はfalseを返します。

String text = "Java Programming Language";

System.out.println(text.contains("Program")); // true
System.out.println(text.contains("Python")); // false
System.out.println(text.contains("java")); // false（大文字小文字を区別）

より詳細な位置情報が必要な場合は、indexOf()メソッドを使用します。このメソッドは指定した文字列が最初に見つかった位置のインデックスを返し、見つからない場合は-1を返します。lastIndexOf()メソッドを使用すれば、最後に見つかった位置を取得することも可能です。

文字列の開始・終了判定

startsWith()メソッドとendsWith()メソッドは、文字列が特定のパターンで始まる、または終わるかを判定します。ファイル拡張子の確認やURL のプロトコル判定など、実用的な場面で頻繁に使用されます。

String fileName = "document.pdf";
String url = "https://example.com";

System.out.println(fileName.endsWith(".pdf")); // true
System.out.println(fileName.endsWith(".txt")); // false
System.out.println(url.startsWith("https://")); // true
System.out.println(url.startsWith("http://")); // false

startsWith()メソッドには、検索開始位置を指定できるオーバーロードバージョンも存在し、文字列の途中から開始判定を行うことも可能です。これらのメソッドも大文字小文字を区別するため、必要に応じて事前に文字列を統一することを検討してください。

文字列の変換と整形処理

JavaのStringクラスでは、文字列を様々な形式に変換したり、見やすい形に整形したりする豊富な機能が提供されています。これらの処理は、ユーザーインターフェースでの表示やデータの標準化、システム間でのデータ交換などで頻繁に使用される重要な機能です。ここでは、文字列の変換と整形に関する主要な処理方法について詳しく解説します。

大文字・小文字の変換

Java Stringクラスには、文字列の大文字・小文字を変換するためのメソッドが用意されています。これらの機能は、文字列の正規化や比較処理において特に有用です。

toUpperCase()メソッドは、文字列内のすべての文字を大文字に変換します。以下のコード例をご覧ください。

String originalText = "Hello World";
String upperText = originalText.toUpperCase();
System.out.println(upperText); // 出力: HELLO WORLD

一方、toLowerCase()メソッドは、すべての文字を小文字に変換します。

String originalText = "Hello World";
String lowerText = originalText.toLowerCase();
System.out.println(lowerText); // 出力: hello world

これらのメソッドには、ロケール（地域設定）を指定できるオーバーロード版も存在します。特定の言語や地域の大文字・小文字変換ルールを適用したい場合に使用します。

import java.util.Locale;

String turkishText = "İSTANBUL";
String lowerTurkish = turkishText.toLowerCase(Locale.forLanguageTag("tr"));
System.out.println(lowerTurkish); // トルコ語のルールで変換

書式付き文字列の出力

Java Stringクラスでは、format()メソッドを使用して書式付きの文字列を生成することができます。この機能により、数値の桁数指定や小数点以下の表示制御など、柔軟な文字列フォーマットが可能になります。

基本的な使用方法は以下の通りです。

String name = "田中太郎";
int age = 30;
double salary = 450000.75;

String formattedText = String.format("名前: %s, 年齢: %d歳, 給与: %.2f円", name, age, salary);
System.out.println(formattedText);
// 出力: 名前: 田中太郎, 年齢: 30歳, 給与: 450000.75円

主要なフォーマット指定子には以下のようなものがあります。

• %s: 文字列
• %d: 整数
• %f: 浮動小数点数
• %c: 文字
• %b: 真偽値

さらに詳細な書式制御も可能です。

// 数値の桁数指定と0埋め
String paddedNumber = String.format("%05d", 123);
System.out.println(paddedNumber); // 出力: 00123

// 文字列の幅指定と右寄せ
String alignedText = String.format("%10s", "Java");
System.out.println(alignedText); // 出力: "      Java"

// 小数点以下の桁数指定
String preciseNumber = String.format("%.3f", 3.14159);
System.out.println(preciseNumber); // 出力: 3.142

数値と文字列の相互変換

プログラム開発において、数値データと文字列データの相互変換は頻繁に必要となる処理です。Java Stringクラスおよび関連するクラスでは、これらの変換を効率的に行うためのメソッドが豊富に用意されています。

数値から文字列への変換

数値を文字列に変換する方法はいくつかあります。最も簡単な方法はString.valueOf()メソッドを使用することです。

int intValue = 100;
double doubleValue = 3.14159;
boolean boolValue = true;

String intString = String.valueOf(intValue);
String doubleString = String.valueOf(doubleValue);
String boolString = String.valueOf(boolValue);

System.out.println("整数: " + intString);     // 出力: 整数: 100
System.out.println("小数: " + doubleString);   // 出力: 小数: 3.14159
System.out.println("真偽値: " + boolString);   // 出力: 真偽値: true

各数値型のクラスが提供するtoString()メソッドも利用できます。

Integer intObj = 250;
Double doubleObj = 2.71828;

String intStr = intObj.toString();
String doubleStr = doubleObj.toString();

// 静的メソッドとしても利用可能
String staticIntStr = Integer.toString(250);
String staticDoubleStr = Double.toString(2.71828);

より高度な書式制御が必要な場合は、前述のString.format()メソッドを活用します。

double price = 1234.5;
String formattedPrice = String.format("¥%,.0f", price);
System.out.println(formattedPrice); // 出力: ¥1,235

文字列から数値への変換

文字列を数値に変換する場合は、各数値型のラッパークラスが提供するparseメソッドを使用します。ただし、変換できない文字列を指定した場合はNumberFormatExceptionが発生するため、適切な例外処理が必要です。

try {
    String intString = "123";
    String doubleString = "45.67";
    String boolString = "true";
    
    int convertedInt = Integer.parseInt(intString);
    double convertedDouble = Double.parseDouble(doubleString);
    boolean convertedBool = Boolean.parseBoolean(boolString);
    
    System.out.println("変換された整数: " + convertedInt);
    System.out.println("変換された小数: " + convertedDouble);
    System.out.println("変換された真偽値: " + convertedBool);
    
} catch (NumberFormatException e) {
    System.err.println("数値変換エラー: " + e.getMessage());
}

各数値型の主要なparseメソッドは以下の通りです。

16進数や8進数などの特殊な進数を扱う場合は、基数を指定できるオーバーロード版を使用します。

// 16進数文字列を10進数に変換
String hexString = "FF";
int hexValue = Integer.parseInt(hexString, 16);
System.out.println(hexValue); // 出力: 255

// 2進数文字列を10進数に変換
String binaryString = "1010";
int binaryValue = Integer.parseInt(binaryString, 2);
System.out.println(binaryValue); // 出力: 10

高度な文字列処理機能

Javaの文字列処理は基本的な操作だけでなく、より複雑で柔軟な処理も可能です。正規表現を用いたパターンマッチング、様々な置換処理、文字コード変換、ストリーム処理など、実際の開発現場で求められる高度な機能を理解することで、効率的で保守性の高いコードを書くことができます。

正規表現を使用したパターンマッチング

Java Stringクラスでは、正規表現を活用した柔軟なパターンマッチングが可能です。文字列が特定のパターンに合致するかを確認したり、パターンにマッチする部分を抽出したりできます。

基本的なパターンマッチングにはmatches()メソッドを使用します：

String email = "user@example.com";
boolean isValidEmail = email.matches("[a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\\.[a-zA-Z]{2,}");
System.out.println(isValidEmail); // true

より詳細なパターンマッチング処理にはPatternクラスとMatcherクラスを組み合わせます：

import java.util.regex.Pattern;
import java.util.regex.Matcher;

String text = "電話番号: 03-1234-5678, 090-9876-5432";
Pattern pattern = Pattern.compile("\\d{2,4}-\\d{4}-\\d{4}");
Matcher matcher = pattern.matcher(text);

while (matcher.find()) {
    System.out.println("見つかった電話番号: " + matcher.group());
}

パターンマッチングは入力値の検証、ログファイルの解析、テキストデータの構造化など、様々な場面で活用できる強力な機能です。

文字列の置換処理

Java Stringクラスでは、文字列内の特定の部分を別の文字列に置き換える処理を行うことができます。単純な文字列置換から正規表現を使った高度な置換まで、用途に応じて適切な方法を選択できます。

単純な文字列置換

基本的な文字列置換にはreplace()メソッドを使用します。このメソッドは指定した文字や文字列のすべての出現箇所を新しい文字列に置き換えます：

String original = "Hello World! World is beautiful.";
String replaced = original.replace("World", "Java");
System.out.println(replaced); // "Hello Java! Java is beautiful."

単一文字の置換にはreplace(char, char)メソッドも利用できます：

String text = "a-b-c-d-e";
String result = text.replace('-', '_');
System.out.println(result); // "a_b_c_d_e"

最初に見つかった部分のみを置換したい場合はreplaceFirst()メソッドを使用します：

String text = "test test test";
String result = text.replaceFirst("test", "example");
System.out.println(result); // "example test test"

正規表現による置換

より柔軟な置換処理には正規表現を活用したreplaceAll()メソッドを使用します。パターンにマッチするすべての部分を置換できます：

String text = "価格: 1000円, 送料: 500円, 税込: 1650円";
String result = text.replaceAll("\\d+", "***");
System.out.println(result); // "価格: ***円, 送料: ***円, 税込: ***円"

キャプチャグループを使用することで、マッチした部分を参照して置換することも可能です：

String date = "2024-03-15";
String result = date.replaceAll("(\\d{4})-(\\d{2})-(\\d{2})", "$3/$2/$1");
System.out.println(result); // "15/03/2024"

複雑な置換処理ではMatcherクラスのreplaceAll()やappendReplacement()メソッドを使用することで、より細かい制御が可能になります。

文字コードとバイト配列の変換

Java Stringクラスでは、文字列と byte 配列の相互変換を通じて、異なる文字コード間での変換処理を行うことができます。国際化対応やファイル入出力、ネットワーク通信において重要な機能です。

文字列をバイト配列に変換する際はgetBytes()メソッドを使用します：

String text = "こんにちは世界";

// デフォルト文字コードでの変換
byte[] defaultBytes = text.getBytes();

// 指定した文字コードでの変換
byte[] utf8Bytes = text.getBytes("UTF-8");
byte[] sjisBytes = text.getBytes("Shift_JIS");
byte[] eucBytes = text.getBytes("EUC-JP");

バイト配列から文字列への変換にはStringのコンストラクタを使用します：

// バイト配列から文字列に変換
String restoredText = new String(utf8Bytes, "UTF-8");
System.out.println(restoredText); // "こんにちは世界"

文字コード変換の際は例外処理を適切に行うことが重要です：

try {
    String original = "文字コード変換テスト";
    byte[] bytes = original.getBytes("UTF-8");
    String converted = new String(bytes, "UTF-8");
    System.out.println("変換成功: " + converted);
} catch (UnsupportedEncodingException e) {
    System.out.println("サポートされていない文字コードです");
}

文字列のストリーム処理

Java 8以降、文字列をストリームとして扱うことで、関数型プログラミングのスタイルで効率的な文字列処理を実現できます。大量のデータを扱う際や、複雑な変換処理を行う際に特に有効です。

文字列を文字単位でストリーム化するにはchars()メソッドを使用します：

String text = "Hello World";

// 各文字を処理
text.chars()
    .mapToObj(c -> (char) c)
    .forEach(System.out::println);

// 特定の文字をカウント
long vowelCount = text.toLowerCase()
    .chars()
    .filter(c -> "aeiou".indexOf(c) != -1)
    .count();
System.out.println("母音の数: " + vowelCount);

複数行の文字列を行単位でストリーム処理することも可能です：

String multiLine = "apple\nbanana\ncherry\ndate";

List<String> upperCaseLines = multiLine.lines()
    .map(String::toUpperCase)
    .filter(line -> line.length() > 4)
    .collect(Collectors.toList());

upperCaseLines.forEach(System.out::println); // APPLE, BANANA, CHERRY

文字列のストリーム処理では、map、filter、reduce などのストリーム API を活用することで、可読性が高く保守しやすいコードを記述できます：

String sentence = "Java String processing with streams";

String result = Arrays.stream(sentence.split(" "))
    .filter(word -> word.length() > 4)
    .map(String::toUpperCase)
    .collect(Collectors.joining("-"));

System.out.println(result); // "STRING-PROCESSING-STREAMS"

Stringクラス使用時の注意点とベストプラクティス

JavaのStringクラスを効率的に使用するためには、その特性を正しく理解し、適切な実装方法を選択することが重要です。文字列操作において発生しがちな問題を回避し、パフォーマンスを最適化するためのポイントを詳しく見ていきましょう。

文字列の不変性について

JavaにおいてStringオブジェクトは一度作成されると変更できない不変（immutable）オブジェクトとして設計されています。この特性は文字列操作を行う際に重要な影響を与えます。

文字列に対して変更操作を行うと、既存のオブジェクトが変更されるのではなく、新しいStringオブジェクトが生成されます。以下のコード例で確認してみましょう。

String str = "Hello";
str = str + " World";  // 新しいStringオブジェクトが生成される

この処理では、元の「Hello」のStringオブジェクトは変更されず、「Hello World」という新しいStringオブジェクトが作成され、変数strがそれを参照するように変更されます。

不変性のメリットとしては以下が挙げられます：

• スレッドセーフな操作が可能
• 文字列リテラルプールによるメモリ効率化
• ハッシュ値のキャッシュが可能
• セキュリティ面での安全性確保

null値と空文字列の違い

Java stringの処理において、null値と空文字列の違いを正確に理解することは、予期しない例外やバグを防ぐために不可欠です。

null値は「参照が存在しない」状態を表し、空文字列は「長さが0の文字列オブジェクト」を表します。この違いを理解せずに処理を行うと、NullPointerExceptionが発生する可能性があります。

安全な判定を行うためのベストプラクティスは以下の通りです：

// 安全なnull・空文字列判定
if (str != null && !str.isEmpty()) {
    // 文字列が存在し、空でない場合の処理
}

// Java 11以降では isBlank() も使用可能
if (str != null && !str.isBlank()) {
    // 文字列が存在し、空白文字のみでない場合の処理
}

文字列結合のパフォーマンス考慮点

Stringの不変性により、頻繁な文字列結合操作は深刻なパフォーマンス問題を引き起こす可能性があります。特にループ内での文字列結合では、毎回新しいStringオブジェクトが生成されるため、メモリ使用量が急激に増加し、ガベージコレクションの負荷も高くなります。

以下は非効率な文字列結合の例です：

String result = "";
for (int i = 0; i  1000; i++) {
    result += "text" + i;  // 毎回新しいStringオブジェクトを生成
}

このような場合には、StringBufferやStringBuilderクラスの使用が効果的です。

StringBufferの活用

StringBufferは可変長の文字列バッファを提供するクラスで、スレッドセーフな文字列操作が可能です。内部的に文字配列を持ち、容量が不足した場合は自動的に拡張されます。

StringBufferの主な特徴：

• 同期化されたメソッドによりマルチスレッド環境で安全
• append()メソッドによる効率的な文字列追加
• insert()、delete()、replace()等の豊富な操作メソッド
• 容量管理による効率的なメモリ使用

StringBuffer buffer = new StringBuffer();
for (int i = 0; i  1000; i++) {
    buffer.append("text").append(i);
}
String result = buffer.toString();

StringBuilderの活用

StringBuilderはStringBufferとほぼ同じAPIを提供しますが、同期化処理が省かれているため、シングルスレッド環境ではより高いパフォーマンスを実現できます。

StringBuilderとStringBufferの使い分け：

• StringBuilder：シングルスレッド環境での文字列操作に最適
• StringBuffer：マルチスレッド環境で安全性が必要な場合に使用

効率的なStringBuilder使用例：

StringBuilder builder = new StringBuilder(1000);  // 初期容量を指定
builder.append("開始テキスト");
builder.append(System.lineSeparator());

for (String item : items) {
    builder.append("項目: ").append(item).append(System.lineSeparator());
}

String result = builder.toString();

初期容量を適切に設定することで、配列の再確保回数を減らし、さらなるパフォーマンス向上が期待できます。一般的に、最終的な文字列長が予想できる場合は、その値を初期容量として指定することが推奨されます。

Stringクラスの関連クラスと連携

JavaのString文字列処理において、Stringクラス単体で全ての文字列操作を行うことは可能ですが、より効率的で適切な処理のためには関連するクラスとの使い分けが重要です。文字列の頻繁な変更や大量の文字列処理を行う場合、Stringクラスの不変性による性能上の制約を解決するための専用クラスが提供されています。

StringBuilderクラスとの使い分け

StringBuilderクラスは、Stringクラスの不変性による性能問題を解決する可変文字列クラスです。文字列の連結や変更を頻繁に行う場面において、Stringクラスよりも大幅に高いパフォーマンスを発揮します。

StringBuilderは単一スレッドでの使用に最適化されており、同期処理のオーバーヘッドがないため非常に高速です。以下のような場面でStringBuilderを選択することが推奨されます：

• ループ処理内での文字列連結
• 動的な文字列の構築
• 大量の文字列操作が必要な場合
• 単一スレッド環境での処理

// 非効率なString使用例
String result = "";
for (int i = 0; i  1000; i++) {
    result += "data" + i;
}

// 効率的なStringBuilder使用例
StringBuilder sb = new StringBuilder();
for (int i = 0; i  1000; i++) {
    sb.append("data").append(i);
}
String result = sb.toString();

StringBuilderの主要メソッドには、append()（文字列追加）、insert()（文字列挿入）、delete()（文字列削除）、reverse()（文字列反転）があり、メソッドチェーンによる連続処理も可能です。

StringBufferクラスとの使い分け

StringBufferクラスは、StringBuilderクラスとほぼ同様の機能を持つ可変文字列クラスですが、スレッドセーフな設計となっている点が大きな違いです。マルチスレッド環境での文字列操作において安全性を保証します。

StringBufferの使用を検討すべき場面は以下の通りです：

• 複数スレッドから同時に文字列操作を行う場合
• 並行処理での文字列構築
• スレッドセーフティが重要な要件となる場合

// マルチスレッド環境でのStringBuffer使用例
StringBuffer buffer = new StringBuffer();
// 複数スレッドから安全に操作可能
buffer.append("Thread safe operation");

ただし、同期処理によるオーバーヘッドのため、単一スレッド環境ではStringBuilderよりも性能が劣る点に注意が必要です。Java 5以降では、単一スレッドでの使用にはStringBuilderが推奨されています。

その他の文字列処理クラス

String、StringBuilder、StringBuffer以外にも、特定の用途に特化した文字列処理クラスが提供されています。これらのクラスを適切に活用することで、より専門的で効率的な文字列処理が可能になります。

StringTokenizerクラスは、区切り文字を用いた文字列の分割処理に特化したクラスです：

StringTokenizer tokenizer = new StringTokenizer("apple,banana,cherry", ",");
while (tokenizer.hasMoreTokens()) {
    System.out.println(tokenizer.nextToken());
}

StringJoinerクラス（Java 8以降）は、区切り文字を指定した文字列結合処理を効率的に行います：

StringJoiner joiner = new StringJoiner(", ", "[", "]");
joiner.add("apple").add("banana").add("cherry");
// 結果: [apple, banana, cherry]

Formatterクラスは、printf形式の書式指定による文字列フォーマット処理を提供します。また、Patternクラス・Matcherクラスは正規表現による高度な文字列パターンマッチングと置換処理を実現します。

これらの文字列処理クラスを適切に選択し組み合わせることで、性能と保守性を両立した効率的なJava文字列処理を実現できます。