本文へスキップ

本ページはプロモーションが含まれています

Java入門

Javaエスケープシーケンス一覧|\t・\n・\\の使い方と落とし穴

CATEGORY
DRAWN BY
TOM
DATE
REV.
READ
約25分
SHEETS
13枚
エスケープシーケンス(\t・\n・\\ の一覧と落とし穴)

トム

SESで約8年、環境を変えられないもどかしさの中にいました。32歳で自社開発企業に転職し、今はClaude Codeと自動化で、仕事も時間も組み直している途中です。
・Javaバックエンドエンジニア(Java歴12年以上)
・資格:基本情報技術者/応用情報技術者/Java Silver/Python3エンジニア認定基礎
詳細なプロフィール

𝕏

文字列に " を入れただけで、コンパイルが通らなくなる。

Javaのエスケープシーケンスは、\ のあとに1文字を続けて、そのままでは書けない文字を表す書き方です。

よく使うのは改行の \n、タブの \t、ダブルクォートの \"、バックスラッシュの \\ の4つで、言語仕様に決まっているのは全部で11種類あります。

一覧表を冒頭に置き、Windowsの改行 \r\n、正規表現の "\\d"、コメントに書いた \u000a でエラーになる話まで、手元で実行した出力付きでまとめました。

この記事でわかること

  • Javaのエスケープシーケンス11種類の一覧と、それぞれの文字コード
  • \n・\t・\"・\\ の使い方と実行結果
  • char と String で \' と \" の扱いが違う理由
  • Windowsの改行 \r\n と System.lineSeparator()、%n の使い分け
  • 正規表現で "\\d" と二重に書く理由と、ファイルパスの書き方
  • Unicodeエスケープ \uXXXX がエスケープシーケンスと別物である理由
  • 端末の文字に色を付けるANSIエスケープシーケンスと、プロパティファイル・JSON・CSVのルール

文字列のメソッド(比較・分割・置換)はJavaの文字列操作まとめ、テキストブロックの書き方はJavaテキストブロックとは?が担当です。この記事は、その手前の「\ をどう書くか」だけを扱います。

PARTS LIST /目次

Javaのエスケープシーケンス一覧(全11種類)

Javaのエスケープシーケンスは、Java言語仕様(JLS)の3.10.7節で決まっている11種類だけです。

まず全部を表で見て、そのあとで実際に使うものを絞ります。表の「Unicode」は、エスケープを解釈したあとに文字列へ入る1文字の文字コードです。

書き方意味Unicode使える場所
\bバックスペースU+0008文字・文字列・テキストブロック
\s半角スペースU+0020文字・文字列・テキストブロック(Java 15〜)
\tタブ(水平タブ)U+0009文字・文字列・テキストブロック
\n改行(LF)U+000A文字・文字列・テキストブロック
\f改ページ(フォームフィード)U+000C文字・文字列・テキストブロック
\r復帰(CR)U+000D文字・文字列・テキストブロック
\+改行行の継続(改行を消す)なしテキストブロックだけ(Java 15〜)
\"ダブルクォートU+0022文字・文字列・テキストブロック
\'シングルクォートU+0027文字・文字列・テキストブロック
\\バックスラッシュU+005C文字・文字列・テキストブロック
\0〜\3778進数で文字コードを指定U+0000〜U+00FF文字・文字列・テキストブロック

Javaのエスケープシーケンス一覧(JLS 3.10.7)

表の内容は Java言語仕様 3.10.7 Escape Sequences と同じです。

一覧を見て「\d や \u がない」と気づいた人は鋭いです。\d は正規表現の書き方で、Javaの文字列には存在しません。\u はこの表とは別の仕組みで、後半の節で扱います。

よく使うのは \n・\t・\"・\\ の4つ

11種類のうち、普段のコードで出てくるのは \n・\t・\"・\\ の4つです。

\b や \f は、プリンターや古い端末を制御していた時代の名残りで、業務コードで見かける場面はかなり少なめ。\r は、Windowsの改行や進捗表示で出てきます。

  • \n:ログやメッセージの途中で改行する
  • \t:表の形でコンソールに出す、TSVを作る
  • \":JSONやHTMLの断片を文字列に入れる
  • \\:Windowsのパスや正規表現を書く

この4つを覚えておけば、文字列まわりのコンパイルエラーの大半は自分で直せます。

\s と行末の \ は Java 15 で増えた

\s と、行末に置く \ の2つは、テキストブロックと同じ Java 15 で正式に入ったエスケープです(JEP 378)。

ここで勘違いしやすい点が1つあります。\s はテキストブロック専用ではありません。ふつうの文字列リテラルや char でも使えます。

一方、行末の \ は「改行を消す」働きなので、もともと改行を書けない文字列リテラルでは使えず、テキストブロックの中だけで意味を持ちます。

System.out.println("a\sb");   // Java 15以降なら通常の文字列でも使える
a b

Java 11 や Java 8 のプロジェクトで \s を書くと、一覧にない文字として扱われてコンパイルエラーになります。古い版を使っている現場では、" " と書いておくほうが無難です。

一覧にない \d などはコンパイルエラーになる

\ のあとに一覧にない文字を書くと、その時点でコンパイルエラーです。JLSにも「\ の次が改行か b s t n f r " ' \ 0〜7 でなければコンパイルエラー」と書かれています。

