Comma décimal séparé (',') avec numberDecimal inputType dans EditText

L' inputType numberDecimal dans EditText utilise le point '.' En tant que séparateur décimal. En Europe, il est courant d'utiliser une virgule à la place. Même si mes paramètres régionaux sont définis en allemand, le séparateur décimal est toujours le '.'

Existe-t-il un moyen d'obtenir la virgule comme séparateur décimal?

  • Référencement d'une chaîne dans une ressource de matrice de chaînes avec xml
  • Android Studio AVD, CRASH, GRADLE PROBLEMS, ne peut pas démarrer
  • Android: Comment puis-je vérifier si un périphérique possède les fonctionnalités Camera2 api mises en œuvre ou non?
  • Gestion de la mémoire HttpClient
  • Android - Sélection par programme de l'option de menu
  • Android: PendingIntent from Notification ne déclenche pas onCreate () si l'activation de l'activité sur l'écran
  • Générer un Javadoc pour mon projet Android
  • Android WebView: gérer les changements d'orientation
  • Android Studio: comment choisir ce qu'il faut importer de VCS
  • Android: erreur de connexion Google Play Games Services (java.lang.IllegalStateException: GoogleApiClient doit être connecté.)
  • Utilisation de debug.keystore spécifiée dans les versions Maven Android
  • L'installation d'APK signé n'installe pas d'application sur Android Wear
  • 13 Solutions collect form web for “Comma décimal séparé (',') avec numberDecimal inputType dans EditText”

    Une solution de contournement (jusqu'à ce que Google corrige ce bogue) consiste à utiliser EditText avec android:inputType="numberDecimal" et android:digits="0123456789.," .

    Ajoutez ensuite TextChangedListener à EditText avec AfterTextChanged suivant:

     public void afterTextChanged(Editable s) { double doubleValue = 0; if (s != null) { try { doubleValue = Double.parseDouble(s.toString().replace(',', '.')); } catch (NumberFormatException e) { //Error } } //Do something with doubleValue } 

    Une variation des solutions «digit» offertes ici:

     char separator = DecimalFormatSymbols.getInstance().getDecimalSeparator(); input.setKeyListener(DigitsKeyListener.getInstance("0123456789" + separator)); 

    Prise en compte du séparateur localisé.

    Le masque de devise de code suivant pour EditText ($ 123,125.155)

    Mise en page Xml

      <EditText android:inputType="numberDecimal" android:layout_height="wrap_content" android:layout_width="200dp" android:digits="0123456789.,$" /> 

    Code

     EditText testFilter=... testFilter.addTextChangedListener( new TextWatcher() { boolean isEdiging; @Override public void onTextChanged(CharSequence s, int start, int before, int count) { } @Override public void beforeTextChanged(CharSequence s, int start, int count, int after) { } @Override public void afterTextChanged(Editable s) { if(isEdiging) return; isEdiging = true; String str = s.toString().replaceAll( "[^\\d]", "" ); double s1 = Double.parseDouble(str); NumberFormat nf2 = NumberFormat.getInstance(Locale.ENGLISH); ((DecimalFormat)nf2).applyPattern("$ ###,###.###"); s.replace(0, s.length(), nf2.format(s1)); isEdiging = false; } }); 

    C'est un bug connu dans le SDK d'Android. La seule solution consiste à créer votre propre clavier doux. Vous pouvez trouver un exemple de mise en œuvre ici .

    La réponse de Martins ne fonctionnera pas si vous créez une instanciation dans EditText par programme. Je suis allé de l'avant et modifié la classe DigitsKeyListener incluse de l'API 14 pour permettre la virgule et la période en tant que séparateur décimal.

    Pour utiliser cela, appelez setKeyListener() sur EditText , par exemple

     // Don't allow for signed input (minus), but allow for decimal points editText.setKeyListener( new MyDigitsKeyListener( false, true ) ); 

    Cependant, vous devez encore utiliser l'astuce de Martin dans TextChangedListener où vous remplacez des virgules avec des périodes

     import android.text.InputType; import android.text.SpannableStringBuilder; import android.text.Spanned; import android.text.method.NumberKeyListener; import android.view.KeyEvent; class MyDigitsKeyListener extends NumberKeyListener { /** * The characters that are used. * * @see KeyEvent#getMatch * @see #getAcceptedChars */ private static final char[][] CHARACTERS = new char[][] { new char[] { '0', '1', '2', '3', '4', '5', '6', '7', '8', '9' }, new char[] { '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', '-' }, new char[] { '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', '.', ',' }, new char[] { '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', '-', '.', ',' }, }; private char[] mAccepted; private boolean mSign; private boolean mDecimal; private static final int SIGN = 1; private static final int DECIMAL = 2; private static MyDigitsKeyListener[] sInstance = new MyDigitsKeyListener[4]; @Override protected char[] getAcceptedChars() { return mAccepted; } /** * Allocates a DigitsKeyListener that accepts the digits 0 through 9. */ public MyDigitsKeyListener() { this(false, false); } /** * Allocates a DigitsKeyListener that accepts the digits 0 through 9, * plus the minus sign (only at the beginning) and/or decimal point * (only one per field) if specified. */ public MyDigitsKeyListener(boolean sign, boolean decimal) { mSign = sign; mDecimal = decimal; int kind = (sign ? SIGN : 0) | (decimal ? DECIMAL : 0); mAccepted = CHARACTERS[kind]; } /** * Returns a DigitsKeyListener that accepts the digits 0 through 9. */ public static MyDigitsKeyListener getInstance() { return getInstance(false, false); } /** * Returns a DigitsKeyListener that accepts the digits 0 through 9, * plus the minus sign (only at the beginning) and/or decimal point * (only one per field) if specified. */ public static MyDigitsKeyListener getInstance(boolean sign, boolean decimal) { int kind = (sign ? SIGN : 0) | (decimal ? DECIMAL : 0); if (sInstance[kind] != null) return sInstance[kind]; sInstance[kind] = new MyDigitsKeyListener(sign, decimal); return sInstance[kind]; } /** * Returns a DigitsKeyListener that accepts only the characters * that appear in the specified String. Note that not all characters * may be available on every keyboard. */ public static MyDigitsKeyListener getInstance(String accepted) { // TODO: do we need a cache of these to avoid allocating? MyDigitsKeyListener dim = new MyDigitsKeyListener(); dim.mAccepted = new char[accepted.length()]; accepted.getChars(0, accepted.length(), dim.mAccepted, 0); return dim; } public int getInputType() { int contentType = InputType.TYPE_CLASS_NUMBER; if (mSign) { contentType |= InputType.TYPE_NUMBER_FLAG_SIGNED; } if (mDecimal) { contentType |= InputType.TYPE_NUMBER_FLAG_DECIMAL; } return contentType; } @Override public CharSequence filter(CharSequence source, int start, int end, Spanned dest, int dstart, int dend) { CharSequence out = super.filter(source, start, end, dest, dstart, dend); if (mSign == false && mDecimal == false) { return out; } if (out != null) { source = out; start = 0; end = out.length(); } int sign = -1; int decimal = -1; int dlen = dest.length(); /* * Find out if the existing text has '-' or '.' characters. */ for (int i = 0; i < dstart; i++) { char c = dest.charAt(i); if (c == '-') { sign = i; } else if (c == '.' || c == ',') { decimal = i; } } for (int i = dend; i < dlen; i++) { char c = dest.charAt(i); if (c == '-') { return ""; // Nothing can be inserted in front of a '-'. } else if (c == '.' || c == ',') { decimal = i; } } /* * If it does, we must strip them out from the source. * In addition, '-' must be the very first character, * and nothing can be inserted before an existing '-'. * Go in reverse order so the offsets are stable. */ SpannableStringBuilder stripped = null; for (int i = end - 1; i >= start; i--) { char c = source.charAt(i); boolean strip = false; if (c == '-') { if (i != start || dstart != 0) { strip = true; } else if (sign >= 0) { strip = true; } else { sign = i; } } else if (c == '.' || c == ',') { if (decimal >= 0) { strip = true; } else { decimal = i; } } if (strip) { if (end == start + 1) { return ""; // Only one character, and it was stripped. } if (stripped == null) { stripped = new SpannableStringBuilder(source, start, end); } stripped.delete(i - start, i + 1 - start); } } if (stripped != null) { return stripped; } else if (out != null) { return out; } else { return null; } } } 

    Vous pouvez utiliser la solution de contournement suivante pour inclure également une virgule comme entrée valide: –

    Par XML:

     <EditText android:inputType="number" android:digits="0123456789.," /> 

    Par programme:

     EditText input = new EditText(THE_CONTEXT); input.setKeyListener(DigitsKeyListener.getInstance("0123456789.,")); 

    De cette façon, le système Android affichera le clavier des nombres et permettra l'entrée de la virgule. J'espère que cela répond à la question 🙂

    Pour les solutions Mono (Droid):

     decimal decimalValue = decimal.Parse(input.Text.Replace(",", ".") , CultureInfo.InvariantCulture); 

    Vous pourriez faire ce qui suit:

     DecimalFormatSymbols d = DecimalFormatSymbols.getInstance(Locale.getDefault()); input.setFilters(new InputFilter[] { new DecimalDigitsInputFilter(5, 2) }); input.setKeyListener(DigitsKeyListener.getInstance("0123456789" + d.getDecimalSeparator())); 

    Et puis vous pouvez utiliser un filtre d'entrée:

      public class DecimalDigitsInputFilter implements InputFilter { Pattern mPattern; public DecimalDigitsInputFilter(int digitsBeforeZero, int digitsAfterZero) { DecimalFormatSymbols d = new DecimalFormatSymbols(Locale.getDefault()); String s = "\\" + d.getDecimalSeparator(); mPattern = Pattern.compile("[0-9]{0," + (digitsBeforeZero - 1) + "}+((" + s + "[0-9]{0," + (digitsAfterZero - 1) + "})?)||(" + s + ")?"); } @Override public CharSequence filter(CharSequence source, int start, int end, Spanned dest, int dstart, int dend) { Matcher matcher = mPattern.matcher(dest); if (!matcher.matches()) return ""; return null; } 

    }

    Je pense que cette solution est moins complexe que les autres écrits ici:

     <EditText android:inputType="numberDecimal" android:digits="0123456789," /> 

    De cette façon, lorsque vous appuyez sur '.' Dans le clavier doux, rien ne se passe; Seuls les nombres et les virgules sont autorisés.

    IMHO la meilleure approche pour ce problème est d'utiliser simplement InputFilter. Un bon gist est ici DecimalDigitsInputFilter . Ensuite, vous pouvez simplement:

     editText.setInputType(TYPE_NUMBER_FLAG_DECIMAL | TYPE_NUMBER_FLAG_SIGNED | TYPE_CLASS_NUMBER) editText.setKeyListener(DigitsKeyListener.getInstance("0123456789,.-")) editText.setFilters(new InputFilter[] {new DecimalDigitsInputFilter(5,2)}); 

    Android possède un formateur de format intégré.

    Vous pouvez ajouter ceci à votre EditText pour autoriser les décimales et les virgules: android:inputType="numberDecimal" et android:digits="0123456789.,"

    Ensuite, quelque part dans votre code, soit lorsque l'utilisateur clique sur enregistrer ou après l'entrée du texte (utilisez un auditeur).

     // Format the number to the appropriate double try { Number formatted = NumberFormat.getInstance().parse(editText.getText().toString()); cost = formatted.doubleValue(); } catch (ParseException e) { System.out.println("Error parsing cost string " + editText.getText().toString()); cost = 0.0; } 

    Vous pourriez utiliser ce qui suit pour différentes régions

     private void localeDecimalInput(final EditText editText){ DecimalFormat decFormat = (DecimalFormat) DecimalFormat.getInstance(Locale.getDefault()); DecimalFormatSymbols symbols=decFormat.getDecimalFormatSymbols(); final String defaultSeperator=Character.toString(symbols.getDecimalSeparator()); editText.addTextChangedListener(new TextWatcher() { @Override public void beforeTextChanged(CharSequence s, int start, int count, int after) { } @Override public void onTextChanged(CharSequence s, int start, int before, int count) { } @Override public void afterTextChanged(Editable editable) { if(editable.toString().contains(defaultSeperator)) editText.setKeyListener(DigitsKeyListener.getInstance("0123456789")); else editText.setKeyListener(DigitsKeyListener.getInstance("0123456789" + defaultSeperator)); } }); } 

    Pour localiser votre utilisation d'entrée:

     char sep = DecimalFormatSymbols.getInstance().getDecimalSeparator(); 

    Puis ajoutez:

     textEdit.setKeyListener(DigitsKeyListener.getInstance("0123456789" + sep)); 

    Que n'oubliez pas de remplacer "," par "." Alors Float ou Double peut l'analyser sans erreur.

    coAndroid est un fan Android de Google, tout sur les téléphones Android, Android Wear, Android Dev et Android Games Apps.