Używanie wyrażeń regularnych do wyodrębniania wartości w Javie

Allain zasadniczo ma kod java, więc możesz go użyć. Jednak jego wyrażenie pasuje tylko do , Jeśli twoje liczby są poprzedzone tylko strumieniem znaków wyrazowych.

"(\\d+)"

Powinien być w stanie znaleźć pierwszy ciąg cyfr. Nie musisz określać, co jest przed nim, jeśli jesteś pewien, że będzie to pierwszy ciąg cyfr. Podobnie, nie ma sensu określać, co jest po nim, chyba że chcesz tego. Jeśli chcesz tylko numer i jesteś pewien, że będzie to pierwszy ciąg jednej lub więcej cyfr to wszystko, czego potrzebujesz.

Jeśli spodziewasz się, że zostanie przesunięta przez spacje, będzie jeszcze bardziej wyraźne określenie

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

Jeśli potrzebujesz wszystkich trzech części, to wystarczy:

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

Edytuj wyrażenia podane przez Allaina i Jacka sugerują, że musisz określić podzbiór niecyfrów, aby uchwycić cyfry . Jeśli powiesz silnikowi regex, którego szukasz \d, to ignoruj wszystko przed cyframi. Jeśli wyrażenie J lub A pasuje do twojego wzorca, to całe dopasowanie równa się łańcuch wejściowy. I nie ma powodu, by to określać. Prawdopodobnie spowalnia czyste dopasowanie, Jeśli nie jest całkowicie ignorowane.

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());
        }
    }
}

Wyjście:

1234
789
2345

Oprócz Pattern , Klasa Java String posiada również kilka metod, które mogą pracować z wyrażeniami regularnymi, w Twoim przypadku kod będzie:

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

Gdzie \\D jest znakiem niecyfrowym.

W Javie 1.4 i nowszych:

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);
}

Ta funkcja zbiera wszystkie pasujące sekwencje z string. W tym przykładzie pobiera wszystkie adresy e-mail z string.

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;
}

Dla message = "[email protected], <[email protected]>>>> [email protected]" utworzy listę 3 elementów.

Spróbuj zrobić coś takiego:

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

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

Spójrz możesz to zrobić używając 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);
}

Ponieważ bierzemy te dane liczbowe do trzech różnych zmiennych, możemy użyć tych danych w dowolnym miejscu kodu (do dalszego wykorzystania)

Proste Rozwiązanie

// 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
}

Roztwór w klasie 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);

A może [^\\d]*([0-9]+[\\s]*[.,]{0,1}[\\s]*[0-9]*).* myślę, że zajmie się liczbami z częścią ułamkową. Włączyłem białe spacje i włączyłem , jako możliwy separator. Staram się wydobyć liczby z Ciągu, w tym pływaków i biorąc pod uwagę, że użytkownik może popełnić błąd i zawierać białe spacje podczas wpisywania numeru.

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);
}

Czasami można użyć simple .metoda split ("REGEXP") dostępna w Javie.lang.Sznurek. Na przykład:

String input = "first,second,third";

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

Jeśli czytasz z pliku, to może Ci to pomóc

              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());
         }