Extraer dígitos de una cadena en Java

Tengo un Stringobjeto Java Necesito extraer solo dígitos de él. Daré un ejemplo:

"123-456-789" quiero "123456789"

¿Existe una función de biblioteca que extrae solo dígitos?

Gracias por las respuestas Antes de probar esto, ¿debo saber si tengo que instalar alguna biblioteca adicional?

Puede usar expresiones regulares y eliminar no dígitos.

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

Aquí hay una solución más detallada. Menos elegante, pero probablemente más rápido:

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

Código de prueba:

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

Salida:

0123456789

Por cierto: no utilicé Character.isDigit (ch) porque acepta muchos otros caracteres, excepto 0 - 9.

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

Usando Google Guava:

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

ACTUALIZAR:

El uso de CharMatcher precalculado puede mejorar aún más el rendimiento

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

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

Esto ignorará los puntos decimales.

por ejemplo: si tiene una entrada como 445.3kgserá la salida 445.3.

Usando Google Guava:

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

CharMatcher es conectable y bastante interesante de usar, por ejemplo, puede hacer lo siguiente:

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

salida == 123-456-789

Use expresiones regulares para cumplir con sus requisitos.

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

Me inspiré en el código Sean Patrick Floyd y lo reescribí poco para obtener el máximo rendimiento que obtengo.

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

Hago una prueba de rendimiento a una cadena muy larga con números mínimos y el resultado es:

• El código original es un 25,5% más lento
• El enfoque de la guayaba es 2.5-3 veces más lento
• La expresión regular con D + es 3-3.5 veces más lenta
• La expresión regular con solo D es 25 veces más lenta

Por cierto, depende de la longitud de esa cadena. Con una cuerda que contiene solo 6 números, la guayaba es 50% más lenta y la expresión regular 1 veces más lenta

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

Salida: 11

Puedes usar str.replaceAll("[^0-9]", "");

He finalizado el código para los números de teléfono +9 (987) 124124.

Los caracteres Unicode ocupan 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 );
}

Código:

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