正規表現を覚えたての頃にやりがちな書き方で試します。

public class BadEscape {
    public static void main(String[] args) {
        String regex = "\d+";
        System.out.println(regex);
    }
}
BadEscape.java:3: エラー: エスケープ文字が不正です
        String regex = "\d+";
                         ^
エラー1個

英語の環境では illegal escape character と表示されます。このエラーが出たら、\ を1つ足して "\\d+" にするのが答えです。なぜ2つ要るのかは、正規表現の節で図にします。

基本の使い方を実行結果で確かめる

ここからは、エスケープシーケンスを実際に動かして確かめます。この記事のコードは、すべて OpenJDK 23.0.1(macOS)で javac・java に通し、表示された出力をそのまま載せています。

\s や toList() を使っているので、手元で動かすときは Java 17 以降を使ってください。まず、全部のエスケープが「1文字」になることを確かめておきます。

public class EscapeList {
    public static void main(String[] args) {
        String[][] list = {
            {"\\b", "\b"}, {"\\s", "\s"}, {"\\t", "\t"}, {"\\n", "\n"},
            {"\\f", "\f"}, {"\\r", "\r"}, {"\\\"", "\""}, {"\\'", "\'"},
            {"\\\\", "\\"}, {"\\101", "\101"}, {"\\0", "\0"}
        };
        for (String[] e : list) {
            // 書いた文字列 → 実際に入る文字の数と文字コード
            System.out.printf("%-5s 長さ%d  U+%04X%n",
                    e[0], e[1].length(), (int) e[1].charAt(0));
        }
    }
}
\b    長さ1  U+0008
\s    長さ1  U+0020
\t    長さ1  U+0009
\n    長さ1  U+000A
\f    長さ1  U+000C
\r    長さ1  U+000D
\"    長さ1  U+0022
\'    長さ1  U+0027
\\    長さ1  U+005C
\101  長さ1  U+0041
\0    長さ1  U+0000

ソースでは2文字以上に見えても、length() はどれも1です。エスケープシーケンスは「コンパイラへの書き方の約束」で、文字列の中身には \ は残りません。

改行 \n とタブ \t

\n は改行、\t はタブを1文字入れます。コンソールに表のような形で出したいときは \t が手軽です。

public class Basic {
    public static void main(String[] args) {
        System.out.println("名前\t点数");
        System.out.println("トム\t82");
        System.out.println("1行目\n2行目");
        System.out.println("彼は\"OK\"と言った");
        System.out.println("It's \'fine\'");
        System.out.println("C:\\Users\\tom\\memo.txt");
        System.out.println("a\sb");
    }
}
名前	点数
トム	82
1行目
2行目
彼は"OK"と言った
It's 'fine'
C:\Users\tom\memo.txt
a b

タブの幅は、表示する側(端末やエディタ)が決めます。全角文字が混ざると列がずれることがあるので、きれいにそろえたいときは String.format("%-10s", …) で幅を指定するほうが確実です。

ダブルクォート \" とバックスラッシュ \\

文字列リテラルは " で始まって " で終わるので、中に " を書くと、そこで文字列が終わったとみなされます。中身として " を入れたいときに使うのが \" です。

\ も同じ理屈です。\ は「次の文字と組み合わせて特別な意味にする」合図なので、\ そのものを入れたいときは \\ と2つ重ねます。

\" と \\ は「記号そのものを中身として入れる」ためのエスケープ。ソースの見た目より1文字ずつ短くなる、と覚えると数え間違えません。

JSONを文字列で組み立てると \" だらけになって読めなくなります。Java 15 以降なら、テキストブロックに書き換えるとほとんどの \" が消えます(後半の節で触れます)。

\r・\b・\f は表示先で見え方が変わる

\r(復帰)は、カーソルを行の先頭に戻す制御文字です。改行はしないので、端末に出すと同じ行が上書きされます。コマンドラインツールの進捗表示はこの動きを使っています。

public class Progress {
    public static void main(String[] args) throws InterruptedException {
        for (int i = 0; i <= 100; i += 25) {
            System.out.print("\r進み具合: " + i + "%");
            Thread.sleep(300);
        }
        System.out.println();
        String s = "12345\rAB";
        System.out.println(s.chars().boxed().toList());
    }
}
進み具合: 0%進み具合: 25%進み具合: 50%進み具合: 75%進み具合: 100%
[49, 50, 51, 52, 53, 13, 65, 66]

上の1行目は、出力を端末ではなく別のプログラムで受け取ったときの姿です。端末で動かすと同じ行が書き換わっていきますが、ファイルやログに流すと \r は文字コード13のまま残り、全部が1行につながります。

\b(バックスペース)と \f(改ページ)も同じで、見え方は出力先しだいです。ログに混ぜると、あとで検索したときに見えない文字として引っかかるので、意図して使うとき以外は入れないほうが安全です。

8進数エスケープは3桁まで

\ のあとに 0〜7 の数字を書くと、8進数で文字コードを指定できます。範囲は \0 から \377(10進数で255)までです。

public class Octal {
    public static void main(String[] args) {
        System.out.println("\101\102\103");   // 8進数で A B C
        System.out.println("\1234");          // \123 と 4 に分かれる
        System.out.println("\400");           // \40 と 0 に分かれる
        System.out.println("\u0041\u0042");   // Unicodeエスケープのほうが読みやすい
    }
}
ABC
S4
 0
