자바 정규식

Java는 java.util.regex 패키지에서 강력한 정규식 API를 제공합니다. 이 튜토리얼에서는 정규식 API를 사용하는 방법을 설명합니다.

정규식

정규식은 텍스트 검색에 사용되는 텍스트 패턴입니다. 즉, 텍스트에서 패턴이 나타나는 것을 검색합니다. 예를 들어 정규식을 사용하여 웹 페이지에서 이메일 주소나 하이퍼링크를 검색할 수 있습니다.

정규식 예

다음은 텍스트 검색을 위한 간단한 Java 정규식의 예입니다. http://

String text    =        
   "This is the text to be searched " +       
  "for occurrences of the http:// pattern.";String pattern = ".*http://.*";boolean matches = Pattern.matches(pattern, text);
System.out.println("matches = " + matches);

예제 코드 실제 ​​감지되지 않습니다. 발견된 http://가 도메인 이름과 접미사(.com, .net 등)를 포함하는 등의 법적 하이퍼링크의 일부인지 여부. 코드는 단순히 http:// 문자열이 나타나는지 찾습니다.

Java6의 정규식에 대한 API

이 튜토리얼에서는 Java6의 정규식에 대한 API를 소개합니다.

패턴(java.util.regex.Pattern)

패턴이라고 하는 클래스 java.util.regex.Pattern은 필요할 때마다 Java 정규식 API의 기본 항목입니다. Pattern 클래스에서 시작하여 정규식을 사용하려면

Pattern.matches()

정규식 패턴이 텍스트와 일치하는지 확인하는 가장 직접적인 방법은 정적 메소드 Pattern을 호출하는 것입니다. .matches(), 예는 다음과 같습니다.

String text    =        
  "This is the text to be searched " +        
  "for occurrences of the pattern.";String pattern = ".*is.*";boolean matches = Pattern.matches(pattern, text);
System.out.println("matches = " + matches);

위 코드는 "is"라는 단어가 변수 텍스트에 나타나는지 검색하여 "is"가 전후에 0개 이상의 문자를 포함할 수 있도록 허용합니다. (.*로 지정)

Pattern .matches() 메서드는 텍스트에서 패턴이 한 번 나타나는지 확인하거나 Pattern 클래스의 기본 설정에 적합합니다.

여러 항목을 일치시켜야 하는 경우 다른 일치 텍스트를 출력하거나 기본이 아닌 설정이 필요합니다. Pattern.compile() 메서드를 통해 Pattern 인스턴스를 가져와야 합니다.

Pattern.compile()

텍스트에 여러 번 나타나는 정규식을 일치시켜야 하는 경우 Pattern.compile() 메서드를 통해 Pattern 객체를 생성해야 합니다. 예는 다음과 같습니다.

String text    =        
"This is the text to be searched " +        
"for occurrences of the http:// pattern.";
String patternString = ".*http://.*";
Pattern pattern = Pattern.compile(patternString);

Compile 메서드에서 특수 플래그를 지정할 수 있습니다.

Pattern pattern = Pattern.compile(patternString, Pattern.CASE_INSENSITIVE);

Pattern 클래스에는 여러 플래그(int 유형)가 포함되어 있습니다. 패턴 매칭 패턴. 위 코드의 플래그는 패턴 일치가 대소문자를 무시하도록 만듭니다

Pattern.matcher()

Pattern 객체를 얻으면 Matcher 객체를 얻을 수 있습니다. Matcher 예제는 텍스트의 패턴을 일치시키는 데 사용됩니다.

Matcher matcher = pattern.matcher(text);

Matcher 클래스에는 텍스트가 패턴과 일치하는지 확인할 수 있는 match() 메서드가 있습니다. 다음은 Matcher의 전체 예입니다

String text    =        
"This is the text to be searched " +        
"for occurrences of the http:// pattern.";
String patternString = ".*http://.*";
Pattern pattern = Pattern.compile(patternString, Pattern.CASE_INSENSITIVE);
Matcher matcher = pattern.matcher(text);boolean matches = matcher.matches();
System.out.println("matches = " + matches);

Pattern.split()

Pattern 클래스의 Split() 메서드는 정규 표현식을 구분 기호로 사용하여 텍스트를 문자열 배열로 분할할 수 있습니다. 유형. 예:

String text = "A sep Text sep With sep Many sep Separators";String patternString = "sep";
Pattern pattern = Pattern.compile(patternString);String[] split = pattern.split(text);
System.out.println("split.length = " + split.length);for(String element : split){
    System.out.println("element = " + element);
}

위 예에서 텍스트는 5개의 문자열을 포함하는 배열로 나뉩니다.

