정규 표현식을 사용하여 Java에서 값 추출

거친 형태의 여러 줄이 있습니다.

[some text] [some number] [some more text]

Java Regex 클래스를 사용하여 [일부 번호]로 텍스트를 추출하고 싶습니다.

나는 어떤 정규 표현식을 사용하고 싶은지 대략 알고 있습니다 (모든 제안을 환영하지만). 내가 정말로 관심이있는 것은 정규식 문자열을 가져와 소스 데이터에 사용하여 [일부 숫자] 값을 생성하는 Java 호출입니다.

편집 : 나는 하나의 [일부 숫자] (기본적으로 첫 번째 인스턴스)에만 관심이 있다고 덧붙여 야합니다. 소스 문자열이 짧고 여러 번 [일부 숫자]를 찾지 않을 것입니다.

전체 예 :

private static final Pattern p = Pattern.compile("^([a-zA-Z]+)([0-9]+)(.*)");
public static void main(String[] args) {
    // create matcher for pattern p and given string
    Matcher m = p.matcher("Testing123Testing");

    // if an occurrence if a pattern was found in a given string...
    if (m.find()) {
        // ...then you can use group() methods.
        System.out.println(m.group(0)); // whole matched expression
        System.out.println(m.group(1)); // first expression from round brackets (Testing)
        System.out.println(m.group(2)); // second one (123)
        System.out.println(m.group(3)); // third one (Testing)
    }
}

첫 번째 숫자를 찾고 있기 때문에 다음 정규 표현식을 사용할 수 있습니다.

^\D+(\d+).*

그리고 m.group(1)당신에게 첫 번째 숫자를 반환합니다. 부호있는 숫자에는 빼기 부호가 포함될 수 있습니다.

^\D+(-?\d+).*

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

public class Regex1 {
    public static void main(String[]args) {
        Pattern p = Pattern.compile("\\d+");
        Matcher m = p.matcher("hello1234goodboy789very2345");
        while(m.find()) {
            System.out.println(m.group());
        }
    }
}

산출:

1234
789
2345

Allain은 기본적으로 Java 코드를 가지고 있으므로 사용할 수 있습니다. 그러나 숫자 앞에 단어 문자 만 오는 경우 에만 그의 표현이 일치 합니다 .

"(\\d+)"

첫 번째 숫자 문자열을 찾을 수 있어야합니다. 첫 번째 숫자 문자열이 확실하다면 이전의 내용을 지정할 필요가 없습니다. 마찬가지로, 원하는 경우를 제외하고 그 이후의 내용을 지정하는 데 사용할 수 없습니다. 숫자를 원하고 하나 이상의 숫자로 된 첫 번째 문자열이 확실하다면 이것이 전부입니다.

공백으로 오프셋 될 것으로 예상하면 더 명확하게 지정할 수 있습니다.

"\\s+(\\d+)\\s+"

더 좋을 수도 있습니다.

세 부분이 모두 필요한 경우 다음을 수행하십시오.

"(\\D+)(\\d+)(.*)"

편집 Allain이 잭에 의해 주어진 표현은 캡처하기 위해 비 숫자의 일부 하위 집합을 지정해야하는 것이 좋습니다 자리 . 당신이 찾고있는 정규식 엔진에 말하면 \d숫자 앞의 모든 것을 무시합니다. J 또는 A의 발현이 경우 에 맞는 당신의 패턴을, 다음 전체 경기는 동일 입력 문자열을 . 그리고 그것을 지정할 이유가 없습니다. 완전히 무시하지 않으면 깔끔한 일치 속도가 느려질 수 있습니다.

Java String 클래스에는 Pattern 외에도 정규 표현식에서 작동 할 수있는 몇 가지 메소드가 있으며,이 경우 코드는 다음과 같습니다.

"ab123abc".replaceFirst("\\D*(\\d*).*", "$1")

여기서, \\D숫자가 아닌 문자이다.

Java 1.4 이상에서 :

String input = "...";
Matcher matcher = Pattern.compile("[^0-9]+([0-9]+)[^0-9]+").matcher(input);
if (matcher.find()) {
    String someNumberStr = matcher.group(1);
    // if you need this to be an int:
    int someNumberInt = Integer.parseInt(someNumberStr);
}

이 함수는 문자열에서 일치하는 모든 시퀀스를 수집합니다. 이 예에서는 문자열에서 모든 전자 메일 주소를 가져옵니다.

static final String EMAIL_PATTERN = "[_A-Za-z0-9-\\+]+(\\.[_A-Za-z0-9-]+)*@"
        + "[A-Za-z0-9-]+(\\.[A-Za-z0-9]+)*(\\.[A-Za-z]{2,})";