AB

"\1234" は「\123(S)」と「4」の2文字になります。8進数は最大3桁、しかも先頭が 0〜3 のときだけ3桁まで読む決まりなので、\400 は \40(スペース)と 0 に分かれます。

JLSにも、8進数エスケープはC言語との互換のためにあり、U+00FF までしか表せないので普通はUnicodeエスケープを使う、と書かれています。新しく書くコードで8進数を使う理由はほぼありません。例外は、後半で触れる端末の色付けで \033 と書く慣習くらいです。

見えない文字はエスケープの形に戻して確かめる

タブ・\r・ゼロ幅スペースは、画面に出しても目で見分けられません。比較が合わない、CSVの列がずれる、といったときは、見えない文字をエスケープの形に戻して出すと原因がすぐ分かります。

public class Visible {
    /** 見えない文字をエスケープの形に戻して返す */
    static String visible(String s) {
        StringBuilder sb = new StringBuilder();
        for (char c : s.toCharArray()) {
            switch (c) {
                case '\t' -> sb.append("\\t");
                case '\n' -> sb.append("\\n");
                case '\r' -> sb.append("\\r");
                case '\\' -> sb.append("\\\\");
                default -> {
                    if (Character.isISOControl(c) || c == '​') {
                        sb.append(String.format("\\u%04X", (int) c));
                    } else {
                        sb.append(c);
                    }
                }
            }
        }
        return sb.toString();
    }

    public static void main(String[] args) {
        String fromWindows = "ID\tNAME\r\n";
        String withZwsp = "tom​";
        System.out.println("[" + fromWindows + "]");
        System.out.println(visible(fromWindows));
        System.out.println("tom".equals(withZwsp) + " " + visible(withZwsp));
    }
}
[ID	NAME
]
ID\tNAME\r\n
false tom​

1行目は、そのまま出した結果です。] が次の行に落ちたことで改行が入っているとは分かりますが、\r があるかどうかまでは分かりません。2行目では \t・\r・\n がすべて見えています。

3行目の "tom".equals(...) が false なのは、末尾にゼロ幅スペース(U+200B)が付いているからです。Webのフォームやコピーした文字列から紛れ込む文字で、画面上は tom としか見えません。

switch の -> の書き方は Java 14 からです。古い版では、case '\t': のコロンの形に直し、各ケースの最後に break を足してください。

char と String で変わる \' と \" の扱い

\' と \" は、char(文字)と String(文字列)のどちらに書くかで、要る・要らないが入れ替わります。

理由は単純で、char は ' で囲み、String は " で囲むからです。囲みに使っている記号だけはエスケープが必要で、もう一方の記号はそのまま書けます。

char の中では ' をエスケープする