Pattern.pattern()

Pattern 클래스의 Pattern은 Pattern 개체를 만드는 데 사용되는 정규식을 반환합니다. 예:

String patternString = "sep";Pattern pattern = Pattern.compile(patternString);String pattern2 = pattern.pattern();

위의 코드는 sep 이며, PatternString 변수와 동일합니다.

Matcher(java.util.regex.Matcher)

java.util.regex.Matcher 클래스는 텍스트에서 여러 정규 표현식을 일치시키는 데 사용됩니다. 텍스트는 동일한 정규식과 일치합니다.

Matcher에는 유용한 메소드가 많이 있습니다. 자세한 내용은 공식 JavaDoc을 참조하세요. 여기서는 핵심 메소드만 소개합니다.

다음 코드는 Matcher 사용 방법을 보여줍니다

String text    =        
"This is the text to be searched " +        
"for occurrences of the http:// pattern.";
String patternString = ".*http://.*";
Pattern pattern = Pattern.compile(patternString);
Matcher matcher = pattern.matcher(text);
boolean matches = matcher.matches();

먼저 Pattern을 만든 다음 Matcher를 가져오고 match() 메서드를 호출하고 true를 반환하여 패턴 일치를 나타내고 false를 반환합니다. 일치하지 않음을 나타냅니다.

Matcher로 더 많은 일을 할 수 있습니다.

Matcher 생성

Pattern의 matcher() 메소드를 통해 Matcher를 생성합니다.

String text    =        
"This is the text to be searched " +        
"for occurrences of the http:// pattern.";
String patternString = ".*http://.*";
Pattern pattern = Pattern.compile(patternString);
Matcher matcher = pattern.matcher(text);

matches()

Matcher 클래스의 match() 메서드는 텍스트의 정규 표현식과 일치하는 데 사용됩니다.

boolean matches = matcher.matches();

텍스트가 정규 표현식과 일치하는 경우 표현식, match() 메서드는 true를 반환합니다. 그렇지 않으면 false를 반환합니다.

matches() 메서드를 사용하여 여러 번 나타나는 정규 표현식을 찾을 수 없습니다. 필요한 경우 find(), start() 및 end() 메소드를 사용하십시오.

lookingAt()

lookingAt()는 match() 메서드와 유사하지만 lookingAt() 메서드는 텍스트 시작 부분의 정규식과 일치한다는 점입니다. 🎜>

match()는 전체 텍스트에 대해 정규식을 일치시킵니다. 즉, 정규식이 텍스트의 시작 부분과 일치하지만 전체 텍스트와 일치하지 않는 경우 lookingAt()는 true를 반환하고 match()는 false를 반환합니다. 예:

String text    =        
"This is the text to be searched " +        
"for occurrences of the http:// pattern.";
String patternString = "This is the";
Pattern pattern = Pattern.compile(patternString, Pattern.CASE_INSENSITIVE);
Matcher matcher = pattern.matcher(text);
System.out.println("lookingAt = " + matcher.lookingAt());
System.out.println("matches   = " + matcher.matches());

위의 예는 텍스트 시작 부분과 전체 텍스트의 정규식 "this is the"를 각각 일치시킵니다. 텍스트 시작 부분을 일치시키는 메서드( lookingAt())가 반환됩니다. 진실.

전체 텍스트에 대한 정규식 일치 방법(matches())은 전체 텍스트에 추가 문자가 포함되어 있고 정규식에서는 텍스트가 추가 문자 없이 "this is the"와 정확하게 일치해야 하기 때문에 false를 반환합니다. 문자 앞이나 뒤.

find() + start() + end()

find() 메소드는 텍스트에 나타나는 정규식을 찾는 데 사용됩니다. 텍스트는 Pattern.matcher( text)를 통해 생성됩니다. 방법. 텍스트에 일치하는 항목이 여러 개 있는 경우 find() 메서드는 첫 번째 항목을 반환하고 이후 find()를 호출할 때마다 다음 항목을 반환합니다.

start() 및 end()는 전체 텍스트에서 일치하는 각 문자열의 시작 및 끝 위치를 반환합니다. 실제로 end()는 문자열 끝의 마지막 숫자를 반환합니다. 이러한 방식으로 start() 및 end()의 반환 값을 String.substring()에서 직접 사용할 수 있습니다.

String text    =        
"This is the text which is to be searched " +        
"for occurrences of the word 'is'.";
String patternString = "is";
Pattern pattern = Pattern.compile(patternString);
Matcher matcher = pattern.matcher(text);
int count = 0;while(matcher.find()) {
    count++;
    System.out.println("found: " + count + " : "  + matcher.start() + " - " + matcher.end());
    }

