Java를 사용하여 정규 표현을 사용하여 더 큰 문자열의 하위 문자열 검색

Java를 사용하여 정규 표현을 사용하여 더 큰 문자열의 하위 문자열 검색

다음과 같은 문자열이 있는 경우:

FOO[BAR]

각 괄호 사이에 어떤 문자열이 있어도 문자열을 얻을 수 있도록 문자열에서 "BAR" 문자열을 꺼내는 일반적인 방법이 필요합니다.

예.

FOO[DOG] = DOG
FOO[CAT] = CAT

비-권리 수량자, 특히 *를 사용할 수 있어야 합니다.아마 다음과 같은 것이 필요할 것입니다.

Pattern MY_PATTERN = Pattern.compile("\\[(.*?)\\]");

그러면 문자열과 일치하는 패턴이 나타나고 첫 번째 그룹의 대괄호 안에 텍스트가 들어갑니다.자세한 내용은 Pattern API 문서를 참조하십시오.

문자열을 추출하려면 다음과 같은 방법을 사용할 수 있습니다.

Matcher m = MY_PATTERN.matcher("FOO[BAR]");
while (m.find()) {
    String s = m.group(1);
    // s now contains "BAR"
}

비정규 방식:

String input = "FOO[BAR]", extracted;
extracted = input.substring(input.indexOf("["),input.indexOf("]"));

또는 퍼포먼스/메모리 사용량을 약간 향상시키려면 (Hosam님 감사합니다)

String input = "FOO[BAR]", extracted;
extracted = input.substring(input.indexOf('['),input.lastIndexOf(']'));

다음으로 동작 예를 제시하겠습니다.

RegexpExample.java

package org.regexp.replace;

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

public class RegexpExample
{
    public static void main(String[] args)
    {
        String string = "var1[value1], var2[value2], var3[value3]";
        Pattern pattern = Pattern.compile("(\\[)(.*?)(\\])");
        Matcher matcher = pattern.matcher(string);

        List<String> listMatches = new ArrayList<String>();

        while(matcher.find())
        {
            listMatches.add(matcher.group(2));
        }

        for(String s : listMatches)
        {
            System.out.println(s);
        }
    }
}

다음과 같이 표시됩니다.

value1
value2
value3

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

public static String get_match(String s, String p) {
    // returns first match of p in s for first group in regular expression 
    Matcher m = Pattern.compile(p).matcher(s);
    return m.find() ? m.group(1) : "";
}

get_match("FOO[BAR]", "\\[(.*?)\\]")  // returns "BAR"

public static List<String> get_matches(String s, String p) {
    // returns all matches of p in s for first group in regular expression 
    List<String> matches = new ArrayList<String>();
    Matcher m = Pattern.compile(p).matcher(s);
    while(m.find()) {
        matches.add(m.group(1));
    }
    return matches;
}

get_matches("FOO[BAR] FOO[CAT]", "\\[(.*?)\\]")) // returns [BAR, CAT]

그 사이에 있는 가 있다면.[] , 을할 수 있습니다.\[([^\]]*)\]음음음같 뭇매하다

Pattern regex = Pattern.compile("\\[([^\\]]*)\\]");
Matcher m = regex.matcher(str);
if (m.find()) {
    result = m.group();
}

ID가 영숫자일 경우에만 컨텐츠 추출을 제한할 수 있습니다.

[a-zA-Z][a-z-A-Z0-9_]*\s*\[([^\]]*)\]

하면 .Foo [Bar] , 「」myDevice_123["input"]예를 들어.

주요호

주된 문제는 다음과 같은 내용을 추출하는 것입니다.

FOO[BAR[CAT[123]]+DOG[FOO]]

Regex가 됩니다.BAR[CAT[123 ★★★★★★★★★★★★★★★★★」FOO.
를 규음음 음음음음음음으로 \[(.*)\]좀 더 에서 내용을 는 '어쩌다', '어쩌다', '어쩌다', '어쩌다', '어쩌다', '어쩌다', '어쩌다', '어쩌다', '어쩌다', '어쩌다', '어쩌다', '어쩌다,

FOO[BAR[CAT[123]]+DOG[FOO]] = myOtherFoo[BAR[5]]

어떤 정규식도 작동하지 않을 것이다.

더 합니다. Regex의 균형을 때문입니다.[]이치노

보다 심플한 솔루션

, 「」의 이 복잡해지고 있는 .[] '어떠한 '어떠한', '어떠한', '어떠한', '어떠한', '어떠한', '어떠한', '어떠한', '어떠한', '어떠한', '어떠한', '어떠한', '의 쌍을[]정규식이 아닌 일반 오래된 코드를 사용하여 문자열을 추출합니다.

int i;
int brackets = 0;
string c;
result = "";
for (i = input.indexOf("["); i < str.length; i++) {
    c = str.substring(i, i + 1);
    if (c == '[') {
        brackets++;
    } else if (c == ']') {
        brackets--;
        if (brackets <= 0) 
            break;
    }
    result = result + c;
}   

이것은 실제 코드보다 더 의사 코드입니다.저는 Java 코더가 아니기 때문에 구문이 맞는지 모르겠지만, 개선은 충분히 쉬울 것입니다.
한 것은 이 , 이 코드가 작동해야 하고, 이 코드가 작동해야 하고, 이 코드가 작동해야 한다, 라고 하는 할 수 입니다.[]아무리 복잡해도.

당신의 정규 표현은 다음과 같습니다.

/FOO\[(.+)\]/

FOO가 일정하다고 가정합니다.

이를 Java로 표현하려면:

Pattern p = Pattern.compile("FOO\\[(.+)\\]");
Matcher m = p.matcher(inputLine);

String input = "FOO[BAR]";
String result = input.substring(input.indexOf("[")+1,input.lastIndexOf("]"));

처음 '['와 마지막 '] 사이의 값이 반환됩니다.

후 [바] = > 바

Foo [ Bar [ test ]= > Bar [ test ]

주의: 입력 문자열의 형식이 올바르지 않은지 여부를 확인하는 오류를 추가해야 합니다.

/FOO\[(^\]]*)\]/ 내에서 다른 닫힘 괄호가 허용되지 않는다고 가정합니다.

최대 수의 비 []문자를 다음 중 하나로 지정합니다.[그리고.]이것들은 백슬래시를 사용하여 이스케이프할 필요가 있습니다(자바에서는 다시 이스케이프할 필요가 있습니다).non-의 정의는 문자 클래스이므로 내부가 됩니다.[그리고.](즉,[^\\]])의 결과:

FOO\\[([^\\]]+)\\]

이와 같이 mYearInDB.toString() =[2013]에서 오는 문자열을 해석하고 싶다면 2013을 제공합니다.

Matcher n = MY_PATTERN.matcher("FOO[BAR]"+mYearInDB.toString());
while (n.find()) {
 extracredYear  = n.group(1);
 // s now contains "BAR"
    }
    System.out.println("Extrated output is : "+extracredYear);

"FOO[DOG]".replaceAll("^.*?\\[|\\].*", "");

이렇게 하면 각 괄호 안의 문자열만 반환됩니다.

이렇게 하면 바깥쪽 문자열이 대괄호에서 모두 삭제됩니다.

이 Java 샘플 코드는 온라인으로 테스트할 수 있습니다.http://tpcg.io/wZoFu0

이 정규식은 https://regex101.com/r/oUAzsS/1 에서 테스트할 수 있습니다.

언급URL : https://stackoverflow.com/questions/600733/using-java-to-find-substring-of-a-bigger-string-using-regular-expression