Java replaceマスター講座：基礎から応用まで完全解説【効率UPの裏技も】

public String replace(CharSequence target, CharSequence replacement)

String originalString = "Hello, World!";
String newString = originalString.replace("World", "Java");
System.out.println(newString); // 出力: Hello, Java!

リテラル文字列を置換
• 正規表現を使用しない

正規表現パターンを使用して置換
より柔軟な置換が可能だが、特殊文字のエスケープが必要

String text = "The cat and the Cat";
System.out.println(text.replace("cat", "dog"));     // 出力: The dog and the Cat
System.out.println(text.replaceAll("(?i)cat", "dog")); // 出力: The dog and the dog

replaceAllメソッドと正規表現の組み合わせ：

String text = "HELLO hello HeLLo";
String result = text.replaceAll("(?i)hello", "hi");
System.out.println(result); // 出力: HI hi HI

PatternクラスとMatcherクラスの使用：

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

String text = "HELLO hello HeLLo";
Pattern pattern = Pattern.compile("hello", Pattern.CASE_INSENSITIVE);
Matcher matcher = pattern.matcher(text);
String result = matcher.replaceAll("hi");
System.out.println(result); // 出力: HI hi HI

String text = "The year is 2023, and the date is 2023-05-15.";
String result = text.replaceAll("\\d{4}", "YYYY");
System.out.println(result); // 出力: The year is YYYY, and the date is YYYY-05-15.

String email = "Please contact john.doe@example.com or jane@email.co.uk";
String anonymized = email.replaceAll("([a-zA-Z0-9._-]+@[a-zA-Z0-9._-]+\\.[a-zA-Z0-9_-]+)", "****@****.***");
System.out.println(anonymized);
// 出力: Please contact ****@****.*** or ****@****.***

連続したreplace呼び出し：

String text = "The quick brown fox jumps over the lazy dog";
String result = text.replace("quick", "slow")
                    .replace("brown", "red")
                    .replace("lazy", "energetic");
System.out.println(result);
// 出力: The slow red fox jumps over the energetic dog

Mapを使用した動的な置換：

import java.util.Map;
import java.util.HashMap;

String text = "The quick brown fox jumps over the lazy dog";
Map<String, String> replacements = new HashMap<>();
replacements.put("quick", "slow");
replacements.put("brown", "red");
replacements.put("lazy", "energetic");

for (Map.Entry<String, String> entry : replacements.entrySet()) {
    text = text.replace(entry.getKey(), entry.getValue());
}
System.out.println(text);
// 出力: The slow red fox jumps over the energetic dog

String numbers = "1 2 3 4 5 6 7 8 9 10";
String result = numbers.replaceAll("\\d+", m -> {
    int num = Integer.parseInt(m.group());
    return (num % 2 == 0) ? "even" : String.valueOf(num);
});
System.out.println(result); // 出力: 1 even 3 even 5 even 7 even 9 even

String dates = "2023-05-15, 2023/05/16, 2023.05.17";
String result = dates.replaceAll("(\\d{4})[-.](\\d{2})[-.](\\d{2})", m -> {
   String year = m.group(1);
   String month = m.group(2);
   String day = m.group(3);
   return day + "/" + month + "/" + year;
});
System.out.println(result); // 出力: 15/05/2023, 16/05/2023, 17/05/2023

// String.replace() の例
String text = "Hello, World!";
for (int i = 0; i < 1000; i++) {
    text = text.replace("o", "0");
}

// StringBuilder の例
StringBuilder sb = new StringBuilder("Hello, World!");
for (int i = 0; i < 1000; i++) {
    int index;
    while ((index = sb.indexOf("o")) != -1) {
        sb.replace(index, index + 1, "0");
    }
}

String.replace()： 約 2500 ms
StringBuilder： 約 150 ms

List<String> lines = Files.readAllLines(Paths.get("large_file.txt"));
lines.parallelStream()
     .map(line -> line.replaceAll("pattern", "replacement"))
     .forEach(System.out::println);

正規表現パターンを再利用する

   Pattern pattern = Pattern.compile("regex");
   Matcher matcher = pattern.matcher(input);
   while (matcher.find()) {
       // 処理
   }

単一スレッドの場合は StringBuilder を使用（同期化のオーバーヘッドがない）
マルチスレッド環境では StringBuffer を使用（スレッドセーフ）

大きな StringBuilder オブジェクトを使い終わったら null を代入して参照を解放

StringBuilder largeBuilder = new StringBuilder(1000000);
// 処理
largeBuilder = null; // メモリを解放

import java.util.stream.Collectors;
import java.util.stream.Stream;

public class CsvCleaner {
    public static String cleanCsvLine(String line) {
        return Stream.of(line.split(","))
                     .map(field -> field.trim()
                                        .replace("\"", "")
                                        .replaceAll("\\s+", " ")
                                        .replaceAll("(\\d{2})/(\\d{2})/(\\d{4})", "$3-$2-$1"))
                     .collect(Collectors.joining(","));
    }

    public static void main(String[] args) {
        String dirtyLine = "\"John Doe\" , 30 ,  \"New     York\" , \"01/15/2023\"";
        String cleanLine = cleanCsvLine(dirtyLine);
        System.out.println(cleanLine);
        // 出力: John Doe,30,New York,2023-15-01
    }
}

各フィールドの前後の空白を削除
ダブルクォーテーションを削除
連続する空白を1つの空白に置換
日付形式を変換（MM/DD/YYYY → YYYY-MM-DD）

import java.nio.file.Files;
import java.nio.file.Paths;
import java.util.regex.Pattern;
import java.util.stream.Stream;