这个例子在文本中找到模式 “is” 4次，输出如下:

found: 1 : 2 - 4
 found: 2 : 5 - 7
 found: 3 : 23 - 25
 found: 4 : 70 - 72

reset()

reset() 方法会重置Matcher 内部的 匹配状态。当find() 方法开始匹配时,Matcher 内部会记录截至当前查找的距离。调用 reset() 会重新从文本开头查找。

也可以调用 reset(CharSequence) 方法. 这个方法重置Matcher,同时把一个新的字符串作为参数传入，用于代替创建 Matcher 的原始字符串。

group()

假设想在一个文本中查找URL链接，并且想把找到的链接提取出来。当然可以通过 start()和 end()方法完成。但是用group()方法更容易些。

分组在正则表达式中用括号表示，例如:

(John)

此正则表达式匹配John, 括号不属于要匹配的文本。括号定义了一个分组。当正则表达式匹配到文本后，可以访问分组内的部分。

使用group(int groupNo) 方法访问一个分组。一个正则表达式可以有多个分组。每个分组由一对括号标记。想要访问正则表达式中某分组匹配的文本，可以把分组编号传入 group(int groupNo)方法。

group(0) 表示整个正则表达式，要获得一个有括号标记的分组，分组编号应该从1开始计算。

String text    =  
"John writes about this, and John writes about that," +                        
" and John writes about everything. "  ;
String patternString1 = "(John)";
Pattern pattern = Pattern.compile(patternString1);
Matcher matcher = pattern.matcher(text);while(matcher.find()) {
    System.out.println("found: " + matcher.group(1));
    }

以上代码在文本中搜索单词John.从每个匹配文本中，提取分组1，就是由括号标记的部分。输出如下

found: John
 found: John 
 found: John

多分组

上面提到，一个正则表达式可以有多个分组，例如：

(John) (.+?)

这个表达式匹配文本”John” 后跟一个空格,然后跟1个或多个字符，最后跟一个空格。你可能看不到最后的空格。

这个表达式包括一些字符有特别意义。字符 点 . 表示任意字符。 字符 + 表示出现一个或多个，和. 在一起表示 任何字符,出现一次或多次。字符? 表示 匹配尽可能短的文本。

完整代码如下

String text    =          
"John writes about this, and John Doe writes about that," +                  
" and John Wayne writes about everything."
        ;
        String patternString1 = "(John) (.+?) ";
        Pattern pattern = Pattern.compile(patternString1);
        Matcher matcher = pattern.matcher(text);
        while(matcher.find()) {
                 System.out.println("found: " + matcher.group(1) +                      
                  " "       + matcher.group(2));
                  }

注意代码中引用分组的方式。代码输出如下

found: John writes 
found: John Doe 
found: John Wayne

嵌套分组

在正则表达式中分组可以嵌套分组，例如

((John) (.+?))

这是之前的例子，现在放在一个大分组里.(表达式末尾有一个空格)。

当遇到嵌套分组时, 分组编号是由左括号的顺序确定的。上例中，分组1 是那个大分组。分组2 是包括John的分组，分组3 是包括 .+? 的分组。当需要通过groups(int groupNo) 引用分组时，了解这些非常重要。

以下代码演示如何使用嵌套分组

String text    =          
"John writes about this, and John Doe writes about that," +                  
" and John Wayne writes about everything."
        ;
        String patternString1 = "((John) (.+?)) ";
        Pattern pattern = Pattern.compile(patternString1);
        Matcher matcher = pattern.matcher(text);
        while(matcher.find()) {
              System.out.println("found:   ");
              }

输出如下

found: 
 found: 
 found:

replaceAll() + replaceFirst()

replaceAll() 和 replaceFirst() 方法可以用于替换Matcher搜索字符串中的一部分。replaceAll() 方法替换全部匹配的正则表达式，replaceFirst() 只替换第一个匹配的。

在处理之前，Matcher 会先重置。所以这里的匹配表达式从文本开头开始计算。

示例如下

String text    =          
"John writes about this, and John Doe writes about that," +                  
" and John Wayne writes about everything."
        ;
        String patternString1 = "((John) (.+?)) ";
        Pattern pattern = Pattern.compile(patternString1);
        Matcher matcher = pattern.matcher(text);
        String replaceAll = matcher.replaceAll("Joe Blocks ");
        System.out.println("replaceAll   = " + replaceAll);
        String replaceFirst = matcher.replaceFirst("Joe Blocks ");
        System.out.println("replaceFirst = " + replaceFirst);

输出如下

