正規表現に関するサンプル(選択、結合、繰り返しなど

正規表現に関するJavaサンプルプログラム集です。



正規表現

このページには、以下のサンプルを掲載しています。 下の項目をクリックをすると各サンプルにジャンプします。 ※2週間以内の新着記事はNewアイコン、更新記事はUpアイコンが表示されます。
  1. 正規表現-繰り返し文字1 ( RegularSample1.java )  
  2. 正規表現-繰り返し文字2 ( RegularSample2.java )  
  3. 正規表現-文字のグループ化 ( RegularSample3.java )  
  4. 正規表現-文字の選択1 ( RegularSample4.java )  
  5. 正規表現-文字の選択2 ( RegularSample5.java )  
  6. 正規表現-文字のN回繰り返し ( RegularSample6.java )  
  7. 正規表現-グループ文字のN回繰り返し ( RegularSample7.java )  
  8. 正規表現-文字のN回〜M回の繰り返し ( RegularSample8.java )  
  9. 正規表現-グループ文字のN回〜M回の繰り返し ( RegularSample9.java )  
  10. 正規表現-文字の否定 ( RegularSample10.java )  
  11. 正規表現-文字列の置換1 ( RegularSample11.java )  
  12. 正規表現-文字列の置換2 ( RegularSample12.java )  

1. 繰り返し文字1

[ サンプルプログラムのソースコード - RegularSample1.java - ]
  1. public class RegularSample1 {
  2.   public static void main(String[] args) {
  3.     String[] strs = {"a","aaa","bccd","bcaacd","fgcdaa","bcaacaad"};
  4.     String reg = "a*"; 
  5.     for (int i = 0; i < strs.length; i++) {
  6.       if ( strs[i].matches(reg) ) {
  7.         System.out.println("文字列" + (i + 1) + ":\""
  8.            + strs[i] + "\"は、正規表現\""+ reg + "\"にマッチする");
  9.       } else {
  10.         System.out.println("文字列" + (i + 1) + ":\""
  11.            + strs[i] + "\"は、正規表現\"" + reg + "\"にマッチしない");
  12.       }
  13.     }
  14.   }
  15. }
[ サンプルプログラムの実行結果 ]

文字列1:"a"は、正規表現"a*"にマッチする
文字列2:"aaa"は、正規表現"a*"にマッチする
文字列3:"bccd"は、正規表現"a*"にマッチしない
文字列4:"bcaacd"は、正規表現"a*"にマッチしない
文字列5:"fgcdaa"は、正規表現"a*"にマッチしない
文字列6:"bcaacaad"は、正規表現"a*"にマッチしない
[ サンプルプログラムの解説 ]
正規表現で"*"(アスタリスク)は、直前の文字を0回以上繰り返すと言う意味になります。サンプルの場合は、"a*"なので、 aを0回以上繰り返す文字列にマッチ[注]します。実行結果の文字列4〜6は、一見マッチしそうなのですが、a以外の文字も含まれているため"a*"にはマッチしません。 文字列4〜6もマッチさせるようにするには、次のサンプル「繰り返し文字2」のような記述が必要になります。


2. 繰り返し文字2

[ サンプルプログラムのソースコード - RegularSample2.java - ]
  1. public class RegularSample2 {
  2.   public static void main(String[] args) {
  3.     String[] strs = {"a","aaa","bccd","bcaacd","fgcdaa","bcaacaad"};
  4.     String reg = ".*a+.*"; 
  5.     for (int i = 0; i < strs.length; i++) {
  6.       if ( strs[i].matches(reg) ) {
  7.         System.out.println("文字列" + (i + 1) + ":\""
  8.             + strs[i] + "\"は、正規表現\""+ reg + "\"にマッチする");
  9.       } else {
  10.         System.out.println("文字列" + (i + 1) + ":\""
  11.             + strs[i] + "\"は、正規表現\"" + reg + "\"にマッチしない");
  12.       }
  13.     }
  14.   }
  15. }
[ サンプルプログラムの実行結果 ]

文字列1:"a"は、正規表現".*a+.*"にマッチする
文字列2:"aaa"は、正規表現".*a+.*"にマッチする
文字列3:"bccd"は、正規表現".*a+.*"にマッチしない
文字列4:"bcaacd"は、正規表現".*a+.*"にマッチする
文字列5:"fgcdaa"は、正規表現".*a+.*"にマッチする
文字列6:"bcaacaad"は、正規表現".*a+.*"にマッチする
[ サンプルプログラムの解説 ]
正規表現で"+"(プラス記号)は、直前の文字を1回以上繰り返すと言う意味になります。サンプルの"a+"の場合、文字aを1回以上繰り返すと言う意味になります。 サンプルでは、"a+"の前後に".*"と記述されていますが、"."(ドット)は、正規表現で任意の一文字と言う意味になります。"*"(アスタリスク) は、前のサンプル「繰り返し文字1」で出てきましたね。これらを組み合わせて".*a+.*"で 任意の文字0個以上の組み合わせ+文字"a"が1文字以上+任意の文字0個以上の組み合わせという意味になります。 文字列1、2は、文字aの1回以上の繰り返しなのでもちろんマッチします。 文字列3は、文字"a"が1文字も含まれないためマッチしません。 文字列4〜6は、a以外の文字も含まれていますが、".*"が"a+"の前後にあるためマッチします。
前のサンプルの表現方法で"*"(アスタリスク)を使って".*a*.*"のような記述をすると任意の文字が0回以上+aが0回以上+任意の文字が0回以上となって 結局全ての文字がマッチするので文字列1〜6の全部にマッチしてしまいます。


3. 文字のグループ化

[ サンプルプログラムのソースコード - RegularSample3.java - ]
  1. public class RegularSample3 {
  2.   public static void main(String[] args) {
  3.     String[] strs = {"a","abc","abcabc","bcabcd","fabda","babccaabcd"};
  4.     String reg = ".*(abc)+.*"; 
  5.     for (int i = 0; i < strs.length; i++) {
  6.       if ( strs[i].matches(reg) ) {
  7.         System.out.println("文字列" + (i + 1) + ":\""
  8.             + strs[i] + "\"は、正規表現\""+ reg + "\"にマッチする");
  9.       } else {
  10.         System.out.println("文字列" + (i + 1) + ":\""
  11.             + strs[i] + "\"は、正規表現\"" + reg + "\"にマッチしない");
  12.       }
  13.     }
  14.   }
  15. }
[ サンプルプログラムの実行結果 ]

文字列1:"a"は、正規表現".*(abc)+.*"にマッチしない
文字列2:"abc"は、正規表現".*(abc)+.*"にマッチする
文字列3:"abcabc"は、正規表現".*(abc)+.*"にマッチする
文字列4:"bcabcd"は、正規表現".*(abc)+.*"にマッチする
文字列5:"fabda"は、正規表現".*(abc)+.*"にマッチしない
文字列6:"babccaabcd"は、正規表現".*(abc)+.*"にマッチする
[ サンプルプログラムの解説 ]
丸括弧"("、")"で文字をグループ化できます。上のサンプルだと"abc"を丸括弧でグループ化しています。 グループ化した文字列が1回以上繰返される文字列を含む文字列を表しています。


4. 文字の選択1

[ サンプルプログラムのソースコード - RegularSample4.java - ]
  1. public class RegularSample4 {
  2.   public static void main(String[] args) {
  3.     String[] strs = {"a","abc","bddd","efef","efefc","acefef"};
  4.     String reg = ".*[abc]+.*"; 
  5.     for (int i = 0; i < strs.length; i++) {
  6.       if ( strs[i].matches(reg) ) {
  7.         System.out.println("文字列" + (i + 1) + ":\""
  8.             + strs[i] + "\"は、正規表現\""+ reg + "\"にマッチする");
  9.       } else {
  10.         System.out.println("文字列" + (i + 1) + ":\""
  11.             + strs[i] + "\"は、正規表現\"" + reg + "\"にマッチしない");
  12.       }
  13.     }
  14.    }
  15. }
[ サンプルプログラムの実行結果 ]

文字列1:"a"は、正規表現".*[abc]+.*"にマッチする
文字列2:"abc"は、正規表現".*[abc]+.*"にマッチする
文字列3:"bddd"は、正規表現".*[abc]+.*"にマッチする
文字列4:"efef"は、正規表現".*[abc]+.*"にマッチしない
文字列5:"efefc"は、正規表現".*[abc]+.*"にマッチする
文字列6:"acefef"は、正規表現".*[abc]+.*"にマッチする
[ サンプルプログラムの解説 ]
角括弧"["、"]"は、カッコ内の文字のどれか1文字と言う意味になります。上のサンプルの".*[abc]+.*"で「a」または「b」、「c」 の文字が文字列内に1文字以上含まれる文字列とマッチすると言うことになります。


5. 文字の選択2

[ サンプルプログラムのソースコード - RegularSample5.java - ]
  1. public class RegularSample5 {
  2.   public static void main(String[] args) {
  3.     String[] strs = {"a","abc","bddd","efef","efefc","acefef","efababef"};
  4.     String reg = ".*(ab|c)+.*"; 
  5.     for (int i = 0; i < strs.length; i++) {
  6.       if ( strs[i].matches(reg) ) {
  7.         System.out.println("文字列" + (i + 1) + ":\""
  8.             + strs[i] + "\"は、正規表現\""+ reg + "\"にマッチする");
  9.       } else {
  10.         System.out.println("文字列" + (i + 1) + ":\""
  11.             + strs[i] + "\"は、正規表現\"" + reg + "\"にマッチしない");
  12.       }
  13.     }
  14.    }
  15. }
[ サンプルプログラムの実行結果 ]

文字列1:"a"は、正規表現".*(ab|c)+.*"にマッチしない
文字列2:"abc"は、正規表現".*(ab|c)+.*"にマッチする
文字列3:"bddd"は、正規表現".*(ab|c)+.*"にマッチしない
文字列4:"efef"は、正規表現".*(ab|c)+.*"にマッチしない
文字列5:"efefc"は、正規表現".*(ab|c)+.*"にマッチする
文字列6:"acefef"は、正規表現".*(ab|c)+.*"にマッチする
文字列7:"efababef"は、正規表現".*(ab|c)+.*"にマッチする
[ サンプルプログラムの解説 ]
前述(サンプル6-3)の通り丸括弧"("、")"は、グループ化ですが、「|」を置くことで前後の文字列のうちどちらかと言う意味になります。 上のサンプルの場合、「ab」または、「c」が1回以上繰り返される文字列にマッチします。


6. 文字のN回繰り返し

[ サンプルプログラムのソースコード - RegularSample6.java - ]
  1. public class RegularSample6 {
  2.   public static void main(String[] args) {
  3.     String[] strs = {"a","abc","bdaaadd","eaafef","efaaaaefc","acaaefaaef","efababef"};
  4.     String reg = ".*a{3}.*"; 
  5.     for (int i = 0; i < strs.length; i++) {
  6.       if ( strs[i].matches(reg) ) {
  7.         System.out.println("文字列" + (i + 1) + ":\""
  8.             + strs[i] + "\"は、正規表現\""+ reg + "\"にマッチする");
  9.       } else {
  10.         System.out.println("文字列" + (i + 1) + ":\""
  11.             + strs[i] + "\"は、正規表現\"" + reg + "\"にマッチしない");
  12.       }
  13.     }
  14.    }
  15. }
[ サンプルプログラムの実行結果 ]

文字列1:"a"は、正規表現".*a{3}.*"にマッチしない
文字列2:"abc"は、正規表現".*a{3}.*"にマッチしない
文字列3:"bdaaadd"は、正規表現".*a{3}.*"にマッチする
文字列4:"eaafef"は、正規表現".*a{3}.*"にマッチしない
文字列5:"efaaaaefc"は、正規表現".*a{3}.*"にマッチする
文字列6:"acaaefaaef"は、正規表現".*a{3}.*"にマッチしない
文字列7:"efababef"は、正規表現".*a{3}.*"にマッチしない
[ サンプルプログラムの解説 ]
波括弧「{」と「}」で囲まれた部分は直前の文字を波括弧で括った回数だけ繰り返す文字列にマッチします。 上記の場合、文字"a"を3回繰り返す文字列が含まれている文字列と言うことになります。 文字列3と5の赤字部分が正規表現".*a{3}.*"にマッチする文字列になります。 文字列5の場合、文字列"a"が4回繰り返されていて3回ではないのですが4回目の"a"は、".*"の部分にマッチするため 文字列全体としてはマッチしてしまいます。この文字列もマッチさせるには、後述のサンプル「文字の否定」と組み合わせて "[^a]*a{3}[^a]*"のように記述します。 文字列1、2、4、7は、文字"a"の繰り返しが3回に届いていないのでマッチしません。 文字列6は、文字"a"の個数は3個以上ありますが連続して3文字以上並んでいないためマッチしません。


7. グループ文字のN回繰り返し

[ サンプルプログラムのソースコード - RegularSample7.java - ]
  1. public class RegularSample7 {
  2.   public static void main(String[] args) {
  3.     String[] strs = {"a","abc","bdabadd","eababfef",
  4.                      "efabababefc","abababababefaaef","efabcdabef"};
  5.     String reg = ".*(ab){3}.*"; 
  6.     for (int i = 0; i < strs.length; i++) {
  7.       if ( strs[i].matches(reg) ) {
  8.         System.out.println("文字列" + (i + 1) + ":\""
  9.             + strs[i] + "\"は、正規表現\""+ reg + "\"にマッチする");
  10.       } else {
  11.         System.out.println("文字列" + (i + 1) + ":\""
  12.             + strs[i] + "\"は、正規表現\"" + reg + "\"にマッチしない");
  13.       }
  14.     }
  15.    }
  16. }
[ サンプルプログラムの実行結果 ]

文字列1:"a"は、正規表現".*(ab){3}.*"にマッチしない
文字列2:"abc"は、正規表現".*(ab){3}.*"にマッチしない
文字列3:"bdabadd"は、正規表現".*(ab){3}.*"にマッチしない
文字列4:"eababfef"は、正規表現".*(ab){3}.*"にマッチしない
文字列5:"efabababefc"は、正規表現".*(ab){3}.*"にマッチする
文字列6:"abababababefaaef"は、正規表現".*(ab){3}.*"にマッチする
文字列7:"efabcdabef"は、正規表現".*(ab){3}.*"にマッチしない
[ サンプルプログラムの解説 ]
丸括弧で括ったグループ文字も波括弧で繰り返し回数を指定できます。 上記の場合、文字列「ab」を3回繰り返す文字列が含まれている文字列と言うことになります。 実行結果5と6の赤字部分が正規表現".*ab{3}.*"にマッチする文字列になります。 実行結果1、2、4、6、7は、文字「ab」が3回以上繰り返していないのでマッチしません。


8. 文字のN回〜M回の繰り返し

[ サンプルプログラムのソースコード - RegularSample8.java - ]
  1. public class RegularSample8 {
  2.   public static void main(String[] args) {
  3.     String[] strs = {"a","aaa","aaaa","aaaaa","aaaaaa","aabaaba","caaad"};
  4.     String reg = "a{3,5}"; 
  5.     for (int i = 0; i < strs.length; i++) {
  6.       if ( strs[i].matches(reg) ) {
  7.         System.out.println("文字列" + (i + 1) + ":\""
  8.             + strs[i] + "\"は、正規表現\""+ reg + "\"にマッチする");
  9.       } else {
  10.         System.out.println("文字列" + (i + 1) + ":\""
  11.             + strs[i] + "\"は、正規表現\"" + reg + "\"にマッチしない");
  12.       }
  13.     }
  14.    }
  15. }
[ サンプルプログラムの実行結果 ]

文字列1:"a"は、正規表現"a{3,5}"にマッチしない
文字列2:"aaa"は、正規表現"a{3,5}"にマッチする
文字列3:"aaaa"は、正規表現"a{3,5}"にマッチする
文字列4:"aaaaa"は、正規表現"a{3,5}"にマッチする
文字列5:"aaaaaa"は、正規表現"a{3,5}"にマッチしない
文字列6:"aabaaba"は、正規表現"a{3,5}"にマッチしない
文字列7:"caaad"は、正規表現"a{3,5}"にマッチしない
[ サンプルプログラムの解説 ]
a{n,m}で文字「a」をn回以上、m回以下の繰り返すと言う意味になります。 上の例だと文字「a」を3回以上5回以下繰り返すと言うことなります。 実行結果の文字列1は、aが3文字より少ないなので、マッチしません。 文字列5は、aが5文字より多いためマッチしません。


9. グループ文字のN回〜M回の繰り返し

[ サンプルプログラムのソースコード - RegularSample9.java - ]
  1. public class RegularSample9 {
  2.   public static void main(String[] args) {
  3.     String[] strs = {"ab","abab","ababab","abababababab","acacacac","cdabababba","caaad"};
  4.     String reg = "(ab){3,5}"; 
  5.     for (int i = 0; i < strs.length; i++) {
  6.       if ( strs[i].matches(reg) ) {
  7.         System.out.println("文字列" + (i + 1) + ":\""
  8.             + strs[i] + "\"は、正規表現\""+ reg + "\"にマッチする");
  9.       } else {
  10.         System.out.println("文字列" + (i + 1) + ":\""
  11.             + strs[i] + "\"は、正規表現\"" + reg + "\"にマッチしない");
  12.       }
  13.     }
  14.    }
  15. }
[ サンプルプログラムの実行結果 ]

文字列1:"ab"は、正規表現"(ab){3,5}"にマッチしない
文字列2:"abab"は、正規表現"(ab){3,5}"にマッチしない
文字列3:"ababab"は、正規表現"(ab){3,5}"にマッチする
文字列4:"abababababab"は、正規表現"(ab){3,5}"にマッチしない
文字列5:"acacacac"は、正規表現"(ab){3,5}"にマッチしない
文字列6:"cdabababba"は、正規表現"(ab){3,5}"にマッチしない
文字列7:"caaad"は、正規表現"(ab){3,5}"にマッチしない
[ サンプルプログラムの解説 ]
(ab){n,m}で文字「ab」をn回以上、m回以下の繰り返すと言う意味になります。 サンプルの場合だと文字「ab」を3回以上5回以下繰り返すと言うことなります。 実行結果の文字列1と文字列2は、abの繰り返しが3回より少ないなので、マッチしません。 文字列3は、ちょうど3回なのでマッチします。 文字列4は、6回の繰り返しで5回より多いのでマッチしません。 文字列5は、abではなくacの繰り返しなのでマッチしません。 文字列6は、abを3回繰り返していますが、abの前後にcdとbaが入っているのでマッチしません。 前後に余計な文字が入った場合もマッチさせる場合は、「.*(ab){3,5}.*」のように前後に.*を付けます。 この場合は、文字列3も文字列6も両方ともマッチします。 文字列7にいたっては、abがまったく含まれていないのでマッチしません。


10. 文字の否定

[ サンプルプログラムのソースコード - RegularSample10.java - ]
  1. public class RegularSample10 {
  2.   public static void main(String[] args) {
  3.     String[] strs = {"ab","cdefa","cdbef","cdefg","cdeabfg","cf","cbbbf"};
  4.     String reg = "[^b]+"; 
  5.     for (int i = 0; i < strs.length; i++) {
  6.       if ( strs[i].matches(reg) ) {
  7.         System.out.println("文字列" + (i + 1) + ":\""
  8.             + strs[i] + "\"は、正規表現\""+ reg + "\"にマッチする");
  9.       } else {
  10.         System.out.println("文字列" + (i + 1) + ":\""
  11.             + strs[i] + "\"は、正規表現\"" + reg + "\"にマッチしない");
  12.       }
  13.     }
  14.    }
  15. }
[ サンプルプログラムの実行結果 ]

文字列1:"ab"は、正規表現"[^b]+"にマッチしない
文字列2:"cdefa"は、正規表現"[^b]+"にマッチする
文字列3:"cdbef"は、正規表現"[^b]+"にマッチしない
文字列4:"cdefg"は、正規表現"[^b]+"にマッチする
文字列5:"cdeabfg"は、正規表現"[^b]+"にマッチしない
文字列6:"cf"は、正規表現"[^b]+"にマッチする
文字列7:"cbbbf"は、正規表現"[^b]+"にマッチしない
[ サンプルプログラムの解説 ]
[^b]+で文字「b」が含まれない文字列と言うことになります。 文字列1、3、5、7は、文字「b」が1文字以上含まれているのでマッチしません。 文字列2、4、6は、文字「b」が1文字も含まれていないので、マッチします。

11. 文字列の置換1

[ サンプルプログラムのソースコード - RegularSample11.java - ]
  1. public class RegularSample11 {
  2.   public static void main(String[] args) {
  3.     String[] strs = {"id=A043-2584",
  4.                  "id=B043-2965"  };
  5.     String reg = "[A-Z][0-9]{3}"; 
  6.     for (int i = 0; i < strs.length; i++) {
  7.       System.out.println("文字列 : " + strs[i] + " は、"
  8.           + strs[i].replaceAll(reg, "****") + " に置き換えられました。");
  9.     }
  10.   }
  11. }
[ サンプルプログラムの実行結果 ]

文字列 : id=A043-2584 は、id=****-2584 に置き換えられました。
文字列 : id=B043-2965 は、id=****-2965 に置き換えられました。
[ サンプルプログラムの解説 ]
正規表現でマッチした文字列を置換するには、StringクラスのreplaceAllメソッド(サンプル11行目赤字部分)を 使います。第一引数に置換対象となる文字列の正規表現。第二引数に置換する文字列を 指定します。


12. 文字列の置換2

[ サンプルプログラムのソースコード - RegularSample12.java - ]
  1. public class RegularSample12 {
  2.   public static void main(String[] args) {
  3.     String[] strs = {"<b>item1_1</b>","<b>item1_2</b>","<b>item2_01</b>"};
  4.     String reg = "<b>(.+)_([0-9]+)</b>"; 
  5.     for (int i = 0; i < strs.length; i++) {
  6.       System.out.println("文字列 : " + strs[i] + " は、"
  7.           + strs[i].replaceAll(reg, "<h1>$1-$2</h1>") + " に置き換えられました。");
  8.     }
  9.   }
  10. }
[ サンプルプログラムの実行結果 ]

文字列 : <b>item1_1</b> は、<h1>item1-1</h1> に置き換えられました。
文字列 : <b>item1_2</b> は、<h1>item1-2</h1> に置き換えられました。
文字列 : <b>item2_01</b> は、<h1>item2-01</h1> に置き換えられました。
[ サンプルプログラムの解説 ]
正規表現でマッチした部分の一部をそのままにしておきたい場合は、正規表現内で残しておきたい部分を丸括弧「()」でくくります。 StringクラスのreplaceAllメソッドの第二引数で「$+数字」で記述されているところが正規表現中の括弧で指定した文字列に対応します。 「$+数字」の数字部分は、正規表現内の括弧の左からの位置に対応しています。サンプルの場合「(.+)」の部分が「$1」で「([0-9]+)」の 部分が「$2」となります。7行目のreg=〜の赤字部分と10行目のreplaceAllメソッドの第二引数内の赤字部分、 7行目のreg=〜の青字部分と10行目のreplaceAllメソッドの第二引数内の青字部分がそれぞれ対応した文字列となります。




最終更新日:2019/02/13

2015-03-01からの訪問者数
  1428 人