public class LogAnalyzer {
    private static final Pattern LOG_PATTERN = Pattern.compile("(\\d{4}-\\d{2}-\\d{2} \\d{2}:\\d{2}:\\d{2}) \\[(.+?)\\] (.+)");

    public static void analyzeLog(String filePath) throws Exception {
        try (Stream<String> lines = Files.lines(Paths.get(filePath))) {
            lines.map(line -> LOG_PATTERN.matcher(line))
                 .filter(matcher -> matcher.matches())
                 .map(matcher -> {
                     String timestamp = matcher.group(1);
                     String level = matcher.group(2);
                     String message = matcher.group(3)
                         .replaceAll("\\b(error|exception|failed)\\b", "<span style='color:red'>$1</span>");
                     return String.format("%s [%s] %s", timestamp, level, message);
                 })
                 .forEach(System.out::println);
        }
    }

    public static void main(String[] args) throws Exception {
        analyzeLog("application.log");
    }
}

ログファイルの各行を正規表現でパースし、タイムスタンプ、ログレベル、メッセージを抽出
エラー関連のキーワードを強調表示するためにHTMLタグで囲む

import java.util.Map;
import java.util.regex.Pattern;

public class SimpleTemplateEngine {
    private static final Pattern PLACEHOLDER_PATTERN = Pattern.compile("\\{\\{(.+?)\\}\\}");

    public static String render(String template, Map<String, Object> context) {
        return PLACEHOLDER_PATTERN.matcher(template).replaceAll(match -> {
            String key = match.group(1).trim();
            return context.getOrDefault(key, "").toString();
        });
    }

    public static void main(String[] args) {
        String template = "Hello, {{name}}! Your order #{{orderId}} for {{itemCount}} item(s) has been processed.";
        Map<String, Object> context = Map.of(
            "name", "John Doe",
            "orderId", 12345,
            "itemCount", 3
        );

        String result = render(template, context);
        System.out.println(result);
        // 出力: Hello, John Doe! Your order #12345 for 3 item(s) has been processed.
    }
}

{{placeholder}}形式のプレースホルダーを使用
コンテキストマップから値を取得してプレースホルダーを置換
存在しないキーの場合は空文字列に置換

public static String safeReplace(String original, String target, String replacement) {
    if (original == null) {
        return null;
    }
    return original.replace(
        Objects.toString(target, ""),
        Objects.toString(replacement, "")
    );
}

// 使用例
System.out.println(safeReplace(null, "a", "b"));  // 出力: null
System.out.println(safeReplace("hello", null, "world"));  // 出力: hello
System.out.println(safeReplace("hello", "l", null));  // 出力: heo

String text = "1.23 * 4.56";
System.out.println(text.replaceAll(".", "X"));  // 出力: XXXXXXXXXXXXX
System.out.println(text.replaceAll("\\*", "X"));  // 出力: 1.23 X 4.56

// Pattern.quoteを使用した安全な置換
String safe = text.replaceAll(Pattern.quote("."), "X");
System.out.println(safe);  // 出力: 1X23 * 4X56

String text = "こんにちは、世界！";
System.out.println(text.replaceAll("\\p{InHiragana}", "X"));  // 出力: XXXにちは、世界！

// 正規化を使用した置換
import java.text.Normalizer;

String normalized = Normalizer.normalize(text, Normalizer.Form.NFKC);
System.out.println(normalized.replaceAll("\\p{InHiragana}", "X"));  // 出力: XXXにちは、世界！

StringBuilderを使用して、メモリ効率を改善します。
大規模なデータセットの場合は、ストリーム処理を検討します。

置換前後で文字列長をチェックし、変化がなくなったら処理を終了します。

StringBuffer（スレッドセーフ）の使用を検討します。
可能な限り、不変オブジェクトを使用します。

String csvLine = "John Doe , 30 , New York , Software Engineer";
String[] fields = csvLine.split(",");
String processedLine = Arrays.stream(fields)
    .map(String::trim)
    .map(field -> field.replace("New York", "NY"))
    .collect(Collectors.joining(", "));
System.out.println(processedLine);
// 出力: John Doe, 30, NY, Software Engineer

String phoneNumbers = "Call me at 1234567890 or (987) 654-3210";
String formattedNumbers = phoneNumbers.replaceAll("(\\d{3})(\\d{3})(\\d{4})", "($1) $2-$3");
System.out.println(formattedNumbers);
// 出力: Call me at (123) 456-7890 or (987) 654-3210

Pattern pattern = Pattern.compile("(\\d{3})(\\d{3})(\\d{4})");
Matcher matcher = pattern.matcher(phoneNumbers);
String formattedNumbers = matcher.replaceAll("($1) $2-$3");

String multiLineText = "The quick brown fox\njumps over the lazy dog\nThe dog is also quick";
List<String> processedLines = Arrays.stream(multiLineText.split("\n"))
    .map(line -> line.replace("quick", "fast"))
    .map(line -> line.replace("lazy", "energetic"))
    .map(String::toUpperCase)
    .collect(Collectors.toList());

String result = IntStream.range(0, processedLines.size())
    .mapToObj(i -> String.format("%d: %s", i + 1, processedLines.get(i)))
    .collect(Collectors.joining("\n"));

System.out.println(result);
// 出力:
// 1: THE FAST BROWN FOX
// 2: JUMPS OVER THE ENERGETIC DOG
// 3: THE DOG IS ALSO FAST

List<String> processedLines = Arrays.stream(multiLineText.split("\n"))
    .parallel()
    .map(line -> line.replace("quick", "fast"))
    .map(line -> line.replace("lazy", "energetic"))
    .map(String::toUpperCase)
    .collect(Collectors.toList());