char のリテラルで ' を表したいときは '\'' と書きます。''' と書くと、2つ目の ' で文字が終わったとみなされてコンパイルエラーです。

" は char の囲みではないので、'"' でも '\"' でも同じ1文字になります。

String の中では " をエスケープする

String では逆に、" だけがエスケープ必須です。' は "It's" のようにそのまま書けて、"\'" と書いても同じ文字列になります。

public class Quotes {
    public static void main(String[] args) {
        char single = '\'';   // charの中の ' はエスケープが要る
        char dbl1 = '"';      // charの中の " はそのままでよい
        char dbl2 = '\"';     // エスケープしても同じ
        String s1 = "'";      // Stringの中の ' はそのままでよい
        String s2 = "\'";     // エスケープしても同じ
        String s3 = "\"";     // Stringの中の " はエスケープが要る
        System.out.println(single + " " + dbl1 + " " + dbl2);
        System.out.println(s1 + " " + s2 + " " + s3);
        System.out.println(dbl1 == dbl2);
        System.out.println(s1.equals(s2));
    }
}
' " "
' ' "
true
true
書く場所' を入れる" を入れる
char('…')◎ '\'' が必須○ '"' でも '\"' でもよい
String("…")○ "'" でも "\'" でもよい◎ "\"" が必須
テキストブロック("""…""")○ そのまま○ そのまま(""" が続くときだけ1つエスケープ)

クォートのエスケープが必要な場所(◎=必須、○=任意)

迷ったら「囲んでいる記号と同じものだけエスケープ」と覚えておけば十分です。任意のほうまで毎回エスケープすると、レビューで「これ要る?」と聞かれる程度の害しかありませんが、読む人の目は確実に疲れます。

Windowsの改行 \r\n と System.lineSeparator()

改行は1文字とは限りません。macOS や Linux の改行は \n(LF)の1文字ですが、Windows の標準の改行は \r\n(CR+LF)の2文字です。

Javaには、動いているOSの改行を返す System.lineSeparator() があります。APIドキュメントにも、UNIX系では "\n"、Windowsでは "\r\n" を返すと書かれています。

OSで改行コードが違う

改行コードの違いは、ファイルを書き出すときと、外から受け取った文字列を分割するときに効いてきます。

OS改行コードエスケープで書くと文字コード
macOS・LinuxLF\n10
WindowsCR+LF\r\n13, 10
古いMac OS(9以前)CR\r13

OSごとの改行コード

\n 決め打ちで書いたファイルを Windows のメモ帳で開いても、Windows 10 の2018年の更新以降のメモ帳なら LF を改行として表示します。困るのは、相手のシステムが CRLF を前提にしているCSVの取り込みや、改行コードまで比較するテストのほうです。

printf・String.format の %n

printf と String.format の書式では、%n が「そのOSの改行」になります。Formatter のドキュメントでも、%n は System.lineSeparator() が返す改行だと説明されています。

public class LineSep {
    public static void main(String[] args) {
        String sep = System.lineSeparator();
        System.out.println("lineSeparatorの中身: " + sep.chars().boxed().toList());

        String withN = String.format("A%nB");
        System.out.println("%nの中身: " + withN.chars().boxed().toList());

        String windows = "1行目\r\n2行目\r\n3行目";
        System.out.println("split(\"\\n\"): " + java.util.Arrays.toString(windows.split("\n")).replace("\r", "<CR>"));
        System.out.println("split(\"\\\\R\"): " + java.util.Arrays.toString(windows.split("\\R")));
        System.out.println("lines(): " + windows.lines().toList());
    }
}
lineSeparatorの中身: [10]
%nの中身: [65, 10, 66]
split("\n"): [1行目<CR>, 2行目<CR>, 3行目]
split("\\R"): [1行目, 2行目, 3行目]
lines(): [1行目, 2行目, 3行目]

macOS で動かしたので、lineSeparator() も %n も 10(LF)の1文字です。Windows で同じコードを動かすと [13, 10] になります。

使い分けは次のとおりです。

  • 画面やログに出すだけ:println か %n に任せる
  • 決まった形式のファイルを書く(CSVの仕様がCRLFなど):"\r\n" を明示する
  • 同じファイルをどのOSでも同じ中身にしたい:"\n" を明示する

printf の書式の中で \n を使っても動きますが、%n と混ぜるとOSによって改行コードが混在します。1つのファイルの中ではどちらかにそろえてください。

改行コードが混ざった文字列は \R か lines() で分ける

上の実行結果の3行目が落とし穴です。Windows から来た文字列を split("\n") で分けると、各行の末尾に \r が残ります。画面では見えないので、equals で比較して一致しない原因になりがちです。

正規表現の \R は、\r\n・\n・\r などをまとめて「1つの改行」として扱います。Java 11 以降なら String.lines() も同じように改行の種類を気にせず分けてくれます。

ハマりポイント
split("\n") だと Windows の行末に \r が残る

見た目は同じ文字列なのに equals が false になったら、文字コードを出してみてください。末尾に 13 があれば \r の消し忘れです。外から受け取る文字列は split("\\R") か lines() で分けておくと、改行コードを気にしなくて済みます。

正規表現で "\\d" と二重に書く理由

正規表現の \d(数字1文字)を Java で書くと "\\d" になります。\ が2つ要るのは、文字列が2回読まれるからです。

1回目はコンパイラ(javac)が、エスケープシーケンスとして読みます。2回目は実行時に、正規表現エンジン(Pattern)が正規表現として読みます。

コンパイラと正規表現エンジンで2回読まれる

"\\d+" が数字の並びにマッチするまでの流れを図にしました。

flowchart TD
    A["ソースに書く文字<br/>\\d+"] -->|"javacが \\ を<br/>1文字の \ に変える"| B["Stringの中身<br/>\d+(3文字)"]
    B -->|"Patternが正規表現として解釈"| C["意味<br/>数字が1文字以上"]

javac は \\ を \ 1文字に変えるので、Stringの中身は \d+ の3文字になります。その \d+ を受け取った Pattern が、「\d は数字」と解釈します。

import java.util.Arrays;
import java.util.regex.Pattern;

public class RegexEscape {
    public static void main(String[] args) {
        String regex = "\\d+";
        System.out.println("正規表現エンジンに渡る文字列: " + regex);
        System.out.println("a12b345".replaceAll(regex, "#"));

        System.out.println(Arrays.toString("1.2.3".split(".")));
        System.out.println(Arrays.toString("1.2.3".split("\\.")));
        System.out.println(Arrays.toString("1.2.3".split(Pattern.quote("."))));

        String path = "C:\\Users\\tom\\memo.txt";
        System.out.println(Arrays.toString(path.split("\\\\")));
        System.out.println(path.replace("\\", "/"));
        System.out.println(path.replaceAll("\\\\", "/"));
    }
}
正規表現エンジンに渡る文字列: \d+
a#b#
[]
[1, 2, 3]
[1, 2, 3]
[C:, Users, tom, memo.txt]
C:/Users/tom/memo.txt
C:/Users/tom/memo.txt

println(regex) の結果が \d+ になっているのが、1回目の解釈が終わった証拠です。

. や | で split するときの書き方

split の引数は正規表現です。. は正規表現で「任意の1文字」なので、"1.2.3".split(".") は全部の文字を区切りとみなし、空の配列 [] が返ります。上の実行結果の3行目の [] です。

. を文字として扱うには "\\." と書くか、Pattern.quote(".") で「この文字列をそのまま探して」と指定します。区切り文字が変数で渡ってくるときは、Pattern.quote のほうが事故が少なくなります。

split の空要素の扱いや replace と replaceAll の違いは、Javaの文字列操作まとめにまとめています。メタ文字の一覧はJava正規表現入門が詳しいです。

バックスラッシュ1文字にマッチさせるには "\\\\"

いちばん数え間違えやすいのが、\ そのものを正規表現で探すケースです。正規表現エンジンに \\(2文字)を渡す必要があり、その2文字をJavaの文字列で書くと "\\\\"(4文字)になります。

やりたいこと正規表現Javaの文字列
数字1文字\d"\\d"
ドット1文字\."\\."
改行(種類を問わない)\R"\\R"
バックスラッシュ1文字\\"\\\\"

正規表現とJavaの文字列の書き方の対応

正規表現を使わない replace("\\", "/") なら、\ は1回しか解釈されないので2つで済みます。上の実行結果で、replace と replaceAll が同じ結果になっているのを確かめてください。

トム
トム

\ の数で迷ったら「この文字列は何回読まれる?」と数えるのが近道です。1回なら2倍、正規表現なら4倍。

ファイルパスの \\ はどう書くか

Windows のパス C:\Users\tom\memo.txt をそのまま文字列に書くと、\U や \t がエスケープとして読まれます。\U は一覧にないのでコンパイルエラー、\t はタブに化けます。

パスの書き方は、\\ を重ねる方法と、区切り文字を書かずに組み立てる方法の2つです。

Windowsのパスは \\ を重ねる

固定のパスを書くなら、\ をすべて \\ にします。

String path = "C:\\Users\\tom\\memo.txt";
System.out.println(path);
C:\Users\tom\memo.txt

"C:\temp\new" のような書き方は、たまたまコンパイルが通ってしまうのが厄介です。\t がタブ、\n が改行になり、「ファイルが見つからない」エラーだけが実行時に出ます。

Path.of で区切り文字を書かずに組み立てる

OSをまたいで動かすコードなら、区切り文字そのものを書かない方法があります。Path.of(Java 11〜)に部品を並べて渡すと、そのOSの区切り文字でつないでくれます。

import java.io.File;
import java.nio.file.Path;

public class PathJoin {
    public static void main(String[] args) {
        Path p = Path.of("data", "2026", "memo.txt");
        System.out.println(p);
        System.out.println("区切り文字: " + File.separator);
    }
}
data/2026/memo.txt
区切り文字: /

macOS では / でつながりました。Windows で動かすと File.separator は \ になり、同じコードで data\2026\memo.txt になります。設定ファイルから読んだパスを使う場合は、そもそもソースにエスケープを書く必要がありません。

ファイルの読み込み方そのものはJavaのファイル読み込み7選で扱っています。

Unicodeエスケープ \uXXXX はエスケープシーケンスと別物

\u3042(あ)のような \uXXXX は、見た目がエスケープシーケンスに似ていますが、JLSでは別の節(3.3 Unicode Escapes)に書かれた別の仕組みです。

いちばん大きな違いは、処理される順番です。Unicodeエスケープは、コンパイルの最初の段階で、ソース全体に対して変換されます。文字列の中かどうか、コメントの中かどうかは関係ありません。

\uXXXX はコンパイルの最初に変換される

JLSの3.2節では、ソースを読む手順が3段階に分かれています。Unicodeエスケープはその1番目で、エスケープシーケンスの解釈は3番目です。

flowchart TD
    A["ソースファイル"] --> B["1. Unicodeエスケープを変換<br/>(コメントの中も含めて全部)"]
    B --> C["2. 改行の位置で行に分ける"]
    C --> D["3. 文字列・コメントなどに区切り<br/>エスケープシーケンスを解釈"]
    D --> E["クラスファイル"]

正しく使えば、Unicodeエスケープは普通に便利です。

public class UnicodeOk {
    public static void main(String[] args) {
        System.out.println("\u3042\u3044");   // Unicodeエスケープ
        System.out.println("\\u3042");        // バックスラッシュが2つなら変換されない
        char c = '\u0041';
        System.out.println(c);
    }
}
あい
\u3042
A

コメント中の \u000a でコンパイルエラーになる

\u000a は改行(LF)の文字コードです。手順1で本物の改行に変わるので、文字列の中に書くと、文字列の途中で行が切れたことになります。

String lf = "\u000a";
UnicodeInString.java:3: エラー: 文字列リテラルが閉じられていません
        String lf = "\u000a";
                    ^
UnicodeInString.java:3: エラー: 文字列リテラルが閉じられていません
        String lf = "\u000a";
                           ^
エラー2個

もっと驚くのがコメントです。// のコメントは行末までなので、コメントの途中に \u000a があると、そこで行が終わり、残りがコードとして読まれます。

public class UnicodeTrap {
    public static void main(String[] args) {
        // 改行は \u000a で書く
        System.out.println("ok");
    }
}
UnicodeTrap.java:4: エラー: ';'がありません
        System.out.println("ok");
              ^
エラー1個

エラーの行番号は4行目ですが、原因は3行目のコメントです。コメントの「で書く」がコードとして扱われ、次の行の System とつながって意味の通らない文になっています。

ハマりポイント
コメントに \u000a や \u000d を書かない

エラーの行と原因の行がずれるので、気づくまでに時間がかかります。改行は文字列でもコメントでも \n と書き、文字コードの説明をコメントに書くときは「U+000A」のように \ を付けない書き方にしておくと安全です。

JLS の 3.10.5節にも、"\u000a" は手順1で本物の改行になるので文字列として正しくない、"\n" を使うように、という説明があります。

文字列に \u と書きたいときは \\u

\u の文字そのものを出したいときは、\ を2つ重ねて "\\u3042" と書きます。上の UnicodeOk の2行目がその例で、出力は \u3042 の6文字です。

JLSのルールでは、\ が偶数個続いた直後の u はUnicodeエスケープの始まりになりません。\\ が先に「\ 1つ分」として組になるからです。

書き方変換されるタイミング例
エスケープシーケンス手順3(文字列・文字の中だけ)"\n" → 改行
Unicodeエスケープ手順1(ソース全体)"\u3042" → あ
\\u変換されない"\\u3042" → \u3042 の6文字

エスケープシーケンスとUnicodeエスケープの違い

ソースファイルが UTF-8 なら、日本語はそのまま書けば済みます。Unicodeエスケープの出番は、見えない文字(ゼロ幅スペース U+200B など)をはっきり書きたいときくらいです。

端末の文字に色を付けるANSIエスケープシーケンス

「エスケープシーケンス 色」で調べて来た人が探しているのは、たぶんこちらです。端末の文字に色を付ける仕組みは、ANSIエスケープシーケンスと呼ばれる別物で、Javaの言語仕様ではなく端末側の約束事です。

ESC(文字コード27)という制御文字のあとに [31m のような文字を続けると、対応している端末が「ここから赤」と解釈します。Javaから見れば、ESC 1文字と普通の文字の並びにすぎません。

ESC は \u001B か \033 で書く

Javaのエスケープシーケンスには ESC を表すものがないので、Unicodeエスケープの \u001B か、8進数エスケープの \033 で書きます。どちらも文字コード27の同じ1文字です。

public class Ansi {
    public static void main(String[] args) {
        String red = "\u001B[31m";
        String reset = "\u001B[0m";
        String msg = red + "エラー" + reset + ": 設定ファイルがありません";
        System.out.println(msg);
        System.out.println(msg.length());
        System.out.println("\033[1m太字\033[0m");   // 8進数の \033 も同じ ESC
        System.out.println((int) "\033".charAt(0) + " " + (int) "\u001B".charAt(0));
    }
}
[31mエラー[0m: 設定ファイルがありません
26
[1m太字[0m
27 27

上の出力は、端末ではなく別のプログラムで受け取ったときの表示です。ESC 自体は見えず、[31m などの文字だけが残っています。色に対応した端末で動かすと、「エラー」が赤、「太字」が太字で表示されます。

よく使う番号は次のとおりです。

書き方意味
\u001B[0m色・装飾をすべて元に戻す
\u001B[1m太字
\u001B[31m文字を赤
\u001B[32m文字を緑
\u001B[33m文字を黄
\u001B[34m文字を青

よく使うANSIエスケープシーケンス

色を付けたら、最後に \u001B[0m で戻すのを忘れないでください。戻さないと、そのあとに出る文字やプロンプトまで赤いままになります。

ログファイルには色のコードを残さない

2行目の length() が26になっている点に注目です。見た目は「エラー: 設定ファイルがありません」の17文字なのに、色のコード9文字が文字列に含まれています。

ログファイルに色付きの文字列を書くと、[31m のような文字がそのまま残り、grep で「エラー:」を探しても引っかからなくなります。色は端末に出すときだけ付け、ファイルには付けない設計にしておくのが無難です。

ログ出力のライブラリ(Logback など)には、端末向けの出力だけに色を付ける設定があります。自分で \u001B を書くのは、小さなコマンドラインツールくらいにとどめておくと後が楽です。

テキストブロックと translateEscapes()(Java 15〜)

Java 15 で入ったテキストブロック(""" で囲む複数行の文字列)では、エスケープシーケンスの出番が大きく減ります。" も改行も、そのまま書けるからです。

ここでは、テキストブロックで新しく意味を持った \+改行と \s、同じ版で増えた translateEscapes() だけを見ます。テキストブロックの書き方全体はJavaテキストブロックとは?にまとめています。

行末の \ で改行を消す

テキストブロックの行末に \ を置くと、その行の改行が消えて次の行とつながります。長いSQLを読みやすく折り返しつつ、実際の文字列は1行にしたいときに使えます。

String sql = """
    SELECT id, name \
    FROM users \
    WHERE id = 1
    """;
System.out.print(sql);
SELECT id, name FROM users WHERE id = 1

\ の直前のスペースは残るので、単語がくっつかないよう、スペースを1つ入れてから \ を置いています。

\s で行末の空白を残す

テキストブロックでは、各行の末尾の空白が自動で削られます。固定長の文字列のように、末尾の空白に意味があるときは \s を置くと、そこまでの空白が残ります。

String padded = """
    red  \s
    blue \s
    """;
System.out.print(padded.replace(" ", "_"));
red___
blue__

空白を _ に置き換えて見えるようにしました。\s 自身も1文字のスペースになるので、red のあとは空白が3文字分です。

JLSでは、テキストブロックは「改行をLFにそろえる → 余分なインデントを消す → エスケープを解釈する」の順に処理されると決まっています。エスケープの解釈が最後なので、\s はインデントの削除に巻き込まれません。

外から読んだ \n の2文字を本物の改行に変える

設定ファイルやデータベースに 1行目\n2行目 と書かれていても、Javaで読み込んだ時点では \ と n の2文字のままです。エスケープを解釈するのはコンパイラだけで、実行時に読んだ文字列は変換されません。

Java 15 で追加された String.translateEscapes() を使うと、文字列の中のエスケープシーケンスを、コンパイラと同じルールで本物の文字に変えられます。

String fromConfig = "1行目\\n2行目\\t(タブ)";
System.out.println("変換前: " + fromConfig);
System.out.println("変換後: " + fromConfig.translateEscapes());
変換前: 1行目\n2行目\t(タブ)
変換後: 1行目
2行目	(タブ)

ソースの "\\n" は、外から読み込んだ \n(2文字)の代わりです。translateEscapes() は \uXXXX は変換しないので、Unicodeエスケープを含むデータには使えません。外部の入力をそのまま変換すると、思わぬ制御文字が入ることもあるので、変換してよい項目だけに使ってください。

LOGこの記事を書いたとき全部のコードをjavacに通して出力を貼った

エスケープの出力例は、\ を1つ数え間違えるだけで別物になります。なのでこの記事は、載せたコードを全部 OpenJDK 23.0.1 で javac・java に通し、表示された出力をそのまま貼りました。コメントの \u000a のエラーが、原因の3行目ではなく4行目で報告されたのも、その実行で出たままの表示です。

プロパティファイル・JSON・CSVのエスケープはJavaと別ルール

Javaのソースを書いているときの \ のルールは、ソースの中だけの話です。設定ファイルやデータの形式には、それぞれ別のエスケープのルールがあります。

ここを混同すると、Javaのコードは正しいのに、読み込んだ値だけがおかしい、という分かりにくい不具合になります。よく出会う3つを順に見ます。

プロパティファイルでもパスの \ は重ねる

.properties ファイルを Properties.load で読むと、Javaのソースとよく似たエスケープの解釈が行われます。\t・\n・\uXXXX・\\ などが変換され、意味のない \ は消えます(Properties のドキュメント)。

Windowsのパスをプロパティファイルに書くと、どうなるか試しました。

import java.io.StringReader;
import java.util.Properties;

public class PropsEscape {
    public static void main(String[] args) throws Exception {
        // ファイルに書いた内容をそのまま再現するため、テキストブロックで書く
        String file = """
            path1=C:\\Users\\tom\\memo.txt
            path2=C:\\\\Users\\\\tom\\\\memo.txt
            path3=C:/Users/tom/memo.txt
            msg=1行目\\n2行目
            """;
        System.out.print("ファイルの中身:\n" + file);

        Properties p = new Properties();
        p.load(new StringReader(file));
        System.out.println("path1 = " + p.getProperty("path1"));
        System.out.println("path2 = " + p.getProperty("path2"));
        System.out.println("path3 = " + p.getProperty("path3"));
        System.out.println("msg   = " + p.getProperty("msg"));
    }
}
ファイルの中身:
path1=C:\Users\tom\memo.txt
path2=C:\\Users\\tom\\memo.txt
path3=C:/Users/tom/memo.txt
msg=1行目\n2行目
path1 = C:Users	ommemo.txt
path2 = C:\Users\tom\memo.txt
path3 = C:/Users/tom/memo.txt
msg   = 1行目
2行目

ファイルに C:\Users\tom\memo.txt と書いた path1 は、\U と \m の \ が消え、\t がタブに化けて C:Users ommemo.txt になりました。Javaのソースと違ってエラーにならず、黙って別の値になるのが厄介なところです。

プロパティファイルでも、パスの \ は \\ と重ねるか、path3 のように / で書きます。msg のように、ファイルに \n と書けば読み込み時に改行になるので、translateEscapes() は要りません。

JSONの文字列は \" と \\ と \uXXXX

JSONの文字列にもエスケープがあり、\"・\\・\/・\b・\f・\n・\r・\t・\uXXXX が使えます(RFC 8259 の7節)。Javaとよく似ていますが、\/ があり、\s や8進数はありません。

JSONをJavaの文字列リテラルに直接書くと、JSONのエスケープとJavaのエスケープが重なります。JSONの値に " を含めたいときは、JSONとして \"、そのJSONをJavaのソースに書くと \\\" です。

String json = "{\"msg\": \"彼は\\\"OK\\\"と言った\"}";
System.out.println(json);
{"msg": "彼は\"OK\"と言った"}

ここまで来ると、人の目で数えるのは限界です。JSONは手で組み立てず、ライブラリに任せるのが確実です。JacksonやGsonの使い方はJavaのJSON変換にまとめています。

CSVは \ ではなく "" で囲んで重ねる

CSVのルール(RFC 4180)では、\ はエスケープに使いません。カンマや改行を含む値は " で囲み、値の中の " は "" と2つ重ねて表します。

値CSVに書くと
東京東京
東京,大阪"東京,大阪"
彼は"OK"と言った"彼は""OK""と言った"

CSVでの値の書き方(RFC 4180)

Javaの感覚で \" と書いてしまうと、\ が値の一部として残ります。CSVを自前の split(",") で読み書きすると、この「" で囲まれたカンマ」を正しく扱えないので、量が多いならCSV用のライブラリを使うほうが安全です。

C・Python・JavaScriptとのエスケープの違い

ほかの言語からJavaに来た人がつまずくのは、「あの言語にあったエスケープがJavaにはない」場面です。主な違いを表にしました。

項目JavaCPythonJavaScript
\n \t \\ \"○○○○
\a(ベル)・\v(垂直タブ)×○○\v のみ
\xhh(16進数2桁)×○○○
\s(スペース)○×××
8進数○○○△ strictモードではエラー
一覧にない \ の扱いコンパイルエラー処理系しだい\ が残る(3.12以降は警告)\ が消える
raw文字列(エスケープしない書き方)××○ r"…"○ String.raw

言語ごとのエスケープの違い(○=ある、×=ない)

いちばん大きいのは、Javaに raw 文字列がないことです。Pythonなら正規表現を r"\d+" と書けますが、Javaでは "\\d+" と書くしかありません。行末の \ を使えるテキストブロックも、エスケープ自体は解釈されるので raw 文字列の代わりにはなりません。

逆に、一覧にない \ をコンパイルエラーにしてくれるのはJavaの良いところです。Pythonで "C:\temp" と書くと黙ってタブが入りますが、Javaなら \U のような書き間違いはコンパイルの時点で止まります。

よくある質問

エスケープシーケンスについて、検索でよく調べられている疑問をまとめました。

Q1. Javaのエスケープシーケンスとは何ですか?

文字列や文字のリテラルの中で、そのままでは書けない文字を \ と1文字の組み合わせで表す書き方です。改行の \n、タブの \t、ダブルクォートの \"、バックスラッシュの \\ など、Java言語仕様で11種類が決まっています。

Q2. Javaで改行するには \n と System.lineSeparator() のどちらを使えばいいですか?

画面やログに出すだけなら、println や書式の %n に任せるのが簡単です。ファイルの形式で改行コードが決まっているときは "\r\n" や "\n" を明示し、OSに合わせたいときだけ System.lineSeparator() を使います。

Q3. Javaの正規表現で \ を2つ書くのはなぜですか?

文字列がコンパイラと正規表現エンジンの2回読まれるからです。"\\d" はコンパイラが \d に変え、その \d を正規表現エンジンが数字として解釈します。\ 1文字を探すときは "\\\\" と4つ書きます。

Q4. Javaの文字列でバックスラッシュを表示するにはどうしますか?

\\ と2つ重ねて書きます。"C:\\Users" は C:\Users と表示されます。Windowsのパスを書くときは、すべての \ を \\ にするか、Path.of で区切り文字を書かずに組み立てます。

Q5. エスケープ文字が不正ですというエラーはどう直しますか?

\ のあとに一覧にない文字(\d や \U など)を書いたときのコンパイルエラーです。正規表現なら "\\d"、Windowsのパスなら "C:\\Users" のように、\ をもう1つ足して直します。

Q6. \s はテキストブロックでしか使えませんか?

いいえ、Java 15 以降なら通常の文字列リテラルや char でも使えます。テキストブロックの中だけで使えるのは、行末に置いて改行を消す \ のほうです。Java 11 などの古い版では \s はコンパイルエラーになります。

Q7. コメントに \u000a と書くとエラーになるのはなぜですか?

Unicodeエスケープ \uXXXX は、コンパイルの最初にソース全体で変換されるからです。コメントの中の \u000a も本物の改行になり、残りの部分がコードとして読まれてエラーになります。

Q8. Javaでコンソールの文字に色を付けるにはどうしますか?

ESC(文字コード27)を \u001B か \033 で書き、"\u001B[31m" のようなANSIエスケープシーケンスを文字列の前に付けます。色に対応した端末で赤く表示され、最後に "\u001B[0m" で元に戻します。ログファイルには色のコードを書かないようにします。

まとめ:迷ったら「何回読まれるか」を数える

Javaのエスケープシーケンスは11種類で、実務で使うのは \n・\t・\"・\\ の4つです。数え間違いが起きるのは、文字列が2回以上読まれる場面でした。

【要点まとめ】

  • エスケープシーケンスは11種類。一覧にない \d などはコンパイルエラー
  • \s と行末の \ は Java 15 から。\s は通常の文字列でも使える
  • char では '、String では " だけがエスケープ必須
  • Windowsの改行は \r\n。分割は split("\\R") か lines() で
  • 正規表現は2回読まれるので "\\d"、\ 1文字は "\\\\"
  • \uXXXX は別物。コンパイルの最初に変換されるのでコメントに \u000a を書かない
  • 端末の色はANSIエスケープシーケンス。ESC は \u001B で書く
  • プロパティファイル・JSON・CSVは、Javaのソースとは別のエスケープのルール

\ の数で迷ったら、その文字列がコンパイラと正規表現エンジンの何回読まれるかを数える。これだけで、\\ の数え間違いはほぼ防げます。

文字列の比較や分割など、エスケープの外側の操作は次の記事に続きます。

あわせて読む
NEXT STEP
自分のコードで split や replaceAll を grep し、"\\" の数を1か所だけ数え直してみる。

改行の分割に split("\n") を使っている箇所があれば、Windows から来るデータで \r が残らないかも合わせて見ておくと安心です。

途中経過は、また書きます。

NEXT READ本棚から1本

AIで開発を組み直すなら、まずこの5冊から

入門・実践・設計まで、Claude Codeの本をレベル別に5冊選んで比べました。

→ おすすめ5冊を見る

トム

SESで約8年、環境を変えられないもどかしさの中にいました。32歳で自社開発企業に転職し、今はClaude Codeと自動化で、仕事も時間も組み直している途中です。
・Javaバックエンドエンジニア(Java歴12年以上)
・資格:基本情報技術者/応用情報技術者/Java Silver/Python3エンジニア認定基礎
詳細なプロフィール

𝕏

Java入門

TOC