public List<String> getAllEmails(String message) {      
    List<String> result = null;
    Matcher matcher = Pattern.compile(EMAIL_PATTERN).matcher(message);

    if (matcher.find()) {
        result = new ArrayList<String>();
        result.add(matcher.group());

        while (matcher.find()) {
            result.add(matcher.group());
        }
    }

    return result;
}

들어 message = "adf@gmail.com, <another@osiem.osiem>>>> lalala@aaa.pl"는 3 개 요소의 목록을 생성합니다.

다음과 같이 해보십시오 :

Pattern p = Pattern.compile("^.+(\\d+).+");
Matcher m = p.matcher("Testing123Testing");

if (m.find()) {
    System.out.println(m.group(1));
}

간단한 솔루션

// Regexplanation:
// ^       beginning of line
// \\D+    1+ non-digit characters
// (\\d+)  1+ digit characters in a capture group
// .*      0+ any character
String regexStr = "^\\D+(\\d+).*";

// Compile the regex String into a Pattern
Pattern p = Pattern.compile(regexStr);

// Create a matcher with the input String
Matcher m = p.matcher(inputStr);

// If we find a match
if (m.find()) {
    // Get the String from the first capture group
    String someDigits = m.group(1);
    // ...do something with someDigits
}

Util 클래스의 솔루션

public class MyUtil {
    private static Pattern pattern = Pattern.compile("^\\D+(\\d+).*");
    private static Matcher matcher = pattern.matcher("");

    // Assumptions: inputStr is a non-null String
    public static String extractFirstNumber(String inputStr){
        // Reset the matcher with a new input String
        matcher.reset(inputStr);

        // Check if there's a match
        if(matcher.find()){
            // Return the number (in the first capture group)
            return matcher.group(1);
        }else{
            // Return some default value, if there is no match
            return null;
        }
    }
}

...

// Use the util function and print out the result
String firstNum = MyUtil.extractFirstNumber("Testing4234Things");
System.out.println(firstNum);

StringTokenizer를 사용하여 할 수 있습니다.

String str = "as:"+123+"as:"+234+"as:"+345;
StringTokenizer st = new StringTokenizer(str,"as:");

while(st.hasMoreTokens())
{
  String k = st.nextToken();    // you will get first numeric data i.e 123
  int kk = Integer.parseInt(k);
  System.out.println("k string token in integer        " + kk);

  String k1 = st.nextToken();   //  you will get second numeric data i.e 234
  int kk1 = Integer.parseInt(k1);
  System.out.println("new string k1 token in integer   :" + kk1);

  String k2 = st.nextToken();   //  you will get third numeric data i.e 345
  int kk2 = Integer.parseInt(k2);
  System.out.println("k2 string token is in integer   : " + kk2);
}

이 숫자 데이터를 세 개의 다른 변수로 가져 오기 때문에 코드의 어느 곳에서나이 데이터를 사용할 수 있습니다 (추가 사용).

[^\\d]*([0-9]+[\\s]*[.,]{0,1}[\\s]*[0-9]*).*분수 부분으로 숫자를 처리 할 것이라고 생각 합니까 ? 공백을 포함 ,하고 가능한 구분 기호로 포함 했습니다. 부동 소수점을 포함하여 문자열에서 숫자를 가져 오려고 시도하고 사용자가 실수를하고 숫자를 입력하는 동안 공백을 포함 할 수 있음을 고려하고 있습니다.

때로는 java.lang.String에서 사용 가능한 간단한 .split ( "REGEXP") 메소드를 사용할 수 있습니다. 예를 들면 다음과 같습니다.

String input = "first,second,third";

//To retrieve 'first' 
input.split(",")[0] 
//second
input.split(",")[1]
//third
input.split(",")[2]

Pattern p = Pattern.compile("(\\D+)(\\d+)(.*)");
Matcher m = p.matcher("this is your number:1234 thank you");
if (m.find()) {
    String someNumberStr = m.group(2);
    int someNumberInt = Integer.parseInt(someNumberStr);
}

파일에서 읽는 경우 도움이 될 수 있습니다.

              try{
             InputStream inputStream = (InputStream) mnpMainBean.getUploadedBulk().getInputStream();
             BufferedReader br = new BufferedReader(new InputStreamReader(inputStream));
             String line;
             //Ref:03
             while ((line = br.readLine()) != null) {
                if (line.matches("[A-Z],\\d,(\\d*,){2}(\\s*\\d*\\|\\d*:)+")) {
                     String[] splitRecord = line.split(",");
                     //do something
                 }
                 else{
                     br.close();
                     //error
                     return;
                 }
             }
                br.close();

             }
         }
         catch (IOException  ioExpception){
             logger.logDebug("Exception " + ioExpception.getStackTrace());
         }