replaceAll = Joe Blocks about this, and Joe Blocks writes about that,and Joe Blocks writes about everything.
replaceFirst = Joe Blocks about this, and John Doe writes about that,and John Wayne writes about everything.

输出中的换行和缩进是为了可读而增加的。

注意第1个字符串中所有出现 John 后跟一个单词 的地方，都被替换为 Joe Blocks 。第2个字符串中，只有第一个出现的被替换。

appendReplacement() + appendTail()

appendReplacement() 和 appendTail() 方法用于替换输入文本中的字符串短语，同时把替换后的字符串附加到一个 StringBuffer 中。

当find() 方法找到一个匹配项时，可以调用 appendReplacement() 方法，这会导致输入字符串被增加到StringBuffer 中，而且匹配文本被替换。 从上一个匹配文本结尾处开始，直到本次匹配文本会被拷贝。

appendReplacement() 会记录拷贝StringBuffer 中的内容，可以持续调用find(),直到没有匹配项。

直到最后一个匹配项目，输入文本中剩余一部分没有拷贝到 StringBuffer. 这部分文本是从最后一个匹配项结尾，到文本末尾部分。通过调用 appendTail() 方法，可以把这部分内容拷贝到 StringBuffer 中.

String text    =          
"John writes about this, and John Doe writes about that," +                  
" and John Wayne writes about everything."
        ;
        String patternString1 = "((John) (.+?)) ";
        Pattern      pattern      = Pattern.compile(patternString1);
        Matcher      matcher      = pattern.matcher(text);
        StringBuffer stringBuffer = new StringBuffer();
        while(matcher.find()){
              matcher.appendReplacement(stringBuffer, "Joe Blocks ");
              System.out.println(stringBuffer.toString());
              }
matcher.appendTail(stringBuffer);
System.out.println(stringBuffer.toString());

注意我们在while循环中调用appendReplacement() 方法。在循环完毕后调用appendTail()。 代码输出如下:

Joe Blocks
 Joe Blocks about this, and Joe Blocks
 Joe Blocks about this, and Joe Blocks writes about that, and Joe Blocks
 Joe Blocks about this, and Joe Blocks writes about that, and Joe Blocks
 writes about everything.

Java 正则表达式语法

为了更有效的使用正则表达式，需要了解正则表达式语法。正则表达式语法很复杂，可以写出非常高级的表达式。只有通过大量的练习才能掌握这些语法规则。

Java 正则表达式语法

为了更有效的使用正则表达式，需要了解正则表达式语法。正则表达式语法很复杂，可以写出非常高级的表达式。只有通过大量的练习才能掌握这些语法规则。

本篇文字，我们将通过例子了解正则表达式语法的基础部分。介绍重点将会放在为了使用正则表达式所需要了解的核心概念，不会涉及过多的细节。详细解释，参见 Java DOC 中的 Pattern 类.

基本语法

고급 기능을 소개하기 전에 정규식의 기본 구문을 간단히 살펴보겠습니다.

문자

는 정규식에서 가장 일반적으로 사용되는 표현식 중 하나이며 그 기능은 단순히 특정 문자를 일치시키는 것입니다. 예:

John

이 간단한 표현식은 입력 텍스트의 John 텍스트와 일치합니다.

표현에는 모든 영어 문자를 사용할 수 있습니다. 문자 쌍의 8진수, 16진수 또는 유니코드 인코딩을 사용할 수도 있습니다. 예:

101x41u0041

위의 세 가지 표현식은 모두 대문자 A를 나타냅니다. 첫 번째는 8진수 인코딩(101), 두 번째는 16진수 인코딩(41), 세 번째는 유니코드 인코딩(0041)입니다.

문자 분류

문자 분류를 일치시킬 수 있는 구조입니다. 하나가 아닌 여러 문자. 즉, 문자 클래스는 입력 텍스트의 한 문자를 문자 클래스에서 허용되는 여러 문자와 일치시킵니다. 예를 들어 문자 a, b 또는 c를 일치시키려는 경우 표현식은 다음과 같습니다.

[abc]

대괄호([])를 사용하여 문자를 나타냅니다. 분류. 대괄호 자체는 일치 항목의 일부가 아닙니다.

문자 분류를 통해 많은 일을 할 수 있습니다. 예를 들어 John이라는 단어를 일치시키려는 경우 첫 글자는 대문자이고 소문자 J일 수 있습니다.

[Jj]ohn

문자 분류 [Jj]는 J 또는 j와 일치합니다. , 나머지 ohn은 정확합니다. 문자 일치 ohn.

사전 정의된 문자 범주

