Extrahieren Sie Ziffern aus einer Zeichenfolge in Java

Ich habe ein Java- StringObjekt. Ich muss nur Ziffern daraus extrahieren. Ich werde ein Beispiel geben:

"123-456-789" Ich will "123456789"

Gibt es eine Bibliotheksfunktion, die nur Ziffern extrahiert?

Danke für die Antworten. Bevor ich diese versuche, muss ich wissen, ob ich zusätzliche Bibliotheken installieren muss.

Sie können Regex verwenden und Nicht-Ziffern löschen.

str = str.replaceAll("\\D+","");

Hier ist eine ausführlichere Lösung. Weniger elegant, aber wahrscheinlich schneller:

public static String stripNonDigits(
            final CharSequence input /* inspired by seh's comment */){
    final StringBuilder sb = new StringBuilder(
            input.length() /* also inspired by seh's comment */);
    for(int i = 0; i < input.length(); i++){
        final char c = input.charAt(i);
        if(c > 47 && c < 58){
            sb.append(c);
        }
    }
    return sb.toString();
}

Testcode:

public static void main(final String[] args){
    final String input = "0-123-abc-456-xyz-789";
    final String result = stripNonDigits(input);
    System.out.println(result);
}

Ausgabe:

0123456789

Übrigens: Ich habe Character.isDigit (ch) nicht verwendet, da es viele andere Zeichen außer 0 - 9 akzeptiert.

public String extractDigits(String src) {
    StringBuilder builder = new StringBuilder();
    for (int i = 0; i < src.length(); i++) {
        char c = src.charAt(i);
        if (Character.isDigit(c)) {
            builder.append(c);
        }
    }
    return builder.toString();
}

Verwenden von Google Guava:

CharMatcher.inRange('0','9').retainFrom("123-456-789")

AKTUALISIEREN:

Die Verwendung von Precomputed CharMatcher kann die Leistung weiter verbessern

CharMatcher ASCII_DIGITS=CharMatcher.inRange('0','9').precomputed();  
ASCII_DIGITS.retainFrom("123-456-789");

input.replaceAll("[^0-9?!\\.]","")

Dadurch werden die Dezimalstellen ignoriert.

Beispiel: Wenn Sie einen Eingang haben, wird 445.3kgder Ausgang sein 445.3.

Verwenden von Google Guava:

CharMatcher.DIGIT.retainFrom("123-456-789");

CharMatcher ist steckbar und sehr interessant zu bedienen. Sie können beispielsweise Folgendes tun:

String input = "My phone number is 123-456-789!";
String output = CharMatcher.is('-').or(CharMatcher.DIGIT).retainFrom(input);

Ausgabe == 123-456-789

Verwenden Sie reguläre Ausdrücke, um Ihren Anforderungen zu entsprechen.

String num,num1,num2;
String str = "123-456-789";
String regex ="(\\d+)";
Matcher matcher = Pattern.compile( regex ).matcher( str);
while (matcher.find( ))
{
num = matcher.group();     
System.out.print(num);                 
}

Ich habe mich vom Code Sean Patrick Floyd inspirieren lassen und ihn wenig umgeschrieben, um maximale Leistung zu erzielen.

public static String stripNonDigitsV2( CharSequence input ) {
    if (input == null)
        return null;
    if ( input.length() == 0 )
        return "";

    char[] result = new char[input.length()];
    int cursor = 0;
    CharBuffer buffer = CharBuffer.wrap( input );

    while ( buffer.hasRemaining() ) {
        char chr = buffer.get();
        if ( chr > 47 && chr < 58 )
            result[cursor++] = chr;
    }

    return new String( result, 0, cursor );
}

Ich mache einen Leistungstest für einen sehr langen String mit minimalen Zahlen und das Ergebnis ist:

• Der ursprüngliche Code ist 25,5% langsamer
• Der Guavenansatz ist 2,5-3 mal langsamer
• Der reguläre Ausdruck mit D + ist 3-3,5-mal langsamer
• Der reguläre Ausdruck mit nur D ist mehr als 25 Mal langsamer

Übrigens hängt es davon ab, wie lang diese Zeichenfolge ist. Mit String, der nur 6 Zahlen enthält, ist Guave 50% langsamer und Regexp 1 mal langsamer

public class FindDigitFromString 
{

    public static void main(String[] args) 
    {
        String s="  Hi How Are You 11  ";        
        String s1=s.replaceAll("[^0-9]+", "");
        //*replacing all the value of string except digit by using "[^0-9]+" regex.*
       System.out.println(s1);          
   }
}

Ausgabe: 11

Sie können verwenden str.replaceAll("[^0-9]", "");

Ich habe den Code für die Telefonnummern +9 (987) 124124 festgelegt.

Unicode-Zeichen belegen 4 Bytes.

public static String stripNonDigitsV2( CharSequence input ) {
    if (input == null)
        return null;
    if ( input.length() == 0 )
        return "";

    char[] result = new char[input.length()];
    int cursor = 0;
    CharBuffer buffer = CharBuffer.wrap( input );
    int i=0;
    while ( i< buffer.length()  ) { //buffer.hasRemaining()
        char chr = buffer.get(i);
        if (chr=='u'){
            i=i+5;
            chr=buffer.get(i);
        }

        if ( chr > 39 && chr < 58 )
            result[cursor++] = chr;
        i=i+1;
    }

    return new String( result, 0, cursor );
}

Code:

public class saasa {

    public static void main(String[] args) {
        // TODO Auto-generated method stub
        String t="123-456-789";
        t=t.replaceAll("-", "");
        System.out.println(t);
    }

import java.util.*;
public class FindDigits{

 public static void main(String []args){
    FindDigits h=new  FindDigits();
    h.checkStringIsNumerical();
 }

 void checkStringIsNumerical(){
    String h="hello 123 for the rest of the 98475wt355";
     for(int i=0;i<h.length();i++)  {
      if(h.charAt(i)!=' '){
       System.out.println("Is this '"+h.charAt(i)+"' is a digit?:"+Character.isDigit(h.charAt(i)));
       }
    }
 }

void checkStringIsNumerical2(){
    String h="hello 123 for 2the rest of the 98475wt355";
     for(int i=0;i<h.length();i++)  {
         char chr=h.charAt(i);
      if(chr!=' '){
       if(Character.isDigit(chr)){
          System.out.print(chr) ;
       }
       }
    }
 }
}