Estrai cifre da una stringa in Java

Ho un Stringoggetto Java . Devo estrarre solo cifre da esso. Faccio un esempio:

"123-456-789" Voglio "123456789"

Esiste una funzione di libreria che estrae solo cifre?

Grazie per le risposte Prima di provare questi, devo sapere se devo installare altri llibrari?

Puoi usare regex ed eliminare le non cifre.

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

Ecco una soluzione più dettagliata. Meno elegante, ma probabilmente più veloce:

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

Codice test:

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

Produzione:

0123456789

A proposito: non ho usato Character.isDigit (ch) perché accetta molti altri caratteri tranne 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();
}

Utilizzando Google Guava:

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

AGGIORNARE:

L'utilizzo di CharMatcher precompilato può migliorare ulteriormente le prestazioni

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

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

Ciò ignorerà i punti decimali.

es: se hai un input come 445.3kgsarà l'output 445.3.

Utilizzando Google Guava:

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

CharMatcher è plug-in e abbastanza interessante da usare, ad esempio puoi fare quanto segue:

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

uscita == 123-456-789

Usa l'espressione regolare per soddisfare le tue esigenze.

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

Mi sono ispirato al codice Sean Patrick Floyd e l'ho riscritto per ottenere le massime prestazioni.

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

faccio Performance test di stringa molto lunga con i numeri minimi e risultato è:

• Il codice originale è più lento del 25,5%
• L'approccio di Guava è 2,5-3 volte più lento
• L'espressione regolare con D + è 3-3,5 volte più lenta
• L'espressione regolare con solo D è più di 25 volte più lenta

A proposito, dipende da quanto è lunga quella stringa. Con una stringa che contiene solo 6 numeri, la guava è più lenta del 50% e regexp 1 volte più 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);          
   }
}

Uscita: 11

Puoi usare str.replaceAll("[^0-9]", "");

Ho finalizzato il codice per i numeri di telefono +9 (987) 124124.

I caratteri Unicode occupano 4 byte.

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

Codice:

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