정규 표현식에 사용할 수 있는 사전 정의된 문자 범주가 몇 가지 있습니다. 예를 들어, d는 숫자를 나타내고, s는 공백 문자를 나타내고, w는 단어 문자를 나타냅니다.

미리 정의된 문자 범주를 대괄호로 묶을 필요는 없습니다. 물론 조합하여 사용할 수도 있습니다.

d[ds]

첫 번째는 임의의 숫자와 일치하고, 첫 번째는 임의의 숫자와 일치합니다. 2는 임의의 숫자 또는 공백 문자와 일치합니다.

미리 정의된 문자 카테고리의 전체 목록은 이 문서 끝에 나열되어 있습니다.

경계 일치

정규식은 단어 경계, 텍스트의 시작 또는 끝과 같은 경계 일치를 지원합니다. 예를 들어, w는 단어와 일치하고, ^는 줄의 시작과 일치하고, $는 줄의 끝과 일치합니다.

^한 줄입니다$

위 표현은 텍스트 한 줄과 일치하며, 텍스트만 한 줄입니다. 줄 표시의 시작과 끝 부분에 주의하세요. 즉, 텍스트 앞이나 뒤에는 어떤 텍스트도 있을 수 없으며 줄의 시작과 끝만 있을 수 있습니다.

일치하는 경계의 전체 목록은 이 기사 끝에 나열되어 있습니다.

정량자 일치

정량자는 표현식의 여러 항목과 일치할 수 있습니다. 예를 들어, 다음 표현식은 0회 이상 나타나는 문자 A와 일치합니다.

A*
정량자 *는 0회 이상을 의미합니다. +는 1번 이상을 의미합니다. ?는 0번 또는 1번을 의미합니다. 다른 수량자가 있습니다. 이 문서 뒷부분의 목록을 참조하세요.

정량자 매칭은 배고픈 모드, 욕심쟁이 모드, 독점 모드로 구분됩니다. 기아 모드는 가능한 한 적은 텍스트와 일치합니다. Greedy 패턴은 가능한 한 많은 텍스트와 일치합니다. 배타적 패턴은 가능한 한 많은 텍스트와 일치하지만 나머지 표현식은 일치하지 못하게 됩니다.

다음은 배고픔 모드, 탐욕 모드, 독점 모드의 차이점을 보여줍니다. 다음 텍스트를 가정해 보세요.

John이 산책을 하다가 John이 넘어져서 John이 무릎을 다쳤습니다.
배고픔 모드의 표현:

John.*?

이 표현식은 John 뒤에 0개 이상의 문자가 오는 것과 일치합니다. .는 모든 문자를 나타냅니다. *는 0회 이상을 의미합니다. ? 다음에 *는 *가 기아 모드에 있음을 의미합니다.

기아 모드에서 수량자는 가능한 적은 수의 문자, 즉 0자에만 일치합니다. 위 예의 표현식은 입력 텍스트에 3번 나타나는 John이라는 단어와 일치합니다.

그리디 모드로 변경하면 표현은 다음과 같습니다.

John.*

그리디 모드에서는 수량자가 최대한 많은 문자와 일치합니다. 이제 표현식은 John의 첫 번째 항목과 일치하고 탐욕 모드에서는 나머지 모든 문자와 일치합니다. 이렇게 하면 일치하는 항목이 하나만 있습니다.

마지막으로 독점 모드로 변경합니다.

John.*+hurt

* 다음에 +는 독점 모드 수량자를 나타냅니다.

텍스트에 John과 상처가 포함되어 있음에도 불구하고 이 표현식은 입력 텍스트에 일치하는 항목이 없습니다. 왜냐면 .*+가 독점적인 패턴이기 때문입니다. 그리디 모드와 달리 전체 표현식이 일치하도록 최대한 많은 텍스트를 일치시킵니다. 배타적 패턴은 가능한 한 많이 일치하지만 나머지 표현식이 일치할 수 있는지 여부는 고려하지 않습니다.

.*+는 첫 번째 John 이후의 모든 문자와 일치하므로 표현식에 남아 있는 상처와 일치하는 항목이 없습니다. 그리디 모드로 변경하면 매칭이 됩니다. 표현식은 다음과 같습니다:

John.*hurt

논리 연산자

정규 표현식은 소수의 논리 연산(AND, OR, NOT)을 지원합니다.

AND 연산이 기본값이며 John 표현식은 J와 o, h와 n을 의미합니다.

또는 작업을 |로 표시하고 지정해야 합니다. 예를 들어 John|hurt라는 표현은 John 또는 상처를 의미합니다.

캐릭터

캐릭터 분류

내장 문자 분류

경계 매칭

정량자