Extraire les chiffres d'une chaîne en Java

J'ai un Stringobjet Java . Je n'ai besoin d'en extraire que des chiffres. Je vais donner un exemple:

"123-456-789" Je voudrais "123456789"

Existe-t-il une fonction de bibliothèque qui extrait uniquement les chiffres?

Merci pour les réponses. Avant de les essayer, je dois savoir si je dois installer des bibliothèques supplémentaires?

Vous pouvez utiliser l'expression régulière et supprimer les non-chiffres.

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

Voici une solution plus détaillée. Moins élégant, mais probablement plus rapide:

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

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

Production:

0123456789

BTW: Je n'ai pas utilisé Character.isDigit (ch) car il accepte de nombreux autres caractères sauf 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();
}

Utilisation de Google Guava:

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

METTRE À JOUR:

L'utilisation de CharMatcher précalculé peut encore améliorer les performances

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

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

Cela ignorera les décimales.

par exemple: si vous avez une entrée comme 445.3kgla sortie sera 445.3.

Utilisation de Google Guava:

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

CharMatcher est enfichable et très intéressant à utiliser, par exemple, vous pouvez faire ce qui suit:

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

sortie == 123-456-789

Utilisez une expression régulière pour correspondre à vos besoins.

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

Je me suis inspiré du code Sean Patrick Floyd et je l'ai peu réécrit pour des performances maximales.

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

Je fais un test de performance sur une chaîne très longue avec un nombre minimal et le résultat est:

• Le code d'origine est 25,5% plus lent
• L'approche de la goyave est 2,5 à 3 fois plus lente
• L'expression régulière avec D + est 3-3,5 fois plus lente
• L'expression régulière avec seulement D est plus de 25 fois plus lente

Btw cela dépend de la longueur de cette chaîne. Avec une chaîne qui ne contient que 6 chiffres, la goyave est 50% plus lente et regexp 1 fois plus lente

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

Sortie: 11

Vous pouvez utiliser str.replaceAll("[^0-9]", "");

J'ai finalisé le code pour les numéros de téléphone +9 (987) 124124.

Les caractères Unicode occupent 4 octets.

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